Testrun stores gw identity key instead of gw pk

- log gw identity key
- better agent testrun logging
- log responses
- change response code for agents

.github/workflows/cd-docs.yml

@@ -6,27 +6,20 @@ on:
 jobs:
   build:
     runs-on: arc-ubuntu-20.04
-    defaults:
-      run:
-        working-directory: documentation/docs
     steps:
       - uses: actions/checkout@v4
       - 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 git python3 && sudo apt-get update --fix-missing
       - name: Install pip3
-        run: sudo apt install -y python3-pip
+        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
-      - name: Setup pnpm
-        uses: pnpm/action-setup@v4.0.0
-        with:
-          version: 9
       - uses: actions/setup-node@v4
         with:
-          node-version: 20
+          node-version: 18
       - name: Install Rust stable
         uses: actions-rs/toolchain@v1
         with:
@@ -36,13 +29,33 @@ jobs:
         with:
           command: build
           args: --workspace --release
+      - name: Install mdbook and plugins
+        run: cd documentation && ./install_mdbook_deps.sh
+      - name: Remove existing Nym config directory (`~/.nym/`)
+        run: cd documentation && ./remove_existing_config.sh
+        continue-on-error: false
+# This is the original flow
+#      - name: Build all projects in documentation/ & move to ~/dist/docs/
+#        run: cd documentation && ./build_all_to_dist.sh
 
-      - name: Install project dependencies
-        run: pnpm i
-      - name: Build project
-        run: pnpm run build
-      - name: Move files to /dist/
-        run: ../scripts/move-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, reset & switch to b332a6b55668f60988e36961f3f62a794ba82ddb
+        run: git pull && git reset --hard && git checkout b332a6b55668f60988e36961f3f62a794ba82ddb
+      - name: Build all projects in documentation/ & move to ~/dist/docs/ from b332a6b55668f60988e36961f3f62a794ba82ddb
+        run: cd documentation && ./build_all_to_dist.sh
+
+      - 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
+        continue-on-error: false
 
       - name: Create Vercel project file
         uses: mobiledevops/secret-to-file-action@v1

.github/workflows/ci-docs.yml

@@ -3,35 +3,28 @@ name: ci-docs
 on:
   workflow_dispatch:
   push:
-    branches-ignore: [master]
+    branches-ignore: master
     paths:
-      - "documentation/docs/**"
-      - ".github/workflows/ci-docs.yml"
+      - 'documentation/docs/**'
+      - '.github/workflows/ci-docs.yml'
 
 jobs:
   build:
     runs-on: arc-ubuntu-20.04
-    defaults:
-      run:
-        working-directory: documentation/docs
     steps:
       - uses: actions/checkout@v4
       - 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 git python3 && sudo apt-get update --fix-missing
       - name: Install pip3
-        run: sudo apt install -y python3-pip
+        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
-      - name: Setup pnpm
-        uses: pnpm/action-setup@v4.0.0
-        with:
-          version: 9
       - uses: actions/setup-node@v4
         with:
-          node-version: 20
+          node-version: 18
       - name: Install Rust stable
         uses: actions-rs/toolchain@v1
         with:
@@ -41,13 +34,30 @@ jobs:
         with:
           command: build
           args: --workspace --release
+      - name: Install mdbook and plugins
+        run: cd documentation && ./install_mdbook_deps.sh
+      - name: Remove existing Nym config directory (`~/.nym/`)
+        run: cd documentation && ./remove_existing_config.sh
+        continue-on-error: false
 
-      - name: Install project dependencies
-        run: pnpm i
-      - name: Build project
-        run: pnpm run build
-      - name: Move files to /dist/
-        run: ../scripts/move-to-dist.sh
+# 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, reset & switch to b332a6b55668f60988e36961f3f62a794ba82ddb
+        run: git pull && git reset --hard && git checkout b332a6b55668f60988e36961f3f62a794ba82ddb
+      - name: Build all projects in documentation/ & move to ~/dist/docs/ from b332a6b55668f60988e36961f3f62a794ba82ddb
+        run: cd documentation && ./build_all_to_dist.sh
+
+      - 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
@@ -58,5 +68,5 @@ jobs:
           SOURCE: "dist/docs/"
           REMOTE_HOST: ${{ secrets.CI_WWW_REMOTE_HOST }}
           REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
-          TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/docs-nextra-${{ env.GITHUB_REF_SLUG }}
+          TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/docs-${{ env.GITHUB_REF_SLUG }}
           EXCLUDE: "/node_modules/"

.github/workflows/ci-sdk-docs-typescript.yml

@@ -0,0 +1,79 @@
+name: ci-sdk-docs-typescript
+
+on:
+  pull_request:
+    paths:
+      - "sdk/typescript/**"
+      - "wasm/**"
+      - '.github/workflows/ci-sdk-docs-typescript.yml'
+
+jobs:
+  build:
+    runs-on: custom-linux
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install rsync
+        run: sudo apt-get install rsync
+        continue-on-error: true
+      - uses: rlespinasse/github-slug-action@v3.x
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 18.17
+      - name: Install Rust stable
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+      - name: Setup yarn
+        run: npm install -g yarn
+
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: '1.20'
+
+      - name: Install wasm-pack
+        run: curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh
+
+      - name: Install wasm-opt
+        uses: ./.github/actions/install-wasm-opt
+        with:
+          version: '116'
+
+      - name: Build branch WASM packages
+        run: make sdk-wasm-build
+
+      - name: Install
+        run: yarn
+      - name: Build
+        run: yarn docs:prod:build
+      - name: Deploy branch to CI www (docs)
+        continue-on-error: true
+        uses: easingthemes/ssh-deploy@main
+        env:
+          SSH_PRIVATE_KEY: ${{ secrets.CI_WWW_SSH_PRIVATE_KEY }}
+          ARGS: "-rltgoDzvO --delete"
+          SOURCE: "dist/ts/"
+          REMOTE_HOST: ${{ secrets.CI_WWW_REMOTE_HOST }}
+          REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
+          TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/sdk-ts-docs-${{ env.GITHUB_REF_SLUG }}
+          EXCLUDE: "/dist/, /node_modules/"
+      - name: Matrix - Node Install
+        run: npm install
+        working-directory: .github/workflows/support-files
+      - name: Matrix - Send Notification
+        env:
+          NYM_NOTIFICATION_KIND: ts-packages
+          NYM_PROJECT_NAME: "sdk-ts-docs"
+          NYM_CI_WWW_BASE: "${{ secrets.NYM_CI_WWW_BASE }}/docs/sdk/typescript"
+          NYM_CI_WWW_LOCATION: "sdk-ts-docs-${{ env.GITHUB_REF_SLUG }}"
+          GIT_COMMIT_MESSAGE: "${{ github.event.head_commit.message }}"
+          GIT_BRANCH: "${GITHUB_REF##*/}"
+          IS_SUCCESS: "${{ job.status == 'success' }}"
+          MATRIX_SERVER: "${{ secrets.MATRIX_SERVER }}"
+          MATRIX_ROOM: "${{ secrets.MATRIX_ROOM }}"
+          MATRIX_USER_ID: "${{ secrets.MATRIX_USER_ID }}"
+          MATRIX_TOKEN: "${{ secrets.MATRIX_TOKEN }}"
+          MATRIX_DEVICE_ID: "${{ secrets.MATRIX_DEVICE_ID }}"
+        uses: docker://keybaseio/client:stable-node
+        with:
+          args: .github/workflows/support-files/notifications/entry_point.sh

.github/workflows/pr-validation.yml

@@ -4,9 +4,7 @@ on:
   pull_request:
     branches:
       - develop
-      - "release/**"
-    paths-ignore:
-      - "documentation/**"
+      - 'release/**'
     types:
       - labeled
       - unlabeled

.github/workflows/push-node-status-agent.yaml

@@ -2,10 +2,6 @@ name: Build and upload Node Status agent container to harbor.nymte.ch
 
 on:
   workflow_dispatch:
-    inputs:
-      gateway_probe_git_ref:
-        type: string
-        description: Which gateway probe git ref to build the image with
 
 env:
   WORKING_DIRECTORY: "nym-node-status-agent"
@@ -36,26 +32,25 @@ jobs:
         with:
           cmd: yq -oy '.package.version' ${{ env.WORKING_DIRECTORY }}/Cargo.toml
 
-      - name: cleanup-gateway-probe-ref
-        id: cleanup_gateway_probe_ref
+      - name: Check if tag exists
         run: |
-          GATEWAY_PROBE_GIT_REF=${{ github.event.inputs.gateway_probe_git_ref }}
-          GIT_REF_SLUG="${GATEWAY_PROBE_GIT_REF//\//-}"
-          echo "git_ref=${GIT_REF_SLUG}" >> $GITHUB_OUTPUT
+          if git rev-parse ${{ steps.get_version.outputs.value }} >/dev/null 2>&1; then
+            echo "Tag ${{ steps.get_version.outputs.value }} already exists"
+          fi
 
       - name: Remove existing tag if exists
         run: |
-          if git rev-parse ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }}-${{ steps.cleanup_gateway_probe_ref.outputs.git_ref }} >/dev/null 2>&1; then
-            git push --delete origin ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }}-${{ steps.cleanup_gateway_probe_ref.outputs.git_ref }}
-            git tag -d ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }}-${{ steps.cleanup_gateway_probe_ref.outputs.git_ref }}
+          if git rev-parse ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }} >/dev/null 2>&1; then
+            git push --delete origin ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }}
+            git tag -d ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }}
           fi
 
       - name: Create tag
         run: |
-          git tag -a ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }}-${{ steps.cleanup_gateway_probe_ref.outputs.git_ref }} -m "Version ${{ steps.get_version.outputs.result }}-${{ steps.cleanup_gateway_probe_ref.outputs.git_ref }}"
-          git push origin ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }}-${{ steps.cleanup_gateway_probe_ref.outputs.git_ref }}
+          git tag -a ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }} -m "Version ${{ steps.get_version.outputs.result }}"
+          git push origin ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }}
 
       - name: BuildAndPushImageOnHarbor
         run: |
-          docker build --build-arg GIT_REF=${{ github.event.inputs.gateway_probe_git_ref }} -f ${{ env.WORKING_DIRECTORY }}/Dockerfile . -t harbor.nymte.ch/nym/${{ env.CONTAINER_NAME }}:${{ steps.get_version.outputs.result }}-${{ steps.cleanup_gateway_probe_ref.outputs.git_ref }}
+          docker build -f ${{ env.WORKING_DIRECTORY }}/Dockerfile . -t harbor.nymte.ch/nym/${{ env.CONTAINER_NAME }}:${{ steps.get_version.outputs.result }} -t harbor.nymte.ch/nym/${{ env.CONTAINER_NAME }}:latest
           docker push harbor.nymte.ch/nym/${{ env.CONTAINER_NAME }} --all-tags

.github/workflows/push-nym-node.yaml

@@ -1,55 +0,0 @@
-name: Build and upload nym node container to harbor.nymte.ch
-on:
-  workflow_dispatch:
-
-env:
-  WORKING_DIRECTORY: "nym-node"
-  CONTAINER_NAME: "nym-node"
-
-jobs:
-  build-container:
-    runs-on: arc-ubuntu-22.04-dind
-    steps:
-      - name: Login to Harbor
-        uses: docker/login-action@v3
-        with:
-          registry: harbor.nymte.ch
-          username: ${{ secrets.HARBOR_ROBOT_USERNAME }}
-          password: ${{ secrets.HARBOR_ROBOT_SECRET }}
-
-      - name: Checkout repo
-        uses: actions/checkout@v4
-
-      - name: Configure git identity
-        run: |
-          git config --global user.email "lawrence@nymtech.net"
-          git config --global user.name "Lawrence Stalder"
-
-      - name: Get version from cargo.toml
-        uses: mikefarah/yq@v4.44.3
-        id: get_version
-        with:
-          cmd: yq -oy '.package.version' ${{ env.WORKING_DIRECTORY }}/Cargo.toml
-
-      - name: Check if tag exists
-        run: |
-          if git rev-parse ${{ steps.get_version.outputs.value }} >/dev/null 2>&1; then
-            echo "Tag ${{ steps.get_version.outputs.value }} already exists"
-          fi
-
-      - name: Remove existing tag if exists
-        run: |
-          if git rev-parse ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }} >/dev/null 2>&1; then
-            git push --delete origin ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }}
-            git tag -d ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }}
-          fi
-
-      - name: Create tag
-        run: |
-          git tag -a ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }} -m "Version ${{ steps.get_version.outputs.result }}"
-          git push origin ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }}
-
-      - name: BuildAndPushImageOnHarbor
-        run: |
-          docker build -f ${{ env.WORKING_DIRECTORY }}/Dockerfile . -t harbor.nymte.ch/nym/${{ env.CONTAINER_NAME }}:${{ steps.get_version.outputs.result }} -t harbor.nymte.ch/nym/${{ env.CONTAINER_NAME }}:latest
-          docker push harbor.nymte.ch/nym/${{ env.CONTAINER_NAME }} --all-tags

.github/workflows/push-validator-rewarder.yaml

@@ -1,49 +0,0 @@
-name: Build and upload Validator Rewarder container to harbor.nymte.ch
-on:
-  workflow_dispatch:
-
-env:
-  WORKING_DIRECTORY: "nym-validator-rewarder"
-  CONTAINER_NAME: "validator-rewarder"
-
-jobs:
-  build-container:
-    runs-on: arc-ubuntu-22.04-dind
-    steps:
-      - name: Login to Harbor
-        uses: docker/login-action@v3
-        with:
-          registry: harbor.nymte.ch
-          username: ${{ secrets.HARBOR_ROBOT_USERNAME }}
-          password: ${{ secrets.HARBOR_ROBOT_SECRET }}
-
-      - name: Checkout repo
-        uses: actions/checkout@v4
-
-      - name: Configure git identity
-        run: |
-          git config --global user.email "lawrence@nymtech.net"
-          git config --global user.name "Lawrence Stalder"
-
-      - name: Get version from cargo.toml
-        uses: mikefarah/yq@v4.44.3
-        id: get_version
-        with:
-          cmd: yq -oy '.package.version' ${{ env.WORKING_DIRECTORY }}/Cargo.toml
-
-      - name: Remove existing tag if exists
-        run: |
-          if git rev-parse ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }} >/dev/null 2>&1; then
-            git push --delete origin ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }}
-            git tag -d ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }}
-          fi
-
-      - name: Create tag
-        run: |
-          git tag -a ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }} -m "Version ${{ steps.get_version.outputs.result }}"
-          git push origin ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }}
-
-      - name: BuildAndPushImageOnHarbor
-        run: |
-          docker build -f ${{ env.WORKING_DIRECTORY }}/Dockerfile . -t harbor.nymte.ch/nym/${{ env.CONTAINER_NAME }}:${{ steps.get_version.outputs.result }} -t harbor.nymte.ch/nym/${{ env.CONTAINER_NAME }}:latest
-          docker push harbor.nymte.ch/nym/${{ env.CONTAINER_NAME }} --all-tags

Cargo.toml

@@ -98,7 +98,6 @@ members = [
     "common/wasm/utils",
     "common/wireguard",
     "common/wireguard-types",
-    # "documentation/autodoc",
     "explorer-api",
     "explorer-api/explorer-api-requests",
     "explorer-api/explorer-client",
@@ -204,7 +203,7 @@ axum-extra = "0.9.4"
 base64 = "0.22.1"
 bincode = "1.3.3"
 bip39 = { version = "2.0.0", features = ["zeroize"] }
-bit-vec = "0.7.0"                                     # can we unify those?
+bit-vec = "0.7.0" # can we unify those?
 bitvec = "1.0.0"
 blake3 = "1.5.4"
 bloomfilter = "1.0.14"
@@ -272,7 +271,7 @@ ipnetwork = "0.20"
 isocountry = "0.3.2"
 itertools = "0.13.0"
 k256 = "0.13"
-lazy_static = "1.5.0"
+lazy_static = "1.4.0"
 ledger-transport = "0.10.0"
 ledger-transport-hid = "0.10.0"
 log = "0.4"

common/authenticator-requests/Cargo.toml

@@ -17,7 +17,6 @@ thiserror = { workspace = true }
 
 nym-credentials-interface = { path = "../credentials-interface" }
 nym-crypto = { path = "../crypto", features = ["asymmetric"] }
-nym-network-defaults = { path = "../network-defaults" }
 nym-service-provider-requests-common = { path = "../service-provider-requests-common" }
 nym-sphinx = { path = "../nymsphinx" }
 nym-wireguard-types = { path = "../wireguard-types" }

common/authenticator-requests/src/lib.rs

@@ -4,14 +4,13 @@
 pub mod v1;
 pub mod v2;
 pub mod v3;
-pub mod v4;
 
 mod error;
 
 pub use error::Error;
-pub use v4 as latest;
+pub use v3 as latest;
 
-pub const CURRENT_VERSION: u8 = 4;
+pub const CURRENT_VERSION: u8 = 3;
 
 fn make_bincode_serializer() -> impl bincode::Options {
     use bincode::Options;

common/authenticator-requests/src/v3/conversion.rs

@@ -9,7 +9,7 @@ impl From<v2::request::AuthenticatorRequest> for v3::request::AuthenticatorReque
     fn from(authenticator_request: v2::request::AuthenticatorRequest) -> Self {
         Self {
             protocol: Protocol {
-                version: 3,
+                version: 2,
                 service_provider_type: ServiceProviderType::Authenticator,
             },
             data: authenticator_request.data.into(),

common/authenticator-requests/src/v4/conversion.rs

@@ -1,200 +0,0 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use nym_service_provider_requests_common::{Protocol, ServiceProviderType};
-
-use crate::{v3, v4};
-
-impl From<v3::request::AuthenticatorRequest> for v4::request::AuthenticatorRequest {
-    fn from(authenticator_request: v3::request::AuthenticatorRequest) -> Self {
-        Self {
-            protocol: Protocol {
-                version: 4,
-                service_provider_type: ServiceProviderType::Authenticator,
-            },
-            data: authenticator_request.data.into(),
-            reply_to: authenticator_request.reply_to,
-            request_id: authenticator_request.request_id,
-        }
-    }
-}
-
-impl From<v3::request::AuthenticatorRequestData> for v4::request::AuthenticatorRequestData {
-    fn from(authenticator_request_data: v3::request::AuthenticatorRequestData) -> Self {
-        match authenticator_request_data {
-            v3::request::AuthenticatorRequestData::Initial(init_msg) => {
-                v4::request::AuthenticatorRequestData::Initial(init_msg.into())
-            }
-            v3::request::AuthenticatorRequestData::Final(gw_client) => {
-                v4::request::AuthenticatorRequestData::Final(gw_client.into())
-            }
-            v3::request::AuthenticatorRequestData::QueryBandwidth(pub_key) => {
-                v4::request::AuthenticatorRequestData::QueryBandwidth(pub_key)
-            }
-            v3::request::AuthenticatorRequestData::TopUpBandwidth(top_up_message) => {
-                v4::request::AuthenticatorRequestData::TopUpBandwidth(top_up_message.into())
-            }
-        }
-    }
-}
-
-impl From<v3::registration::InitMessage> for v4::registration::InitMessage {
-    fn from(init_msg: v3::registration::InitMessage) -> Self {
-        Self {
-            pub_key: init_msg.pub_key,
-        }
-    }
-}
-
-impl From<Box<v3::registration::FinalMessage>> for Box<v4::registration::FinalMessage> {
-    fn from(gw_client: Box<v3::registration::FinalMessage>) -> Self {
-        Box::new(v4::registration::FinalMessage {
-            gateway_client: gw_client.gateway_client.into(),
-            credential: gw_client.credential,
-        })
-    }
-}
-
-impl From<Box<v3::topup::TopUpMessage>> for Box<v4::topup::TopUpMessage> {
-    fn from(top_up_message: Box<v3::topup::TopUpMessage>) -> Self {
-        Box::new(v4::topup::TopUpMessage {
-            pub_key: top_up_message.pub_key,
-            credential: top_up_message.credential,
-        })
-    }
-}
-
-impl From<v3::registration::GatewayClient> for v4::registration::GatewayClient {
-    fn from(gw_client: v3::registration::GatewayClient) -> Self {
-        Self {
-            pub_key: gw_client.pub_key,
-            private_ips: gw_client.private_ip.into(),
-            mac: gw_client.mac.into(),
-        }
-    }
-}
-
-impl From<v4::registration::GatewayClient> for v3::registration::GatewayClient {
-    fn from(gw_client: v4::registration::GatewayClient) -> Self {
-        Self {
-            pub_key: gw_client.pub_key,
-            private_ip: gw_client.private_ips.ipv4.into(),
-            mac: gw_client.mac.into(),
-        }
-    }
-}
-
-impl From<v3::registration::ClientMac> for v4::registration::ClientMac {
-    fn from(mac: v3::registration::ClientMac) -> Self {
-        Self::new(mac.to_vec())
-    }
-}
-
-impl From<v4::registration::ClientMac> for v3::registration::ClientMac {
-    fn from(mac: v4::registration::ClientMac) -> Self {
-        Self::new(mac.to_vec())
-    }
-}
-
-impl TryFrom<v4::response::AuthenticatorResponse> for v3::response::AuthenticatorResponse {
-    type Error = crate::Error;
-
-    fn try_from(
-        authenticator_response: v4::response::AuthenticatorResponse,
-    ) -> Result<Self, Self::Error> {
-        Ok(Self {
-            data: authenticator_response.data.try_into()?,
-            reply_to: authenticator_response.reply_to,
-            protocol: authenticator_response.protocol,
-        })
-    }
-}
-
-impl TryFrom<v4::response::AuthenticatorResponseData> for v3::response::AuthenticatorResponseData {
-    type Error = crate::Error;
-
-    fn try_from(
-        authenticator_response_data: v4::response::AuthenticatorResponseData,
-    ) -> Result<Self, Self::Error> {
-        match authenticator_response_data {
-            v4::response::AuthenticatorResponseData::PendingRegistration(
-                pending_registration_response,
-            ) => Ok(
-                v3::response::AuthenticatorResponseData::PendingRegistration(
-                    pending_registration_response.into(),
-                ),
-            ),
-            v4::response::AuthenticatorResponseData::Registered(registered_response) => Ok(
-                v3::response::AuthenticatorResponseData::Registered(registered_response.into()),
-            ),
-            v4::response::AuthenticatorResponseData::RemainingBandwidth(
-                remaining_bandwidth_response,
-            ) => Ok(v3::response::AuthenticatorResponseData::RemainingBandwidth(
-                remaining_bandwidth_response.into(),
-            )),
-            v4::response::AuthenticatorResponseData::TopUpBandwidth(_) => {
-                Err(Self::Error::Conversion(
-                    "a v3 request couldn't produce a v4 only type of response".to_string(),
-                ))
-            }
-        }
-    }
-}
-
-impl From<v4::response::PendingRegistrationResponse> for v3::response::PendingRegistrationResponse {
-    fn from(value: v4::response::PendingRegistrationResponse) -> Self {
-        Self {
-            request_id: value.request_id,
-            reply_to: value.reply_to,
-            reply: value.reply.into(),
-        }
-    }
-}
-
-impl From<v4::response::RegisteredResponse> for v3::response::RegisteredResponse {
-    fn from(value: v4::response::RegisteredResponse) -> Self {
-        Self {
-            request_id: value.request_id,
-            reply_to: value.reply_to,
-            reply: value.reply.into(),
-        }
-    }
-}
-
-impl From<v4::response::RemainingBandwidthResponse> for v3::response::RemainingBandwidthResponse {
-    fn from(value: v4::response::RemainingBandwidthResponse) -> Self {
-        Self {
-            request_id: value.request_id,
-            reply_to: value.reply_to,
-            reply: value.reply.map(Into::into),
-        }
-    }
-}
-
-impl From<v4::registration::RegistrationData> for v3::registration::RegistrationData {
-    fn from(value: v4::registration::RegistrationData) -> Self {
-        Self {
-            nonce: value.nonce,
-            gateway_data: value.gateway_data.into(),
-            wg_port: value.wg_port,
-        }
-    }
-}
-
-impl From<v4::registration::RegistredData> for v3::registration::RegistredData {
-    fn from(value: v4::registration::RegistredData) -> Self {
-        Self {
-            pub_key: value.pub_key,
-            private_ip: value.private_ips.ipv4.into(),
-            wg_port: value.wg_port,
-        }
-    }
-}
-
-impl From<v4::registration::RemainingBandwidthData> for v3::registration::RemainingBandwidthData {
-    fn from(value: v4::registration::RemainingBandwidthData) -> Self {
-        Self {
-            available_bandwidth: value.available_bandwidth,
-        }
-    }
-}

common/authenticator-requests/src/v4/mod.rs

@@ -1,10 +0,0 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-pub mod conversion;
-pub mod registration;
-pub mod request;
-pub mod response;
-pub mod topup;
-
-pub const VERSION: u8 = 4;

common/authenticator-requests/src/v4/registration.rs

@@ -1,281 +0,0 @@
-// -2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::error::Error;
-use base64::{engine::general_purpose, Engine};
-use nym_credentials_interface::CredentialSpendingData;
-use nym_network_defaults::constants::{WG_TUN_DEVICE_IP_ADDRESS_V4, WG_TUN_DEVICE_IP_ADDRESS_V6};
-use nym_wireguard_types::PeerPublicKey;
-use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
-use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
-use std::time::SystemTime;
-use std::{fmt, ops::Deref, str::FromStr};
-
-#[cfg(feature = "verify")]
-use hmac::{Hmac, Mac};
-#[cfg(feature = "verify")]
-use nym_crypto::asymmetric::encryption::PrivateKey;
-#[cfg(feature = "verify")]
-use sha2::Sha256;
-
-pub type PendingRegistrations = HashMap<PeerPublicKey, RegistrationData>;
-pub type PrivateIPs = HashMap<IpPair, Taken>;
-
-#[cfg(feature = "verify")]
-pub type HmacSha256 = Hmac<Sha256>;
-
-pub type Nonce = u64;
-pub type Taken = Option<SystemTime>;
-
-pub const BANDWIDTH_CAP_PER_DAY: u64 = 1024 * 1024 * 1024; // 1 GB
-
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
-pub struct IpPair {
-    pub ipv4: Ipv4Addr,
-    pub ipv6: Ipv6Addr,
-}
-
-impl IpPair {
-    pub fn new(ipv4: Ipv4Addr, ipv6: Ipv6Addr) -> Self {
-        IpPair { ipv4, ipv6 }
-    }
-}
-
-impl fmt::Display for IpPair {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "({}, {})", self.ipv4, self.ipv6)
-    }
-}
-
-impl From<IpAddr> for IpPair {
-    fn from(value: IpAddr) -> Self {
-        let (before_last_byte, last_byte) = match value {
-            std::net::IpAddr::V4(ipv4_addr) => (ipv4_addr.octets()[2], ipv4_addr.octets()[3]),
-            std::net::IpAddr::V6(ipv6_addr) => (ipv6_addr.octets()[14], ipv6_addr.octets()[15]),
-        };
-        let last_bytes = (before_last_byte as u16) << 8 | last_byte as u16;
-        let ipv4 = Ipv4Addr::new(
-            WG_TUN_DEVICE_IP_ADDRESS_V4.octets()[0],
-            WG_TUN_DEVICE_IP_ADDRESS_V4.octets()[1],
-            before_last_byte,
-            last_byte,
-        );
-        let ipv6 = Ipv6Addr::new(
-            WG_TUN_DEVICE_IP_ADDRESS_V6.segments()[0],
-            WG_TUN_DEVICE_IP_ADDRESS_V6.segments()[1],
-            WG_TUN_DEVICE_IP_ADDRESS_V6.segments()[2],
-            WG_TUN_DEVICE_IP_ADDRESS_V6.segments()[3],
-            WG_TUN_DEVICE_IP_ADDRESS_V6.segments()[4],
-            WG_TUN_DEVICE_IP_ADDRESS_V6.segments()[5],
-            WG_TUN_DEVICE_IP_ADDRESS_V6.segments()[6],
-            last_bytes,
-        );
-        IpPair::new(ipv4, ipv6)
-    }
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct InitMessage {
-    /// Base64 encoded x25519 public key
-    pub pub_key: PeerPublicKey,
-}
-
-impl InitMessage {
-    pub fn new(pub_key: PeerPublicKey) -> Self {
-        InitMessage { pub_key }
-    }
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct FinalMessage {
-    /// Gateway client data
-    pub gateway_client: GatewayClient,
-
-    /// Ecash credential
-    pub credential: Option<CredentialSpendingData>,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct RegistrationData {
-    pub nonce: u64,
-    pub gateway_data: GatewayClient,
-    pub wg_port: u16,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct RegistredData {
-    pub pub_key: PeerPublicKey,
-    pub private_ips: IpPair,
-    pub wg_port: u16,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct RemainingBandwidthData {
-    pub available_bandwidth: i64,
-}
-
-/// Client that wants to register sends its PublicKey bytes mac digest encrypted with a DH shared secret.
-/// Gateway/Nym node can then verify pub_key payload using the same process
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct GatewayClient {
-    /// Base64 encoded x25519 public key
-    pub pub_key: PeerPublicKey,
-
-    /// Assigned private IPs (v4 and v6)
-    pub private_ips: IpPair,
-
-    /// Sha256 hmac on the data (alongside the prior nonce)
-    pub mac: ClientMac,
-}
-
-impl GatewayClient {
-    #[cfg(feature = "verify")]
-    pub fn new(
-        local_secret: &PrivateKey,
-        remote_public: x25519_dalek::PublicKey,
-        private_ips: IpPair,
-        nonce: u64,
-    ) -> Self {
-        // convert from 1.0 x25519-dalek private key into 2.0 x25519-dalek
-        #[allow(clippy::expect_used)]
-        let static_secret = x25519_dalek::StaticSecret::from(local_secret.to_bytes());
-        let local_public: x25519_dalek::PublicKey = (&static_secret).into();
-
-        let dh = static_secret.diffie_hellman(&remote_public);
-
-        // TODO: change that to use our nym_crypto::hmac module instead
-        #[allow(clippy::expect_used)]
-        let mut mac = HmacSha256::new_from_slice(dh.as_bytes())
-            .expect("x25519 shared secret is always 32 bytes long");
-
-        mac.update(local_public.as_bytes());
-        mac.update(private_ips.to_string().as_bytes());
-        mac.update(&nonce.to_le_bytes());
-
-        GatewayClient {
-            pub_key: PeerPublicKey::new(local_public),
-            private_ips,
-            mac: ClientMac(mac.finalize().into_bytes().to_vec()),
-        }
-    }
-
-    // Reusable secret should be gateways Wireguard PK
-    // Client should perform this step when generating its payload, using its own WG PK
-    #[cfg(feature = "verify")]
-    pub fn verify(&self, gateway_key: &PrivateKey, nonce: u64) -> Result<(), Error> {
-        // convert from 1.0 x25519-dalek private key into 2.0 x25519-dalek
-        #[allow(clippy::expect_used)]
-        let static_secret = x25519_dalek::StaticSecret::from(gateway_key.to_bytes());
-
-        let dh = static_secret.diffie_hellman(&self.pub_key);
-
-        // TODO: change that to use our nym_crypto::hmac module instead
-        #[allow(clippy::expect_used)]
-        let mut mac = HmacSha256::new_from_slice(dh.as_bytes())
-            .expect("x25519 shared secret is always 32 bytes long");
-
-        mac.update(self.pub_key.as_bytes());
-        mac.update(self.private_ips.to_string().as_bytes());
-        mac.update(&nonce.to_le_bytes());
-
-        mac.verify_slice(&self.mac)
-            .map_err(|source| Error::FailedClientMacVerification {
-                client: self.pub_key.to_string(),
-                source,
-            })
-    }
-
-    pub fn pub_key(&self) -> PeerPublicKey {
-        self.pub_key
-    }
-}
-
-// TODO: change the inner type into generic array of size HmacSha256::OutputSize
-// TODO2: rely on our internal crypto/hmac
-#[derive(Debug, Clone)]
-pub struct ClientMac(Vec<u8>);
-
-impl fmt::Display for ClientMac {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", general_purpose::STANDARD.encode(&self.0))
-    }
-}
-
-impl ClientMac {
-    #[allow(dead_code)]
-    pub fn new(mac: Vec<u8>) -> Self {
-        ClientMac(mac)
-    }
-}
-
-impl Deref for ClientMac {
-    type Target = Vec<u8>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl FromStr for ClientMac {
-    type Err = Error;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let mac_bytes: Vec<u8> =
-            general_purpose::STANDARD
-                .decode(s)
-                .map_err(|source| Error::MalformedClientMac {
-                    mac: s.to_string(),
-                    source,
-                })?;
-
-        Ok(ClientMac(mac_bytes))
-    }
-}
-
-impl Serialize for ClientMac {
-    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        let encoded_key = general_purpose::STANDARD.encode(self.0.clone());
-        serializer.serialize_str(&encoded_key)
-    }
-}
-
-impl<'de> Deserialize<'de> for ClientMac {
-    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
-        let encoded_key = String::deserialize(deserializer)?;
-        ClientMac::from_str(&encoded_key).map_err(serde::de::Error::custom)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use nym_crypto::asymmetric::encryption;
-
-    #[test]
-    fn create_ip_pair() {
-        let ipv4: IpAddr = Ipv4Addr::from_str("10.1.10.50").unwrap().into();
-        let ipv6: IpAddr = Ipv6Addr::from_str("fc01::0a32").unwrap().into();
-
-        assert_eq!(IpPair::from(ipv4), IpPair::from(ipv6));
-    }
-
-    #[test]
-    #[cfg(feature = "verify")]
-    fn client_request_roundtrip() {
-        let mut rng = rand::thread_rng();
-
-        let gateway_key_pair = encryption::KeyPair::new(&mut rng);
-        let client_key_pair = encryption::KeyPair::new(&mut rng);
-
-        let nonce = 1234567890;
-
-        let client = GatewayClient::new(
-            client_key_pair.private_key(),
-            x25519_dalek::PublicKey::from(gateway_key_pair.public_key().to_bytes()),
-            IpPair::new("10.0.0.42".parse().unwrap(), "fc00::42".parse().unwrap()),
-            nonce,
-        );
-        assert!(client.verify(gateway_key_pair.private_key(), nonce).is_ok())
-    }
-}

common/authenticator-requests/src/v4/request.rs

@@ -1,136 +0,0 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use super::{
-    registration::{FinalMessage, InitMessage},
-    topup::TopUpMessage,
-};
-use nym_service_provider_requests_common::{Protocol, ServiceProviderType};
-use nym_sphinx::addressing::Recipient;
-use nym_wireguard_types::PeerPublicKey;
-use serde::{Deserialize, Serialize};
-
-use crate::make_bincode_serializer;
-
-use super::VERSION;
-
-fn generate_random() -> u64 {
-    use rand::RngCore;
-    let mut rng = rand::rngs::OsRng;
-    rng.next_u64()
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct AuthenticatorRequest {
-    pub protocol: Protocol,
-    pub data: AuthenticatorRequestData,
-    pub reply_to: Recipient,
-    pub request_id: u64,
-}
-
-impl AuthenticatorRequest {
-    pub fn from_reconstructed_message(
-        message: &nym_sphinx::receiver::ReconstructedMessage,
-    ) -> Result<Self, bincode::Error> {
-        use bincode::Options;
-        make_bincode_serializer().deserialize(&message.message)
-    }
-
-    pub fn new_initial_request(init_message: InitMessage, reply_to: Recipient) -> (Self, u64) {
-        let request_id = generate_random();
-        (
-            Self {
-                protocol: Protocol {
-                    service_provider_type: ServiceProviderType::Authenticator,
-                    version: VERSION,
-                },
-                data: AuthenticatorRequestData::Initial(init_message),
-                reply_to,
-                request_id,
-            },
-            request_id,
-        )
-    }
-
-    pub fn new_final_request(final_message: FinalMessage, reply_to: Recipient) -> (Self, u64) {
-        let request_id = generate_random();
-        (
-            Self {
-                protocol: Protocol {
-                    service_provider_type: ServiceProviderType::Authenticator,
-                    version: VERSION,
-                },
-                data: AuthenticatorRequestData::Final(Box::new(final_message)),
-                reply_to,
-                request_id,
-            },
-            request_id,
-        )
-    }
-
-    pub fn new_query_request(peer_public_key: PeerPublicKey, reply_to: Recipient) -> (Self, u64) {
-        let request_id = generate_random();
-        (
-            Self {
-                protocol: Protocol {
-                    service_provider_type: ServiceProviderType::Authenticator,
-                    version: VERSION,
-                },
-                data: AuthenticatorRequestData::QueryBandwidth(peer_public_key),
-                reply_to,
-                request_id,
-            },
-            request_id,
-        )
-    }
-
-    pub fn new_topup_request(top_up_message: TopUpMessage, reply_to: Recipient) -> (Self, u64) {
-        let request_id = generate_random();
-        (
-            Self {
-                protocol: Protocol {
-                    service_provider_type: ServiceProviderType::Authenticator,
-                    version: VERSION,
-                },
-                data: AuthenticatorRequestData::TopUpBandwidth(Box::new(top_up_message)),
-                reply_to,
-                request_id,
-            },
-            request_id,
-        )
-    }
-
-    pub fn to_bytes(&self) -> Result<Vec<u8>, bincode::Error> {
-        use bincode::Options;
-        make_bincode_serializer().serialize(self)
-    }
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub enum AuthenticatorRequestData {
-    Initial(InitMessage),
-    Final(Box<FinalMessage>),
-    QueryBandwidth(PeerPublicKey),
-    TopUpBandwidth(Box<TopUpMessage>),
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::str::FromStr;
-
-    #[test]
-    fn check_first_bytes_protocol() {
-        let version = 4;
-        let data = AuthenticatorRequest {
-            protocol: Protocol { version, service_provider_type: ServiceProviderType::Authenticator },
-            data: AuthenticatorRequestData::Initial(InitMessage::new(
-                PeerPublicKey::from_str("yvNUDpT5l7W/xDhiu6HkqTHDQwbs/B3J5UrLmORl1EQ=").unwrap(),
-            )),
-            reply_to: Recipient::try_from_base58_string("D1rrpsysCGCYXy9saP8y3kmNpGtJZUXN9SvFoUcqAsM9.9Ssso1ea5NfkbMASdiseDSjTN1fSWda5SgEVjdSN4CvV@GJqd3ZxpXWSNxTfx7B1pPtswpetH4LnJdFeLeuY5KUuN").unwrap(),
-            request_id: 1,
-        };
-        let bytes = *data.to_bytes().unwrap().first_chunk::<2>().unwrap();
-        assert_eq!(bytes, [version, ServiceProviderType::Authenticator as u8]);
-    }
-}

common/authenticator-requests/src/v4/response.rs

@@ -1,157 +0,0 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use super::registration::{RegistrationData, RegistredData, RemainingBandwidthData};
-use nym_service_provider_requests_common::{Protocol, ServiceProviderType};
-use nym_sphinx::addressing::Recipient;
-use serde::{Deserialize, Serialize};
-
-use crate::make_bincode_serializer;
-
-use super::VERSION;
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct AuthenticatorResponse {
-    pub protocol: Protocol,
-    pub data: AuthenticatorResponseData,
-    pub reply_to: Recipient,
-}
-
-impl AuthenticatorResponse {
-    pub fn new_pending_registration_success(
-        registration_data: RegistrationData,
-        request_id: u64,
-        reply_to: Recipient,
-    ) -> Self {
-        Self {
-            protocol: Protocol {
-                service_provider_type: ServiceProviderType::Authenticator,
-                version: VERSION,
-            },
-            data: AuthenticatorResponseData::PendingRegistration(PendingRegistrationResponse {
-                reply: registration_data,
-                reply_to,
-                request_id,
-            }),
-            reply_to,
-        }
-    }
-
-    pub fn new_registered(
-        registred_data: RegistredData,
-        reply_to: Recipient,
-        request_id: u64,
-    ) -> Self {
-        Self {
-            protocol: Protocol {
-                service_provider_type: ServiceProviderType::Authenticator,
-                version: VERSION,
-            },
-            data: AuthenticatorResponseData::Registered(RegisteredResponse {
-                reply: registred_data,
-                reply_to,
-                request_id,
-            }),
-            reply_to,
-        }
-    }
-
-    pub fn new_remaining_bandwidth(
-        remaining_bandwidth_data: Option<RemainingBandwidthData>,
-        reply_to: Recipient,
-        request_id: u64,
-    ) -> Self {
-        Self {
-            protocol: Protocol {
-                service_provider_type: ServiceProviderType::Authenticator,
-                version: VERSION,
-            },
-            data: AuthenticatorResponseData::RemainingBandwidth(RemainingBandwidthResponse {
-                reply: remaining_bandwidth_data,
-                reply_to,
-                request_id,
-            }),
-            reply_to,
-        }
-    }
-
-    pub fn new_topup_bandwidth(
-        remaining_bandwidth_data: RemainingBandwidthData,
-        reply_to: Recipient,
-        request_id: u64,
-    ) -> Self {
-        Self {
-            protocol: Protocol {
-                service_provider_type: ServiceProviderType::Authenticator,
-                version: VERSION,
-            },
-            data: AuthenticatorResponseData::TopUpBandwidth(TopUpBandwidthResponse {
-                reply: remaining_bandwidth_data,
-                reply_to,
-                request_id,
-            }),
-            reply_to,
-        }
-    }
-
-    pub fn recipient(&self) -> Recipient {
-        self.reply_to
-    }
-
-    pub fn to_bytes(&self) -> Result<Vec<u8>, bincode::Error> {
-        use bincode::Options;
-        make_bincode_serializer().serialize(self)
-    }
-
-    pub fn from_reconstructed_message(
-        message: &nym_sphinx::receiver::ReconstructedMessage,
-    ) -> Result<Self, bincode::Error> {
-        use bincode::Options;
-        make_bincode_serializer().deserialize(&message.message)
-    }
-
-    pub fn id(&self) -> Option<u64> {
-        match &self.data {
-            AuthenticatorResponseData::PendingRegistration(response) => Some(response.request_id),
-            AuthenticatorResponseData::Registered(response) => Some(response.request_id),
-            AuthenticatorResponseData::RemainingBandwidth(response) => Some(response.request_id),
-            AuthenticatorResponseData::TopUpBandwidth(response) => Some(response.request_id),
-        }
-    }
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub enum AuthenticatorResponseData {
-    PendingRegistration(PendingRegistrationResponse),
-    Registered(RegisteredResponse),
-    RemainingBandwidth(RemainingBandwidthResponse),
-    TopUpBandwidth(TopUpBandwidthResponse),
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct PendingRegistrationResponse {
-    pub request_id: u64,
-    pub reply_to: Recipient,
-    pub reply: RegistrationData,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct RegisteredResponse {
-    pub request_id: u64,
-    pub reply_to: Recipient,
-    pub reply: RegistredData,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct RemainingBandwidthResponse {
-    pub request_id: u64,
-    pub reply_to: Recipient,
-    pub reply: Option<RemainingBandwidthData>,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct TopUpBandwidthResponse {
-    pub request_id: u64,
-    pub reply_to: Recipient,
-    pub reply: RemainingBandwidthData,
-}

common/authenticator-requests/src/v4/topup.rs

@@ -1,15 +0,0 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use nym_credentials_interface::CredentialSpendingData;
-use nym_wireguard_types::PeerPublicKey;
-use serde::{Deserialize, Serialize};
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct TopUpMessage {
-    /// Base64 encoded x25519 public key
-    pub pub_key: PeerPublicKey,
-
-    /// Ecash credential
-    pub credential: CredentialSpendingData,
-}

common/bandwidth-controller/Cargo.toml

@@ -14,15 +14,14 @@ thiserror = { workspace = true }
 url = { workspace = true }
 zeroize = { workspace = true }
 
+nym-ecash-time = { path = "../ecash-time" }
 nym-credential-storage = { path = "../credential-storage" }
 nym-credentials = { path = "../credentials" }
 nym-credentials-interface = { path = "../credentials-interface" }
 nym-crypto = { path = "../crypto", features = ["rand", "asymmetric", "stream_cipher", "aes", "hashing"] }
-nym-ecash-contract-common = { path = "../cosmwasm-smart-contracts/ecash-contract" }
-nym-ecash-time = { path = "../ecash-time" }
 nym-network-defaults = { path = "../network-defaults" }
-nym-task = { path = "../task" }
 nym-validator-client = { path = "../client-libs/validator-client", default-features = false }
+nym-ecash-contract-common = { path = "../cosmwasm-smart-contracts/ecash-contract" }
 
 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.nym-validator-client]
 path = "../client-libs/validator-client"

common/bandwidth-controller/src/event.rs

@@ -1,25 +1,13 @@
 // Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-#[derive(Debug)]
+// See other comments for other TaskStatus message enumds about abusing the Error trait when we
+// should have a new trait for TaskStatus messages
+#[derive(Debug, thiserror::Error)]
 pub enum BandwidthStatusMessage {
+    #[error("remaining bandwidth: {0}")]
     RemainingBandwidth(i64),
+
+    #[error("no bandwidth left")]
     NoBandwidth,
 }
-
-impl std::fmt::Display for BandwidthStatusMessage {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            BandwidthStatusMessage::RemainingBandwidth(b) => {
-                write!(f, "remaining bandwidth: {}", b)
-            }
-            BandwidthStatusMessage::NoBandwidth => write!(f, "no bandwidth left"),
-        }
-    }
-}
-
-impl nym_task::TaskStatusEvent for BandwidthStatusMessage {
-    fn as_any(&self) -> &dyn std::any::Any {
-        self
-    }
-}

common/client-core/Cargo.toml

@@ -43,7 +43,6 @@ nym-gateway-requests = { path = "../gateway-requests" }
 nym-metrics = { path = "../nym-metrics" }
 nym-nonexhaustive-delayqueue = { path = "../nonexhaustive-delayqueue" }
 nym-sphinx = { path = "../nymsphinx" }
-nym-statistics-common = { path = "../statistics" }
 nym-pemstore = { path = "../pemstore" }
 nym-topology = { path = "../topology", features = ["serializable"] }
 nym-validator-client = { path = "../client-libs/validator-client", default-features = false }

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

@@ -1,8 +1,8 @@
 // Copyright 2022-2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
+use super::packet_statistics_control::PacketStatisticsReporter;
 use super::received_buffer::ReceivedBufferMessage;
-use super::statistics_control::StatisticsControl;
 use super::topology_control::geo_aware_provider::GeoAwareTopologyProvider;
 use crate::client::base_client::storage::helpers::store_client_keys;
 use crate::client::base_client::storage::MixnetClientStorage;
@@ -12,6 +12,7 @@ use crate::client::key_manager::persistence::KeyStore;
 use crate::client::key_manager::ClientKeys;
 use crate::client::mix_traffic::transceiver::{GatewayReceiver, GatewayTransceiver, RemoteGateway};
 use crate::client::mix_traffic::{BatchMixMessageSender, MixTrafficController};
+use crate::client::packet_statistics_control::PacketStatisticsControl;
 use crate::client::real_messages_control;
 use crate::client::real_messages_control::RealMessagesController;
 use crate::client::received_buffer::{
@@ -48,20 +49,16 @@ use nym_sphinx::addressing::clients::Recipient;
 use nym_sphinx::addressing::nodes::NodeIdentity;
 use nym_sphinx::params::PacketType;
 use nym_sphinx::receiver::{ReconstructedMessage, SphinxMessageReceiver};
-use nym_statistics_common::clients::ClientStatsSender;
-use nym_statistics_common::StatsReportingConfig;
 use nym_task::connections::{ConnectionCommandReceiver, ConnectionCommandSender, LaneQueueLengths};
 use nym_task::{TaskClient, TaskHandle};
 use nym_topology::provider_trait::TopologyProvider;
 use nym_topology::HardcodedTopologyProvider;
 use nym_validator_client::{nyxd::contract_traits::DkgQueryClient, UserAgent};
 use rand::rngs::OsRng;
-use sha2::Digest;
 use std::fmt::Debug;
 use std::os::raw::c_int as RawFd;
 use std::path::Path;
 use std::sync::Arc;
-use tokio::sync::mpsc::Sender;
 use url::Url;
 
 #[cfg(all(
@@ -187,7 +184,6 @@ pub struct BaseClientBuilder<'a, C, S: MixnetClientStorage> {
     custom_gateway_transceiver: Option<Box<dyn GatewayTransceiver + Send>>,
     shutdown: Option<TaskClient>,
     user_agent: Option<UserAgent>,
-    stats_reporting_config: Option<StatsReportingConfig>,
 
     setup_method: GatewaySetup,
 }
@@ -211,7 +207,6 @@ where
             custom_gateway_transceiver: None,
             shutdown: None,
             user_agent: None,
-            stats_reporting_config: None,
             setup_method: GatewaySetup::MustLoad { gateway_id: None },
         }
     }
@@ -255,12 +250,6 @@ where
         self
     }
 
-    #[must_use]
-    pub fn with_statistics_reporting(mut self, config: StatsReportingConfig) -> Self {
-        self.stats_reporting_config = Some(config);
-        self
-    }
-
     pub fn with_stored_topology<P: AsRef<Path>>(
         mut self,
         file: P,
@@ -284,7 +273,7 @@ where
         self_address: Recipient,
         topology_accessor: TopologyAccessor,
         mix_tx: BatchMixMessageSender,
-        stats_tx: ClientStatsSender,
+        stats_tx: PacketStatisticsReporter,
         shutdown: TaskClient,
     ) {
         info!("Starting loop cover traffic stream...");
@@ -317,7 +306,7 @@ where
         client_connection_rx: ConnectionCommandReceiver,
         shutdown: TaskClient,
         packet_type: PacketType,
-        stats_tx: ClientStatsSender,
+        stats_tx: PacketStatisticsReporter,
     ) {
         info!("Starting real traffic stream...");
 
@@ -346,7 +335,7 @@ where
         reply_key_storage: SentReplyKeys,
         reply_controller_sender: ReplyControllerSender,
         shutdown: TaskClient,
-        metrics_reporter: ClientStatsSender,
+        packet_statistics_control: PacketStatisticsReporter,
     ) {
         info!("Starting received messages buffer controller...");
         let controller: ReceivedMessagesBufferController<SphinxMessageReceiver> =
@@ -356,7 +345,7 @@ where
                 mixnet_receiver,
                 reply_key_storage,
                 reply_controller_sender,
-                metrics_reporter,
+                packet_statistics_control,
             );
         controller.start_with_shutdown(shutdown)
     }
@@ -597,19 +586,11 @@ where
         Ok(())
     }
 
-    fn start_statistics_control(
-        stats_reporting_config: Option<StatsReportingConfig>,
-        client_stats_id: String,
-        input_sender: Sender<InputMessage>,
-        shutdown: TaskClient,
-    ) -> ClientStatsSender {
-        info!("Starting statistics control...");
-        StatisticsControl::create_and_start_with_shutdown(
-            stats_reporting_config,
-            client_stats_id,
-            input_sender.clone(),
-            shutdown.with_suffix("controller"),
-        )
+    fn start_packet_statistics_control(shutdown: TaskClient) -> PacketStatisticsReporter {
+        info!("Starting packet statistics control...");
+        let (packet_statistics_control, packet_stats_reporter) = PacketStatisticsControl::new();
+        packet_statistics_control.start_with_shutdown(shutdown);
+        packet_stats_reporter
     }
 
     fn start_mix_traffic_controller(
@@ -739,17 +720,6 @@ where
             self.user_agent.clone(),
         );
 
-        let client_stats_id = format!(
-            "{:x}",
-            sha2::Sha256::digest(self_address.identity().to_bytes())
-        );
-        let stats_reporter = Self::start_statistics_control(
-            self.stats_reporting_config,
-            client_stats_id,
-            input_sender.clone(),
-            shutdown.fork("statistics_control"),
-        );
-
         // needs to be started as the first thing to block if required waiting for the gateway
         Self::start_topology_refresher(
             topology_provider,
@@ -761,6 +731,9 @@ where
         )
         .await?;
 
+        let packet_stats_reporter =
+            Self::start_packet_statistics_control(shutdown.fork("packet_statistics_control"));
+
         let gateway_packet_router = PacketRouter::new(
             ack_sender,
             mixnet_messages_sender,
@@ -792,7 +765,7 @@ where
             reply_storage.key_storage(),
             reply_controller_sender.clone(),
             shutdown.fork("received_messages_buffer"),
-            stats_reporter.clone(),
+            packet_stats_reporter.clone(),
         );
 
         // The message_sender is the transmitter for any component generating sphinx packets
@@ -831,7 +804,7 @@ where
             client_connection_rx,
             shutdown.fork("real_traffic_controller"),
             self.config.debug.traffic.packet_type,
-            stats_reporter.clone(),
+            packet_stats_reporter.clone(),
         );
 
         if !self
@@ -846,7 +819,7 @@ where
                 self_address,
                 shared_topology_accessor.clone(),
                 message_sender,
-                stats_reporter.clone(),
+                packet_stats_reporter,
                 shutdown.fork("cover_traffic_stream"),
             );
         }
@@ -874,7 +847,6 @@ where
                 topology_accessor: shared_topology_accessor,
                 gateway_connection: GatewayConnection { gateway_ws_fd },
             },
-            stats_reporter,
             task_handle: shutdown,
         })
     }
@@ -886,7 +858,6 @@ pub struct BaseClient {
     pub client_input: ClientInputStatus,
     pub client_output: ClientOutputStatus,
     pub client_state: ClientState,
-    pub stats_reporter: ClientStatsSender,
 
     pub task_handle: TaskHandle,
 }

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

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::client::mix_traffic::BatchMixMessageSender;
+use crate::client::packet_statistics_control::{PacketStatisticsEvent, PacketStatisticsReporter};
 use crate::client::topology_control::TopologyAccessor;
 use crate::{config, spawn_future};
 use futures::task::{Context, Poll};
@@ -12,7 +13,6 @@ use nym_sphinx::addressing::clients::Recipient;
 use nym_sphinx::cover::generate_loop_cover_packet;
 use nym_sphinx::params::{PacketSize, PacketType};
 use nym_sphinx::utils::sample_poisson_duration;
-use nym_statistics_common::clients::{packet_statistics::PacketStatisticsEvent, ClientStatsSender};
 use rand::{rngs::OsRng, CryptoRng, Rng};
 use std::pin::Pin;
 use std::sync::Arc;
@@ -63,7 +63,7 @@ where
 
     packet_type: PacketType,
 
-    stats_tx: ClientStatsSender,
+    stats_tx: PacketStatisticsReporter,
 }
 
 impl<R> Stream for LoopCoverTrafficStream<R>
@@ -109,7 +109,7 @@ impl LoopCoverTrafficStream<OsRng> {
         topology_access: TopologyAccessor,
         traffic_config: config::Traffic,
         cover_config: config::CoverTraffic,
-        stats_tx: ClientStatsSender,
+        stats_tx: PacketStatisticsReporter,
     ) -> Self {
         let rng = OsRng;
 
@@ -198,9 +198,9 @@ impl LoopCoverTrafficStream<OsRng> {
                 }
             }
         } else {
-            self.stats_tx.report(
-                PacketStatisticsEvent::CoverPacketSent(cover_traffic_packet_size.size()).into(),
-            );
+            self.stats_tx.report(PacketStatisticsEvent::CoverPacketSent(
+                cover_traffic_packet_size.size(),
+            ));
         }
 
         // TODO: I'm not entirely sure whether this is really required, because I'm not 100%

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

@@ -7,9 +7,9 @@ pub(crate) mod helpers;
 pub mod inbound_messages;
 pub mod key_manager;
 pub mod mix_traffic;
+pub(crate) mod packet_statistics_control;
 pub mod real_messages_control;
 pub mod received_buffer;
 pub mod replies;
-pub mod statistics_control;
 pub mod topology_control;
 pub(crate) mod transmission_buffer;

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

@@ -1,25 +1,48 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use super::ClientStatsEvents;
-use core::fmt;
 use std::{
     collections::VecDeque,
     time::{Duration, Instant},
 };
 
 use nym_metrics::{inc, inc_by};
-use serde::{Deserialize, Serialize};
 use si_scale::helpers::bibytes2;
 
+// Metrics server
+use futures::future::{FusedFuture, OptionFuture};
+use futures::FutureExt;
+#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
+use http_body_util::Full;
+#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
+use hyper::body::Bytes;
+#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
+use hyper::server::conn::http1;
+#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
+use hyper::service::service_fn;
+#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
+use hyper::{Request, Response};
+#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
+use hyper_util::rt::TokioIo;
+#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
+use std::convert::Infallible;
+#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
+#[cfg(feature = "metrics-server")]
+use std::net::SocketAddr;
+#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
+use tokio::net::TcpListener;
+
+use crate::spawn_future;
+
+// Time interval between reporting packet statistics
+const PACKET_REPORT_INTERVAL_SECS: u64 = 2;
+// Interval for taking snapshots of the packet statistics
+const SNAPSHOT_INTERVAL_MS: u64 = 500;
 // When computing rates, we include snapshots that are up to this old. We set it to some odd number
 // a tad larger than an integer number of snapshot intervals, so that we don't have to worry about
 // threshold effects.
 // Also, set it larger than the packet report interval so that we don't miss notable singular events
 const RECORDING_WINDOW_MS: u64 = 2300;
 
-#[derive(Default, Debug, Clone, Serialize, Deserialize)]
-pub(crate) struct PacketStatistics {
+#[derive(Default, Debug, Clone)]
+struct PacketStatistics {
     // Sent
     real_packets_sent: u64,
     real_packets_sent_size: usize,
@@ -49,7 +72,7 @@ pub(crate) struct PacketStatistics {
 }
 
 impl PacketStatistics {
-    fn handle(&mut self, event: PacketStatisticsEvent) {
+    fn handle_event(&mut self, event: PacketStatisticsEvent) {
         match event {
             PacketStatisticsEvent::RealPacketSent(packet_size) => {
                 self.real_packets_sent += 1;
@@ -166,64 +189,29 @@ impl std::ops::Sub for PacketStatistics {
     }
 }
 
-pub struct MixnetBandwidthStatisticsEvent {
-    pub rates: PacketRates,
-}
-
-impl MixnetBandwidthStatisticsEvent {
-    pub fn new(rates: PacketRates) -> Self {
-        Self { rates }
-    }
-}
-
-impl nym_task::TaskStatusEvent for MixnetBandwidthStatisticsEvent {
-    fn as_any(&self) -> &dyn std::any::Any {
-        self
-    }
-}
-
-impl fmt::Display for MixnetBandwidthStatisticsEvent {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self.rates.summary())
-    }
-}
-
 #[derive(Debug, Clone)]
-pub struct PacketRates {
-    pub real_packets_sent: f64,
-    pub real_packets_sent_size: f64,
-    pub cover_packets_sent: f64,
-    pub cover_packets_sent_size: f64,
+struct PacketRates {
+    real_packets_sent: f64,
+    real_packets_sent_size: f64,
+    cover_packets_sent: f64,
+    cover_packets_sent_size: f64,
 
-    pub real_packets_received: f64,
-    pub real_packets_received_size: f64,
-    pub cover_packets_received: f64,
-    pub cover_packets_received_size: f64,
+    real_packets_received: f64,
+    real_packets_received_size: f64,
+    cover_packets_received: f64,
+    cover_packets_received_size: f64,
 
-    pub total_acks_received: f64,
-    pub total_acks_received_size: f64,
-    pub real_acks_received: f64,
-    pub real_acks_received_size: f64,
-    pub cover_acks_received: f64,
-    pub cover_acks_received_size: f64,
+    total_acks_received: f64,
+    total_acks_received_size: f64,
+    real_acks_received: f64,
+    real_acks_received_size: f64,
+    cover_acks_received: f64,
+    cover_acks_received_size: f64,
 
-    pub real_packets_queued: f64,
-    pub retransmissions_queued: f64,
-    pub reply_surbs_queued: f64,
-    pub additional_reply_surbs_queued: f64,
-}
-
-impl fmt::Display for PacketRates {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(
-            f,
-            "down: {}/s, up: {}/s (cover down: {}/s, cover up: {}/s)",
-            bibytes2(self.real_packets_received_size),
-            bibytes2(self.real_packets_sent_size),
-            bibytes2(self.cover_packets_received_size),
-            bibytes2(self.cover_packets_sent_size),
-        )
-    }
+    real_packets_queued: f64,
+    retransmissions_queued: f64,
+    reply_surbs_queued: f64,
+    additional_reply_surbs_queued: f64,
 }
 
 impl From<PacketStatistics> for PacketRates {
@@ -342,46 +330,56 @@ impl PacketRates {
     }
 }
 
-/// Event Space used for counting the Packet types used in a connection.
 #[derive(Debug)]
-pub enum PacketStatisticsEvent {
-    /// The real packets sent. Recall that acks are sent by the gateway, so it's not included here.
+pub(crate) enum PacketStatisticsEvent {
+    // The real packets sent. Recall that acks are sent by the gateway, so it's not included here.
     RealPacketSent(usize),
-    /// The cover packets sent
+    // The cover packets sent
     CoverPacketSent(usize),
 
-    /// Real packets received
+    // Real packets received
     RealPacketReceived(usize),
-    /// Cover packets received
+    // Cover packets received
     CoverPacketReceived(usize),
 
-    /// Ack of any type received. This is mostly used as a consistency check, and should be the sum
-    /// of real and cover acks received.
+    // Ack of any type received. This is mostly used as a consistency check, and should be the sum
+    // of real and cover acks received.
     AckReceived(usize),
-    /// Out of the total acks received, this is the subset of those that were real
+    // Out of the total acks received, this is the subset of those that were real
     RealAckReceived(usize),
-    /// Out of the total acks received, this is the subset of those that were for cover traffic
+    // Out of the total acks received, this is the subset of those that were for cover traffic
     CoverAckReceived(usize),
 
-    /// Types of packets queued
+    // Types of packets queued
     RealPacketQueued,
-    /// Types of packets queued
     RetransmissionQueued,
-    /// Types of packets queued
     ReplySurbRequestQueued,
-    /// Types of packets queued
     AdditionalReplySurbRequestQueued,
 }
 
-impl From<PacketStatisticsEvent> for ClientStatsEvents {
-    fn from(event: PacketStatisticsEvent) -> ClientStatsEvents {
-        ClientStatsEvents::PacketStatistics(event)
+type PacketStatisticsReceiver = tokio::sync::mpsc::UnboundedReceiver<PacketStatisticsEvent>;
+
+#[derive(Clone)]
+pub(crate) struct PacketStatisticsReporter {
+    stats_tx: tokio::sync::mpsc::UnboundedSender<PacketStatisticsEvent>,
+}
+
+impl PacketStatisticsReporter {
+    pub(crate) fn new(stats_tx: tokio::sync::mpsc::UnboundedSender<PacketStatisticsEvent>) -> Self {
+        Self { stats_tx }
+    }
+
+    pub(crate) fn report(&self, event: PacketStatisticsEvent) {
+        self.stats_tx.send(event).unwrap_or_else(|err| {
+            log::error!("Failed to report packet stat: {:?}", err);
+        });
     }
 }
 
-/// Statistics tracking for Packet based I/O
-#[derive(Default)]
-pub struct PacketStatisticsControl {
+pub(crate) struct PacketStatisticsControl {
+    // Incoming packet stats events from other tasks
+    stats_rx: PacketStatisticsReceiver,
+
     // Keep track of packet statistics over time
     stats: PacketStatistics,
 
@@ -394,28 +392,18 @@ pub struct PacketStatisticsControl {
 }
 
 impl PacketStatisticsControl {
-    pub(crate) fn handle_event(&mut self, event: PacketStatisticsEvent) {
-        self.stats.handle(event)
-    }
+    pub(crate) fn new() -> (Self, PacketStatisticsReporter) {
+        let (stats_tx, stats_rx) = tokio::sync::mpsc::unbounded_channel();
 
-    pub(crate) fn snapshot(&mut self) {
-        self.update_history();
-        self.update_rates();
-    }
-
-    pub(crate) fn report(&self) -> PacketStatistics {
-        self.stats.clone()
-    }
-
-    pub(crate) fn local_report(&mut self, task_client: &mut nym_task::TaskClient) {
-        let rates = self.report_rates();
-        self.check_for_notable_events();
-        self.report_counters();
-
-        // Report our current bandwidth used to e.g a GUI client
-        if let Some(rates) = rates {
-            task_client.send_status_msg(Box::new(MixnetBandwidthStatisticsEvent::new(rates)));
-        }
+        (
+            Self {
+                stats_rx,
+                stats: PacketStatistics::default(),
+                history: VecDeque::new(),
+                rates: VecDeque::new(),
+            },
+            PacketStatisticsReporter::new(stats_tx),
+        )
     }
 
     // Add the current stats to the history, and remove old ones.
@@ -468,13 +456,11 @@ impl PacketStatisticsControl {
         }
     }
 
-    fn report_rates(&self) -> Option<PacketRates> {
+    fn report_rates(&self) {
         if let Some((_, rates)) = self.rates.back() {
             log::debug!("{}", rates.summary());
             log::debug!("{}", rates.detailed_summary());
-            return Some(rates.clone());
         }
-        None
     }
 
     fn report_counters(&self) {
@@ -512,4 +498,124 @@ impl PacketStatisticsControl {
 
         // IDEA: if there is a burst of acks, that could indicate tokio task starvation.
     }
+
+    pub(crate) async fn run_with_shutdown(&mut self, mut shutdown: nym_task::TaskClient) {
+        log::debug!("Started PacketStatisticsControl with graceful shutdown support");
+
+        let report_interval = Duration::from_secs(PACKET_REPORT_INTERVAL_SECS);
+        let mut report_interval = tokio::time::interval(report_interval);
+        let snapshot_interval = Duration::from_millis(SNAPSHOT_INTERVAL_MS);
+        let mut snapshot_interval = tokio::time::interval(snapshot_interval);
+
+        cfg_if::cfg_if! {
+            if #[cfg(all(target_arch = "wasm32", target_os = "unknown"))] {
+                log::warn!("Metrics server is not supported on wasm32-unknown-unknown");
+                let listener: Option<WasmEmpty> = None;
+            } else if #[cfg(feature = "metrics-server")] {
+                let mut metrics_port = 18000;
+                let listener: Option<TcpListener>;
+                loop {
+                    let addr = SocketAddr::from(([0, 0, 0, 0], metrics_port));
+                    match TcpListener::bind(addr).await {
+                        Ok(l) => {
+                            log::info!("###############################");
+                            log::info!("Metrics endpoint is at: {:?}", l.local_addr());
+                            log::info!("###############################");
+                            listener = Some(l);
+                            break;
+                        },
+                        Err(err) => {
+                            log::warn!("Failed to bind metrics server: {:?}", err);
+                            metrics_port += 1;
+                        }
+                    };
+                }
+            } else {
+                log::info!("Metrics server is disabled!");
+                let listener: Option<TcpListener> = None;
+            }
+        }
+
+        loop {
+            // it seems at some point tokio changed its select precondition evaluation,
+            // and it's no longer checked before the future is evaluated.
+            let accept_future: OptionFuture<_> = listener
+                .as_ref()
+                .map(|l| l.accept())
+                .map(FutureExt::fuse)
+                .into();
+
+            tokio::select! {
+                stats_event = self.stats_rx.recv() => match stats_event {
+                    Some(stats_event) => {
+                        log::trace!("PacketStatisticsControl: Received stats event");
+                        self.stats.handle_event(stats_event);
+                    },
+                    None => {
+                        log::trace!("PacketStatisticsControl: stopping since stats channel was closed");
+                        break;
+                    }
+                },
+                // conditional will disable the branch if we're in wasm32-unknown-unknown
+                // use `_` to calm down clippy when running for wasm
+                _result = accept_future, if !accept_future.is_terminated() => {
+                    cfg_if::cfg_if! {
+                        if #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))] {
+                            if let Some(Ok((stream, _))) = _result {
+                                let io = TokioIo::new(stream);
+
+                                tokio::task::spawn(async move {
+                                    if let Err(err) = http1::Builder::new()
+                                        .serve_connection(io, service_fn(serve_metrics))
+                                        .await
+                                    {
+                                        log::warn!("Error serving connection: {:?}", err);
+                                    }
+                                });
+                            } else {
+                                log::warn!("Error accepting connection");
+                            }
+                        }
+                    }
+                }
+                _ = snapshot_interval.tick() => {
+                    self.update_history();
+                    self.update_rates();
+                }
+                _ = report_interval.tick() => {
+                    self.report_rates();
+                    self.check_for_notable_events();
+                    self.report_counters();
+                }
+                _ = shutdown.recv_with_delay() => {
+                    log::trace!("PacketStatisticsControl: Received shutdown");
+                    break;
+                },
+            }
+        }
+        log::debug!("PacketStatisticsControl: Exiting");
+    }
+
+    pub(crate) fn start_with_shutdown(mut self, task_client: nym_task::TaskClient) {
+        spawn_future(async move {
+            self.run_with_shutdown(task_client).await;
+        })
+    }
+}
+
+#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
+async fn serve_metrics(
+    _: Request<hyper::body::Incoming>,
+) -> Result<Response<Full<Bytes>>, Infallible> {
+    use nym_metrics::metrics;
+
+    Ok(Response::new(Full::new(Bytes::from(metrics!()))))
+}
+
+#[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
+struct WasmEmpty;
+
+#[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
+impl WasmEmpty {
+    async fn accept(&self) {}
 }

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

@@ -1,9 +1,9 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use super::action_controller::{AckActionSender, Action};
-use nym_statistics_common::clients::{packet_statistics::PacketStatisticsEvent, ClientStatsSender};
+use crate::client::packet_statistics_control::{PacketStatisticsEvent, PacketStatisticsReporter};
 
+use super::action_controller::{AckActionSender, Action};
 use futures::StreamExt;
 use log::*;
 use nym_gateway_client::AcknowledgementReceiver;
@@ -19,7 +19,7 @@ pub(super) struct AcknowledgementListener {
     ack_key: Arc<AckKey>,
     ack_receiver: AcknowledgementReceiver,
     action_sender: AckActionSender,
-    stats_tx: ClientStatsSender,
+    stats_tx: PacketStatisticsReporter,
 }
 
 impl AcknowledgementListener {
@@ -27,7 +27,7 @@ impl AcknowledgementListener {
         ack_key: Arc<AckKey>,
         ack_receiver: AcknowledgementReceiver,
         action_sender: AckActionSender,
-        stats_tx: ClientStatsSender,
+        stats_tx: PacketStatisticsReporter,
     ) -> Self {
         AcknowledgementListener {
             ack_key,
@@ -40,7 +40,7 @@ impl AcknowledgementListener {
     async fn on_ack(&mut self, ack_content: Vec<u8>) {
         trace!("Received an ack");
         self.stats_tx
-            .report(PacketStatisticsEvent::AckReceived(ack_content.len()).into());
+            .report(PacketStatisticsEvent::AckReceived(ack_content.len()));
 
         let frag_id = match recover_identifier(&self.ack_key, &ack_content)
             .map(FragmentIdentifier::try_from_bytes)
@@ -57,13 +57,13 @@ impl AcknowledgementListener {
         if frag_id == COVER_FRAG_ID {
             trace!("Received an ack for a cover message - no need to do anything");
             self.stats_tx
-                .report(PacketStatisticsEvent::CoverAckReceived(ack_content.len()).into());
+                .report(PacketStatisticsEvent::CoverAckReceived(ack_content.len()));
             return;
         }
 
         trace!("Received {} from the mix network", frag_id);
         self.stats_tx
-            .report(PacketStatisticsEvent::RealAckReceived(ack_content.len()).into());
+            .report(PacketStatisticsEvent::RealAckReceived(ack_content.len()));
         self.action_sender
             .unbounded_send(Action::new_remove(frag_id))
             .unwrap();

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

@@ -8,6 +8,7 @@ use self::{
     sent_notification_listener::SentNotificationListener,
 };
 use crate::client::inbound_messages::InputMessageReceiver;
+use crate::client::packet_statistics_control::PacketStatisticsReporter;
 use crate::client::real_messages_control::message_handler::MessageHandler;
 use crate::client::replies::reply_controller::ReplyControllerSender;
 use crate::spawn_future;
@@ -23,7 +24,6 @@ use nym_sphinx::{
     chunking::fragment::{Fragment, FragmentIdentifier},
     Delay as SphinxDelay,
 };
-use nym_statistics_common::clients::ClientStatsSender;
 use rand::{CryptoRng, Rng};
 use std::{
     sync::{Arc, Weak},
@@ -209,7 +209,7 @@ where
         connectors: AcknowledgementControllerConnectors,
         message_handler: MessageHandler<R>,
         reply_controller_sender: ReplyControllerSender,
-        stats_tx: ClientStatsSender,
+        stats_tx: PacketStatisticsReporter,
     ) -> Self {
         let (retransmission_tx, retransmission_rx) = mpsc::unbounded();
 

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

@@ -35,7 +35,7 @@ use crate::client::replies::reply_controller;
 use crate::config;
 pub(crate) use acknowledgement_control::{AckActionSender, Action};
 
-use nym_statistics_common::clients::ClientStatsSender;
+use super::packet_statistics_control::PacketStatisticsReporter;
 
 pub(crate) mod acknowledgement_control;
 pub(crate) mod message_handler;
@@ -145,7 +145,7 @@ impl RealMessagesController<OsRng> {
         reply_controller_receiver: ReplyControllerReceiver,
         lane_queue_lengths: LaneQueueLengths,
         client_connection_rx: ConnectionCommandReceiver,
-        stats_tx: ClientStatsSender,
+        stats_tx: PacketStatisticsReporter,
     ) -> Self {
         let rng = OsRng;
 

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

@@ -3,6 +3,7 @@
 
 use self::sending_delay_controller::SendingDelayController;
 use crate::client::mix_traffic::BatchMixMessageSender;
+use crate::client::packet_statistics_control::{PacketStatisticsEvent, PacketStatisticsReporter};
 use crate::client::real_messages_control::acknowledgement_control::SentPacketNotificationSender;
 use crate::client::topology_control::TopologyAccessor;
 use crate::client::transmission_buffer::TransmissionBuffer;
@@ -18,7 +19,6 @@ use nym_sphinx::forwarding::packet::MixPacket;
 use nym_sphinx::params::PacketSize;
 use nym_sphinx::preparer::PreparedFragment;
 use nym_sphinx::utils::sample_poisson_duration;
-use nym_statistics_common::clients::{packet_statistics::PacketStatisticsEvent, ClientStatsSender};
 use nym_task::connections::{
     ConnectionCommand, ConnectionCommandReceiver, ConnectionId, LaneQueueLengths, TransmissionLane,
 };
@@ -115,8 +115,8 @@ where
     /// Report queue lengths so that upstream can backoff sending data, and keep connections open.
     lane_queue_lengths: LaneQueueLengths,
 
-    /// Channel used for sending metrics events (specifically `PacketStatistics` events) to the metrics tracker.
-    stats_tx: ClientStatsSender,
+    /// Channel used for sending statistics events to `PacketStatisticsControl`.
+    stats_tx: PacketStatisticsReporter,
 }
 
 #[derive(Debug)]
@@ -175,7 +175,7 @@ where
         topology_access: TopologyAccessor,
         lane_queue_lengths: LaneQueueLengths,
         client_connection_rx: ConnectionCommandReceiver,
-        stats_tx: ClientStatsSender,
+        stats_tx: PacketStatisticsReporter,
     ) -> Self {
         OutQueueControl {
             config,
@@ -277,7 +277,7 @@ where
             } else {
                 PacketStatisticsEvent::CoverPacketSent(packet_size)
             };
-            self.stats_tx.report(event.into());
+            self.stats_tx.report(event);
         }
 
         // notify ack controller about sending our message only after we actually managed to push it
@@ -373,13 +373,13 @@ where
             TransmissionLane::Retransmission => Some(PacketStatisticsEvent::RetransmissionQueued),
         };
         if let Some(stat_event) = stat_event {
-            self.stats_tx.report(stat_event.into());
+            self.stats_tx.report(stat_event);
         }
         // To avoid comparing apples to oranges when presenting the fraction of packets that are
         // retransmissions, we also need to keep track to the total number of real messages queued,
         // even though we also track the actual number of messages sent later in the pipeline.
         self.stats_tx
-            .report(PacketStatisticsEvent::RealPacketQueued.into());
+            .report(PacketStatisticsEvent::RealPacketQueued);
 
         Some(real_next)
     }

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

@@ -1,8 +1,9 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::client::replies::{
-    reply_controller::ReplyControllerSender, reply_storage::SentReplyKeys,
+use crate::client::{
+    packet_statistics_control::{PacketStatisticsEvent, PacketStatisticsReporter},
+    replies::{reply_controller::ReplyControllerSender, reply_storage::SentReplyKeys},
 };
 use crate::spawn_future;
 use futures::channel::mpsc;
@@ -19,7 +20,6 @@ use nym_sphinx::anonymous_replies::{encryption_key::EncryptionKeyDigest, SurbEnc
 use nym_sphinx::message::{NymMessage, PlainMessage};
 use nym_sphinx::params::ReplySurbKeyDigestAlgorithm;
 use nym_sphinx::receiver::{MessageReceiver, MessageRecoveryError, ReconstructedMessage};
-use nym_statistics_common::clients::{packet_statistics::PacketStatisticsEvent, ClientStatsSender};
 use std::collections::HashSet;
 use std::sync::Arc;
 
@@ -46,7 +46,7 @@ struct ReceivedMessagesBufferInner<R: MessageReceiver> {
     // and every now and then remove ids older than X
     recently_reconstructed: HashSet<i32>,
 
-    stats_tx: ClientStatsSender,
+    stats_tx: PacketStatisticsReporter,
 }
 
 impl<R: MessageReceiver> ReceivedMessagesBufferInner<R> {
@@ -61,12 +61,16 @@ impl<R: MessageReceiver> ReceivedMessagesBufferInner<R> {
             // received and sent packets due to the sphinx layers being removed by the exit gateway
             // before it reaches the mixnet client.
             self.stats_tx
-                .report(PacketStatisticsEvent::CoverPacketReceived(fragment_data_size).into());
+                .report(PacketStatisticsEvent::CoverPacketReceived(
+                    fragment_data_size,
+                ));
             return None;
         }
 
         self.stats_tx
-            .report(PacketStatisticsEvent::RealPacketReceived(fragment_data_size).into());
+            .report(PacketStatisticsEvent::RealPacketReceived(
+                fragment_data_size,
+            ));
 
         let fragment = match self.message_receiver.recover_fragment(fragment_data) {
             Err(err) => {
@@ -159,7 +163,7 @@ impl<R: MessageReceiver> ReceivedMessagesBuffer<R> {
         local_encryption_keypair: Arc<encryption::KeyPair>,
         reply_key_storage: SentReplyKeys,
         reply_controller_sender: ReplyControllerSender,
-        stats_tx: ClientStatsSender,
+        stats_tx: PacketStatisticsReporter,
     ) -> Self {
         ReceivedMessagesBuffer {
             inner: Arc::new(Mutex::new(ReceivedMessagesBufferInner {
@@ -500,13 +504,13 @@ impl<R: MessageReceiver + Clone + Send + 'static> ReceivedMessagesBufferControll
         mixnet_packet_receiver: MixnetMessageReceiver,
         reply_key_storage: SentReplyKeys,
         reply_controller_sender: ReplyControllerSender,
-        metrics_reporter: ClientStatsSender,
+        packet_statistics_reporter: PacketStatisticsReporter,
     ) -> Self {
         let received_buffer = ReceivedMessagesBuffer::new(
             local_encryption_keypair,
             reply_key_storage,
             reply_controller_sender,
-            metrics_reporter,
+            packet_statistics_reporter,
         );
 
         ReceivedMessagesBufferController {

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

@@ -1,154 +0,0 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-//! # Statistics collection and reporting.
-//!
-//! Modular metrics collection and reporting system. submodules can be added to collect different types of metrics.
-//! On creation the Statistics controller will start a task that will listen for incoming stats events and
-//! multiplex them out to the appropriate metrics module based on type.
-//!
-//! Adding A new module you need to write a new module that implements the `StatsObj` trait and add it to
-//! the `stats` hashmap in the `StatisticsControl` struct during it's initialization in the `new` function in
-//! this file.
-
-#![warn(clippy::expect_used)]
-#![warn(clippy::unwrap_used)]
-#![warn(clippy::todo)]
-#![warn(clippy::dbg_macro)]
-
-use std::time::Duration;
-
-use nym_sphinx::addressing::Recipient;
-use nym_statistics_common::{
-    clients::{ClientStatsController, ClientStatsReceiver, ClientStatsSender},
-    StatsReportingConfig,
-};
-use nym_task::connections::TransmissionLane;
-
-use crate::{
-    client::inbound_messages::{InputMessage, InputMessageSender},
-    spawn_future,
-};
-
-/// Time interval between reporting statistics to the given provider if it exist
-const STATS_REPORT_INTERVAL_SECS: u64 = 300;
-/// Time interval between reporting statistics locally (logging/task_client)
-const LOCAL_REPORT_INTERVAL: Duration = Duration::from_secs(2);
-/// Interval for taking snapshots of the statistics
-const SNAPSHOT_INTERVAL: Duration = Duration::from_millis(500);
-
-/// Launches and manages metrics collection and reporting.
-///
-/// This is designed to be generic to allow for multiple types of metrics to be collected and
-/// reported.
-pub(crate) struct StatisticsControl {
-    /// Keep store the different types of metrics collectors
-    stats: ClientStatsController,
-
-    /// Incoming packet stats events from other tasks
-    stats_rx: ClientStatsReceiver,
-
-    /// Channel to send stats report through the mixnet
-    report_tx: InputMessageSender,
-
-    /// Service-provider address to send stats reports
-    reporting_address: Option<Recipient>,
-}
-
-impl StatisticsControl {
-    pub(crate) fn create(
-        reporting_config: Option<StatsReportingConfig>,
-        client_stats_id: String,
-        report_tx: InputMessageSender,
-    ) -> (Self, ClientStatsSender) {
-        let (stats_tx, stats_rx) = tokio::sync::mpsc::unbounded_channel();
-        let (reporting_address, client_type) = match reporting_config {
-            Some(cfg) => (Some(cfg.reporting_address), cfg.reporting_type),
-            None => (None, "".into()),
-        };
-
-        let stats = ClientStatsController::new(client_stats_id, client_type);
-
-        (
-            StatisticsControl {
-                stats,
-                stats_rx,
-                reporting_address,
-                report_tx,
-            },
-            ClientStatsSender::new(Some(stats_tx)),
-        )
-    }
-
-    async fn report_stats(&mut self, recipient: Recipient) {
-        let stats_report = self.stats.build_report();
-
-        let report_message = InputMessage::new_regular(
-            recipient,
-            stats_report.into(),
-            TransmissionLane::General,
-            None,
-        );
-        if let Err(err) = self.report_tx.send(report_message).await {
-            log::error!("Failed to report client stats: {:?}", err);
-        } else {
-            self.stats.reset();
-        }
-    }
-
-    async fn run_with_shutdown(&mut self, mut task_client: nym_task::TaskClient) {
-        log::debug!("Started StatisticsControl with graceful shutdown support");
-
-        let stats_report_interval = Duration::from_secs(STATS_REPORT_INTERVAL_SECS);
-        let mut stats_report_interval = tokio::time::interval(stats_report_interval);
-        let mut local_report_interval = tokio::time::interval(LOCAL_REPORT_INTERVAL);
-        let mut snapshot_interval = tokio::time::interval(SNAPSHOT_INTERVAL);
-
-        loop {
-            tokio::select! {
-                stats_event = self.stats_rx.recv() => match stats_event {
-                        Some(stats_event) => self.stats.handle_event(stats_event),
-                        None => {
-                            log::trace!("StatisticsControl: shutting down due to closed stats channel");
-                            break;
-                        }
-                },
-                _ = snapshot_interval.tick() => {
-                    self.stats.snapshot();
-                }
-                _ = stats_report_interval.tick(), if self.reporting_address.is_some() => {
-                    // SAFTEY : this branch executes only if reporting is not none, so unwrapp is fine
-                    #[allow(clippy::unwrap_used)]
-                    self.report_stats(self.reporting_address.unwrap()).await;
-                }
-
-                _ = local_report_interval.tick() => {
-                    self.stats.local_report(&mut task_client);
-                }
-                _ = task_client.recv_with_delay() => {
-                    log::trace!("StatisticsControl: Received shutdown");
-                    break;
-                },
-            }
-        }
-        task_client.recv_timeout().await;
-        log::debug!("StatisticsControl: Exiting");
-    }
-
-    pub(crate) fn start_with_shutdown(mut self, task_client: nym_task::TaskClient) {
-        spawn_future(async move {
-            self.run_with_shutdown(task_client).await;
-        })
-    }
-
-    pub(crate) fn create_and_start_with_shutdown(
-        reporting_config: Option<StatsReportingConfig>,
-        client_stats_id: String,
-        report_tx: InputMessageSender,
-        task_client: nym_task::TaskClient,
-    ) -> ClientStatsSender {
-        let (controller, sender) = Self::create(reporting_config, client_stats_id, report_tx);
-        controller.start_with_shutdown(task_client);
-        sender
-    }
-}

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

@@ -112,7 +112,7 @@ impl GeoAwareTopologyProvider {
     async fn get_topology(&self) -> Option<NymTopology> {
         let mixnodes = match self
             .validator_client
-            .get_all_basic_active_mixing_assigned_nodes(Some(self.client_version.clone()))
+            .get_basic_active_mixing_assigned_nodes(Some(self.client_version.clone()))
             .await
         {
             Err(err) => {

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

@@ -99,7 +99,7 @@ impl NymApiTopologyProvider {
     async fn get_current_compatible_topology(&mut self) -> Option<NymTopology> {
         let mixnodes = match self
             .validator_client
-            .get_all_basic_active_mixing_assigned_nodes(Some(self.client_version.clone()))
+            .get_basic_active_mixing_assigned_nodes(Some(self.client_version.clone()))
             .await
         {
             Err(err) => {

common/client-core/src/error.rs

@@ -212,29 +212,12 @@ pub enum ClientCoreError {
 }
 
 /// Set of messages that the client can send to listeners via the task manager
-#[derive(Debug)]
+#[derive(thiserror::Error, Debug)]
 pub enum ClientCoreStatusMessage {
+    // NOTE: The nym-connect frontend listens for these strings, so don't change them until we have a more robust mechanism in place
+    #[error("The connected gateway is slow, or the connection to it is slow")]
     GatewayIsSlow,
+    // NOTE: The nym-connect frontend listens for these strings, so don't change them until we have a more robust mechanism in place
+    #[error("The connected gateway is very slow, or the connection to it is very slow")]
     GatewayIsVerySlow,
 }
-
-impl std::fmt::Display for ClientCoreStatusMessage {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            ClientCoreStatusMessage::GatewayIsSlow => write!(
-                f,
-                "The connected gateway is slow, or the connection to it is slow"
-            ),
-            ClientCoreStatusMessage::GatewayIsVerySlow => write!(
-                f,
-                "The connected gateway is very slow, or the connection to it is very slow"
-            ),
-        }
-    }
-}
-
-impl nym_task::TaskStatusEvent for ClientCoreStatusMessage {
-    fn as_any(&self) -> &dyn std::any::Any {
-        self
-    }
-}

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

@@ -121,9 +121,7 @@ pub async fn current_mixnodes<R: Rng>(
 
     log::trace!("Fetching list of mixnodes from: {nym_api}");
 
-    let mixnodes = client
-        .get_all_basic_active_mixing_assigned_nodes(None)
-        .await?;
+    let mixnodes = client.get_basic_active_mixing_assigned_nodes(None).await?;
     let valid_mixnodes = mixnodes
         .iter()
         .filter_map(|mixnode| mixnode.try_into().ok())

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

@@ -18,7 +18,7 @@ use nym_api_requests::ecash::{
     PartialExpirationDateSignatureResponse, VerificationKeyResponse,
 };
 use nym_api_requests::models::{
-    ApiHealthResponse, GatewayCoreStatusResponse, MixnodeCoreStatusResponse, MixnodeStatusResponse,
+    GatewayCoreStatusResponse, MixnodeCoreStatusResponse, MixnodeStatusResponse,
     NymNodeDescription, RewardEstimationResponse, StakeSaturationResponse,
 };
 use nym_api_requests::models::{LegacyDescribedGateway, MixNodeBondAnnotated};
@@ -192,8 +192,6 @@ impl<C, S> Client<C, S> {
 }
 
 // validator-api wrappers
-// we have to allow the use of deprecated method here as they're calling the deprecated trait methods
-#[allow(deprecated)]
 impl<C, S> Client<C, S> {
     pub fn api_url(&self) -> &Url {
         self.nym_api.current_url()
@@ -203,54 +201,46 @@ impl<C, S> Client<C, S> {
         self.nym_api.change_base_url(new_endpoint)
     }
 
-    #[deprecated]
     pub async fn get_cached_mixnodes(&self) -> Result<Vec<MixNodeDetails>, ValidatorClientError> {
         Ok(self.nym_api.get_mixnodes().await?)
     }
 
-    #[deprecated]
     pub async fn get_cached_mixnodes_detailed(
         &self,
     ) -> Result<Vec<MixNodeBondAnnotated>, ValidatorClientError> {
         Ok(self.nym_api.get_mixnodes_detailed().await?)
     }
 
-    #[deprecated]
     pub async fn get_cached_mixnodes_detailed_unfiltered(
         &self,
     ) -> Result<Vec<MixNodeBondAnnotated>, ValidatorClientError> {
         Ok(self.nym_api.get_mixnodes_detailed_unfiltered().await?)
     }
 
-    #[deprecated]
     pub async fn get_cached_rewarded_mixnodes(
         &self,
     ) -> Result<Vec<MixNodeDetails>, ValidatorClientError> {
         Ok(self.nym_api.get_rewarded_mixnodes().await?)
     }
 
-    #[deprecated]
     pub async fn get_cached_rewarded_mixnodes_detailed(
         &self,
     ) -> Result<Vec<MixNodeBondAnnotated>, ValidatorClientError> {
         Ok(self.nym_api.get_rewarded_mixnodes_detailed().await?)
     }
 
-    #[deprecated]
     pub async fn get_cached_active_mixnodes(
         &self,
     ) -> Result<Vec<MixNodeDetails>, ValidatorClientError> {
         Ok(self.nym_api.get_active_mixnodes().await?)
     }
 
-    #[deprecated]
     pub async fn get_cached_active_mixnodes_detailed(
         &self,
     ) -> Result<Vec<MixNodeBondAnnotated>, ValidatorClientError> {
         Ok(self.nym_api.get_active_mixnodes_detailed().await?)
     }
 
-    #[deprecated]
     pub async fn get_cached_gateways(&self) -> Result<Vec<GatewayBond>, ValidatorClientError> {
         Ok(self.nym_api.get_gateways().await?)
     }
@@ -314,8 +304,6 @@ pub struct NymApiClient {
     // we could re-implement the communication with the REST API on port 1317
 }
 
-// we have to allow the use of deprecated method here as they're calling the deprecated trait methods
-#[allow(deprecated)]
 impl NymApiClient {
     pub fn new(api_url: Url) -> Self {
         let nym_api = nym_api::Client::new(api_url, None);
@@ -348,7 +336,7 @@ impl NymApiClient {
         self.nym_api.change_base_url(new_endpoint);
     }
 
-    #[deprecated(note = "use get_all_basic_active_mixing_assigned_nodes instead")]
+    #[deprecated(note = "use get_basic_active_mixing_assigned_nodes instead")]
     pub async fn get_basic_mixnodes(
         &self,
         semver_compatibility: Option<String>,
@@ -406,7 +394,7 @@ impl NymApiClient {
 
     /// retrieve basic information for nodes that got assigned 'mixing' node in this epoch
     /// this includes legacy mixnodes and nym-nodes
-    pub async fn get_all_basic_active_mixing_assigned_nodes(
+    pub async fn get_basic_active_mixing_assigned_nodes(
         &self,
         semver_compatibility: Option<String>,
     ) -> Result<Vec<SkimmedNode>, ValidatorClientError> {
@@ -436,93 +424,26 @@ impl NymApiClient {
         Ok(nodes)
     }
 
-    /// retrieve basic information for nodes are capable of operating as a mixnode
-    /// this includes legacy mixnodes and nym-nodes
-    pub async fn get_all_basic_mixing_capable_nodes(
-        &self,
-        semver_compatibility: Option<String>,
-    ) -> Result<Vec<SkimmedNode>, ValidatorClientError> {
-        // TODO: deal with paging in macro or some helper function or something, because it's the same pattern everywhere
-        let mut page = 0;
-        let mut nodes = Vec::new();
-
-        loop {
-            let mut res = self
-                .nym_api
-                .get_basic_mixing_capable_nodes(
-                    semver_compatibility.clone(),
-                    false,
-                    Some(page),
-                    None,
-                )
-                .await?;
-
-            nodes.append(&mut res.nodes.data);
-            if nodes.len() < res.nodes.pagination.total {
-                page += 1
-            } else {
-                break;
-            }
-        }
-
-        Ok(nodes)
-    }
-
-    /// retrieve basic information for all bonded nodes on the network
-    pub async fn get_all_basic_nodes(
-        &self,
-        semver_compatibility: Option<String>,
-    ) -> Result<Vec<SkimmedNode>, ValidatorClientError> {
-        // TODO: deal with paging in macro or some helper function or something, because it's the same pattern everywhere
-        let mut page = 0;
-        let mut nodes = Vec::new();
-
-        loop {
-            let mut res = self
-                .nym_api
-                .get_basic_nodes(semver_compatibility.clone(), false, Some(page), None)
-                .await?;
-
-            nodes.append(&mut res.nodes.data);
-            if nodes.len() < res.nodes.pagination.total {
-                page += 1
-            } else {
-                break;
-            }
-        }
-
-        Ok(nodes)
-    }
-
-    pub async fn health(&self) -> Result<ApiHealthResponse, ValidatorClientError> {
-        Ok(self.nym_api.health().await?)
-    }
-
-    #[deprecated]
     pub async fn get_cached_active_mixnodes(
         &self,
     ) -> Result<Vec<MixNodeDetails>, ValidatorClientError> {
         Ok(self.nym_api.get_active_mixnodes().await?)
     }
 
-    #[deprecated]
     pub async fn get_cached_rewarded_mixnodes(
         &self,
     ) -> Result<Vec<MixNodeDetails>, ValidatorClientError> {
         Ok(self.nym_api.get_rewarded_mixnodes().await?)
     }
 
-    #[deprecated]
     pub async fn get_cached_mixnodes(&self) -> Result<Vec<MixNodeDetails>, ValidatorClientError> {
         Ok(self.nym_api.get_mixnodes().await?)
     }
 
-    #[deprecated]
     pub async fn get_cached_gateways(&self) -> Result<Vec<GatewayBond>, ValidatorClientError> {
         Ok(self.nym_api.get_gateways().await?)
     }
 
-    #[deprecated]
     pub async fn get_cached_described_gateways(
         &self,
     ) -> Result<Vec<LegacyDescribedGateway>, ValidatorClientError> {
@@ -571,7 +492,6 @@ impl NymApiClient {
         Ok(bonds)
     }
 
-    #[deprecated]
     pub async fn get_gateway_core_status_count(
         &self,
         identity: IdentityKeyRef<'_>,
@@ -583,7 +503,6 @@ impl NymApiClient {
             .await?)
     }
 
-    #[deprecated]
     pub async fn get_mixnode_core_status_count(
         &self,
         mix_id: NodeId,
@@ -595,7 +514,6 @@ impl NymApiClient {
             .await?)
     }
 
-    #[deprecated]
     pub async fn get_mixnode_status(
         &self,
         mix_id: NodeId,
@@ -603,7 +521,6 @@ impl NymApiClient {
         Ok(self.nym_api.get_mixnode_status(mix_id).await?)
     }
 
-    #[deprecated]
     pub async fn get_mixnode_reward_estimation(
         &self,
         mix_id: NodeId,
@@ -611,7 +528,6 @@ impl NymApiClient {
         Ok(self.nym_api.get_mixnode_reward_estimation(mix_id).await?)
     }
 
-    #[deprecated]
     pub async fn get_mixnode_stake_saturation(
         &self,
         mix_id: NodeId,
@@ -643,7 +559,6 @@ impl NymApiClient {
             .await?)
     }
 
-    #[deprecated]
     pub async fn spent_credentials_filter(
         &self,
     ) -> Result<SpentCredentialsResponse, ValidatorClientError> {

common/client-libs/validator-client/src/connection_tester.rs

@@ -164,7 +164,7 @@ async fn test_nym_api_connection(
 ) -> ConnectionResult {
     let result = match timeout(
         Duration::from_secs(CONNECTION_TEST_TIMEOUT_SEC),
-        client.health(),
+        client.get_cached_mixnodes(),
     )
     .await
     {

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

@@ -11,8 +11,7 @@ use nym_api_requests::ecash::models::{
 };
 use nym_api_requests::ecash::VerificationKeyResponse;
 use nym_api_requests::models::{
-    AnnotationResponse, ApiHealthResponse, LegacyDescribedMixNode, NodePerformanceResponse,
-    NymNodeDescription,
+    AnnotationResponse, LegacyDescribedMixNode, NodePerformanceResponse, NymNodeDescription,
 };
 use nym_api_requests::nym_nodes::PaginatedCachedNodesResponse;
 use nym_api_requests::pagination::PaginatedResponse;
@@ -55,26 +54,12 @@ pub fn rfc_3339_date() -> Vec<BorrowedFormatItem<'static>> {
 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
 #[cfg_attr(not(target_arch = "wasm32"), async_trait)]
 pub trait NymApiClientExt: ApiClient {
-    async fn health(&self) -> Result<ApiHealthResponse, NymAPIError> {
-        self.get_json(
-            &[
-                routes::API_VERSION,
-                routes::API_STATUS_ROUTES,
-                routes::HEALTH,
-            ],
-            NO_PARAMS,
-        )
-        .await
-    }
-
-    #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn get_mixnodes(&self) -> Result<Vec<MixNodeDetails>, NymAPIError> {
         self.get_json(&[routes::API_VERSION, routes::MIXNODES], NO_PARAMS)
             .await
     }
 
-    #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn get_mixnodes_detailed(&self) -> Result<Vec<MixNodeBondAnnotated>, NymAPIError> {
         self.get_json(
@@ -89,7 +74,6 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn get_gateways_detailed(&self) -> Result<Vec<GatewayBondAnnotated>, NymAPIError> {
         self.get_json(
@@ -104,7 +88,6 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn get_mixnodes_detailed_unfiltered(
         &self,
@@ -121,14 +104,12 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn get_gateways(&self) -> Result<Vec<GatewayBond>, NymAPIError> {
         self.get_json(&[routes::API_VERSION, routes::GATEWAYS], NO_PARAMS)
             .await
     }
 
-    #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn get_gateways_described(&self) -> Result<Vec<LegacyDescribedGateway>, NymAPIError> {
         self.get_json(
@@ -138,7 +119,6 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn get_mixnodes_described(&self) -> Result<Vec<LegacyDescribedMixNode>, NymAPIError> {
         self.get_json(
@@ -148,7 +128,6 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    #[tracing::instrument(level = "debug", skip_all)]
     async fn get_nodes_described(
         &self,
         page: Option<u32>,
@@ -168,7 +147,6 @@ pub trait NymApiClientExt: ApiClient {
             .await
     }
 
-    #[tracing::instrument(level = "debug", skip_all)]
     async fn get_nym_nodes(
         &self,
         page: Option<u32>,
@@ -188,7 +166,6 @@ pub trait NymApiClientExt: ApiClient {
             .await
     }
 
-    #[deprecated]
     #[tracing::instrument(level = "debug", skip_all)]
     async fn get_basic_mixnodes(
         &self,
@@ -213,7 +190,6 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn get_basic_gateways(
         &self,
@@ -322,82 +298,6 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    /// retrieve basic information for nodes that got assigned 'mixing' node in this epoch
-    /// this includes legacy mixnodes and nym-nodes
-    #[instrument(level = "debug", skip(self))]
-    async fn get_basic_mixing_capable_nodes(
-        &self,
-        semver_compatibility: Option<String>,
-        no_legacy: bool,
-        page: Option<u32>,
-        per_page: Option<u32>,
-    ) -> Result<PaginatedCachedNodesResponse<SkimmedNode>, NymAPIError> {
-        let mut params = Vec::new();
-
-        if let Some(arg) = &semver_compatibility {
-            params.push(("semver_compatibility", arg.clone()))
-        }
-
-        if no_legacy {
-            params.push(("no_legacy", "true".to_string()))
-        }
-
-        if let Some(page) = page {
-            params.push(("page", page.to_string()))
-        }
-
-        if let Some(per_page) = per_page {
-            params.push(("per_page", per_page.to_string()))
-        }
-
-        self.get_json(
-            &[
-                routes::API_VERSION,
-                "unstable",
-                "nym-nodes",
-                "skimmed",
-                "mixnodes",
-                "all",
-            ],
-            &params,
-        )
-        .await
-    }
-
-    #[instrument(level = "debug", skip(self))]
-    async fn get_basic_nodes(
-        &self,
-        semver_compatibility: Option<String>,
-        no_legacy: bool,
-        page: Option<u32>,
-        per_page: Option<u32>,
-    ) -> Result<PaginatedCachedNodesResponse<SkimmedNode>, NymAPIError> {
-        let mut params = Vec::new();
-
-        if let Some(arg) = &semver_compatibility {
-            params.push(("semver_compatibility", arg.clone()))
-        }
-
-        if no_legacy {
-            params.push(("no_legacy", "true".to_string()))
-        }
-
-        if let Some(page) = page {
-            params.push(("page", page.to_string()))
-        }
-
-        if let Some(per_page) = per_page {
-            params.push(("per_page", per_page.to_string()))
-        }
-
-        self.get_json(
-            &[routes::API_VERSION, "unstable", "nym-nodes", "skimmed"],
-            &params,
-        )
-        .await
-    }
-
-    #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn get_active_mixnodes(&self) -> Result<Vec<MixNodeDetails>, NymAPIError> {
         self.get_json(
@@ -407,7 +307,6 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn get_active_mixnodes_detailed(&self) -> Result<Vec<MixNodeBondAnnotated>, NymAPIError> {
         self.get_json(
@@ -423,7 +322,6 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn get_rewarded_mixnodes(&self) -> Result<Vec<MixNodeDetails>, NymAPIError> {
         self.get_json(
@@ -433,7 +331,6 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn get_mixnode_report(
         &self,
@@ -452,7 +349,6 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn get_gateway_report(
         &self,
@@ -471,7 +367,6 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn get_mixnode_history(
         &self,
@@ -490,7 +385,6 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn get_gateway_history(
         &self,
@@ -509,7 +403,6 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn get_rewarded_mixnodes_detailed(
         &self,
@@ -527,7 +420,6 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn get_gateway_core_status_count(
         &self,
@@ -560,7 +452,6 @@ pub trait NymApiClientExt: ApiClient {
         }
     }
 
-    #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn get_mixnode_core_status_count(
         &self,
@@ -594,7 +485,6 @@ pub trait NymApiClientExt: ApiClient {
         }
     }
 
-    #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn get_mixnode_status(
         &self,
@@ -613,7 +503,6 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn get_mixnode_reward_estimation(
         &self,
@@ -632,7 +521,6 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn compute_mixnode_reward_estimation(
         &self,
@@ -653,7 +541,6 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn get_mixnode_stake_saturation(
         &self,
@@ -672,7 +559,6 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn get_mixnode_inclusion_probability(
         &self,
@@ -708,7 +594,6 @@ pub trait NymApiClientExt: ApiClient {
             .await
     }
 
-    #[deprecated]
     async fn get_mixnode_avg_uptime(&self, mix_id: NodeId) -> Result<UptimeResponse, NymAPIError> {
         self.get_json(
             &[
@@ -723,7 +608,6 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn get_mixnodes_blacklisted(&self) -> Result<Vec<NodeId>, NymAPIError> {
         self.get_json(
@@ -733,7 +617,6 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn get_gateways_blacklisted(&self) -> Result<Vec<IdentityKey>, NymAPIError> {
         self.get_json(
@@ -794,7 +677,6 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn double_spending_filter_v1(&self) -> Result<SpentCredentialsResponse, NymAPIError> {
         self.get_json(

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

@@ -36,8 +36,6 @@ pub mod ecash {
 }
 
 pub const STATUS_ROUTES: &str = "status";
-pub const API_STATUS_ROUTES: &str = "api-status";
-pub const HEALTH: &str = "health";
 pub const MIXNODE: &str = "mixnode";
 pub const GATEWAY: &str = "gateway";
 pub const NYM_NODES: &str = "nym-nodes";

common/commands/src/validator/mixnet/query/query_all_gateways.rs

@@ -2,9 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::context::QueryClientWithNyxd;
-use crate::utils::show_error;
+use crate::utils::{pretty_cosmwasm_coin, show_error};
 use clap::Parser;
 use comfy_table::Table;
+use nym_validator_client::client::NymApiClientExt;
 
 #[derive(Debug, Parser)]
 pub struct Args {
@@ -14,11 +15,12 @@ pub struct Args {
 }
 
 pub async fn query(args: Args, client: &QueryClientWithNyxd) {
-    match client.get_all_cached_described_nodes().await {
+    match client.nym_api.get_gateways().await {
         Ok(res) => match args.identity_key {
             Some(identity_key) => {
                 let node = res.iter().find(|node| {
-                    node.ed25519_identity_key()
+                    node.gateway
+                        .identity_key
                         .to_string()
                         .eq_ignore_ascii_case(&identity_key)
                 });
@@ -30,16 +32,14 @@ pub async fn query(args: Args, client: &QueryClientWithNyxd) {
             None => {
                 let mut table = Table::new();
 
-                table.set_header(vec!["Node Id", "Identity Key", "Version", "Is Legacy"]);
-                for node in res
-                    .into_iter()
-                    .filter(|node| node.description.declared_role.entry)
-                {
+                table.set_header(vec!["Identity Key", "Owner", "Host", "Bond", "Version"]);
+                for node in res {
                     table.add_row(vec![
-                        node.node_id.to_string(),
-                        node.ed25519_identity_key().to_base58_string(),
-                        node.description.build_information.build_version,
-                        (!node.contract_node_type.is_nym_node()).to_string(),
+                        node.gateway.identity_key.to_string(),
+                        node.owner.to_string(),
+                        node.gateway.host.to_string(),
+                        pretty_cosmwasm_coin(&node.pledge_amount),
+                        node.gateway.version.clone(),
                     ]);
                 }
 

common/commands/src/validator/mixnet/query/query_all_mixnodes.rs

@@ -2,9 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::context::QueryClientWithNyxd;
-use crate::utils::show_error;
+use crate::utils::{pretty_decimal_with_denom, show_error};
 use clap::Parser;
 use comfy_table::Table;
+use nym_validator_client::client::NymApiClientExt;
 
 #[derive(Debug, Parser)]
 pub struct Args {
@@ -14,11 +15,13 @@ pub struct Args {
 }
 
 pub async fn query(args: Args, client: &QueryClientWithNyxd) {
-    match client.get_all_cached_described_nodes().await {
+    match client.nym_api.get_mixnodes().await {
         Ok(res) => match args.identity_key {
             Some(identity_key) => {
                 let node = res.iter().find(|node| {
-                    node.ed25519_identity_key()
+                    node.bond_information
+                        .mix_node
+                        .identity_key
                         .to_string()
                         .eq_ignore_ascii_case(&identity_key)
                 });
@@ -30,16 +33,25 @@ pub async fn query(args: Args, client: &QueryClientWithNyxd) {
             None => {
                 let mut table = Table::new();
 
-                table.set_header(vec!["Node Id", "Identity Key", "Version", "Is Legacy"]);
-                for node in res
-                    .into_iter()
-                    .filter(|node| node.description.declared_role.mixnode)
-                {
+                table.set_header(vec![
+                    "Mix id",
+                    "Identity Key",
+                    "Owner",
+                    "Host",
+                    "Bond",
+                    "Total Delegations",
+                    "Version",
+                ]);
+                for node in res {
+                    let denom = &node.bond_information.original_pledge().denom;
                     table.add_row(vec![
-                        node.node_id.to_string(),
-                        node.ed25519_identity_key().to_base58_string(),
-                        node.description.build_information.build_version,
-                        (!node.contract_node_type.is_nym_node()).to_string(),
+                        node.mix_id().to_string(),
+                        node.bond_information.mix_node.identity_key.clone(),
+                        node.bond_information.owner.clone().into_string(),
+                        node.bond_information.mix_node.host.clone(),
+                        pretty_decimal_with_denom(node.rewarding_details.operator, denom),
+                        pretty_decimal_with_denom(node.rewarding_details.delegates, denom),
+                        node.bond_information.mix_node.version,
                     ]);
                 }
 

common/credential-verification/src/ecash/mod.rs

@@ -21,7 +21,7 @@ pub mod error;
 mod helpers;
 mod state;
 
-pub const TIME_RANGE_SEC: i64 = 30;
+const TIME_RANGE_SEC: i64 = 30;
 
 pub struct EcashManager<S> {
     shared_state: SharedState<S>,

common/credential-verification/src/lib.rs

@@ -6,7 +6,7 @@ use std::sync::Arc;
 use time::{Date, OffsetDateTime};
 use tracing::*;
 
-use nym_credentials::ecash::utils::{cred_exp_date, ecash_today, EcashTime};
+use nym_credentials::ecash::utils::{ecash_today, EcashTime};
 use nym_credentials_interface::{Bandwidth, ClientTicket, TicketType};
 use nym_gateway_requests::models::CredentialSpendingRequest;
 use nym_gateway_storage::Storage;
@@ -131,7 +131,7 @@ impl<S: Storage + Clone + 'static> CredentialVerifier<S> {
         let bandwidth = Bandwidth::ticket_amount(credential_type.into());
 
         self.bandwidth_storage_manager
-            .increase_bandwidth(bandwidth, cred_exp_date())
+            .increase_bandwidth(bandwidth, spend_date)
             .await?;
 
         Ok(self

common/gateway-stats-storage/src/lib.rs

@@ -104,8 +104,8 @@ impl PersistentStatsStorage {
             .await?)
     }
 
-    pub async fn get_unique_users(&self, date: Date) -> Result<Vec<String>, StatsStorageError> {
-        Ok(self.session_manager.get_unique_users(date).await?)
+    pub async fn get_unique_users_count(&self, date: Date) -> Result<i32, StatsStorageError> {
+        Ok(self.session_manager.get_unique_users_count(date).await?)
     }
 
     pub async fn delete_unique_users(&self, before_date: Date) -> Result<(), StatsStorageError> {

common/gateway-stats-storage/src/sessions.rs

@@ -71,13 +71,14 @@ impl SessionManager {
         Ok(())
     }
 
-    pub(crate) async fn get_unique_users(&self, date: Date) -> Result<Vec<String>> {
-        sqlx::query_scalar!(
-            "SELECT client_address as count FROM sessions_unique_users WHERE day = ?",
+    pub(crate) async fn get_unique_users_count(&self, date: Date) -> Result<i32> {
+        Ok(sqlx::query!(
+            "SELECT COUNT(*) as count FROM sessions_unique_users WHERE day = ?",
             date
         )
-        .fetch_all(&self.connection_pool)
-        .await
+        .fetch_one(&self.connection_pool)
+        .await?
+        .count)
     }
 
     pub(crate) async fn delete_unique_users(&self, before_date: Date) -> Result<()> {

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

@@ -534,19 +534,17 @@ where
     }
 
     if res.status().is_success() {
-        #[cfg(debug_assertions)]
-        {
-            let text = res.text().await.inspect_err(|err| {
-                tracing::error!("Couldn't even get response text: {err}");
-            })?;
-            tracing::trace!("Result:\n{:#?}", text);
-
-            serde_json::from_str(&text)
-                .map_err(|err| HttpClientError::GenericRequestFailure(err.to_string()))
+        let text = res.text().await?;
+        match serde_json::from_str(&text) {
+            Ok(res) => Ok(res),
+            Err(source) => {
+                #[cfg(debug_assertions)]
+                {
+                    tracing::trace!("Result:\n{:#?}", text);
+                }
+                Err(HttpClientError::ResponseDeserialisationFailure { source })
+            }
         }
-
-        #[cfg(not(debug_assertions))]
-        Ok(res.json().await?)
     } else if res.status() == StatusCode::NOT_FOUND {
         Err(HttpClientError::NotFound)
     } else {

common/ip-packet-requests/src/v6/request.rs

@@ -248,7 +248,7 @@ mod tests {
             data: IpPacketRequestData::StaticConnect(
                 StaticConnectRequest {
                     request_id: 123,
-                    ips: IpPair::new(Ipv4Addr::from_str("10.0.0.1").unwrap(), Ipv6Addr::from_str("fc00::1").unwrap()),
+                    ips: IpPair::new(Ipv4Addr::from_str("10.0.0.1").unwrap(), Ipv6Addr::from_str("2001:db8:a160::1").unwrap()),
                     reply_to: Recipient::try_from_base58_string("D1rrpsysCGCYXy9saP8y3kmNpGtJZUXN9SvFoUcqAsM9.9Ssso1ea5NfkbMASdiseDSjTN1fSWda5SgEVjdSN4CvV@GJqd3ZxpXWSNxTfx7B1pPtswpetH4LnJdFeLeuY5KUuN").unwrap(),
                     reply_to_hops: None,
                     reply_to_avg_mix_delays: None,

common/ip-packet-requests/src/v7/request.rs

@@ -429,7 +429,7 @@ mod tests {
                 SignedStaticConnectRequest {
                     request: StaticConnectRequest {
                         request_id: 123,
-                        ips: IpPair::new(Ipv4Addr::from_str("10.0.0.1").unwrap(), Ipv6Addr::from_str("fc00::1").unwrap()),
+                        ips: IpPair::new(Ipv4Addr::from_str("10.0.0.1").unwrap(), Ipv6Addr::from_str("2001:db8:a160::1").unwrap()),
                         reply_to: Recipient::try_from_base58_string("D1rrpsysCGCYXy9saP8y3kmNpGtJZUXN9SvFoUcqAsM9.9Ssso1ea5NfkbMASdiseDSjTN1fSWda5SgEVjdSN4CvV@GJqd3ZxpXWSNxTfx7B1pPtswpetH4LnJdFeLeuY5KUuN").unwrap(),
                         reply_to_hops: None,
                         reply_to_avg_mix_delays: None,

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

@@ -14,6 +14,7 @@ use nym_task::TaskClient;
 use rand::seq::SliceRandom;
 use rand::thread_rng;
 use std::net::SocketAddr;
+use std::net::ToSocketAddrs;
 use std::sync::Arc;
 use std::time::Duration;
 use tokio::task::JoinHandle;
@@ -312,7 +313,7 @@ impl VerlocMeasurer {
             info!("Starting verloc measurements");
             // TODO: should we also measure gateways?
 
-            let all_mixes = match self.validator_client.get_all_described_nodes().await {
+            let all_mixes = match self.validator_client.get_cached_mixnodes().await {
                 Ok(nodes) => nodes,
                 Err(err) => {
                     error!(
@@ -331,14 +332,22 @@ impl VerlocMeasurer {
             // we only care about address and identity
             let tested_nodes = all_mixes
                 .into_iter()
-                .filter(|n| n.description.declared_role.mixnode)
                 .filter_map(|node| {
-                    // try to parse the identity and host
-                    let node_identity = node.ed25519_identity_key();
+                    let mix_node = node.bond_information.mix_node;
+                    // check if the node has sufficient version to be able to understand the packets
+                    let node_version = parse_version(&mix_node.version).ok()?;
+                    if node_version < self.config.minimum_compatible_node_version {
+                        return None;
+                    }
 
-                    let ip = node.description.host_information.ip_address.first()?;
-                    let verloc_port = node.description.verloc_port();
-                    let verloc_host = SocketAddr::new(*ip, verloc_port);
+                    // try to parse the identity and host
+                    let node_identity =
+                        identity::PublicKey::from_base58_string(mix_node.identity_key).ok()?;
+
+                    let verloc_host = (&*mix_node.host, mix_node.verloc_port)
+                        .to_socket_addrs()
+                        .ok()?
+                        .next()?;
 
                     // TODO: possible problem in the future, this does name resolution and theoretically
                     // if a lot of nodes maliciously mis-configured themselves, it might take a while to resolve them all

common/network-defaults/Cargo.toml

@@ -23,7 +23,3 @@ default = ["env", "network"]
 env = ["dotenvy", "log"]
 network = ["schemars", "serde", "url"]
 utoipa = [ "dep:utoipa" ]
-
-[build-dependencies]
-regex = { workspace = true }
-cargo_metadata = { version = "0.18" }

common/network-defaults/build.rs

@@ -1,85 +0,0 @@
-use cargo_metadata::MetadataCommand;
-use regex::Regex;
-use std::{collections::HashMap, fs, path::PathBuf};
-
-/// Sync variable values defined in code with .env file
-fn main() {
-    let source_of_truth = include_str!("src/mainnet.rs");
-    let mut output_path = workspace_root();
-    output_path.push("envs");
-    output_path.push("mainnet.env");
-
-    println!("{}", output_path.display());
-
-    let variables_to_track = [
-        "NETWORK_NAME",
-        "BECH32_PREFIX",
-        "MIXNET_CONTRACT_ADDRESS",
-        "VESTING_CONTRACT_ADDRESS",
-        "GROUP_CONTRACT_ADDRESS",
-        "ECASH_CONTRACT_ADDRESS",
-        "MULTISIG_CONTRACT_ADDRESS",
-        "COCONUT_DKG_CONTRACT_ADDRESS",
-        "REWARDING_VALIDATOR_ADDRESS",
-        "NYM_API",
-        "NYXD_WS",
-        "EXPLORER_API",
-        "NYM_VPN_API",
-    ];
-
-    let mut replace_with = HashMap::new();
-
-    for var in variables_to_track {
-        // if script fails, debug with `cargo check -vv``
-        println!("Looking for {}", var);
-
-        // read pattern that looks like:
-        // <var>: &str = "<whatever is between quotes>"
-        let pattern = format!(r#"{}: &str\s*=\s*"([^"]*)""#, regex::escape(var));
-
-        let re = Regex::new(&pattern).unwrap();
-        let value = re
-            .captures(source_of_truth)
-            .and_then(|caps| caps.get(1).map(|match_| match_.as_str().to_string()))
-            .expect("Couldn't find var in source file");
-        println!("Storing {}={}", var, value);
-        replace_with.insert(var, value);
-    }
-
-    let mut contents = fs::read_to_string(&output_path).unwrap();
-
-    for (var, value) in replace_with {
-        // match a pattern that looks like:
-        // <var> = <value>
-        // where `<var>` is a variable name inserted into search pattern
-        let pattern = format!(r#"{}\s*=\s*([^\n]*)"#, regex::escape(var));
-
-        // replace matched pattern with
-        // <var>=<value>
-        let re = Regex::new(&pattern).unwrap();
-        contents = re
-            .replace(&contents, |_: &regex::Captures| {
-                format!(r#"{}={}"#, var, value)
-            })
-            .to_string();
-    }
-
-    println!("File contents to write:\n{}", contents);
-    if output_path.exists() {
-        fs::write(output_path, contents).unwrap();
-    } else {
-        panic!("{} doesn't exist", output_path.display());
-    }
-}
-
-fn workspace_root() -> PathBuf {
-    let metadata = MetadataCommand::new()
-        .exec()
-        .expect("Failed to get cargo metadata");
-
-    metadata
-        .workspace_root
-        .into_std_path_buf()
-        .canonicalize()
-        .expect("Failed to canonicalize path")
-}

common/network-defaults/src/constants.rs

@@ -45,15 +45,13 @@ pub mod nyx {
 }
 
 pub mod wireguard {
-    use std::net::{Ipv4Addr, Ipv6Addr};
+    use std::net::{IpAddr, Ipv4Addr};
 
     pub const WG_PORT: u16 = 51822;
 
     // The interface used to route traffic
     pub const WG_TUN_BASE_NAME: &str = "nymwg";
     pub const WG_TUN_DEVICE_ADDRESS: &str = "10.1.0.1";
-    pub const WG_TUN_DEVICE_IP_ADDRESS_V4: Ipv4Addr = Ipv4Addr::new(10, 1, 0, 1);
-    pub const WG_TUN_DEVICE_NETMASK_V4: u8 = 16;
-    pub const WG_TUN_DEVICE_IP_ADDRESS_V6: Ipv6Addr = Ipv6Addr::new(0xfc01, 0, 0, 0, 0, 0, 0, 0x1); // fc01::1
-    pub const WG_TUN_DEVICE_NETMASK_V6: u8 = 112;
+    pub const WG_TUN_DEVICE_IP_ADDRESS: IpAddr = IpAddr::V4(Ipv4Addr::new(10, 1, 0, 1));
+    pub const WG_TUN_DEVICE_NETMASK: &str = "255.255.255.0";
 }

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

@@ -28,9 +28,3 @@ impl From<ConnectionError> for Socks5ClientCoreError {
         }
     }
 }
-
-impl nym_task::TaskStatusEvent for Socks5ClientCoreError {
-    fn as_any(&self) -> &dyn std::any::Any {
-        self
-    }
-}

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

@@ -23,7 +23,8 @@ use nym_client_core::init::types::GatewaySetup;
 use nym_credential_storage::storage::Storage as CredentialStorage;
 use nym_sphinx::addressing::clients::Recipient;
 use nym_sphinx::params::PacketType;
-use nym_task::{TaskClient, TaskHandle, TaskStatus};
+use nym_task::manager::TaskStatus;
+use nym_task::{TaskClient, TaskHandle};
 
 use anyhow::anyhow;
 use nym_validator_client::UserAgent;

common/statistics/Cargo.toml

@@ -11,16 +11,7 @@ license.workspace = true
 
 [dependencies]
 futures = { workspace = true }
-log = { workspace = true }
-sysinfo = { workspace = true }
-serde = { workspace = true }
-serde_json = { workspace = true }
-thiserror = { workspace = true }
 time = { workspace = true }
-tokio = { workspace = true }
-si-scale = { workspace = true }
 
 nym-sphinx = { path = "../nymsphinx" }
 nym-credentials-interface = { path = "../credentials-interface" }
-nym-metrics = { path = "../nym-metrics" }
-nym-task = { path = "../task" }

common/statistics/src/clients/gateway_conn_statistics.rs

@@ -1,83 +0,0 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-//! # Gateway Connection statistics
-//!
-//! Metrics collected by the client while establishing and maintaining connections to the gateway.
-
-use super::ClientStatsEvents;
-use std::collections::VecDeque;
-
-use nym_metrics::{inc, inc_by};
-use serde::{Deserialize, Serialize};
-
-#[derive(Default, Debug, Clone, Serialize, Deserialize)]
-pub(crate) struct GatewayStats {
-    // Sent
-    real_packets_sent: u64,
-    real_packets_sent_size: usize,
-
-    /// failed connection statistics
-    failures: VecDeque<()>, // TODO
-}
-
-impl GatewayStats {
-    fn handle(&mut self, event: GatewayStatsEvent) {
-        match event {
-            GatewayStatsEvent::RealPacketSent(packet_size) => {
-                self.real_packets_sent += 1;
-                self.real_packets_sent_size += packet_size;
-                inc!("real_packets_sent");
-                inc_by!("real_packets_sent_size", packet_size);
-            }
-        }
-    }
-
-    fn summary(&self) -> (String, String) {
-        (
-            format!("packets sent: {}", self.real_packets_sent),
-            "packets received: todo".to_owned(),
-        )
-    }
-}
-
-impl From<GatewayStatsEvent> for ClientStatsEvents {
-    fn from(event: GatewayStatsEvent) -> ClientStatsEvents {
-        ClientStatsEvents::GatewayConn(event)
-    }
-}
-
-/// Event space for Gateway Connection Events
-#[derive(Debug)]
-pub enum GatewayStatsEvent {
-    /// The real packets sent. Recall that acks are sent by the gateway, so it's not included here.
-    RealPacketSent(usize),
-}
-
-/// Gateway Statistics Tracking
-#[derive(Default)]
-pub struct GatewayStatsControl {
-    // Keep track of packet statistics over time
-    stats: GatewayStats,
-}
-
-impl GatewayStatsControl {
-    pub(crate) fn handle_event(&mut self, event: GatewayStatsEvent) {
-        self.stats.handle(event)
-    }
-
-    pub(crate) fn report(&self) -> GatewayStats {
-        self.stats.clone()
-    }
-
-    pub(crate) fn local_report(&self) {
-        self.report_counters();
-    }
-
-    fn report_counters(&self) {
-        log::trace!("packet statistics: {:?}", &self.stats);
-        let (summary_sent, summary_recv) = self.stats.summary();
-        log::debug!("{}", summary_sent);
-        log::debug!("{}", summary_recv);
-    }
-}

common/statistics/src/clients/mod.rs

@@ -1,135 +0,0 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::report::{ClientStatsReport, OsInformation};
-
-use nym_task::TaskClient;
-use time::{OffsetDateTime, Time};
-use tokio::sync::mpsc::UnboundedSender;
-
-/// Active gateway connection statistics.
-pub mod gateway_conn_statistics;
-
-/// Nym API connection statistics.
-pub mod nym_api_statistics;
-
-/// Packet count based statistics.
-pub mod packet_statistics;
-
-/// Channel receiving generic stats events to be used by a statistics aggregator.
-pub type ClientStatsReceiver = tokio::sync::mpsc::UnboundedReceiver<ClientStatsEvents>;
-
-/// Channel allowing generic statistics events to be reported to a stats event aggregator
-#[derive(Clone)]
-pub struct ClientStatsSender {
-    stats_tx: Option<UnboundedSender<ClientStatsEvents>>,
-}
-
-impl ClientStatsSender {
-    /// Create a new statistics Sender
-    pub fn new(stats_tx: Option<UnboundedSender<ClientStatsEvents>>) -> Self {
-        ClientStatsSender { stats_tx }
-    }
-
-    /// Report a statistics event using the sender.
-    pub fn report(&mut self, event: ClientStatsEvents) {
-        if let Some(tx) = self.stats_tx.as_mut() {
-            if let Err(err) = tx.send(event) {
-                log::error!("Failed to send stats event: {:?}", err);
-            }
-        }
-    }
-}
-
-/// Client Statistics events (static for now)
-pub enum ClientStatsEvents {
-    /// Packet count events
-    PacketStatistics(packet_statistics::PacketStatisticsEvent),
-    /// Gateway Connection events
-    GatewayConn(gateway_conn_statistics::GatewayStatsEvent),
-    /// Nym API connection events
-    NymApi(nym_api_statistics::NymApiStatsEvent),
-}
-
-/// Controls stats event handling and reporting
-pub struct ClientStatsController {
-    //static infos
-    last_update_time: OffsetDateTime,
-    client_id: String,
-    client_type: String,
-    os_information: OsInformation,
-
-    // stats collection modules
-    packet_stats: packet_statistics::PacketStatisticsControl,
-    gateway_conn_stats: gateway_conn_statistics::GatewayStatsControl,
-    nym_api_stats: nym_api_statistics::NymApiStatsControl,
-}
-
-impl ClientStatsController {
-    /// Creates a ClientStatsController given a client_id
-    pub fn new(client_id: String, client_type: String) -> Self {
-        ClientStatsController {
-            last_update_time: ClientStatsController::get_update_time(),
-            client_id,
-            client_type,
-            os_information: OsInformation::new(),
-            packet_stats: Default::default(),
-            gateway_conn_stats: Default::default(),
-            nym_api_stats: Default::default(),
-        }
-    }
-    /// Returns a static ClientStatsReport that can be sent somewhere
-    pub fn build_report(&self) -> ClientStatsReport {
-        ClientStatsReport {
-            last_update_time: self.last_update_time,
-            client_id: self.client_id.clone(),
-            client_type: self.client_type.clone(),
-            os_information: self.os_information.clone(),
-            packet_stats: self.packet_stats.report(),
-            gateway_conn_stats: self.gateway_conn_stats.report(),
-            nym_api_stats: self.nym_api_stats.report(),
-        }
-    }
-
-    /// Handle and dispatch incoming stats event
-    pub fn handle_event(&mut self, stats_event: ClientStatsEvents) {
-        match stats_event {
-            ClientStatsEvents::PacketStatistics(event) => self.packet_stats.handle_event(event),
-            ClientStatsEvents::GatewayConn(event) => self.gateway_conn_stats.handle_event(event),
-            ClientStatsEvents::NymApi(event) => self.nym_api_stats.handle_event(event),
-        }
-    }
-
-    /// Reset the metrics to their initial state.
-    ///
-    /// Used to periodically reset the metrics in accordance with periodic reporting strategy
-    pub fn reset(&mut self) {
-        self.nym_api_stats = Default::default();
-        self.gateway_conn_stats = Default::default();
-        //no periodic reset for packet stats
-
-        self.last_update_time = ClientStatsController::get_update_time();
-    }
-
-    /// snapshot the current state of the metrics for module that needs it
-    pub fn snapshot(&mut self) {
-        //no snapshot for gateway_conn_stats
-        //no snapshot for nym_api_stats
-        self.packet_stats.snapshot();
-    }
-
-    pub fn local_report(&mut self, task_client: &mut TaskClient) {
-        self.packet_stats.local_report(task_client);
-        self.gateway_conn_stats.local_report();
-        self.nym_api_stats.local_report();
-    }
-
-    fn get_update_time() -> OffsetDateTime {
-        let now = OffsetDateTime::now_utc();
-        #[allow(clippy::unwrap_used)]
-        //Safety : 0 is always a valid number of seconds, hours and minutes comes from a valid source
-        let new_time = Time::from_hms(now.hour(), now.minute(), 0).unwrap();
-        //allows a bigger anonymity by hiding exact sending time
-        now.replace_time(new_time)
-    }
-}

common/statistics/src/clients/nym_api_statistics.rs

@@ -1,83 +0,0 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-//! # API Connection statistics
-//!
-//! Metrics collected by the client while attempting to pull config from the API.
-
-use super::ClientStatsEvents;
-use std::collections::VecDeque;
-
-use nym_metrics::{inc, inc_by};
-use serde::{Deserialize, Serialize};
-
-#[derive(Default, Debug, Clone, Serialize, Deserialize)]
-pub(crate) struct NymApiStats {
-    // Sent
-    real_packets_sent: u64,
-    real_packets_sent_size: usize,
-
-    /// API connection failure statistics
-    failures: VecDeque<()>, // TODO
-}
-
-impl NymApiStats {
-    fn handle(&mut self, event: NymApiStatsEvent) {
-        match event {
-            NymApiStatsEvent::RealPacketSent(packet_size) => {
-                self.real_packets_sent += 1;
-                self.real_packets_sent_size += packet_size;
-                inc!("real_packets_sent");
-                inc_by!("real_packets_sent_size", packet_size);
-            }
-        }
-    }
-
-    fn summary(&self) -> (String, String) {
-        (
-            format!("packets sent: {}", self.real_packets_sent,),
-            "packets received: todo".to_owned(),
-        )
-    }
-}
-
-/// Event space for Nym API statistics tracking
-#[derive(Debug)]
-pub enum NymApiStatsEvent {
-    /// The real packets sent. Recall that acks are sent by the Api, so it's not included here.
-    RealPacketSent(usize),
-}
-
-impl From<NymApiStatsEvent> for ClientStatsEvents {
-    fn from(event: NymApiStatsEvent) -> ClientStatsEvents {
-        ClientStatsEvents::NymApi(event)
-    }
-}
-
-/// Nym API statistics tracking object
-#[derive(Default)]
-pub struct NymApiStatsControl {
-    // Keep track of packet statistics over time
-    stats: NymApiStats,
-}
-
-impl NymApiStatsControl {
-    pub(crate) fn handle_event(&mut self, event: NymApiStatsEvent) {
-        self.stats.handle(event)
-    }
-
-    pub(crate) fn report(&self) -> NymApiStats {
-        self.stats.clone()
-    }
-
-    pub(crate) fn local_report(&self) {
-        self.report_counters();
-    }
-
-    fn report_counters(&self) {
-        log::trace!("packet statistics: {:?}", &self.stats);
-        let (summary_sent, summary_recv) = self.stats.summary();
-        log::debug!("{}", summary_sent);
-        log::debug!("{}", summary_recv);
-    }
-}

common/statistics/src/error.rs

@@ -1,15 +0,0 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use thiserror::Error;
-
-/// Error types occurring while processing statistics events and reporting.
-#[derive(Debug, Error)]
-#[allow(missing_docs)]
-pub enum StatsError {
-    #[error("Failed to (de)serialize stats report : {0}")]
-    ReportJsonSerialization(#[from] serde_json::Error),
-}
-
-/// Result of a statistics operation.
-pub type Result<T> = core::result::Result<T, StatsError>;

common/statistics/src/events.rs

@@ -0,0 +1,54 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: GPL-3.0-only
+
+use futures::channel::mpsc;
+use nym_credentials_interface::TicketType;
+use nym_sphinx::DestinationAddressBytes;
+use time::OffsetDateTime;
+
+pub type StatsEventSender = mpsc::UnboundedSender<StatsEvent>;
+pub type StatsEventReceiver = mpsc::UnboundedReceiver<StatsEvent>;
+pub enum StatsEvent {
+    SessionStatsEvent(SessionEvent),
+}
+
+impl StatsEvent {
+    pub fn new_session_start(client: DestinationAddressBytes) -> StatsEvent {
+        StatsEvent::SessionStatsEvent(SessionEvent::SessionStart {
+            start_time: OffsetDateTime::now_utc(),
+            client,
+        })
+    }
+
+    pub fn new_session_stop(client: DestinationAddressBytes) -> StatsEvent {
+        StatsEvent::SessionStatsEvent(SessionEvent::SessionStop {
+            stop_time: OffsetDateTime::now_utc(),
+            client,
+        })
+    }
+
+    pub fn new_ecash_ticket(
+        client: DestinationAddressBytes,
+        ticket_type: TicketType,
+    ) -> StatsEvent {
+        StatsEvent::SessionStatsEvent(SessionEvent::EcashTicket {
+            ticket_type,
+            client,
+        })
+    }
+}
+
+pub enum SessionEvent {
+    SessionStart {
+        start_time: OffsetDateTime,
+        client: DestinationAddressBytes,
+    },
+    SessionStop {
+        stop_time: OffsetDateTime,
+        client: DestinationAddressBytes,
+    },
+    EcashTicket {
+        ticket_type: TicketType,
+        client: DestinationAddressBytes,
+    },
+}

common/statistics/src/gateways.rs

@@ -1,89 +0,0 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use nym_credentials_interface::TicketType;
-use nym_sphinx::DestinationAddressBytes;
-use time::OffsetDateTime;
-
-/// Channel for receiving incoming Stats events
-pub type GatewayStatsReceiver = tokio::sync::mpsc::UnboundedReceiver<GatewayStatsEvent>;
-
-/// Channel allowing for generic statistics events to be reported to a stats event aggregator.
-#[derive(Clone)]
-pub struct GatewayStatsReporter {
-    stats_tx: tokio::sync::mpsc::UnboundedSender<GatewayStatsEvent>,
-}
-
-impl GatewayStatsReporter {
-    /// Construct a new gateway statistics event reporter
-    pub fn new(stats_tx: tokio::sync::mpsc::UnboundedSender<GatewayStatsEvent>) -> Self {
-        Self { stats_tx }
-    }
-
-    /// Report a gateway statistivs event using the reporter
-    pub fn report(&self, event: GatewayStatsEvent) {
-        self.stats_tx.send(event).unwrap_or_else(|err| {
-            log::error!("Failed to report gateway stat event : {err}");
-        });
-    }
-}
-
-/// Gateway Statistics events
-pub enum GatewayStatsEvent {
-    /// Events in the lifecycle of an established client tunnel
-    SessionStatsEvent(SessionEvent),
-}
-
-impl GatewayStatsEvent {
-    /// A new session between this gateway and the client remote has successfully opened
-    pub fn new_session_start(client: DestinationAddressBytes) -> GatewayStatsEvent {
-        GatewayStatsEvent::SessionStatsEvent(SessionEvent::SessionStart {
-            start_time: OffsetDateTime::now_utc(),
-            client,
-        })
-    }
-
-    /// An existing session with the client remote has ended
-    pub fn new_session_stop(client: DestinationAddressBytes) -> GatewayStatsEvent {
-        GatewayStatsEvent::SessionStatsEvent(SessionEvent::SessionStop {
-            stop_time: OffsetDateTime::now_utc(),
-            client,
-        })
-    }
-
-    /// A new ecash ticket has been added / requested
-    pub fn new_ecash_ticket(
-        client: DestinationAddressBytes,
-        ticket_type: TicketType,
-    ) -> GatewayStatsEvent {
-        GatewayStatsEvent::SessionStatsEvent(SessionEvent::EcashTicket {
-            ticket_type,
-            client,
-        })
-    }
-}
-
-/// Events in the lifecycle of an established client tunnel
-pub enum SessionEvent {
-    /// A new session between this gateway and the client remote has successfully opened
-    SessionStart {
-        /// The timestamp of the session open event
-        start_time: OffsetDateTime,
-        /// Address of the remote client opening the connection
-        client: DestinationAddressBytes,
-    },
-    /// An existing session with the client remote has ended
-    SessionStop {
-        /// Timestamp of the session end event
-        stop_time: OffsetDateTime,
-        /// Address of the remote client opening the connection
-        client: DestinationAddressBytes,
-    },
-    /// A new ecash ticket has been added / requested
-    EcashTicket {
-        /// Type of ecash ticket that has been created as part of the session
-        ticket_type: TicketType,
-        /// Address of the remote client opening the connection
-        client: DestinationAddressBytes,
-    },
-}

common/statistics/src/lib.rs

@@ -1,69 +1,4 @@
 // Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: GPL-3.0-only
 
-//! Nym Statistics
-//!
-//! This crate contains basic statistics utilities and abstractions to be re-used and
-//! applied throughout both the client and gateway implementations.
-
-#![warn(clippy::expect_used)]
-#![warn(clippy::unwrap_used)]
-#![warn(clippy::todo)]
-#![warn(clippy::dbg_macro)]
-
-use nym_sphinx::addressing::Recipient;
-
-/// Client specific statistics interfaces and events.
-pub mod clients;
-/// Statistics related errors.
-pub mod error;
-/// Gateway specific statistics interfaces and events.
-pub mod gateways;
-/// Statistics reporting abstractions and implementations.
-pub mod report;
-
-/// Stats Reporting config to use when stats reporting is wanted
-#[derive(Clone, Debug)]
-pub struct StatsReportingConfig {
-    /// Client address to report to
-    pub reporting_address: Recipient,
-
-    /// Type of client reporting (vpn_client, authenticator, native-client)
-    pub reporting_type: String,
-}
-
-impl StatsReportingConfig {
-    /// Create a StatsReportingConfig for a native client
-    pub fn new_native(reporting_address: Recipient) -> Self {
-        StatsReportingConfig {
-            reporting_address,
-            reporting_type: NATIVE_CLIENT.to_string(),
-        }
-    }
-    /// Create a StatsReportingConfig for a vpn client
-    pub fn new_vpn(reporting_address: Recipient) -> Self {
-        StatsReportingConfig {
-            reporting_address,
-            reporting_type: VPN_CLIENT.to_string(),
-        }
-    }
-    /// Create a StatsReportingConfig for a socks5 client
-    pub fn new_socks5(reporting_address: Recipient) -> Self {
-        StatsReportingConfig {
-            reporting_address,
-            reporting_type: SOCKS5_CLIENT.to_string(),
-        }
-    }
-    /// Create a StatsReportingConfig for an unspecified client
-    pub fn new_unknown(reporting_address: Recipient) -> Self {
-        StatsReportingConfig {
-            reporting_address,
-            reporting_type: UNKNOWN.to_string(),
-        }
-    }
-}
-
-const VPN_CLIENT: &str = "vpn_client";
-const NATIVE_CLIENT: &str = "native_client";
-const SOCKS5_CLIENT: &str = "socks5_client";
-const UNKNOWN: &str = "unknown";
+pub mod events;

common/statistics/src/report.rs

@@ -1,64 +0,0 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::clients::{
-    gateway_conn_statistics::GatewayStats, nym_api_statistics::NymApiStats,
-    packet_statistics::PacketStatistics,
-};
-
-use super::error::StatsError;
-
-use serde::{Deserialize, Serialize};
-use sysinfo::System;
-use time::OffsetDateTime;
-
-/// Report object containing both data to be reported and client / device context. We take extra care not to overcapture context information.
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct ClientStatsReport {
-    pub(crate) last_update_time: OffsetDateTime,
-    pub(crate) client_id: String,
-    pub(crate) client_type: String,
-    pub(crate) os_information: OsInformation,
-    pub(crate) packet_stats: PacketStatistics,
-    pub(crate) gateway_conn_stats: GatewayStats,
-    pub(crate) nym_api_stats: NymApiStats,
-}
-
-impl From<ClientStatsReport> for Vec<u8> {
-    fn from(value: ClientStatsReport) -> Self {
-        // safety, no custom serialisation
-        #[allow(clippy::unwrap_used)]
-        let report_json = serde_json::to_string(&value).unwrap();
-        report_json.as_bytes().to_vec()
-    }
-}
-
-impl TryFrom<&[u8]> for ClientStatsReport {
-    type Error = StatsError;
-    fn try_from(value: &[u8]) -> Result<Self, Self::Error> {
-        Ok(serde_json::from_slice(value)?)
-    }
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct OsInformation {
-    pub(crate) os_type: String,
-    pub(crate) os_version: Option<String>,
-    pub(crate) os_arch: Option<String>,
-}
-
-impl OsInformation {
-    pub fn new() -> Self {
-        OsInformation {
-            os_type: System::distribution_id(),
-            os_version: System::long_os_version(),
-            os_arch: System::cpu_arch(),
-        }
-    }
-}
-
-impl Default for OsInformation {
-    fn default() -> Self {
-        Self::new()
-    }
-}

common/task/src/event.rs

@@ -1,35 +0,0 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use std::{any::Any, fmt};
-
-pub type SentStatus = Box<dyn TaskStatusEvent>;
-pub type StatusSender = futures::channel::mpsc::Sender<SentStatus>;
-pub type StatusReceiver = futures::channel::mpsc::Receiver<SentStatus>;
-
-pub trait TaskStatusEvent: Send + Sync + Any + fmt::Display {
-    fn as_any(&self) -> &dyn Any;
-}
-
-#[derive(Debug, PartialEq, Eq)]
-pub enum TaskStatus {
-    Ready,
-    ReadyWithGateway(String),
-}
-
-impl fmt::Display for TaskStatus {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            TaskStatus::Ready => write!(f, "Ready"),
-            TaskStatus::ReadyWithGateway(gateway) => {
-                write!(f, "Ready and connected to gateway: {gateway}")
-            }
-        }
-    }
-}
-
-impl TaskStatusEvent for TaskStatus {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-}

common/task/src/lib.rs

@@ -2,14 +2,12 @@
 // SPDX-License-Identifier: Apache-2.0
 
 pub mod connections;
-pub mod event;
 pub mod manager;
 #[cfg(not(target_arch = "wasm32"))]
 pub mod signal;
 pub mod spawn;
 
-pub use event::{StatusReceiver, StatusSender, TaskStatus, TaskStatusEvent};
-pub use manager::{TaskClient, TaskHandle, TaskManager};
+pub use manager::{StatusReceiver, StatusSender, TaskClient, TaskHandle, TaskManager};
 #[cfg(not(target_arch = "wasm32"))]
 pub use signal::wait_for_signal_and_error;
 

common/task/src/manager.rs

@@ -1,21 +1,15 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use std::{
-    error::Error,
-    sync::atomic::{AtomicBool, Ordering},
-    time::Duration,
-};
-
 use futures::{future::pending, FutureExt, SinkExt, StreamExt};
 use log::{log, Level};
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::{error::Error, time::Duration};
 use tokio::sync::{
     mpsc,
     watch::{self, error::SendError},
 };
 
-use crate::event::{SentStatus, StatusReceiver, StatusSender, TaskStatus};
-
 #[cfg(not(target_arch = "wasm32"))]
 use tokio::time::{sleep, timeout};
 
@@ -28,6 +22,10 @@ pub(crate) type SentError = Box<dyn Error + Send + Sync>;
 type ErrorSender = mpsc::UnboundedSender<SentError>;
 type ErrorReceiver = mpsc::UnboundedReceiver<SentError>;
 
+pub type SentStatus = Box<dyn Error + Send + Sync>;
+pub type StatusSender = futures::channel::mpsc::Sender<SentStatus>;
+pub type StatusReceiver = futures::channel::mpsc::Receiver<SentStatus>;
+
 fn try_recover_name(name: &Option<String>) -> String {
     if let Some(name) = name {
         name.clone()
@@ -42,6 +40,15 @@ enum TaskError {
     UnexpectedHalt { shutdown_name: Option<String> },
 }
 
+// TODO: possibly we should create a `Status` trait instead of reusing `Error`
+#[derive(thiserror::Error, Debug, PartialEq, Eq)]
+pub enum TaskStatus {
+    #[error("Ready")]
+    Ready,
+    #[error("Ready and connected to gateway: {0}")]
+    ReadyWithGateway(String),
+}
+
 /// Listens to status and error messages from tasks, as well as notifying them to gracefully
 /// shutdown. Keeps track of if task stop unexpectedly, such as in a panic.
 #[derive(Debug)]

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

@@ -68,7 +68,7 @@ pub async fn current_network_topology_async(
 
     let api_client = NymApiClient::new(url);
     let mixnodes = api_client
-        .get_all_basic_active_mixing_assigned_nodes(None)
+        .get_basic_active_mixing_assigned_nodes(None)
         .await?;
     let gateways = api_client.get_all_basic_entry_assigned_nodes(None).await?;
 

common/wireguard-types/src/config.rs

@@ -1,7 +1,7 @@
 // Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr};
+use std::net::{IpAddr, SocketAddr};
 
 #[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Debug)]
 pub struct Config {
@@ -9,23 +9,15 @@ pub struct Config {
     /// default: `0.0.0.0:51822`
     pub bind_address: SocketAddr,
 
-    /// Private IPv4 address of the wireguard gateway.
+    /// Private IP address of the wireguard gateway.
     /// default: `10.1.0.1`
-    pub private_ipv4: Ipv4Addr,
-
-    /// Private IPv6 address of the wireguard gateway.
-    /// default: `fc01::1`
-    pub private_ipv6: Ipv6Addr,
+    pub private_ip: IpAddr,
 
     /// Port announced to external clients wishing to connect to the wireguard interface.
     /// Useful in the instances where the node is behind a proxy.
     pub announced_port: u16,
 
-    /// The prefix denoting the maximum number of the clients that can be connected via Wireguard using IPv4.
-    /// The maximum value for IPv4 is 32
-    pub private_network_prefix_v4: u8,
-
-    /// The prefix denoting the maximum number of the clients that can be connected via Wireguard using IPv6.
-    /// The maximum value for IPv6 is 128
-    pub private_network_prefix_v6: u8,
+    /// The prefix denoting the maximum number of the clients that can be connected via Wireguard.
+    /// The maximum value for IPv4 is 32 and for IPv6 is 128
+    pub private_network_prefix: u8,
 }

common/wireguard/src/lib.rs

@@ -10,13 +10,13 @@ use defguard_wireguard_rs::WGApi;
 #[cfg(target_os = "linux")]
 use defguard_wireguard_rs::{host::Peer, key::Key, net::IpAddrMask};
 use nym_crypto::asymmetric::encryption::KeyPair;
-#[cfg(target_os = "linux")]
-use nym_network_defaults::constants::WG_TUN_BASE_NAME;
 use nym_wireguard_types::Config;
 use peer_controller::PeerControlRequest;
 use std::sync::Arc;
 use tokio::sync::mpsc::{self, Receiver, Sender};
 
+const WG_TUN_NAME: &str = "nymwg";
+
 pub(crate) mod error;
 pub mod peer_controller;
 pub mod peer_handle;
@@ -93,72 +93,41 @@ pub async fn start_wireguard<St: nym_gateway_storage::Storage + Clone + 'static>
     use std::collections::HashMap;
     use tokio::sync::RwLock;
 
-    let ifname = String::from(WG_TUN_BASE_NAME);
+    let ifname = String::from(WG_TUN_NAME);
     let wg_api = defguard_wireguard_rs::WGApi::new(ifname.clone(), false)?;
     let mut peer_bandwidth_managers = HashMap::with_capacity(all_peers.len());
     let peers = all_peers
         .into_iter()
         .map(Peer::try_from)
-        .collect::<Result<Vec<_>, _>>()?
-        .into_iter()
-        .map(|mut peer| {
-            // since WGApi doesn't set those values on init, let's set them to 0
-            peer.rx_bytes = 0;
-            peer.tx_bytes = 0;
-            peer
-        })
-        .collect::<Vec<_>>();
+        .collect::<Result<Vec<_>, _>>()?;
     for peer in peers.iter() {
         let bandwidth_manager =
             PeerController::generate_bandwidth_manager(storage.clone(), &peer.public_key)
                 .await?
                 .map(|bw_m| Arc::new(RwLock::new(bw_m)));
-        // Update storage with *x_bytes set to 0, as in kernel peers we can't set those values
-        // so we need to restart counting. Hopefully the bandwidth was counted in available_bandwidth
-        storage
-            .insert_wireguard_peer(peer, bandwidth_manager.is_some())
-            .await?;
         peer_bandwidth_managers.insert(peer.public_key.clone(), bandwidth_manager);
     }
     wg_api.create_interface()?;
     let interface_config = InterfaceConfiguration {
         name: ifname.clone(),
         prvkey: BASE64_STANDARD.encode(wireguard_data.inner.keypair().private_key().to_bytes()),
-        address: wireguard_data.inner.config().private_ipv4.to_string(),
+        address: wireguard_data.inner.config().private_ip.to_string(),
         port: wireguard_data.inner.config().announced_port as u32,
         peers,
         mtu: None,
     };
     wg_api.configure_interface(&interface_config)?;
-    std::process::Command::new("ip")
-        .args([
-            "-6",
-            "addr",
-            "add",
-            &format!(
-                "{}/{}",
-                wireguard_data.inner.config().private_ipv6,
-                wireguard_data.inner.config().private_network_prefix_v6
-            ),
-            "dev",
-            (&ifname),
-        ])
-        .output()?;
 
     // Use a dummy peer to create routing rule for the entire network space
     let mut catch_all_peer = Peer::new(Key::new([0; 32]));
-    let network_v4 = IpNetwork::new_truncate(
-        wireguard_data.inner.config().private_ipv4,
-        wireguard_data.inner.config().private_network_prefix_v4,
+    let network = IpNetwork::new_truncate(
+        wireguard_data.inner.config().private_ip,
+        wireguard_data.inner.config().private_network_prefix,
     )?;
-    let network_v6 = IpNetwork::new_truncate(
-        wireguard_data.inner.config().private_ipv6,
-        wireguard_data.inner.config().private_network_prefix_v6,
-    )?;
-    catch_all_peer.set_allowed_ips(vec![
-        IpAddrMask::new(network_v4.network_address(), network_v4.netmask()),
-        IpAddrMask::new(network_v6.network_address(), network_v6.netmask()),
-    ]);
+    catch_all_peer.set_allowed_ips(vec![IpAddrMask::new(
+        network.network_address(),
+        network.netmask(),
+    )]);
     wg_api.configure_peer_routing(&[catch_all_peer])?;
 
     let host = wg_api.read_interface_data()?;

common/wireguard/src/peer_handle.rs

@@ -75,8 +75,8 @@ impl<St: Storage + Clone + 'static> PeerHandle<St> {
 
     async fn active_peer(
         &mut self,
-        storage_peer: &WireguardPeer,
-        kernel_peer: &Peer,
+        storage_peer: WireguardPeer,
+        kernel_peer: Peer,
     ) -> Result<bool, Error> {
         if let Some(bandwidth_manager) = &self.bandwidth_storage_manager {
             let spent_bandwidth = (kernel_peer.rx_bytes + kernel_peer.tx_bytes)
@@ -136,12 +136,9 @@ impl<St: Storage + Clone + 'static> PeerHandle<St> {
                         log::debug!("Peer {:?} not in storage anymore, shutting down handle", self.public_key);
                         return Ok(());
                     };
-                    if !self.active_peer(&storage_peer, &kernel_peer).await? {
+                    if !self.active_peer(storage_peer, kernel_peer).await? {
                         log::debug!("Peer {:?} doesn't have bandwidth anymore, shutting down handle", self.public_key);
                         return Ok(());
-                    } else {
-                        // Update storage values
-                        self.storage.insert_wireguard_peer(&kernel_peer, self.bandwidth_storage_manager.is_some()).await?;
                     }
                 }
 

contracts/ecash/src/contract/mod.rs

@@ -30,7 +30,6 @@ use sylvia::{contract, entry_points};
 
 mod helpers;
 
-mod queued_migrations;
 #[cfg(test)]
 mod test;
 
@@ -106,6 +105,7 @@ impl NymEcashContract<'_> {
             &Config {
                 group_addr,
                 holding_account,
+                redemption_gateway_share: Decimal::percent(5),
                 deposit_amount,
             },
         )?;
@@ -447,8 +447,6 @@ impl NymEcashContract<'_> {
         set_build_information!(ctx.deps.storage)?;
         cw2::ensure_from_older_version(ctx.deps.storage, CONTRACT_NAME, CONTRACT_VERSION)?;
 
-        queued_migrations::remove_redemption_gateway_share(ctx.deps)?;
-
         Ok(Response::new())
     }
 }

contracts/ecash/src/contract/queued_migrations.rs

@@ -1,42 +0,0 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::contract::NymEcashContract;
-use crate::helpers::Config;
-use cosmwasm_std::{Addr, Coin, Decimal, DepsMut};
-use cw4::Cw4Contract;
-use cw_storage_plus::Item;
-use nym_ecash_contract_common::EcashContractError;
-use serde::{Deserialize, Serialize};
-
-pub fn remove_redemption_gateway_share(deps: DepsMut) -> Result<(), EcashContractError> {
-    #[derive(Serialize, Deserialize)]
-    struct OldConfig {
-        group_addr: Cw4Contract,
-        holding_account: Addr,
-
-        redemption_gateway_share: Decimal,
-        deposit_amount: Coin,
-    }
-
-    impl From<OldConfig> for Config {
-        fn from(config: OldConfig) -> Self {
-            Config {
-                group_addr: config.group_addr,
-                holding_account: config.holding_account,
-                deposit_amount: config.deposit_amount,
-            }
-        }
-    }
-
-    const OLD_CONFIG: Item<OldConfig> = Item::new("config");
-
-    let old_config = OLD_CONFIG.load(deps.storage)?;
-    let new_config = old_config.into();
-
-    NymEcashContract::new()
-        .config
-        .save(deps.storage, &new_config)?;
-
-    Ok(())
-}

contracts/ecash/src/helpers.rs

@@ -3,7 +3,8 @@
 
 use crate::constants::{BLACKLIST_PROPOSAL_REPLY_ID, REDEMPTION_PROPOSAL_REPLY_ID};
 use cosmwasm_std::{
-    to_binary, Addr, Coin, CosmosMsg, Reply, StdError, StdResult, SubMsg, SubMsgResult, WasmMsg,
+    to_binary, Addr, Coin, CosmosMsg, Decimal, Reply, StdError, StdResult, SubMsg, SubMsgResult,
+    WasmMsg,
 };
 use cw4::Cw4Contract;
 use nym_contracts_common::events::try_find_attribute;
@@ -21,6 +22,8 @@ pub(crate) const CONTRACT_VERSION: &str = env!("CARGO_PKG_VERSION");
 pub struct Config {
     pub group_addr: Cw4Contract,
     pub holding_account: Addr,
+
+    pub redemption_gateway_share: Decimal,
     pub deposit_amount: Coin,
 }
 

contracts/mixnet/src/gateways/transactions.rs

@@ -4,7 +4,6 @@
 use super::helpers::must_get_gateway_bond_by_owner;
 use super::storage;
 use crate::constants::default_node_costs;
-use crate::interval::storage as interval_storage;
 use crate::mixnet_contract_settings::storage as mixnet_params_storage;
 use crate::nodes::helpers::save_new_nymnode_with_id;
 use crate::nodes::transactions::add_nym_node_inner;
@@ -116,10 +115,6 @@ pub fn try_migrate_to_nymnode(
             comment: "legacy gateway did not have a pre-assigned node id".to_string(),
         })?;
 
-    let current_epoch =
-        interval_storage::current_interval(deps.storage)?.current_epoch_absolute_id();
-    let previous_epoch = current_epoch.saturating_sub(1);
-
     // create nym-node entry
     // for gateways it's quite straightforward as there are no delegations or rewards to worry about
     save_new_nymnode_with_id(
@@ -130,7 +125,6 @@ pub fn try_migrate_to_nymnode(
         cost_params,
         info.sender.clone(),
         gateway_bond.pledge_amount,
-        previous_epoch,
     )?;
 
     storage::PREASSIGNED_LEGACY_IDS.remove(deps.storage, gateway_identity.clone());

contracts/mixnet/src/nodes/helpers.rs

@@ -22,8 +22,6 @@ pub(crate) fn save_new_nymnode(
     pledge: Coin,
 ) -> Result<NodeId, MixnetContractError> {
     let node_id = next_nymnode_id_counter(storage)?;
-    let current_epoch = interval_storage::current_interval(storage)?.current_epoch_absolute_id();
-
     save_new_nymnode_with_id(
         storage,
         node_id,
@@ -32,13 +30,11 @@ pub(crate) fn save_new_nymnode(
         cost_params,
         owner,
         pledge,
-        current_epoch,
     )?;
 
     Ok(node_id)
 }
 
-#[allow(clippy::too_many_arguments)]
 pub(crate) fn save_new_nymnode_with_id(
     storage: &mut dyn Storage,
     node_id: NodeId,
@@ -47,9 +43,10 @@ pub(crate) fn save_new_nymnode_with_id(
     cost_params: NodeCostParams,
     owner: Addr,
     pledge: Coin,
-    last_rewarding_epoch: u32,
 ) -> Result<(), MixnetContractError> {
-    let node_rewarding = NodeRewarding::initialise_new(cost_params, &pledge, last_rewarding_epoch)?;
+    let current_epoch = interval_storage::current_interval(storage)?.current_epoch_absolute_id();
+
+    let node_rewarding = NodeRewarding::initialise_new(cost_params, &pledge, current_epoch)?;
     let node_bond = NymNodeBond::new(node_id, owner, pledge, node, bonding_height);
 
     // save node bond data

documentation/.gitignore

@@ -1 +0,0 @@
-todo.md

documentation/README.md

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

documentation/autodoc/.gitignore

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

documentation/autodoc/Cargo.toml

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

documentation/autodoc/README.md

@@ -1,44 +0,0 @@
-# Autodoc
-
-WIP command output documentation generator. Run via `../scripts/next-scripts/autodoc.sh` to create a bunch of markdown files which are then moved around for importing into the documentation.
-
-## `Error: Os { code: 2, kind: NotFound, message: "No such file or directory" }`
-If you run into this error, make sure that you have the following directory structure:
-
-```sh
-autodoc/
-├── autodoc-generated-markdown/
-│     └── commands/
-├── Cargo.toml
-├── README.md
-└── src
-    └── main.rs
-```
-
-And if you don't - create it and re-run.
-
-If you are encountering this error with this dir structure in place, check that all Nym binaries that are listed in `main.rs` also exist in `nym/target/release/`.
-
-Run this crate on its own with `debug` logging and it should panic on the missing binary:
-
-```sh
- RUST_LOG="debug" cargo run --release
-    Finished `release` profile [optimized] target(s) in 0.20s
-     Running `/home/______/src/nym/target/release/autodoc`
-[2024-10-23T08:11:01Z DEBUG autodoc] now running Some(
-        "nym-api",
-    )
-[2024-10-23T08:11:01Z DEBUG autodoc] stderr: " 2024-10-23T08:11:01.981Z INFO  nym_api > Starting nym api...\n"
-[2024-10-23T08:11:01Z DEBUG autodoc] stderr: " 2024-10-23T08:11:01.985Z INFO  nym_api > Starting nym api...\n"
-[2024-10-23T08:11:01Z INFO  autodoc] SKIPPING ../../target/release/nym-api init
-[2024-10-23T08:11:01Z INFO  autodoc] creating own file for ../../target/release/nym-api init --help
-[2024-10-23T08:11:01Z DEBUG autodoc] stderr: " 2024-10-23T08:11:01.993Z INFO  nym_api > Starting nym api...\n"
-
-< snip >
-
-[2024-10-23T08:11:02Z DEBUG autodoc] now running Some(
-        "nym-cli",
-    )
-Error: Os { code: 2, kind: NotFound, message: "No such file or directory" }
-
-```

documentation/autodoc/autodoc-generated-markdown/nym-api-build-info-help.md

@@ -1,9 +0,0 @@
-```sh
-Show build information of this binary
-
-Usage: nym-api build-info [OPTIONS]
-
-Options:
-  -o, --output <OUTPUT>  [default: text] [possible values: text, json]
-  -h, --help             Print help
-```

documentation/autodoc/autodoc-generated-markdown/nym-api-build-info.md

@@ -1,13 +0,0 @@
-```sh
-
-Binary Name:        nym-api
-Build Timestamp:    2024-10-09T13:56:14.428750844Z
-Build Version:      1.1.42
-Commit SHA:         fac373c1db4fa5389ba61de7943c77023467bccb
-Commit Date:        2024-10-09T14:59:40.000000000+02:00
-Commit Branch:      max/new-docs-framework
-rustc Version:      1.80.0
-rustc Channel:      stable
-cargo Profile:      release
-
-```

documentation/autodoc/autodoc-generated-markdown/nym-api-commands.md

@@ -1,95 +0,0 @@
-# `nym-api` Binary Commands (Autogenerated)
-
-These docs are autogenerated by the [`autodocs`](https://github.com/nymtech/nym/tree/max/new-docs-framework/documentation/autodoc) script.
-```sh
-2024-10-29T09:51:44.008469Z  INFO nym-api/src/main.rs:41: Starting nym api...
-Usage: nym-api [OPTIONS] <COMMAND>
-
-Commands:
-  init        Initialise a Nym Api instance with persistent config.toml file
-  run         Run the Nym Api with provided configuration optionally overriding set parameters
-  build-info  Show build information of this binary
-  help        Print this message or the help of the given subcommand(s)
-
-Options:
-  -c, --config-env-file <CONFIG_ENV_FILE>
-          Path pointing to an env file that configures the Nym API [env: NYMAPI_CONFIG_ENV_FILE_ARG=]
-      --no-banner
-          A no-op flag included for consistency with other binaries (and compatibility with nymvisor, oops) [env: NYMAPI_NO_BANNER_ARG=]
-  -h, --help
-          Print help
-  -V, --version
-          Print version
-```
-
-### `init`
-```sh
-2024-10-29T09:51:44.013292Z  INFO nym-api/src/main.rs:41: Starting nym api...
-Initialise a Nym Api instance with persistent config.toml file
-
-Usage: nym-api init [OPTIONS]
-
-Options:
-      --id <ID>
-          Id of the nym-api we want to initialise. if unspecified, a default value will be used. default: "default" [env: NYMAPI_ID_ARG=] [default: default]
-  -m, --enable-monitor
-          Specifies whether network monitoring is enabled on this API default: false [env: NYMAPI_ENABLE_MONITOR_ARG=]
-  -r, --enable-rewarding
-          Specifies whether network rewarding is enabled on this API default: false [env: NYMAPI_ENABLE_REWARDING_ARG=]
-      --nyxd-validator <NYXD_VALIDATOR>
-          Endpoint to nyxd instance used for contract information. default: http://localhost:26657 [env: NYMAPI_NYXD_VALIDATOR_ARG=]
-      --mnemonic <MNEMONIC>
-          Mnemonic of the network monitor used for sending rewarding and zk-nyms transactions default: None [env: NYMAPI_MNEMONIC_ARG=]
-      --enable-zk-nym
-          Flag to indicate whether credential signer authority is enabled on this API default: false [env: NYMAPI_ENABLE_ZK_NYM_ARG=]
-      --announce-address <ANNOUNCE_ADDRESS>
-          Announced address that is going to be put in the DKG contract where zk-nym clients will connect to obtain their credentials default: None [env: NYMAPI_ANNOUNCE_ADDRESS_NYM_ARG=]
-      --monitor-credentials-mode
-          Set this nym api to work in a enabled credentials that would attempt to use gateway with the bandwidth credential requirement [env: NYMAPI_MONITOR_CREDENTIALS_MODE_ARG=]
-      --bind-address <BIND_ADDRESS>
-          Socket address this api will use for binding its http API. default: `127.0.0.1:8080` in `debug` builds and `0.0.0.0:8080` in `release`
-  -h, --help
-          Print help
-```
-
-### `run`
-```sh
-2024-10-29T09:51:44.032688Z  INFO nym-api/src/main.rs:41: Starting nym api...
-Run the Nym Api with provided configuration optionally overriding set parameters
-
-Usage: nym-api run [OPTIONS]
-
-Options:
-      --id <ID>
-          Id of the nym-api we want to run.if unspecified, a default value will be used. default: "default" [env: NYMAPI_ID_ARG=] [default: default]
-  -m, --enable-monitor <ENABLE_MONITOR>
-          Specifies whether network monitoring is enabled on this API default: None - config value will be used instead [env: NYMAPI_ENABLE_MONITOR_ARG=] [possible values: true, false]
-  -r, --enable-rewarding <ENABLE_REWARDING>
-          Specifies whether network rewarding is enabled on this API default: None - config value will be used instead [env: NYMAPI_ENABLE_REWARDING_ARG=] [possible values: true, false]
-      --nyxd-validator <NYXD_VALIDATOR>
-          Endpoint to nyxd instance used for contract information. default: None - config value will be used instead [env: NYMAPI_NYXD_VALIDATOR_ARG=]
-      --mnemonic <MNEMONIC>
-          Mnemonic of the network monitor used for sending rewarding and zk-nyms transactions default: None - config value will be used instead [env: NYMAPI_MNEMONIC_ARG=]
-      --enable-zk-nym <ENABLE_ZK_NYM>
-          Flag to indicate whether coconut signer authority is enabled on this API default: None - config value will be used instead [env: NYMAPI_ENABLE_ZK_NYM_ARG=] [possible values: true, false]
-      --announce-address <ANNOUNCE_ADDRESS>
-          Announced address that is going to be put in the DKG contract where zk-nym clients will connect to obtain their credentials default: None - config value will be used instead [env: NYMAPI_ANNOUNCE_ADDRESS_ARG=]
-      --monitor-credentials-mode <MONITOR_CREDENTIALS_MODE>
-          Set this nym api to work in a enabled credentials that would attempt to use gateway with the bandwidth credential requirement default: None - config value will be used instead [env: NYMAPI_MONITOR_CREDENTIALS_MODE_ARG=] [possible values: true, false]
-      --bind-address <BIND_ADDRESS>
-          Socket address this api will use for binding its http API. default: `127.0.0.1:8080` in `debug` builds and `0.0.0.0:8080` in `release`
-  -h, --help
-          Print help
-```
-
-### `build-info`
-```sh
-2024-10-29T09:51:44.037915Z  INFO nym-api/src/main.rs:41: Starting nym api...
-Show build information of this binary
-
-Usage: nym-api build-info [OPTIONS]
-
-Options:
-  -o, --output <OUTPUT>  [default: text] [possible values: text, json]
-  -h, --help             Print help
-```

documentation/autodoc/autodoc-generated-markdown/nym-api-init-help.md

@@ -1,25 +0,0 @@
-```sh
-Initialise a Nym Api instance with persistent config.toml file
-
-Usage: nym-api init [OPTIONS]
-
-Options:
-      --id <ID>
-          Id of the nym-api we want to initialise. if unspecified, a default value will be used. default: "default" [default: default]
-  -m, --enable-monitor
-          Specifies whether network monitoring is enabled on this API default: false
-  -r, --enable-rewarding
-          Specifies whether network rewarding is enabled on this API default: false
-      --nyxd-validator <NYXD_VALIDATOR>
-          Endpoint to nyxd instance used for contract information. default: http://localhost:26657
-      --mnemonic <MNEMONIC>
-          Mnemonic of the network monitor used for sending rewarding and zk-nyms transactions default: None
-      --enable-zk-nym
-          Flag to indicate whether credential signer authority is enabled on this API default: false
-      --announce-address <ANNOUNCE_ADDRESS>
-          Announced address that is going to be put in the DKG contract where zk-nym clients will connect to obtain their credentials default: None
-      --monitor-credentials-mode
-          Set this nym api to work in a enabled credentials that would attempt to use gateway with the bandwidth credential requirement
-  -h, --help
-          Print help
-```

documentation/autodoc/autodoc-generated-markdown/nym-client-build-info-help.md

@@ -1,9 +0,0 @@
-```sh
-Show build information of this binary
-
-Usage: nym-client build-info [OPTIONS]
-
-Options:
-  -o, --output <OUTPUT>  [default: text] [possible values: text, json]
-  -h, --help             Print help
-```

documentation/autodoc/autodoc-generated-markdown/nym-client-build-info.md

@@ -1,13 +0,0 @@
-```sh
-
-Binary Name:        nym-client
-Build Timestamp:    2024-10-09T13:56:14.428750844Z
-Build Version:      1.1.39
-Commit SHA:         fac373c1db4fa5389ba61de7943c77023467bccb
-Commit Date:        2024-10-09T14:59:40.000000000+02:00
-Commit Branch:      max/new-docs-framework
-rustc Version:      1.80.0
-rustc Channel:      stable
-cargo Profile:      release
-
-```

documentation/autodoc/autodoc-generated-markdown/nym-client-completions-help.md

@@ -1,11 +0,0 @@
-```sh
-Generate shell completions
-
-Usage: nym-client completions <SHELL>
-
-Arguments:
-  <SHELL>  [possible values: bash, elvish, fish, power-shell, zsh]
-
-Options:
-  -h, --help  Print help
-```

documentation/autodoc/autodoc-generated-markdown/nym-client-generate-fig-spec-help.md

@@ -1,8 +0,0 @@
-```sh
-Generate Fig specification
-
-Usage: nym-client generate-fig-spec
-
-Options:
-  -h, --help  Print help
-```

documentation/autodoc/autodoc-generated-markdown/nym-client-generate-fig-spec.md

@@ -1,585 +0,0 @@
-```sh
-const completion: Fig.Spec = {
-  name: "nym-native-client",
-  description: "Implementation of the Nym Client",
-  subcommands: [
-    {
-      name: "init",
-      description: "Initialise a Nym client. Do this first!",
-      options: [
-        {
-          name: "--id",
-          description: "Id of client we want to create config for",
-          isRepeatable: true,
-          args: {
-            name: "id",
-          },
-        },
-        {
-          name: "--gateway",
-          description: "Id of the gateway we are going to connect to",
-          isRepeatable: true,
-          args: {
-            name: "gateway",
-            isOptional: true,
-          },
-        },
-        {
-          name: "--nyxd-urls",
-          description: "Comma separated list of rest endpoints of the nyxd validators",
-          hidden: true,
-          isRepeatable: true,
-          args: {
-            name: "nyxd_urls",
-            isOptional: true,
-          },
-        },
-        {
-          name: "--nym-apis",
-          description: "Comma separated list of rest endpoints of the API validators",
-          isRepeatable: true,
-          args: {
-            name: "nym_apis",
-            isOptional: true,
-          },
-        },
-        {
-          name: "--custom-mixnet",
-          description: "Path to .json file containing custom network specification",
-          hidden: true,
-          isRepeatable: true,
-          args: {
-            name: "custom_mixnet",
-            isOptional: true,
-            template: "filepaths",
-          },
-        },
-        {
-          name: "--enabled-credentials-mode",
-          description: "Set this client to work in a enabled credentials mode that would attempt to use gateway with bandwidth credential requirement",
-          hidden: true,
-          isRepeatable: true,
-          args: {
-            name: "enabled_credentials_mode",
-            isOptional: true,
-            suggestions: [
-              "true",
-              "false",
-            ],
-          },
-        },
-        {
-          name: "--disable-socket",
-          description: "Whether to not start the websocket",
-          isRepeatable: true,
-          args: {
-            name: "disable_socket",
-            isOptional: true,
-            suggestions: [
-              "true",
-              "false",
-            ],
-          },
-        },
-        {
-          name: ["-p", "--port"],
-          description: "Port for the socket (if applicable) to listen on in all subsequent runs",
-          isRepeatable: true,
-          args: {
-            name: "port",
-            isOptional: true,
-          },
-        },
-        {
-          name: "--host",
-          description: "Ip for the socket (if applicable) to listen for requests",
-          isRepeatable: true,
-          args: {
-            name: "host",
-            isOptional: true,
-          },
-        },
-        {
-          name: ["-o", "--output"],
-          isRepeatable: true,
-          args: {
-            name: "output",
-            isOptional: true,
-            suggestions: [
-              "text",
-              "json",
-            ],
-          },
-        },
-        {
-          name: "--force-tls-gateway",
-          description: "Specifies whether the client will attempt to enforce tls connection to the desired gateway",
-        },
-        {
-          name: "--latency-based-selection",
-          description: "Specifies whether the new gateway should be determined based by latency as opposed to being chosen uniformly",
-          exclusiveOn: [
-            "--gateway",
-          ],
-        },
-        {
-          name: "--fastmode",
-          description: "Mostly debug-related option to increase default traffic rate so that you would not need to modify config post init",
-        },
-        {
-          name: "--no-cover",
-          description: "Disable loop cover traffic and the Poisson rate limiter (for debugging only)",
-        },
-        {
-          name: ["-h", "--help"],
-          description: "Print help",
-        },
-      ],
-    },
-    {
-      name: "run",
-      description: "Run the Nym client with provided configuration client optionally overriding set parameters",
-      options: [
-        {
-          name: "--id",
-          description: "Id of client we want to create config for",
-          isRepeatable: true,
-          args: {
-            name: "id",
-          },
-        },
-        {
-          name: "--gateway",
-          description: "Id of the gateway we want to connect to. If overridden, it is user's responsibility to ensure prior registration happened",
-          isRepeatable: true,
-          args: {
-            name: "gateway",
-            isOptional: true,
-          },
-        },
-        {
-          name: "--nyxd-urls",
-          description: "Comma separated list of rest endpoints of the nyxd validators",
-          hidden: true,
-          isRepeatable: true,
-          args: {
-            name: "nyxd_urls",
-            isOptional: true,
-          },
-        },
-        {
-          name: "--nym-apis",
-          description: "Comma separated list of rest endpoints of the API validators",
-          isRepeatable: true,
-          args: {
-            name: "nym_apis",
-            isOptional: true,
-          },
-        },
-        {
-          name: "--custom-mixnet",
-          description: "Path to .json file containing custom network specification",
-          hidden: true,
-          isRepeatable: true,
-          args: {
-            name: "custom_mixnet",
-            isOptional: true,
-            template: "filepaths",
-          },
-        },
-        {
-          name: "--enabled-credentials-mode",
-          description: "Set this client to work in a enabled credentials mode that would attempt to use gateway with bandwidth credential requirement",
-          hidden: true,
-          isRepeatable: true,
-          args: {
-            name: "enabled_credentials_mode",
-            isOptional: true,
-            suggestions: [
-              "true",
-              "false",
-            ],
-          },
-        },
-        {
-          name: "--disable-socket",
-          description: "Whether to not start the websocket",
-          isRepeatable: true,
-          args: {
-            name: "disable_socket",
-            isOptional: true,
-            suggestions: [
-              "true",
-              "false",
-            ],
-          },
-        },
-        {
-          name: ["-p", "--port"],
-          description: "Port for the socket to listen on",
-          isRepeatable: true,
-          args: {
-            name: "port",
-            isOptional: true,
-          },
-        },
-        {
-          name: "--host",
-          description: "Ip for the socket (if applicable) to listen for requests",
-          isRepeatable: true,
-          args: {
-            name: "host",
-            isOptional: true,
-          },
-        },
-        {
-          name: "--fastmode",
-          description: "Mostly debug-related option to increase default traffic rate so that you would not need to modify config post init",
-        },
-        {
-          name: "--no-cover",
-          description: "Disable loop cover traffic and the Poisson rate limiter (for debugging only)",
-        },
-        {
-          name: ["-h", "--help"],
-          description: "Print help",
-        },
-      ],
-    },
-    {
-      name: "import-credential",
-      description: "Import a pre-generated credential",
-      options: [
-        {
-          name: "--id",
-          description: "Id of client that is going to import the credential",
-          isRepeatable: true,
-          args: {
-            name: "id",
-          },
-        },
-        {
-          name: "--credential-data",
-          description: "Explicitly provide the encoded credential data (as base58)",
-          isRepeatable: true,
-          args: {
-            name: "credential_data",
-            isOptional: true,
-          },
-        },
-        {
-          name: "--credential-path",
-          description: "Specifies the path to file containing binary credential data",
-          isRepeatable: true,
-          args: {
-            name: "credential_path",
-            isOptional: true,
-            template: "filepaths",
-          },
-        },
-        {
-          name: "--version",
-          hidden: true,
-          isRepeatable: true,
-          args: {
-            name: "version",
-            isOptional: true,
-          },
-        },
-        {
-          name: ["-h", "--help"],
-          description: "Print help",
-        },
-      ],
-    },
-    {
-      name: "list-gateways",
-      description: "List all registered with gateways",
-      options: [
-        {
-          name: "--id",
-          description: "Id of client we want to list gateways for",
-          isRepeatable: true,
-          args: {
-            name: "id",
-          },
-        },
-        {
-          name: ["-o", "--output"],
-          isRepeatable: true,
-          args: {
-            name: "output",
-            isOptional: true,
-            suggestions: [
-              "text",
-              "json",
-            ],
-          },
-        },
-        {
-          name: ["-h", "--help"],
-          description: "Print help",
-        },
-      ],
-    },
-    {
-      name: "add-gateway",
-      description: "Add new gateway to this client",
-      options: [
-        {
-          name: "--id",
-          description: "Id of client we want to add gateway for",
-          isRepeatable: true,
-          args: {
-            name: "id",
-          },
-        },
-        {
-          name: "--gateway-id",
-          description: "Explicitly specify id of the gateway to register with. If unspecified, a random gateway will be chosen instead",
-          isRepeatable: true,
-          args: {
-            name: "gateway_id",
-            isOptional: true,
-          },
-        },
-        {
-          name: "--nym-apis",
-          description: "Comma separated list of rest endpoints of the API validators",
-          isRepeatable: true,
-          args: {
-            name: "nym_apis",
-            isOptional: true,
-          },
-        },
-        {
-          name: "--custom-mixnet",
-          description: "Path to .json file containing custom network specification",
-          hidden: true,
-          isRepeatable: true,
-          args: {
-            name: "custom_mixnet",
-            isOptional: true,
-            template: "filepaths",
-          },
-        },
-        {
-          name: ["-o", "--output"],
-          isRepeatable: true,
-          args: {
-            name: "output",
-            isOptional: true,
-            suggestions: [
-              "text",
-              "json",
-            ],
-          },
-        },
-        {
-          name: "--force-tls-gateway",
-          description: "Specifies whether the client will attempt to enforce tls connection to the desired gateway",
-        },
-        {
-          name: "--latency-based-selection",
-          description: "Specifies whether the new gateway should be determined based by latency as opposed to being chosen uniformly",
-          exclusiveOn: [
-            "--gateway-id",
-          ],
-        },
-        {
-          name: "--set-active",
-          description: "Specify whether this new gateway should be set as the active one",
-        },
-        {
-          name: ["-h", "--help"],
-          description: "Print help",
-        },
-      ],
-    },
-    {
-      name: "switch-gateway",
-      description: "Change the currently active gateway. Note that you must have already registered with the new gateway!",
-      options: [
-        {
-          name: "--id",
-          description: "Id of client we want to list gateways for",
-          isRepeatable: true,
-          args: {
-            name: "id",
-          },
-        },
-        {
-          name: "--gateway-id",
-          description: "Id of the gateway we want to switch to",
-          isRepeatable: true,
-          args: {
-            name: "gateway_id",
-          },
-        },
-        {
-          name: ["-h", "--help"],
-          description: "Print help",
-        },
-      ],
-    },
-    {
-      name: "show-ticketbooks",
-      description: "Display information associated with the imported ticketbooks,",
-      options: [
-        {
-          name: "--id",
-          description: "Id of client that is going to display the ticketbook information",
-          isRepeatable: true,
-          args: {
-            name: "id",
-          },
-        },
-        {
-          name: ["-o", "--output"],
-          isRepeatable: true,
-          args: {
-            name: "output",
-            isOptional: true,
-            suggestions: [
-              "text",
-              "json",
-            ],
-          },
-        },
-        {
-          name: ["-h", "--help"],
-          description: "Print help",
-        },
-      ],
-    },
-    {
-      name: "build-info",
-      description: "Show build information of this binary",
-      options: [
-        {
-          name: ["-o", "--output"],
-          isRepeatable: true,
-          args: {
-            name: "output",
-            isOptional: true,
-            suggestions: [
-              "text",
-              "json",
-            ],
-          },
-        },
-        {
-          name: ["-h", "--help"],
-          description: "Print help",
-        },
-      ],
-    },
-    {
-      name: "completions",
-      description: "Generate shell completions",
-      options: [
-        {
-          name: ["-h", "--help"],
-          description: "Print help",
-        },
-      ],
-      args: {
-        name: "shell",
-        suggestions: [
-          "bash",
-          "elvish",
-          "fish",
-          "power-shell",
-          "zsh",
-        ],
-      },
-    },
-    {
-      name: "generate-fig-spec",
-      description: "Generate Fig specification",
-      options: [
-        {
-          name: ["-h", "--help"],
-          description: "Print help",
-        },
-      ],
-    },
-    {
-      name: "help",
-      description: "Print this message or the help of the given subcommand(s)",
-      subcommands: [
-        {
-          name: "init",
-          description: "Initialise a Nym client. Do this first!",
-        },
-        {
-          name: "run",
-          description: "Run the Nym client with provided configuration client optionally overriding set parameters",
-        },
-        {
-          name: "import-credential",
-          description: "Import a pre-generated credential",
-        },
-        {
-          name: "list-gateways",
-          description: "List all registered with gateways",
-        },
-        {
-          name: "add-gateway",
-          description: "Add new gateway to this client",
-        },
-        {
-          name: "switch-gateway",
-          description: "Change the currently active gateway. Note that you must have already registered with the new gateway!",
-        },
-        {
-          name: "show-ticketbooks",
-          description: "Display information associated with the imported ticketbooks,",
-        },
-        {
-          name: "build-info",
-          description: "Show build information of this binary",
-        },
-        {
-          name: "completions",
-          description: "Generate shell completions",
-        },
-        {
-          name: "generate-fig-spec",
-          description: "Generate Fig specification",
-        },
-        {
-          name: "help",
-          description: "Print this message or the help of the given subcommand(s)",
-        },
-      ],
-    },
-  ],
-  options: [
-    {
-      name: ["-c", "--config-env-file"],
-      description: "Path pointing to an env file that configures the client",
-      isRepeatable: true,
-      args: {
-        name: "config_env_file",
-        isOptional: true,
-        template: "filepaths",
-      },
-    },
-    {
-      name: "--no-banner",
-      description: "Flag used for disabling the printed banner in tty",
-    },
-    {
-      name: ["-h", "--help"],
-      description: "Print help",
-    },
-    {
-      name: ["-V", "--version"],
-      description: "Print version",
-    },
-  ],
-};
-
-export default completion;
-```

documentation/autodoc/autodoc-generated-markdown/nym-client-import-credential-help.md

@@ -1,15 +0,0 @@
-```sh
-Import a pre-generated credential
-
-Usage: nym-client import-credential --id <ID> <--credential-data <CREDENTIAL_DATA>|--credential-path <CREDENTIAL_PATH>>
-
-Options:
-      --id <ID>
-          Id of client that is going to import the credential
-      --credential-data <CREDENTIAL_DATA>
-          Explicitly provide the encoded credential data (as base58)
-      --credential-path <CREDENTIAL_PATH>
-          Specifies the path to file containing binary credential data
-  -h, --help
-          Print help
-```

documentation/autodoc/autodoc-generated-markdown/nym-client-init-help.md

@@ -1,27 +0,0 @@
-```sh
-Initialise a Nym client. Do this first!
-
-Usage: nym-client init [OPTIONS] --id <ID>
-
-Options:
-      --id <ID>
-          Id of client we want to create config for
-      --gateway <GATEWAY>
-          Id of the gateway we are going to connect to
-      --force-tls-gateway
-          Specifies whether the client will attempt to enforce tls connection to the desired gateway
-      --latency-based-selection
-          Specifies whether the new gateway should be determined based by latency as opposed to being chosen uniformly
-      --nym-apis <NYM_APIS>
-          Comma separated list of rest endpoints of the API validators
-      --disable-socket <DISABLE_SOCKET>
-          Whether to not start the websocket [possible values: true, false]
-  -p, --port <PORT>
-          Port for the socket (if applicable) to listen on in all subsequent runs
-      --host <HOST>
-          Ip for the socket (if applicable) to listen for requests
-  -o, --output <OUTPUT>
-          [default: text] [possible values: text, json]
-  -h, --help
-          Print help
-```

documentation/autodoc/autodoc-generated-markdown/nym-client-list-gateways-help.md

@@ -1,10 +0,0 @@
-```sh
-List all registered with gateways
-
-Usage: nym-client list-gateways [OPTIONS] --id <ID>
-
-Options:
-      --id <ID>          Id of client we want to list gateways for
-  -o, --output <OUTPUT>  [default: text] [possible values: text, json]
-  -h, --help             Print help
-```

documentation/autodoc/autodoc-generated-markdown/nym-client-run-help.md

@@ -1,21 +0,0 @@
-```sh
-Run the Nym client with provided configuration client optionally overriding set parameters
-
-Usage: nym-client run [OPTIONS] --id <ID>
-
-Options:
-      --id <ID>
-          Id of client we want to create config for
-      --gateway <GATEWAY>
-          Id of the gateway we want to connect to. If overridden, it is user's responsibility to ensure prior registration happened
-      --nym-apis <NYM_APIS>
-          Comma separated list of rest endpoints of the API validators
-      --disable-socket <DISABLE_SOCKET>
-          Whether to not start the websocket [possible values: true, false]
-  -p, --port <PORT>
-          Port for the socket to listen on
-      --host <HOST>
-          Ip for the socket (if applicable) to listen for requests
-  -h, --help
-          Print help
-```

documentation/autodoc/autodoc-generated-markdown/nym-client-switch-gateway-help.md

@@ -1,10 +0,0 @@
-```sh
-Change the currently active gateway. Note that you must have already registered with the new gateway!
-
-Usage: nym-client switch-gateway --id <ID> --gateway-id <GATEWAY_ID>
-
-Options:
-      --id <ID>                  Id of client we want to list gateways for
-      --gateway-id <GATEWAY_ID>  Id of the gateway we want to switch to
-  -h, --help                     Print help
-```

documentation/autodoc/autodoc-generated-markdown/nym-node-bonding-information-help.md

@@ -1,12 +0,0 @@
-```sh
-Show bonding information of this node depending on its currently selected mode
-
-Usage: nym-node bonding-information [OPTIONS]
-
-Options:
-      --id <ID>                    Id of the nym-node to use [env: NYMNODE_ID=] [default: default-nym-node]
-      --config-file <CONFIG_FILE>  Path to a configuration file of this node [env: NYMNODE_CONFIG=]
-      --mode <MODE>                [env: NYMNODE_MODE=] [possible values: mixnode, entry-gateway, exit-gateway]
-  -o, --output <OUTPUT>            Specify the output format of the bonding information (`text` or `json`) [default: text] [possible values: text, json]
-  -h, --help                       Print help
-```

documentation/autodoc/autodoc-generated-markdown/nym-node-bonding-information.md

@@ -1,3 +0,0 @@
-```sh
-2024-10-22T13:00:32.542213Z ERROR nym-node/src/config/upgrade_helpers.rs:16: Failed to finish upgrade - failed to load config file using path '/home/m/.nym/nym-nodes/default-nym-node/config/config.toml'. detailed message: No such file or directory (os error 2)
-```

documentation/autodoc/autodoc-generated-markdown/nym-node-build-info-help.md

@@ -1,9 +0,0 @@
-```sh
-Show build information of this binary
-
-Usage: nym-node build-info [OPTIONS]
-
-Options:
-  -o, --output <OUTPUT>  [default: text] [possible values: text, json]
-  -h, --help             Print help
-```

documentation/autodoc/autodoc-generated-markdown/nym-node-build-info.md

@@ -1,13 +0,0 @@
-```sh
-
-Binary Name:        nym-node
-Build Timestamp:    2024-10-09T13:56:14.428750844Z
-Build Version:      1.1.6
-Commit SHA:         fac373c1db4fa5389ba61de7943c77023467bccb
-Commit Date:        2024-10-09T14:59:40.000000000+02:00
-Commit Branch:      max/new-docs-framework
-rustc Version:      1.80.0
-rustc Channel:      stable
-cargo Profile:      release
-
-```

documentation/autodoc/autodoc-generated-markdown/nym-node-commands.md

@@ -1,237 +0,0 @@
-# `nym-node` Binary Commands (Autogenerated)
-
-These docs are autogenerated by the [`autodocs`](https://github.com/nymtech/nym/tree/max/new-docs-framework/documentation/autodoc) script.
-```sh
-Usage: nym-node [OPTIONS] <COMMAND>
-
-Commands:
-  build-info           Show build information of this binary
-  bonding-information  Show bonding information of this node depending on its currently selected mode
-  node-details         Show details of this node
-  migrate              Attempt to migrate an existing mixnode or gateway into a nym-node
-  run                  Start this nym-node
-  sign                 Use identity key of this node to sign provided message
-  help                 Print this message or the help of the given subcommand(s)
-
-Options:
-  -c, --config-env-file <CONFIG_ENV_FILE>
-          Path pointing to an env file that configures the nym-node and overrides any preconfigured values [env: NYMNODE_CONFIG_ENV_FILE_ARG=]
-      --no-banner
-          Flag used for disabling the printed banner in tty [env: NYMNODE_NO_BANNER=]
-  -h, --help
-          Print help
-  -V, --version
-          Print version
-```
-
-### `build-info`
-```sh
-Show build information of this binary
-
-Usage: nym-node build-info [OPTIONS]
-
-Options:
-  -o, --output <OUTPUT>  [default: text] [possible values: text, json]
-  -h, --help             Print help
-```
-
-### `bonding-information`
-```sh
-Show bonding information of this node depending on its currently selected mode
-
-Usage: nym-node bonding-information [OPTIONS]
-
-Options:
-      --id <ID>                    Id of the nym-node to use [env: NYMNODE_ID=] [default: default-nym-node]
-      --config-file <CONFIG_FILE>  Path to a configuration file of this node [env: NYMNODE_CONFIG=]
-      --mode <MODE>                [env: NYMNODE_MODE=] [possible values: mixnode, entry-gateway, exit-gateway]
-  -o, --output <OUTPUT>            Specify the output format of the bonding information (`text` or `json`) [default: text] [possible values: text, json]
-  -h, --help                       Print help
-```
-
-### `node-details`
-```sh
-Show details of this node
-
-Usage: nym-node node-details [OPTIONS]
-
-Options:
-      --id <ID>                    Id of the nym-node to use [env: NYMNODE_ID=] [default: default-nym-node]
-      --config-file <CONFIG_FILE>  Path to a configuration file of this node [env: NYMNODE_CONFIG=]
-  -o, --output <OUTPUT>            Specify the output format of the node details (`text` or `json`) [default: text] [possible values: text, json]
-  -h, --help                       Print help
-```
-
-### `migrate`
-```sh
-Attempt to migrate an existing mixnode or gateway into a nym-node
-
-Usage: nym-node migrate [OPTIONS] <--id <ID>|--config-file <CONFIG_FILE>> <NODE_TYPE>
-
-Arguments:
-  <NODE_TYPE>  Type of node (mixnode or gateway) to migrate into a nym-node [possible values: mixnode, gateway]
-
-Options:
-      --id <ID>
-          Id of the node that's going to get migrated
-      --config-file <CONFIG_FILE>
-          Path to a configuration file of the node that's going to get migrated
-      --preserve-id
-          Specify whether to preserve id of the imported node
-      --public-ips <PUBLIC_IPS>
-          Comma separated list of public ip addresses that will be announced to the nym-api and subsequently to the clients. In nearly all circumstances, it's going to be identical to the address you're going to use for bonding [env: NYMNODE_PUBLIC_IPS=]
-      --hostname <HOSTNAME>
-          Optional hostname associated with this gateway that will be announced to the nym-api and subsequently to the clients [env: NYMNODE_HOSTNAME=]
-      --location <LOCATION>
-          Optional **physical** location of this node's server. Either full country name (e.g. 'Poland'), two-letter alpha2 (e.g. 'PL'), three-letter alpha3 (e.g. 'POL') or three-digit numeric-3 (e.g. '616') can be provided [env: NYMNODE_LOCATION=]
-      --http-bind-address <HTTP_BIND_ADDRESS>
-          Socket address this node will use for binding its http API. default: `0.0.0.0:8080` [env: NYMNODE_HTTP_BIND_ADDRESS=]
-      --landing-page-assets-path <LANDING_PAGE_ASSETS_PATH>
-          Path to assets directory of custom landing page of this node [env: NYMNODE_HTTP_LANDING_ASSETS=]
-      --http-access-token <HTTP_ACCESS_TOKEN>
-          An optional bearer token for accessing certain http endpoints. Currently only used for prometheus metrics [env: NYMNODE_HTTP_ACCESS_TOKEN=]
-      --expose-system-info <EXPOSE_SYSTEM_INFO>
-          Specify whether basic system information should be exposed. default: true [env: NYMNODE_HTTP_EXPOSE_SYSTEM_INFO=] [possible values: true, false]
-      --expose-system-hardware <EXPOSE_SYSTEM_HARDWARE>
-          Specify whether basic system hardware information should be exposed. default: true [env: NYMNODE_HTTP_EXPOSE_SYSTEM_HARDWARE=] [possible values: true, false]
-      --expose-crypto-hardware <EXPOSE_CRYPTO_HARDWARE>
-          Specify whether detailed system crypto hardware information should be exposed. default: true [env: NYMNODE_HTTP_EXPOSE_CRYPTO_HARDWARE=] [possible values: true, false]
-      --mixnet-bind-address <MIXNET_BIND_ADDRESS>
-          Address this node will bind to for listening for mixnet packets default: `0.0.0.0:1789` [env: NYMNODE_MIXNET_BIND_ADDRESS=]
-      --mixnet-announce-port <MIXNET_ANNOUNCE_PORT>
-          If applicable, custom port announced in the self-described API that other clients and nodes will use. Useful when the node is behind a proxy [env: NYMNODE_MIXNET_ANNOUNCE_PORT=]
-      --nym-api-urls <NYM_API_URLS>
-          Addresses to nym APIs from which the node gets the view of the network [env: NYMNODE_NYM_APIS=]
-      --nyxd-urls <NYXD_URLS>
-          Addresses to nyxd chain endpoint which the node will use for chain interactions [env: NYMNODE_NYXD=]
-      --wireguard-enabled <WIREGUARD_ENABLED>
-          Specifies whether the wireguard service is enabled on this node [env: NYMNODE_WG_ENABLED=] [possible values: true, false]
-      --wireguard-bind-address <WIREGUARD_BIND_ADDRESS>
-          Socket address this node will use for binding its wireguard interface. default: `0.0.0.0:51822` [env: NYMNODE_WG_BIND_ADDRESS=]
-      --wireguard-private-ip <WIREGUARD_PRIVATE_IP>
-          Private IP address of the wireguard gateway. default: `10.1.0.1` [env: NYMNODE_WG_IP=]
-      --wireguard-announced-port <WIREGUARD_ANNOUNCED_PORT>
-          Port announced to external clients wishing to connect to the wireguard interface. Useful in the instances where the node is behind a proxy [env: NYMNODE_WG_ANNOUNCED_PORT=]
-      --wireguard-private-network-prefix <WIREGUARD_PRIVATE_NETWORK_PREFIX>
-          The prefix denoting the maximum number of the clients that can be connected via Wireguard. The maximum value for IPv4 is 32 and for IPv6 is 128 [env: NYMNODE_WG_PRIVATE_NETWORK_PREFIX=]
-      --verloc-bind-address <VERLOC_BIND_ADDRESS>
-          Socket address this node will use for binding its verloc API. default: `0.0.0.0:1790` [env: NYMNODE_VERLOC_BIND_ADDRESS=]
-      --verloc-announce-port <VERLOC_ANNOUNCE_PORT>
-          If applicable, custom port announced in the self-described API that other clients and nodes will use. Useful when the node is behind a proxy [env: NYMNODE_VERLOC_ANNOUNCE_PORT=]
-      --entry-bind-address <ENTRY_BIND_ADDRESS>
-          Socket address this node will use for binding its client websocket API. default: `0.0.0.0:9000` [env: NYMNODE_ENTRY_BIND_ADDRESS=]
-      --announce-ws-port <ANNOUNCE_WS_PORT>
-          Custom announced port for listening for websocket client traffic. If unspecified, the value from the `bind_address` will be used instead [env: NYMNODE_ENTRY_ANNOUNCE_WS_PORT=]
-      --announce-wss-port <ANNOUNCE_WSS_PORT>
-          If applicable, announced port for listening for secure websocket client traffic [env: NYMNODE_ENTRY_ANNOUNCE_WSS_PORT=]
-      --enforce-zk-nyms <ENFORCE_ZK_NYMS>
-          Indicates whether this gateway is accepting only coconut credentials for accessing the mixnet or if it also accepts non-paying clients [env: NYMNODE_ENFORCE_ZK_NYMS=] [possible values: true, false]
-      --mnemonic <MNEMONIC>
-          Custom cosmos wallet mnemonic used for zk-nym redemption. If no value is provided, a fresh mnemonic is going to be generated [env: NYMNODE_MNEMONIC=]
-      --upstream-exit-policy-url <UPSTREAM_EXIT_POLICY_URL>
-          Specifies the url for an upstream source of the exit policy used by this node [env: NYMNODE_UPSTREAM_EXIT_POLICY=]
-      --open-proxy <OPEN_PROXY>
-          Specifies whether this exit node should run in 'open-proxy' mode and thus would attempt to resolve **ANY** request it receives [env: NYMNODE_OPEN_PROXY=] [possible values: true, false]
-  -h, --help
-          Print help
-```
-
-### `run`
-```sh
-Start this nym-node
-
-Usage: nym-node run [OPTIONS]
-
-Options:
-      --id <ID>
-          Id of the nym-node to use [env: NYMNODE_ID=] [default: default-nym-node]
-      --config-file <CONFIG_FILE>
-          Path to a configuration file of this node [env: NYMNODE_CONFIG=]
-      --accept-operator-terms-and-conditions
-          Explicitly specify whether you agree with the terms and conditions of a nym node operator as defined at <https://nymtech.net/terms-and-conditions/operators/v1.0.0> [env: NYMNODE_ACCEPT_OPERATOR_TERMS=]
-      --deny-init
-          Forbid a new node from being initialised if configuration file for the provided specification doesn't already exist [env: NYMNODE_DENY_INIT=]
-      --init-only
-          If this is a brand new nym-node, specify whether it should only be initialised without actually running the subprocesses [env: NYMNODE_INIT_ONLY=]
-      --local
-          Flag specifying this node will be running in a local setting [env: NYMNODE_LOCAL=]
-      --mode <MODE>
-          Specifies the current mode of this nym-node [env: NYMNODE_MODE=] [possible values: mixnode, entry-gateway, exit-gateway]
-  -w, --write-changes
-          If this node has been initialised before, specify whether to write any new changes to the config file [env: NYMNODE_WRITE_CONFIG_CHANGES=]
-      --bonding-information-output <BONDING_INFORMATION_OUTPUT>
-          Specify output file for bonding information of this nym-node, i.e. its encoded keys. NOTE: the required bonding information is still a subject to change and this argument should be treated only as a preview of future features [env: NYMNODE_BONDING_INFORMATION_OUTPUT=]
-  -o, --output <OUTPUT>
-          Specify the output format of the bonding information (`text` or `json`) [env: NYMNODE_OUTPUT=] [default: text] [possible values: text, json]
-      --public-ips <PUBLIC_IPS>
-          Comma separated list of public ip addresses that will be announced to the nym-api and subsequently to the clients. In nearly all circumstances, it's going to be identical to the address you're going to use for bonding [env: NYMNODE_PUBLIC_IPS=]
-      --hostname <HOSTNAME>
-          Optional hostname associated with this gateway that will be announced to the nym-api and subsequently to the clients [env: NYMNODE_HOSTNAME=]
-      --location <LOCATION>
-          Optional **physical** location of this node's server. Either full country name (e.g. 'Poland'), two-letter alpha2 (e.g. 'PL'), three-letter alpha3 (e.g. 'POL') or three-digit numeric-3 (e.g. '616') can be provided [env: NYMNODE_LOCATION=]
-      --http-bind-address <HTTP_BIND_ADDRESS>
-          Socket address this node will use for binding its http API. default: `0.0.0.0:8080` [env: NYMNODE_HTTP_BIND_ADDRESS=]
-      --landing-page-assets-path <LANDING_PAGE_ASSETS_PATH>
-          Path to assets directory of custom landing page of this node [env: NYMNODE_HTTP_LANDING_ASSETS=]
-      --http-access-token <HTTP_ACCESS_TOKEN>
-          An optional bearer token for accessing certain http endpoints. Currently only used for prometheus metrics [env: NYMNODE_HTTP_ACCESS_TOKEN=]
-      --expose-system-info <EXPOSE_SYSTEM_INFO>
-          Specify whether basic system information should be exposed. default: true [env: NYMNODE_HTTP_EXPOSE_SYSTEM_INFO=] [possible values: true, false]
-      --expose-system-hardware <EXPOSE_SYSTEM_HARDWARE>
-          Specify whether basic system hardware information should be exposed. default: true [env: NYMNODE_HTTP_EXPOSE_SYSTEM_HARDWARE=] [possible values: true, false]
-      --expose-crypto-hardware <EXPOSE_CRYPTO_HARDWARE>
-          Specify whether detailed system crypto hardware information should be exposed. default: true [env: NYMNODE_HTTP_EXPOSE_CRYPTO_HARDWARE=] [possible values: true, false]
-      --mixnet-bind-address <MIXNET_BIND_ADDRESS>
-          Address this node will bind to for listening for mixnet packets default: `0.0.0.0:1789` [env: NYMNODE_MIXNET_BIND_ADDRESS=]
-      --mixnet-announce-port <MIXNET_ANNOUNCE_PORT>
-          If applicable, custom port announced in the self-described API that other clients and nodes will use. Useful when the node is behind a proxy [env: NYMNODE_MIXNET_ANNOUNCE_PORT=]
-      --nym-api-urls <NYM_API_URLS>
-          Addresses to nym APIs from which the node gets the view of the network [env: NYMNODE_NYM_APIS=]
-      --nyxd-urls <NYXD_URLS>
-          Addresses to nyxd chain endpoint which the node will use for chain interactions [env: NYMNODE_NYXD=]
-      --wireguard-enabled <WIREGUARD_ENABLED>
-          Specifies whether the wireguard service is enabled on this node [env: NYMNODE_WG_ENABLED=] [possible values: true, false]
-      --wireguard-bind-address <WIREGUARD_BIND_ADDRESS>
-          Socket address this node will use for binding its wireguard interface. default: `0.0.0.0:51822` [env: NYMNODE_WG_BIND_ADDRESS=]
-      --wireguard-private-ip <WIREGUARD_PRIVATE_IP>
-          Private IP address of the wireguard gateway. default: `10.1.0.1` [env: NYMNODE_WG_IP=]
-      --wireguard-announced-port <WIREGUARD_ANNOUNCED_PORT>
-          Port announced to external clients wishing to connect to the wireguard interface. Useful in the instances where the node is behind a proxy [env: NYMNODE_WG_ANNOUNCED_PORT=]
-      --wireguard-private-network-prefix <WIREGUARD_PRIVATE_NETWORK_PREFIX>
-          The prefix denoting the maximum number of the clients that can be connected via Wireguard. The maximum value for IPv4 is 32 and for IPv6 is 128 [env: NYMNODE_WG_PRIVATE_NETWORK_PREFIX=]
-      --verloc-bind-address <VERLOC_BIND_ADDRESS>
-          Socket address this node will use for binding its verloc API. default: `0.0.0.0:1790` [env: NYMNODE_VERLOC_BIND_ADDRESS=]
-      --verloc-announce-port <VERLOC_ANNOUNCE_PORT>
-          If applicable, custom port announced in the self-described API that other clients and nodes will use. Useful when the node is behind a proxy [env: NYMNODE_VERLOC_ANNOUNCE_PORT=]
-      --entry-bind-address <ENTRY_BIND_ADDRESS>
-          Socket address this node will use for binding its client websocket API. default: `0.0.0.0:9000` [env: NYMNODE_ENTRY_BIND_ADDRESS=]
-      --announce-ws-port <ANNOUNCE_WS_PORT>
-          Custom announced port for listening for websocket client traffic. If unspecified, the value from the `bind_address` will be used instead [env: NYMNODE_ENTRY_ANNOUNCE_WS_PORT=]
-      --announce-wss-port <ANNOUNCE_WSS_PORT>
-          If applicable, announced port for listening for secure websocket client traffic [env: NYMNODE_ENTRY_ANNOUNCE_WSS_PORT=]
-      --enforce-zk-nyms <ENFORCE_ZK_NYMS>
-          Indicates whether this gateway is accepting only coconut credentials for accessing the mixnet or if it also accepts non-paying clients [env: NYMNODE_ENFORCE_ZK_NYMS=] [possible values: true, false]
-      --mnemonic <MNEMONIC>
-          Custom cosmos wallet mnemonic used for zk-nym redemption. If no value is provided, a fresh mnemonic is going to be generated [env: NYMNODE_MNEMONIC=]
-      --upstream-exit-policy-url <UPSTREAM_EXIT_POLICY_URL>
-          Specifies the url for an upstream source of the exit policy used by this node [env: NYMNODE_UPSTREAM_EXIT_POLICY=]
-      --open-proxy <OPEN_PROXY>
-          Specifies whether this exit node should run in 'open-proxy' mode and thus would attempt to resolve **ANY** request it receives [env: NYMNODE_OPEN_PROXY=] [possible values: true, false]
-  -h, --help
-          Print help
-```
-
-### `sign`
-```sh
-Use identity key of this node to sign provided message
-
-Usage: nym-node sign [OPTIONS] <--text <TEXT>|--contract-msg <CONTRACT_MSG>>
-
-Options:
-      --id <ID>                      Id of the nym-node to use [env: NYMNODE_ID=] [default: default-nym-node]
-      --config-file <CONFIG_FILE>    Path to a configuration file of this node [env: NYMNODE_CONFIG=]
-      --text <TEXT>                  Signs an arbitrary piece of text with your identity key
-      --contract-msg <CONTRACT_MSG>  Signs a transaction-specific payload, that is going to be sent to the smart contract, with your identity key
-  -o, --output <OUTPUT>              [default: text] [possible values: text, json]
-  -h, --help                         Print help
-```

documentation/autodoc/autodoc-generated-markdown/nym-node-migrate-help.md

@@ -1,68 +0,0 @@
-```sh
-Attempt to migrate an existing mixnode or gateway into a nym-node
-
-Usage: nym-node migrate [OPTIONS] <--id <ID>|--config-file <CONFIG_FILE>> <NODE_TYPE>
-
-Arguments:
-  <NODE_TYPE>  Type of node (mixnode or gateway) to migrate into a nym-node [possible values: mixnode, gateway]
-
-Options:
-      --id <ID>
-          Id of the node that's going to get migrated
-      --config-file <CONFIG_FILE>
-          Path to a configuration file of the node that's going to get migrated
-      --preserve-id
-          Specify whether to preserve id of the imported node
-      --public-ips <PUBLIC_IPS>
-          Comma separated list of public ip addresses that will be announced to the nym-api and subsequently to the clients. In nearly all circumstances, it's going to be identical to the address you're going to use for bonding [env: NYMNODE_PUBLIC_IPS=]
-      --hostname <HOSTNAME>
-          Optional hostname associated with this gateway that will be announced to the nym-api and subsequently to the clients [env: NYMNODE_HOSTNAME=]
-      --location <LOCATION>
-          Optional **physical** location of this node's server. Either full country name (e.g. 'Poland'), two-letter alpha2 (e.g. 'PL'), three-letter alpha3 (e.g. 'POL') or three-digit numeric-3 (e.g. '616') can be provided [env: NYMNODE_LOCATION=]
-      --http-bind-address <HTTP_BIND_ADDRESS>
-          Socket address this node will use for binding its http API. default: `0.0.0.0:8080` [env: NYMNODE_HTTP_BIND_ADDRESS=]
-      --landing-page-assets-path <LANDING_PAGE_ASSETS_PATH>
-          Path to assets directory of custom landing page of this node [env: NYMNODE_HTTP_LANDING_ASSETS=]
-      --http-access-token <HTTP_ACCESS_TOKEN>
-          An optional bearer token for accessing certain http endpoints. Currently only used for prometheus metrics [env: NYMNODE_HTTP_ACCESS_TOKEN=]
-      --expose-system-info <EXPOSE_SYSTEM_INFO>
-          Specify whether basic system information should be exposed. default: true [env: NYMNODE_HTTP_EXPOSE_SYSTEM_INFO=] [possible values: true, false]
-      --expose-system-hardware <EXPOSE_SYSTEM_HARDWARE>
-          Specify whether basic system hardware information should be exposed. default: true [env: NYMNODE_HTTP_EXPOSE_SYSTEM_HARDWARE=] [possible values: true, false]
-      --expose-crypto-hardware <EXPOSE_CRYPTO_HARDWARE>
-          Specify whether detailed system crypto hardware information should be exposed. default: true [env: NYMNODE_HTTP_EXPOSE_CRYPTO_HARDWARE=] [possible values: true, false]
-      --mixnet-bind-address <MIXNET_BIND_ADDRESS>
-          Address this node will bind to for listening for mixnet packets default: `0.0.0.0:1789` [env: NYMNODE_MIXNET_BIND_ADDRESS=]
-      --nym-api-urls <NYM_API_URLS>
-          Addresses to nym APIs from which the node gets the view of the network [env: NYMNODE_NYM_APIS=]
-      --nyxd-urls <NYXD_URLS>
-          Addresses to nyxd chain endpoint which the node will use for chain interactions [env: NYMNODE_NYXD=]
-      --wireguard-enabled <WIREGUARD_ENABLED>
-          Specifies whether the wireguard service is enabled on this node [env: NYMNODE_WG_ENABLED=] [possible values: true, false]
-      --wireguard-bind-address <WIREGUARD_BIND_ADDRESS>
-          Socket address this node will use for binding its wireguard interface. default: `0.0.0.0:51822` [env: NYMNODE_WG_BIND_ADDRESS=]
-      --wireguard-private-ip <WIREGUARD_PRIVATE_IP>
-          Private IP address of the wireguard gateway. default: `10.1.0.1` [env: NYMNODE_WG_IP=]
-      --wireguard-announced-port <WIREGUARD_ANNOUNCED_PORT>
-          Port announced to external clients wishing to connect to the wireguard interface. Useful in the instances where the node is behind a proxy [env: NYMNODE_WG_ANNOUNCED_PORT=]
-      --wireguard-private-network-prefix <WIREGUARD_PRIVATE_NETWORK_PREFIX>
-          The prefix denoting the maximum number of the clients that can be connected via Wireguard. The maximum value for IPv4 is 32 and for IPv6 is 128 [env: NYMNODE_WG_PRIVATE_NETWORK_PREFIX=]
-      --verloc-bind-address <VERLOC_BIND_ADDRESS>
-          Socket address this node will use for binding its verloc API. default: `0.0.0.0:1790` [env: NYMNODE_VERLOC_BIND_ADDRESS=]
-      --entry-bind-address <ENTRY_BIND_ADDRESS>
-          Socket address this node will use for binding its client websocket API. default: `0.0.0.0:9000` [env: NYMNODE_ENTRY_BIND_ADDRESS=]
-      --announce-ws-port <ANNOUNCE_WS_PORT>
-          Custom announced port for listening for websocket client traffic. If unspecified, the value from the `bind_address` will be used instead [env: NYMNODE_ENTRY_ANNOUNCE_WS_PORT=]
-      --announce-wss-port <ANNOUNCE_WSS_PORT>
-          If applicable, announced port for listening for secure websocket client traffic [env: NYMNODE_ENTRY_ANNOUNCE_WSS_PORT=]
-      --enforce-zk-nyms <ENFORCE_ZK_NYMS>
-          Indicates whether this gateway is accepting only coconut credentials for accessing the mixnet or if it also accepts non-paying clients [env: NYMNODE_ENFORCE_ZK_NYMS=] [possible values: true, false]
-      --mnemonic <MNEMONIC>
-          Custom cosmos wallet mnemonic used for zk-nym redemption. If no value is provided, a fresh mnemonic is going to be generated [env: NYMNODE_MNEMONIC=]
-      --upstream-exit-policy-url <UPSTREAM_EXIT_POLICY_URL>
-          Specifies the url for an upstream source of the exit policy used by this node [env: NYMNODE_UPSTREAM_EXIT_POLICY=]
-      --open-proxy <OPEN_PROXY>
-          Specifies whether this exit node should run in 'open-proxy' mode and thus would attempt to resolve **ANY** request it receives [env: NYMNODE_OPEN_PROXY=] [possible values: true, false]
-  -h, --help
-          Print help
-```