auto commit generated command files

* Add debug config to clients

* Add deterministic traffic selection flag

.github/workflows/ci-build.yml

@@ -34,6 +34,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     env:
       CARGO_TERM_COLOR: always
+      IPINFO_API_TOKEN: ${{ secrets.IPINFO_API_TOKEN }}
     steps:
       - name: Install Dependencies (Linux)
         run: sudo apt-get update && sudo apt-get -y install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libudev-dev squashfs-tools protobuf-compiler

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

@@ -8,7 +8,7 @@ on:
         description: Which gateway probe git ref to build the image with
 
 env:
-  WORKING_DIRECTORY: "nym-node-status-agent"
+  WORKING_DIRECTORY: "nym-node-status-api/nym-node-status-agent"
   CONTAINER_NAME: "node-status-agent"
 
 jobs:
@@ -58,4 +58,4 @@ jobs:
       - 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 push harbor.nymte.ch/nym/${{ env.CONTAINER_NAME }} --all-tags
+          docker push harbor.nymte.ch/nym/${{ env.CONTAINER_NAME }} --all-tags

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

@@ -3,7 +3,7 @@ on:
   workflow_dispatch:
 
 env:
-  WORKING_DIRECTORY: "nym-node-status-api"
+  WORKING_DIRECTORY: "nym-node-status-api/nym-node-status-api"
   CONTAINER_NAME: "node-status-api"
 
 jobs:

.github/workflows/push-nyx-chain-watcher.yaml

@@ -0,0 +1,55 @@
+name: Build and upload Nyx Chain Watcher container to harbor.nymte.ch
+on:
+  workflow_dispatch:
+
+env:
+  WORKING_DIRECTORY: "nyx-chain-watcher"
+  CONTAINER_NAME: "nyx-chain-watcher"
+
+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.5
+        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

@@ -29,7 +29,7 @@ jobs:
         uses: mikefarah/yq@v4.44.5
         id: get_version
         with:
-          cmd: yq -oy '.package.version' ${{ env.WORKING_DIRECTORY }}/nym-credential-proxy/Cargo.toml
+          cmd: yq -oy '.package.version' ${{ env.WORKING_DIRECTORY }}/Cargo.toml
 
       - name: Remove existing tag if exists
         run: |

CHANGELOG.md

@@ -4,148 +4,6 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://
 
 ## [Unreleased]
 
-## [2024.14-crunch] (2024-12-11)
-
-- Merge/release/2024.14-crunch ([#5242])
-- bugfix: added explicit openapi servers to account for route prefixes ([#5237])
-- Further config score adjustments ([#5225])
-- feature: remve any filtering on node semver ([#5224])
-- Backport #5218 ([#5220])
-- Derive serialize for UserAgent (#5210) ([#5217])
-- dont consider legacy nodes for rewarded set selection ([#5215])
-- introduce UNSTABLE endpoints for returning network monitor run details ([#5214])
-- Nmv2 add debug config ([#5212])
-- nym-api NMv1 adjustments ([#5209])
-- adjusted config score penalty calculation ([#5206])
-- Fix backwards compat mac generation ([#5202])
-- merge crunch into develop ([#5199])
-- Update Security disclosure email, public key and policy ([#5195])
-- Guard storage access with cache ([#5193])
-- chore: apply 1.84 linter suggestions ([#5192])
-- improvement: make internal gateway clients use the same topology cache ([#5191])
-- Bugfix/credential proxy sequencing ([#5187])
-- Add monitor_run and testing_route indexes ([#5182])
-- Add indexes to monitor run and testing route ([#5181])
-- bugfix: fixed nym-node config migrations (again) ([#5179])
-- bugfix: use default value for verloc config when deserialising missing values ([#5177])
-- Remove peers with no allowed ip from storage ([#5175])
-- Move two minor jobs to free tier github hosted runners ([#5169])
-- Add support for DELETE to nym-http-api-client ([#5166])
-- Fix env var name ([#5165])
-- Add strum::EnumIter for TicketType ([#5164])
-- Add export_to_env to NymNetworkDetails ([#5162])
-- bugfix: correctly expose ecash-related data on nym-api ([#5155])
-- fix: validator-rewarder GH job ([#5151])
-- build(deps): bump cross-spawn from 7.0.3 to 7.0.6 in /testnet-faucet ([#5150])
-- build(deps): bump mikefarah/yq from 4.44.3 to 4.44.5 ([#5149])
-- start session collection for exit gateways ([#5148])
-- add version to clientStatsReport ([#5147])
-- update serde_json_path due to compilation issue ([#5144])
-- chore: remove standalone legacy mixnode/gateway binaries ([#5135])
-- [Product Data] Set up country reporting from vpn-client ([#5134])
-- removed ci-nym-api-tests.yml which was running outdated (and broken) tests ([#5133])
-- CI: reduce jobs running on cluster ([#5132])
-- [DOCS/operators]: Release changes v2024.13-magura & Tokenomics pages v1.0 ([#5128])
-- NS Agent auth with NS API ([#5127])
-- [Product Data] Config deserialization bug fix ([#5126])
-- bugfix: don't send empty BankMsg in ecash contract ([#5121])
-- [Product data] Data consumption with ecash ticket ([#5120])
-- feat: add GH workflow for nym-validator-rewarder ([#5119])
-- feat: add Dockerfile and add env vars for clap arguments ([#5118])
-- feature: config score ([#5117])
-- [Product Data] Add stats reporting configuration in client config  ([#5115])
-- Correct IPv6 address generation ([#5113])
-- feature: rewarding for ticketbook issuance ([#5112])
-- Add granular log on nym-node ([#5111])
-- Send mixnet packet stats using task client ([#5109])
-- Expose time range ([#5108])
-- [Product Data] Client-side stats collection  ([#5107])
-- chore: ecash contract migration to remove unused 'redemption_gateway_share' ([#5104])
-- [Product Data] Better unique user count on gateways ([#5084])
-- feat: add nym node GH workflow ([#5080])
-- IPv6 support for wireguard ([#5059])
-- Node Status API ([#5050])
-- Authenticator CLI client mode ([#5044])
-- Integrate nym-credential-proxy into workspace ([#5027])
-- [Product Data] Introduce data persistence on gateways ([#5022])
-- Bump the patch-updates group across 1 directory with 10 updates ([#5011])
-- build(deps): bump once_cell from 1.19.0 to 1.20.2 ([#4952])
-- Create TaskStatusEvent trait instead of piggybacking on Error ([#4919])
-- build(deps): bump lazy_static from 1.4.0 to 1.5.0 ([#4913])
-- Sync code with .env in build.rs ([#4876])
-- build(deps): bump axios from 1.6.0 to 1.7.5 in /nym-api/tests ([#4790])
-- Bump elliptic from 6.5.4 to 6.5.7 in /testnet-faucet ([#4768])
-
-[#5242]: https://github.com/nymtech/nym/pull/5242
-[#5237]: https://github.com/nymtech/nym/pull/5237
-[#5225]: https://github.com/nymtech/nym/pull/5225
-[#5224]: https://github.com/nymtech/nym/pull/5224
-[#5220]: https://github.com/nymtech/nym/pull/5220
-[#5217]: https://github.com/nymtech/nym/pull/5217
-[#5215]: https://github.com/nymtech/nym/pull/5215
-[#5214]: https://github.com/nymtech/nym/pull/5214
-[#5212]: https://github.com/nymtech/nym/pull/5212
-[#5209]: https://github.com/nymtech/nym/pull/5209
-[#5206]: https://github.com/nymtech/nym/pull/5206
-[#5202]: https://github.com/nymtech/nym/pull/5202
-[#5199]: https://github.com/nymtech/nym/pull/5199
-[#5195]: https://github.com/nymtech/nym/pull/5195
-[#5193]: https://github.com/nymtech/nym/pull/5193
-[#5192]: https://github.com/nymtech/nym/pull/5192
-[#5191]: https://github.com/nymtech/nym/pull/5191
-[#5187]: https://github.com/nymtech/nym/pull/5187
-[#5182]: https://github.com/nymtech/nym/pull/5182
-[#5181]: https://github.com/nymtech/nym/pull/5181
-[#5179]: https://github.com/nymtech/nym/pull/5179
-[#5177]: https://github.com/nymtech/nym/pull/5177
-[#5175]: https://github.com/nymtech/nym/pull/5175
-[#5169]: https://github.com/nymtech/nym/pull/5169
-[#5166]: https://github.com/nymtech/nym/pull/5166
-[#5165]: https://github.com/nymtech/nym/pull/5165
-[#5164]: https://github.com/nymtech/nym/pull/5164
-[#5162]: https://github.com/nymtech/nym/pull/5162
-[#5155]: https://github.com/nymtech/nym/pull/5155
-[#5151]: https://github.com/nymtech/nym/pull/5151
-[#5150]: https://github.com/nymtech/nym/pull/5150
-[#5149]: https://github.com/nymtech/nym/pull/5149
-[#5148]: https://github.com/nymtech/nym/pull/5148
-[#5147]: https://github.com/nymtech/nym/pull/5147
-[#5144]: https://github.com/nymtech/nym/pull/5144
-[#5135]: https://github.com/nymtech/nym/pull/5135
-[#5134]: https://github.com/nymtech/nym/pull/5134
-[#5133]: https://github.com/nymtech/nym/pull/5133
-[#5132]: https://github.com/nymtech/nym/pull/5132
-[#5128]: https://github.com/nymtech/nym/pull/5128
-[#5127]: https://github.com/nymtech/nym/pull/5127
-[#5126]: https://github.com/nymtech/nym/pull/5126
-[#5121]: https://github.com/nymtech/nym/pull/5121
-[#5120]: https://github.com/nymtech/nym/pull/5120
-[#5119]: https://github.com/nymtech/nym/pull/5119
-[#5118]: https://github.com/nymtech/nym/pull/5118
-[#5117]: https://github.com/nymtech/nym/pull/5117
-[#5115]: https://github.com/nymtech/nym/pull/5115
-[#5113]: https://github.com/nymtech/nym/pull/5113
-[#5112]: https://github.com/nymtech/nym/pull/5112
-[#5111]: https://github.com/nymtech/nym/pull/5111
-[#5109]: https://github.com/nymtech/nym/pull/5109
-[#5108]: https://github.com/nymtech/nym/pull/5108
-[#5107]: https://github.com/nymtech/nym/pull/5107
-[#5104]: https://github.com/nymtech/nym/pull/5104
-[#5084]: https://github.com/nymtech/nym/pull/5084
-[#5080]: https://github.com/nymtech/nym/pull/5080
-[#5059]: https://github.com/nymtech/nym/pull/5059
-[#5050]: https://github.com/nymtech/nym/pull/5050
-[#5044]: https://github.com/nymtech/nym/pull/5044
-[#5027]: https://github.com/nymtech/nym/pull/5027
-[#5022]: https://github.com/nymtech/nym/pull/5022
-[#5011]: https://github.com/nymtech/nym/pull/5011
-[#4952]: https://github.com/nymtech/nym/pull/4952
-[#4919]: https://github.com/nymtech/nym/pull/4919
-[#4913]: https://github.com/nymtech/nym/pull/4913
-[#4876]: https://github.com/nymtech/nym/pull/4876
-[#4790]: https://github.com/nymtech/nym/pull/4790
-[#4768]: https://github.com/nymtech/nym/pull/4768
-
 ## [2024.13-magura-drift] (2024-11-29)
 
 - Optimised syncing bandwidth information to storage

Cargo.lock

@@ -11,7 +11,7 @@ dependencies = [
  "macroific",
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -283,7 +283,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "serde",
- "syn 2.0.87",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -352,7 +352,7 @@ checksum = "16e62a023e7c117e27523144c5d2459f4397fcc3cab0085af8e2224f643a0193"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -363,7 +363,7 @@ checksum = "721cae7de5c34fbb2acd27e21e6d2cf7b886dce0c27388d46c4e6c47ea4318dd"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -430,6 +430,14 @@ version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0c4b4d0bd25bd0b74681c0ad21497610ce1b7c91b1022cd21c80c6fbdd9476b0"
 
+[[package]]
+name = "autodoc"
+version = "0.1.0"
+dependencies = [
+ "env_logger 0.11.5",
+ "log",
+]
+
 [[package]]
 name = "axum"
 version = "0.6.20"
@@ -573,7 +581,7 @@ checksum = "57d123550fa8d071b7255cb0cc04dc302baa6c8c4a79f55701552684d8399bce"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -1140,7 +1148,7 @@ dependencies = [
  "heck 0.5.0",
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -1790,7 +1798,7 @@ checksum = "f46882e17999c6cc590af592290432be3bce0428cb0d5f8b6715e4dc7b383eb3"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -1948,7 +1956,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "strsim 0.11.1",
- "syn 2.0.87",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -1970,7 +1978,7 @@ checksum = "733cabb43482b1a1b53eee8583c2b9e8684d592215ea83efd305dd31bc2f0178"
 dependencies = [
  "darling_core 0.20.9",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -2021,7 +2029,7 @@ dependencies = [
  "macroific",
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -2064,7 +2072,7 @@ checksum = "67e77553c4162a157adbf834ebae5b415acbecbeafc7a74b0e886657506a7611"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -2097,7 +2105,7 @@ dependencies = [
  "proc-macro2",
  "proc-macro2-diagnostics",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -2165,7 +2173,7 @@ checksum = "487585f4d0c6655fe74905e2504d8ad6908e4db67f744eb140876906c2f3175d"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -2354,6 +2362,19 @@ dependencies = [
  "termcolor",
 ]
 
+[[package]]
+name = "env_logger"
+version = "0.11.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e13fa619b91fb2381732789fc5de83b45675e882f66623b7d8cb4f643017018d"
+dependencies = [
+ "anstream",
+ "anstyle",
+ "env_filter",
+ "humantime 2.1.0",
+ "log",
+]
+
 [[package]]
 name = "envy"
 version = "0.4.2"
@@ -2531,7 +2552,7 @@ dependencies = [
  "macroific",
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -2765,7 +2786,7 @@ checksum = "87750cf4b7a4c0625b1529e4c543c2182106e4dedc60a2a6455e00d212c489ac"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -2860,7 +2881,7 @@ dependencies = [
  "proc-macro-error2",
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -3248,6 +3269,12 @@ version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
 
+[[package]]
+name = "human-repr"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f58b778a5761513caf593693f8951c97a5b610841e754788400f32102eefdff1"
+
 [[package]]
 name = "humantime"
 version = "1.3.0"
@@ -3822,9 +3849,9 @@ dependencies = [
 
 [[package]]
 name = "libc"
-version = "0.2.162"
+version = "0.2.167"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "18d287de67fe55fd7e1581fe933d965a5a9477b38e949cfa9f8574ef01506398"
+checksum = "09d6582e104315a817dff97f75133544b2e094ee22447d2acf4a74e189ba06fc"
 
 [[package]]
 name = "libm"
@@ -3950,7 +3977,7 @@ dependencies = [
  "cfg-if",
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -3961,7 +3988,7 @@ checksum = "13198c120864097a565ccb3ff947672d969932b7975ebd4085732c9f09435e55"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -3974,7 +4001,7 @@ dependencies = [
  "macroific_core",
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -4128,6 +4155,21 @@ dependencies = [
  "wasm-utils",
 ]
 
+[[package]]
+name = "mixnet-connectivity-check"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "clap 4.5.20",
+ "futures",
+ "nym-bin-common",
+ "nym-crypto",
+ "nym-network-defaults",
+ "nym-sdk",
+ "tokio",
+ "tracing",
+]
+
 [[package]]
 name = "moka"
 version = "0.12.8"
@@ -4431,7 +4473,7 @@ dependencies = [
  "proc-macro-crate",
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -4674,6 +4716,7 @@ dependencies = [
  "opentelemetry-jaeger",
  "pretty_env_logger",
  "schemars",
+ "semver 1.0.23",
  "serde",
  "serde_json",
  "tracing-opentelemetry",
@@ -4751,12 +4794,14 @@ dependencies = [
  "nym-coconut-dkg-common",
  "nym-config",
  "nym-contracts-common",
+ "nym-credential-proxy-requests",
  "nym-credential-storage",
  "nym-credential-utils",
  "nym-credentials",
  "nym-credentials-interface",
  "nym-crypto",
  "nym-ecash-contract-common",
+ "nym-ecash-time",
  "nym-id",
  "nym-mixnet-contract-common",
  "nym-multisig-contract-common",
@@ -4848,6 +4893,7 @@ dependencies = [
  "nym-gateway-requests",
  "nym-id",
  "nym-metrics",
+ "nym-mixnet-client",
  "nym-network-defaults",
  "nym-nonexhaustive-delayqueue",
  "nym-pemstore",
@@ -5006,16 +5052,6 @@ dependencies = [
  "nym-multisig-contract-common",
 ]
 
-[[package]]
-name = "nym-common-models"
-version = "0.1.0"
-dependencies = [
- "anyhow",
- "bincode",
- "nym-crypto",
- "serde",
-]
-
 [[package]]
 name = "nym-compact-ecash"
 version = "0.1.0"
@@ -5092,7 +5128,7 @@ dependencies = [
 
 [[package]]
 name = "nym-credential-proxy"
-version = "0.1.6"
+version = "0.1.3"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -5112,7 +5148,6 @@ dependencies = [
  "nym-credentials",
  "nym-credentials-interface",
  "nym-crypto",
- "nym-ecash-contract-common",
  "nym-http-api-common",
  "nym-network-defaults",
  "nym-validator-client",
@@ -5451,7 +5486,7 @@ dependencies = [
  "nym-mixnode-common",
  "nym-network-defaults",
  "nym-network-requester",
- "nym-node-http-api",
+ "nym-node-metrics",
  "nym-sdk",
  "nym-sphinx",
  "nym-statistics-common",
@@ -5543,8 +5578,11 @@ name = "nym-gateway-stats-storage"
 version = "0.1.0"
 dependencies = [
  "nym-credentials-interface",
+ "nym-node-metrics",
  "nym-sphinx",
+ "nym-statistics-common",
  "sqlx",
+ "strum 0.26.3",
  "thiserror",
  "time",
  "tokio",
@@ -5555,7 +5593,6 @@ dependencies = [
 name = "nym-gateway-storage"
 version = "0.1.0"
 dependencies = [
- "async-trait",
  "bincode",
  "defguard_wireguard_rs",
  "log",
@@ -5620,15 +5657,12 @@ dependencies = [
  "axum-client-ip",
  "bytes",
  "colored",
- "futures",
  "mime",
  "serde",
  "serde_json",
  "serde_yaml",
- "tower 0.4.13",
  "tracing",
  "utoipa",
- "zeroize",
 ]
 
 [[package]]
@@ -5751,11 +5785,11 @@ name = "nym-mixnet-client"
 version = "0.1.0"
 dependencies = [
  "futures",
- "log",
  "nym-sphinx",
  "nym-task",
  "tokio",
  "tokio-util",
+ "tracing",
 ]
 
 [[package]]
@@ -5782,35 +5816,6 @@ dependencies = [
  "utoipa",
 ]
 
-[[package]]
-name = "nym-mixnode"
-version = "1.1.37"
-dependencies = [
- "colored",
- "futures",
- "nym-contracts-common",
- "nym-crypto",
- "nym-http-api-common",
- "nym-metrics",
- "nym-mixnet-client",
- "nym-mixnode-common",
- "nym-node-http-api",
- "nym-nonexhaustive-delayqueue",
- "nym-sphinx",
- "nym-sphinx-params",
- "nym-sphinx-types",
- "nym-task",
- "nym-topology",
- "nym-types",
- "nym-validator-client",
- "thiserror",
- "time",
- "tokio",
- "tokio-util",
- "tracing",
- "url",
-]
-
 [[package]]
 name = "nym-mixnode-common"
 version = "0.1.0"
@@ -5819,11 +5824,9 @@ dependencies = [
  "futures",
  "humantime-serde",
  "log",
- "nym-bin-common",
  "nym-crypto",
  "nym-metrics",
  "nym-network-defaults",
- "nym-node-http-api",
  "nym-sphinx-acknowledgements",
  "nym-sphinx-addressing",
  "nym-sphinx-forwarding",
@@ -5831,7 +5834,6 @@ dependencies = [
  "nym-sphinx-params",
  "nym-sphinx-types",
  "nym-task",
- "nym-validator-client",
  "rand",
  "serde",
  "thiserror",
@@ -5881,6 +5883,7 @@ dependencies = [
  "futures",
  "log",
  "nym-bin-common",
+ "nym-client-core",
  "nym-crypto",
  "nym-network-defaults",
  "nym-sdk",
@@ -5953,9 +5956,12 @@ dependencies = [
 
 [[package]]
 name = "nym-node"
-version = "1.2.0"
+version = "1.1.12"
 dependencies = [
  "anyhow",
+ "async-trait",
+ "axum 0.7.7",
+ "axum-extra",
  "bip39",
  "bs58",
  "cargo_metadata 0.18.1",
@@ -5963,6 +5969,10 @@ dependencies = [
  "clap 4.5.20",
  "colored",
  "cupid",
+ "dashmap",
+ "futures",
+ "headers",
+ "human-repr",
  "humantime-serde",
  "ipnetwork 0.20.0",
  "nym-authenticator",
@@ -5971,63 +5981,60 @@ dependencies = [
  "nym-config",
  "nym-crypto",
  "nym-gateway",
+ "nym-gateway-stats-storage",
+ "nym-http-api-common",
  "nym-ip-packet-router",
- "nym-mixnode",
+ "nym-metrics",
+ "nym-mixnet-client",
  "nym-network-requester",
- "nym-node-http-api",
+ "nym-node-metrics",
+ "nym-node-requests",
+ "nym-nonexhaustive-delayqueue",
  "nym-pemstore",
  "nym-sphinx-acknowledgements",
  "nym-sphinx-addressing",
+ "nym-sphinx-forwarding",
+ "nym-sphinx-framing",
+ "nym-sphinx-types",
  "nym-task",
+ "nym-topology",
  "nym-types",
  "nym-validator-client",
+ "nym-verloc",
  "nym-wireguard",
  "nym-wireguard-types",
  "rand",
  "semver 1.0.23",
  "serde",
  "serde_json",
+ "si-scale",
  "sysinfo",
  "thiserror",
+ "time",
  "tokio",
+ "tokio-util",
  "toml 0.8.14",
+ "tower-http",
  "tracing",
  "tracing-subscriber",
  "url",
+ "utoipa",
+ "utoipa-swagger-ui",
  "zeroize",
 ]
 
 [[package]]
-name = "nym-node-http-api"
+name = "nym-node-metrics"
 version = "0.1.0"
 dependencies = [
- "axum 0.7.7",
- "axum-extra",
- "base64 0.22.1",
- "colored",
  "dashmap",
- "fastrand 2.1.1",
- "headers",
- "hmac",
- "hyper 1.4.1",
- "ipnetwork 0.20.0",
- "nym-crypto",
- "nym-http-api-common",
+ "futures",
  "nym-metrics",
- "nym-node-requests",
- "nym-task",
- "nym-wireguard",
- "rand",
- "serde_json",
- "thiserror",
+ "nym-statistics-common",
+ "strum 0.26.3",
  "time",
  "tokio",
- "tower 0.4.13",
- "tower-http",
  "tracing",
- "utoipa",
- "utoipa-swagger-ui",
- "x25519-dalek",
 ]
 
 [[package]]
@@ -6059,30 +6066,23 @@ name = "nym-node-status-agent"
 version = "1.0.0-rc.1"
 dependencies = [
  "anyhow",
- "bincode",
- "chrono",
  "clap 4.5.20",
  "nym-bin-common",
- "nym-common-models",
  "nym-crypto",
+ "nym-node-status-client",
  "rand",
- "reqwest 0.12.4",
- "serde",
- "serde_json",
  "tempfile",
  "tokio",
- "tokio-util",
  "tracing",
  "tracing-subscriber",
 ]
 
 [[package]]
 name = "nym-node-status-api"
-version = "1.0.0-rc.2"
+version = "1.0.0-rc.6"
 dependencies = [
  "anyhow",
  "axum 0.7.7",
- "bincode",
  "chrono",
  "clap 4.5.20",
  "cosmwasm-std",
@@ -6090,11 +6090,14 @@ dependencies = [
  "futures-util",
  "moka",
  "nym-bin-common",
- "nym-common-models",
  "nym-crypto",
  "nym-explorer-client",
  "nym-network-defaults",
+ "nym-node-metrics",
  "nym-node-requests",
+ "nym-node-status-client",
+ "nym-serde-helpers",
+ "nym-statistics-common",
  "nym-task",
  "nym-validator-client",
  "regex",
@@ -6106,6 +6109,7 @@ dependencies = [
  "strum 0.26.3",
  "strum_macros 0.26.4",
  "thiserror",
+ "time",
  "tokio",
  "tokio-util",
  "tower-http",
@@ -6117,6 +6121,21 @@ dependencies = [
  "utoipauto",
 ]
 
+[[package]]
+name = "nym-node-status-client"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "bincode",
+ "chrono",
+ "nym-crypto",
+ "nym-http-api-client",
+ "reqwest 0.12.4",
+ "serde",
+ "serde_json",
+ "tracing",
+]
+
 [[package]]
 name = "nym-node-tester-utils"
 version = "0.1.0"
@@ -6811,6 +6830,25 @@ dependencies = [
  "zeroize",
 ]
 
+[[package]]
+name = "nym-verloc"
+version = "0.1.0"
+dependencies = [
+ "bytes",
+ "futures",
+ "humantime 2.1.0",
+ "nym-crypto",
+ "nym-task",
+ "nym-validator-client",
+ "rand",
+ "thiserror",
+ "time",
+ "tokio",
+ "tokio-util",
+ "tracing",
+ "url",
+]
+
 [[package]]
 name = "nym-vesting-contract-common"
 version = "0.7.0"
@@ -6892,6 +6930,7 @@ dependencies = [
  "time",
  "tokio",
  "tokio-stream",
+ "tracing",
  "x25519-dalek",
 ]
 
@@ -7225,7 +7264,7 @@ dependencies = [
  "proc-macro2",
  "proc-macro2-diagnostics",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -7312,7 +7351,7 @@ dependencies = [
  "pest_meta",
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -7353,7 +7392,7 @@ checksum = "a4502d8515ca9f32f1fb543d987f63d95a14934883db45bdb48060b6b69257f8"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -7502,7 +7541,7 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "926d36b9553851b8b0005f1275891b392ee4d2d833852c417ed025477350fb9d"
 dependencies = [
- "env_logger",
+ "env_logger 0.7.1",
  "log",
 ]
 
@@ -7568,14 +7607,14 @@ dependencies = [
  "proc-macro-error-attr2",
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.90",
 ]
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.89"
+version = "1.0.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f139b0662de085916d1fb67d2b4169d1addddda1919e696f3252b740b629986e"
+checksum = "37d3544b3f2748c54e147655edb5025752e2303145b5aefb3c3ea2c78b973bb0"
 dependencies = [
  "unicode-ident",
 ]
@@ -7588,7 +7627,7 @@ checksum = "af066a9c399a26e020ada66a034357a868728e72cd426f3adcd35f80d88d88c8"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.90",
  "version_check",
  "yansi",
 ]
@@ -7651,7 +7690,7 @@ dependencies = [
  "itertools 0.12.1",
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -7884,7 +7923,7 @@ checksum = "bcc303e793d3734489387d205e9b186fac9c6cfacedd98cbb2e8a5943595f3e6"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -8111,7 +8150,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "rocket_http",
- "syn 2.0.87",
+ "syn 2.0.90",
  "unicode-xid",
  "version_check",
 ]
@@ -8237,7 +8276,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "rust-embed-utils",
- "syn 2.0.87",
+ "syn 2.0.90",
  "walkdir",
 ]
 
@@ -8293,9 +8332,9 @@ dependencies = [
 
 [[package]]
 name = "rustix"
-version = "0.38.40"
+version = "0.38.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "99e4ea3e1cdc4b559b8e5650f9c8e5998e3e5c1343b4eaf034565f32318d63c0"
+checksum = "d7f649912bc1495e167a6edee79151c84b1bad49748cb4f1f1167f459f6224f6"
 dependencies = [
  "bitflags 2.5.0",
  "errno",
@@ -8486,7 +8525,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "serde_derive_internals 0.29.1",
- "syn 2.0.87",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -8518,7 +8557,7 @@ checksum = "1db149f81d46d2deba7cd3c50772474707729550221e69588478ebf9ada425ae"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -8650,7 +8689,7 @@ checksum = "ad1e866f866923f252f05c889987993144fb74e722403468a4ebd70c3cd756c0"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -8661,7 +8700,7 @@ checksum = "e578a843d40b4189a4d66bba51d7684f57da5bd7c304c64e14bd63efbef49509"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -8672,7 +8711,7 @@ checksum = "18d26a20a969b9e3fdf2fc2d9f21eda6c40e2de84c9408bb5d3b05d499aae711"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -8734,7 +8773,7 @@ checksum = "aafbefbe175fa9bf03ca83ef89beecff7d2a95aaacd5732325b90ac8c3bd7b90"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -8755,7 +8794,7 @@ checksum = "6c64451ba24fc7a6a2d60fc75dd9c83c90903b19028d4eff35e88fc1e86564e9"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -8806,7 +8845,7 @@ dependencies = [
  "darling 0.20.9",
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -9405,7 +9444,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "rustversion",
- "syn 2.0.87",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -9448,9 +9487,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.87"
+version = "2.0.90"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "25aa4ce346d03a6dcd68dd8b4010bcb74e54e62c90c573f394c46eae99aba32d"
+checksum = "919d3b74a5dd0ccd15aeb8f93e7006bd9e14c295087c9896a110f490752bcf31"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -9756,7 +9795,7 @@ checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -9887,7 +9926,7 @@ checksum = "693d596312e88961bc67d7f1f97af8a70227d9f90c31bba5806eec004978d752"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -10166,7 +10205,7 @@ checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -10330,7 +10369,7 @@ checksum = "0ea0b99e8ec44abd6f94a18f28f7934437809dd062820797c52401298116f70e"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.90",
  "termcolor",
 ]
 
@@ -10357,7 +10396,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "serde_derive_internals 0.28.0",
- "syn 2.0.87",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -10560,7 +10599,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "55137c122f712d9330fd985d66fa61bdc381752e89c35708c13ce63049a3002c"
 dependencies = [
  "quote",
- "syn 2.0.87",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -10592,7 +10631,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "serde",
- "syn 2.0.87",
+ "syn 2.0.90",
  "toml 0.5.11",
  "uniffi_build",
  "uniffi_meta",
@@ -10724,7 +10763,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "regex",
- "syn 2.0.87",
+ "syn 2.0.90",
  "uuid",
 ]
 
@@ -10763,7 +10802,7 @@ checksum = "17e82ab96c5a55263b5bed151b8426410d93aa909a453acdbd4b6792b5af7d64"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -10774,7 +10813,7 @@ checksum = "86b8338dc3c9526011ffaa2aa6bd60ddfda9d49d2123108690755c6e34844212"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.90",
  "utoipauto-core",
 ]
 
@@ -10881,7 +10920,7 @@ dependencies = [
  "once_cell",
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.90",
  "wasm-bindgen-shared",
 ]
 
@@ -10915,7 +10954,7 @@ checksum = "26c6ab57572f7a24a4985830b120de1594465e5d500f24afe89e16b4e833ef68"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.90",
  "wasm-bindgen-backend",
  "wasm-bindgen-shared",
 ]
@@ -10949,7 +10988,7 @@ checksum = "4b8220be1fa9e4c889b30fd207d4906657e7e90b12e0e6b0c8b8d8709f5de021"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -11477,7 +11516,7 @@ checksum = "15e934569e47891f7d9411f1a451d947a60e000ab3bd24fbb970f000387d1b3b"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.90",
 ]
 
 [[package]]
@@ -11497,7 +11536,7 @@ checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.87",
+ "syn 2.0.90",
 ]
 
 [[package]]

Cargo.toml

@@ -61,7 +61,6 @@ members = [
     "common/ip-packet-requests",
     "common/ledger",
     "common/mixnode-common",
-    "common/models",
     "common/network-defaults",
     "common/node-tester-utils",
     "common/nonexhaustive-delayqueue",
@@ -99,13 +98,12 @@ members = [
     "common/wasm/utils",
     "common/wireguard",
     "common/wireguard-types",
-    # "documentation/autodoc",
+    "documentation/autodoc",
     "explorer-api",
     "explorer-api/explorer-api-requests",
     "explorer-api/explorer-client",
     "gateway",
     "integrations/bity",
-    "mixnode",
     "sdk/ffi/cpp",
     "sdk/ffi/go",
     "sdk/ffi/shared",
@@ -124,10 +122,11 @@ members = [
     "nym-data-observatory",
     "nym-network-monitor",
     "nym-node",
-    "nym-node/nym-node-http-api",
     "nym-node/nym-node-requests",
-    "nym-node-status-api",
-    "nym-node-status-agent",
+    "nym-node/nym-node-metrics",
+    "nym-node-status-api/nym-node-status-agent",
+    "nym-node-status-api/nym-node-status-api",
+    "nym-node-status-api/nym-node-status-client",
     "nym-outfox",
     "nym-validator-rewarder",
     "tools/echo-server",
@@ -150,22 +149,21 @@ members = [
     "tools/internal/contract-state-importer/importer-contract",
     "tools/internal/testnet-manager",
     "tools/internal/testnet-manager/dkg-bypass-contract",
+    "common/verloc",
+    "tools/internal/mixnet-connectivity-check",
 ]
 
 default-members = [
     "clients/native",
     "clients/socks5",
-    "common/models",
     "explorer-api",
-    "gateway",
-    "mixnode",
     "nym-api",
     "nym-credential-proxy/nym-credential-proxy",
     "nym-data-observatory",
     "nym-node",
-    "nym-node-status-api",
+    "nym-node-status-api/nym-node-status-agent",
+    "nym-node-status-api/nym-node-status-api",
     "nym-validator-rewarder",
-    "nym-node-status-api",
     "service-providers/authenticator",
     "service-providers/ip-packet-router",
     "service-providers/network-requester",
@@ -264,6 +262,7 @@ http-body-util = "0.1"
 httpcodec = "0.2.3"
 humantime = "2.1.0"
 humantime-serde = "1.1.1"
+human-repr = "1.1.0"
 hyper = "1.4.1"
 hyper-util = "0.1"
 indicatif = "0.17.8"

SECURITY.md

@@ -3,37 +3,23 @@ Critical bug or security issue 💥
 If you're here because you're trying to figure out how to notify us of a security issue, send us a PGP encrypted email to:
 
 ```
-security@nymte.ch
+security@nym.com
 ```
 
 Encrypted with our public key which is available below in plain text and also on keyservers:
 
 ```
-pub   rsa4096 2023-10-30 [SC] [expire : 2026-10-29]
+sec   rsa4096/7C3C727F05090550 2023-10-30 [SC] [expire : 2026-10-29]
       24B2592E801A5AAA8666C8BA7C3C727F05090550
-uid          [  ultime ] Security Nym Technologies <security@nymte.ch>
-sub   rsa4096 2023-10-30 [E] [expire : 2026-10-29]
+uid                [  ultime ] Security Nym Technologies <security@nym.com>
+ssb   rsa4096/ACD0FBD79DC70ACC 2023-10-30 [E] [expire : 2026-10-29]
 
 ```
 
 The fingerprint of the key is on the second line above.
 
-If you need to chat __urgently__ to our team for a __critical__ security issue:
-
-go to Matrix, and alert the core engineers with a private direct message:
-
-    Jedrzej Stuczynski @jstuczyn:nymtech.chat
-    Mark Sinclair @mark:nymtech.chat
-    Raphaël Walther @raphael:nymtech.chat
-
 Please avoid opening public issues on GitHub that contain information about a potential security vulnerability as this makes it difficult to reduce the impact and harm of valid security issues.
 
-If you don't know what Matrix is, you can follow this documentation to create an account on this federation of instant messaging servers:
-
-[Matrix for Instant Messaging](https://matrix.org/docs/chat_basics/matrix-for-im/)
-
-
-
 ```
 -----BEGIN PGP PUBLIC KEY BLOCK-----
 
@@ -48,43 +34,69 @@ vMFUIzBMHOPXH16036zGyFMC1esRd2qqil4b9KtLgCOkrD1VgpjcveoA0VyMJCN6
 LmKTrVjwjjDMxby+d49BolRWGnCofXozXwvNQx+CYv8M2WPErTpyYoofYFtpqr7A
 fIufc/e0+um3zoGIbHejrhsbuH9Qf+MKsI+Ng93bdDtjeHz6MEgAlsTm0qeizYpj
 IyKZIObPmfvrAm08hFZ8JnGk+XuooF36XWbJYjCCy0bOyMw1r7ZG99TcSwARAQAB
-tC1TZWN1cml0eSBOeW0gVGVjaG5vbG9naWVzIDxzZWN1cml0eUBueW10ZS5jaD6J
-AlQEEwEKAD4WIQQkslkugBpaqoZmyLp8PHJ/BQkFUAUCZT9elwIbAwUJBaOagAUL
-CQgHAwUVCgkICwUWAgMBAAIeAQIXgAAKCRB8PHJ/BQkFUL7dD/9zO73uI5VR+SWx
-PFmJW+9QsPiQbVRvGwNZurctmQ2s2Pe0vHRELFeqD5oYvSx2Lequ3Ir+zn/C3kDM
-kNs40obSL6jCBiLPkxEY0JqzPM9jZr7EjvlibWV3f6DxooRIqEyfN57I3OBGlqZE
-0Mx7sQuCcgau8C70DF952QhKUwXC2cmpmDKHVEEoio1xGSD4dQhGapCB32RQGtna
-OGfAO9celNMvSq0Lp+aJxeACmWFY5T4/y79JPcT5vSs/yEIRmaH/fn2piwaFBsIq
-gHJJMxO3740P1hF8j7KWUoUofuFaEALHBpEpjWTOj8ej1wmFlu+5F+jSVoc781Wb
-ZZXu04cOBXnGTogzSxMpBe9TtLb28zd6WzFotC25KTI3pngMzXsQGLJLOwvoZKiS
-LFjPRjg1rwobmB3Q3J2W5GYSveia0CDsZGP+g87GVVf/oD2Djpa68xyVYwIYeA6T
-3DNdS77qHiRuGiS4kWXyVjDqOICboR4uCvt09zlkBuLDdTWqWYARUvZjtjs4w/Ol
-rdrBI3A88ti8fRldYaNpu17ME1ilpN44yKoJtqiWc3Tisk8eYLfx6c7FQF3PrRva
-mr7FZvhFsYML5CeNFHTEzN6Y3jjKN/60DvCfodWnWFK47Txkl8UAXGY2W9B0fWqQ
-wUVr8uLuMyyMiKbeoufi7rGOj6AMErkCDQRlP16XARAA8FGmD5J3tM1BOM1niJxZ
-JTdCauzEtxEoBL0RuqGBkR8U29sRM6DwuzjU7PwscFnBaGyU+eU73GwGkH3ozFfF
-tllYhQrhP/kkN+0rEO5Xi+nR+4JCFRqrf3nJXAAPfiksURMp8er1dUOY2/e1ZSoL
-tS+nzUivV8CfE+pgj/5YtGwPC+KYHLATkKkMELCrbW4UO06VWOqQsvr6kivXuJQQ
-LdEAMpBlADmXFG45DmPKQzsBWUgvTwyGy3LX0nys8cgpex9BH8hhr01QmGyP469s
-N3cNrtFuu8U6RAsiCD/8mlBuD3EQEU5SF0lc7kCICAZk+wElmXnimEi0TOYsbz6k
-90lteicX70rA9GNeyI76H+VSOYvWpkRwaJAgUdzrAM1o9SHASq+cZ6nD85OZioQk
-DWM6+Q+sf2oen0qJnnGmUr93kJIC0PIdgrXRrtiNfeRa1Z/H0LmREyyEMoFiVivn
-z1vVk85Oq6Sf3ltUwvmDzuuJOtsp2Qp6+x6Snn/yKauI4uf4Cf/wKUch4r6Bwgg5
-Dw49ky7lwlnALio4GIVoGLpLef93wWoDmp4Klyh3ZPf2nB0U91u3bHRUo7m+D7QJ
-98cyKtqLLzjg7szGf60pIWNWRsadYQT3bSncynqknAjOV3BCvx6/ivsnpj//QjYR
-HtviUAcQ1DBB6UC6q23FIs0AEQEAAYkCPAQYAQoAJhYhBCSyWS6AGlqqhmbIunw8
-cn8FCQVQBQJlP16XAhsMBQkFo5qAAAoJEHw8cn8FCQVQzukP/iLxjOxT+UpPR//c
-prDVSLkP4pF5bmw36U07jvqpS+/KTXsxiiQleffRabOpNLcd+K1ueavyt9nnIwHH
-tHS9kM9A7DBw3LnpEbXki46QDCCI6niGijlLOEeAWqnocwMNTT05wVVgCtO3DQP2
-MoSCcqHpXDChvOyr5d5xjYLVJhlctIMSomcVzGryjknPu0Yj/TkC/4c+m86ZWQUD
-HqMHQIuiEenvb62/F4c5OJIRZPEn70wdddkgJuJU3eHdHrnuhCkjCC93GQGbGj03
-Zqos6699y6hmPeD3U5IUv8ujwZYVCCuDm8gJfrp3R6WLfeZeK9WmTVBpCzsDg3fV
-hSwmOk6pp8DAq1/Dev3yRkFggCEyGK6c9b+a0CRBncl8e5Q0QQIzNiS/uExQP3h+
-ELJs3P0MLP+6FWhNUry09n3lnWkr1hY+v1M0GAxbfdv/tsCN1Pq/VQEz+CTqXqya
-ftWldOHWw6Hh+gtwxcHjG4MBOrO5oICQ3lh2hGwQ58cDgZYSK/OGgJ9BggFl1CcM
-0uGC0/TRCI1zt/4y+7efSZQMZkHo7VC/3MFbp2hcNejpW+BxVuwKTunFvWK3TLhq
-sSlQ5yyhqchooepsFHq9bosKFjLJC01uprBv1rinoNduOy43FbyS7JPRRspANN0R
-iC2pMbWdE0ZTQaFq6tPIg058pjqi
-=nqgX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+=QPTf
 -----END PGP PUBLIC KEY BLOCK-----
+
 ```

clients/native/src/commands/run.rs

@@ -3,10 +3,13 @@
 
 use crate::commands::try_load_current_config;
 use crate::{
-    client::SocketClient,
+    client::{config::Config, SocketClient},
     commands::{override_config, OverrideConfig},
+    error::ClientError,
 };
 use clap::Args;
+use log::*;
+use nym_bin_common::version_checker::is_minor_version_compatible;
 use nym_client_core::cli_helpers::client_run::CommonClientRunArgs;
 use std::error::Error;
 use std::net::IpAddr;
@@ -45,12 +48,36 @@ impl From<Run> for OverrideConfig {
     }
 }
 
+// this only checks compatibility between config the binary. It does not take into consideration
+// network version. It might do so in the future.
+fn version_check(cfg: &Config) -> bool {
+    let binary_version = env!("CARGO_PKG_VERSION");
+    let config_version = &cfg.base.client.version;
+    if binary_version == config_version {
+        true
+    } else {
+        warn!("The native-client binary has different version than what is specified in config file! {} and {}", binary_version, config_version);
+        if is_minor_version_compatible(binary_version, config_version) {
+            info!("but they are still semver compatible. However, consider running the `upgrade` command");
+            true
+        } else {
+            error!("and they are semver incompatible! - please run the `upgrade` command before attempting `run` again");
+            false
+        }
+    }
+}
+
 pub(crate) async fn execute(args: Run) -> Result<(), Box<dyn Error + Send + Sync>> {
     eprintln!("Starting client {}...", args.common_args.id);
 
     let mut config = try_load_current_config(&args.common_args.id).await?;
     config = override_config(config, OverrideConfig::from(args.clone()));
 
+    if !version_check(&config) {
+        error!("failed the local version check");
+        return Err(Box::new(ClientError::FailedLocalVersionCheck));
+    }
+
     SocketClient::new(config, args.common_args.custom_mixnet)
         .run_socket_forever()
         .await

clients/native/src/error.rs

@@ -17,6 +17,9 @@ pub enum ClientError {
     #[error("Failed to validate the loaded config")]
     ConfigValidationFailure,
 
+    #[error("Failed local version check, client and config mismatch")]
+    FailedLocalVersionCheck,
+
     #[error("Attempted to start the client in invalid socket mode")]
     InvalidSocketMode,
 

clients/socks5/src/commands/run.rs

@@ -2,8 +2,14 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::commands::try_load_current_config;
-use crate::commands::{override_config, OverrideConfig};
+use crate::config::Config;
+use crate::{
+    commands::{override_config, OverrideConfig},
+    error::Socks5ClientError,
+};
 use clap::Args;
+use log::*;
+use nym_bin_common::version_checker::is_minor_version_compatible;
 use nym_client_core::cli_helpers::client_run::CommonClientRunArgs;
 use nym_client_core::client::base_client::storage::OnDiskPersistent;
 use nym_client_core::client::topology_control::geo_aware_provider::CountryGroup;
@@ -76,12 +82,38 @@ fn validate_country_group(s: &str) -> Result<CountryGroup, String> {
     }
 }
 
+// this only checks compatibility between config the binary. It does not take into consideration
+// network version. It might do so in the future.
+fn version_check(cfg: &Config) -> bool {
+    let binary_version = env!("CARGO_PKG_VERSION");
+    let config_version = &cfg.core.base.client.version;
+    if binary_version == config_version {
+        true
+    } else {
+        warn!(
+            "The socks5-client binary has different version than what is specified in config file! {binary_version} and {config_version}",
+        );
+        if is_minor_version_compatible(binary_version, config_version) {
+            info!("but they are still semver compatible. However, consider running the `upgrade` command");
+            true
+        } else {
+            error!("and they are semver incompatible! - please run the `upgrade` command before attempting `run` again");
+            false
+        }
+    }
+}
+
 pub(crate) async fn execute(args: Run) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
     eprintln!("Starting client {}...", args.common_args.id);
 
     let mut config = try_load_current_config(&args.common_args.id).await?;
     config = override_config(config, OverrideConfig::from(args.clone()));
 
+    if !version_check(&config) {
+        error!("failed the local version check");
+        return Err(Box::new(Socks5ClientError::FailedLocalVersionCheck));
+    }
+
     let storage =
         OnDiskPersistent::from_paths(config.storage_paths.common_paths, &config.core.base.debug)
             .await?;

clients/socks5/src/error.rs

@@ -14,6 +14,9 @@ pub enum Socks5ClientError {
     #[error("Failed to validate the loaded config")]
     ConfigValidationFailure,
 
+    #[error("Failed local version check, client and config mismatch")]
+    FailedLocalVersionCheck,
+
     #[error("Fail to bind address")]
     FailToBindAddress,
 

common/bandwidth-controller/src/acquire/mod.rs

@@ -17,7 +17,7 @@ use nym_validator_client::coconut::all_ecash_api_clients;
 use nym_validator_client::nym_api::EpochId;
 use nym_validator_client::nyxd::contract_traits::EcashSigningClient;
 use nym_validator_client::nyxd::contract_traits::{DkgQueryClient, EcashQueryClient};
-use nym_validator_client::nyxd::cosmwasm_client::ContractResponseData;
+use nym_validator_client::nyxd::cosmwasm_client::ToSingletonContractData;
 use nym_validator_client::EcashApiClient;
 use rand::rngs::OsRng;
 

common/bin-common/Cargo.toml

@@ -15,6 +15,7 @@ const-str = { workspace = true }
 log = { workspace = true }
 pretty_env_logger = { workspace = true }
 schemars = { workspace = true, features = ["preserve_order"], optional = true }
+semver.workspace = true
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true, optional = true }
 
@@ -43,5 +44,5 @@ tracing = [
     "tracing-opentelemetry",
     "opentelemetry",
 ]
-clap = ["dep:clap", "dep:clap_complete", "dep:clap_complete_fig"]
+clap = [ "dep:clap", "dep:clap_complete", "dep:clap_complete_fig" ]
 models = []

common/bin-common/src/lib.rs

@@ -3,6 +3,7 @@
 
 pub mod build_information;
 pub mod logging;
+pub mod version_checker;
 
 #[cfg(feature = "clap")]
 pub mod completions;

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

@@ -0,0 +1,78 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+pub use semver::Version;
+
+/// Checks if the version is minor version compatible.
+///
+/// Checks whether given `version` is compatible with a given semantic version requirement `req`
+/// according to major-minor semver rules. The semantic version requirement can be passed as a full,
+/// concrete version number, because that's what we'll have in our Cargo.toml files (e.g. 0.3.2).
+/// The patch number in the requirement gets dropped and replaced with a wildcard (0.3.*) as all
+/// minor versions should be compatible with each other.
+pub fn is_minor_version_compatible(version: &str, req: &str) -> bool {
+    let expected_version = match Version::parse(version) {
+        Ok(v) => v,
+        Err(_) => return false,
+    };
+    let req_version = match Version::parse(req) {
+        Ok(v) => v,
+        Err(_) => return false,
+    };
+
+    expected_version.major == req_version.major && expected_version.minor == req_version.minor
+}
+
+pub fn parse_version(raw_version: &str) -> Result<Version, semver::Error> {
+    Version::parse(raw_version)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn version_0_3_0_is_compatible_with_requirement_0_3_x() {
+        assert!(is_minor_version_compatible("0.3.0", "0.3.2"));
+    }
+
+    #[test]
+    fn version_0_3_1_is_compatible_with_minimum_requirement_0_3_x() {
+        assert!(is_minor_version_compatible("0.3.1", "0.3.2"));
+    }
+
+    #[test]
+    fn version_0_3_2_is_compatible_with_minimum_requirement_0_3_x() {
+        assert!(is_minor_version_compatible("0.3.2", "0.3.0"));
+    }
+
+    #[test]
+    fn version_0_2_0_is_not_compatible_with_requirement_0_3_x() {
+        assert!(!is_minor_version_compatible("0.2.0", "0.3.2"));
+    }
+
+    #[test]
+    fn version_0_4_0_is_not_compatible_with_requirement_0_3_x() {
+        assert!(!is_minor_version_compatible("0.4.0", "0.3.2"));
+    }
+
+    #[test]
+    fn version_1_3_2_is_not_compatible_with_requirement_0_3_x() {
+        assert!(!is_minor_version_compatible("1.3.2", "0.3.2"));
+    }
+
+    #[test]
+    fn version_0_4_0_rc_1_is_compatible_with_version_0_4_0_rc_1() {
+        assert!(is_minor_version_compatible("0.4.0-rc.1", "0.4.0-rc.1"));
+    }
+
+    #[test]
+    fn returns_false_on_foo_version() {
+        assert!(!is_minor_version_compatible("foo", "0.3.2"));
+    }
+
+    #[test]
+    fn returns_false_on_bar_version() {
+        assert!(!is_minor_version_compatible("0.3.2", "bar"));
+    }
+}

common/client-core/Cargo.toml

@@ -46,6 +46,7 @@ nym-sphinx = { path = "../nymsphinx" }
 nym-statistics-common = { path = "../statistics" }
 nym-pemstore = { path = "../pemstore" }
 nym-topology = { path = "../topology", features = ["serializable"] }
+nym-mixnet-client = { path = "../client-libs/mixnet-client", default-features = false }
 nym-validator-client = { path = "../client-libs/validator-client", default-features = false }
 nym-task = { path = "../task" }
 nym-credentials-interface = { path = "../credentials-interface" }

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

@@ -514,10 +514,15 @@ where
                     min_gateway_performance: config_topology.minimum_gateway_performance,
                 },
                 nym_api_urls,
+                env!("CARGO_PKG_VERSION").to_string(),
                 user_agent,
             )),
             config::TopologyStructure::GeoAware(group_by) => {
-                Box::new(GeoAwareTopologyProvider::new(nym_api_urls, group_by))
+                Box::new(GeoAwareTopologyProvider::new(
+                    nym_api_urls,
+                    env!("CARGO_PKG_VERSION").to_string(),
+                    group_by,
+                ))
             }
         })
     }

common/client-core/src/client/mix_traffic/transceiver.rs

@@ -14,7 +14,7 @@ use std::os::raw::c_int as RawFd;
 use thiserror::Error;
 
 #[cfg(not(target_arch = "wasm32"))]
-use futures::channel::{mpsc, oneshot};
+use futures::channel::oneshot;
 
 // we need to type erase the error type since we can't have dynamic associated types alongside dynamic dispatch
 #[derive(Debug, Error)]
@@ -170,7 +170,7 @@ pub struct LocalGateway {
 
     // 'sender' part
     /// Channel responsible for taking mix packets and forwarding them further into the further mixnet layers.
-    packet_forwarder: mpsc::UnboundedSender<MixPacket>,
+    packet_forwarder: nym_mixnet_client::forwarder::MixForwardingSender,
 
     // 'receiver' part
     packet_router_tx: Option<oneshot::Sender<PacketRouter>>,
@@ -180,7 +180,7 @@ pub struct LocalGateway {
 impl LocalGateway {
     pub fn new(
         local_identity: identity::PublicKey,
-        packet_forwarder: mpsc::UnboundedSender<MixPacket>,
+        packet_forwarder: nym_mixnet_client::forwarder::MixForwardingSender,
         packet_router_tx: oneshot::Sender<PacketRouter>,
     ) -> Self {
         LocalGateway {
@@ -208,8 +208,7 @@ mod nonwasm_sealed {
     impl GatewaySender for LocalGateway {
         async fn send_mix_packet(&mut self, packet: MixPacket) -> Result<(), ErasedGatewayError> {
             self.packet_forwarder
-                .unbounded_send(packet)
-                .map_err(|err| err.into_send_error())
+                .forward_packet(packet)
                 .map_err(erase_err)
         }
     }

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

@@ -85,10 +85,15 @@ fn check_layer_integrity(topology: NymTopology) -> Result<(), ()> {
 pub struct GeoAwareTopologyProvider {
     validator_client: nym_validator_client::client::NymApiClient,
     filter_on: GroupBy,
+    client_version: String,
 }
 
 impl GeoAwareTopologyProvider {
-    pub fn new(mut nym_api_urls: Vec<Url>, filter_on: GroupBy) -> GeoAwareTopologyProvider {
+    pub fn new(
+        mut nym_api_urls: Vec<Url>,
+        client_version: String,
+        filter_on: GroupBy,
+    ) -> GeoAwareTopologyProvider {
         log::info!(
             "Creating geo-aware topology provider with filter on {}",
             filter_on
@@ -100,13 +105,14 @@ impl GeoAwareTopologyProvider {
                 nym_api_urls[0].clone(),
             ),
             filter_on,
+            client_version,
         }
     }
 
     async fn get_topology(&self) -> Option<NymTopology> {
         let mixnodes = match self
             .validator_client
-            .get_all_basic_active_mixing_assigned_nodes()
+            .get_all_basic_active_mixing_assigned_nodes(Some(self.client_version.clone()))
             .await
         {
             Err(err) => {
@@ -118,7 +124,7 @@ impl GeoAwareTopologyProvider {
 
         let gateways = match self
             .validator_client
-            .get_all_basic_entry_assigned_nodes()
+            .get_all_basic_entry_assigned_nodes(Some(self.client_version.clone()))
             .await
         {
             Err(err) => {

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

@@ -35,11 +35,18 @@ pub struct NymApiTopologyProvider {
 
     validator_client: nym_validator_client::client::NymApiClient,
     nym_api_urls: Vec<Url>,
+
+    client_version: String,
     currently_used_api: usize,
 }
 
 impl NymApiTopologyProvider {
-    pub fn new(config: Config, mut nym_api_urls: Vec<Url>, user_agent: Option<UserAgent>) -> Self {
+    pub fn new(
+        config: Config,
+        mut nym_api_urls: Vec<Url>,
+        client_version: String,
+        user_agent: Option<UserAgent>,
+    ) -> Self {
         nym_api_urls.shuffle(&mut thread_rng());
 
         let validator_client = if let Some(user_agent) = user_agent {
@@ -55,6 +62,7 @@ impl NymApiTopologyProvider {
             config,
             validator_client,
             nym_api_urls,
+            client_version,
             currently_used_api: 0,
         }
     }
@@ -91,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()
+            .get_all_basic_active_mixing_assigned_nodes(Some(self.client_version.clone()))
             .await
         {
             Err(err) => {
@@ -103,7 +111,7 @@ impl NymApiTopologyProvider {
 
         let gateways = match self
             .validator_client
-            .get_all_basic_entry_assigned_nodes()
+            .get_all_basic_entry_assigned_nodes(Some(self.client_version.clone()))
             .await
         {
             Err(err) => {

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

@@ -94,7 +94,7 @@ pub async fn current_gateways<R: Rng>(
 
     log::debug!("Fetching list of gateways from: {nym_api}");
 
-    let gateways = client.get_all_basic_entry_assigned_nodes().await?;
+    let gateways = client.get_all_basic_entry_assigned_nodes(None).await?;
     log::debug!("Found {} gateways", gateways.len());
     log::trace!("Gateways: {:#?}", gateways);
 
@@ -121,7 +121,9 @@ 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().await?;
+    let mixnodes = client
+        .get_all_basic_active_mixing_assigned_nodes(None)
+        .await?;
     let valid_mixnodes = mixnodes
         .iter()
         .filter_map(|mixnode| mixnode.try_into().ok())

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

@@ -87,10 +87,8 @@ impl ClientBandwidth {
 
         if remaining < 0 {
             tracing::warn!("OUT OF BANDWIDTH. remaining: {remaining_bi2}");
-        } else if remaining < 1_000_000 {
-            tracing::info!("remaining bandwidth: {remaining_bi2}");
         } else {
-            tracing::debug!("remaining bandwidth: {remaining_bi2}");
+            tracing::info!("remaining bandwidth: {remaining_bi2}");
         }
 
         self.inner

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

@@ -139,10 +139,6 @@ impl<C, St> GatewayClient<C, St> {
         self.gateway_identity
     }
 
-    pub fn shared_key(&self) -> Option<Arc<SharedGatewayKey>> {
-        self.shared_key.clone()
-    }
-
     pub fn ws_fd(&self) -> Option<RawFd> {
         match &self.connection {
             SocketState::Available(conn) => ws_fd(conn.as_ref()),
@@ -412,7 +408,7 @@ impl<C, St> GatewayClient<C, St> {
             }
 
             Some(_) => {
-                debug!("the gateway is using exactly the same (or older) protocol version as we are. We're good to continue!");
+                info!("the gateway is using exactly the same (or older) protocol version as we are. We're good to continue!");
                 Ok(())
             }
         }
@@ -996,6 +992,24 @@ impl<C, St> GatewayClient<C, St> {
         }
         Ok(())
     }
+
+    #[deprecated(note = "this method does not deal with upgraded keys for legacy clients")]
+    pub async fn authenticate_and_start(
+        &mut self,
+    ) -> Result<AuthenticationResponse, GatewayClientError>
+    where
+        C: DkgQueryClient + Send + Sync,
+        St: CredentialStorage,
+        <St as CredentialStorage>::StorageError: Send + Sync + 'static,
+    {
+        let shared_key = self.perform_initial_authentication().await?;
+        self.claim_initial_bandwidth().await?;
+
+        // this call is NON-blocking
+        self.start_listening_for_mixnet_messages()?;
+
+        Ok(shared_key)
+    }
 }
 
 // type alias for an ease of use

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

@@ -111,11 +111,6 @@ impl PartiallyDelegatedRouter {
             }
         };
 
-        if self.stream_return.is_canceled() {
-            // nothing to do, receiver has been dropped
-            return;
-        }
-
         let return_res = match ret {
             Err(err) => self.stream_return.send(Err(err)),
             Ok(_) => {

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

@@ -9,10 +9,14 @@ license.workspace = true
 
 [dependencies]
 futures = { workspace = true }
-log = { workspace = true }
-tokio = { workspace = true, features = ["time", "net", "rt"] }
-tokio-util = { workspace = true, features = ["codec"] }
+tracing = { workspace = true }
+tokio = { workspace = true, features = ["time"] }
+tokio-util = { workspace = true, features = ["codec"], optional = true }
 
 # internal
 nym-sphinx = { path = "../../nymsphinx" }
-nym-task = { path = "../../task" }
+nym-task = { path = "../../task", optional = true }
+
+[features]
+default = ["client"]
+client = ["tokio-util", "nym-task", "tokio/net", "tokio/rt"]

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

@@ -3,7 +3,6 @@
 
 use futures::channel::mpsc;
 use futures::StreamExt;
-use log::*;
 use nym_sphinx::addressing::nodes::NymNodeRoutingAddress;
 use nym_sphinx::framing::codec::NymCodec;
 use nym_sphinx::framing::packet::FramedNymPacket;
@@ -18,13 +17,14 @@ use std::time::Duration;
 use tokio::net::TcpStream;
 use tokio::time::sleep;
 use tokio_util::codec::Framed;
+use tracing::*;
 
+#[derive(Clone, Copy)]
 pub struct Config {
     initial_reconnection_backoff: Duration,
     maximum_reconnection_backoff: Duration,
     initial_connection_timeout: Duration,
     maximum_connection_buffer_size: usize,
-    use_legacy_version: bool,
 }
 
 impl Config {
@@ -33,14 +33,12 @@ impl Config {
         maximum_reconnection_backoff: Duration,
         initial_connection_timeout: Duration,
         maximum_connection_buffer_size: usize,
-        use_legacy_version: bool,
     ) -> Self {
         Config {
             initial_reconnection_backoff,
             maximum_reconnection_backoff,
             initial_connection_timeout,
             maximum_connection_buffer_size,
-            use_legacy_version,
         }
     }
 }
@@ -200,9 +198,8 @@ impl SendWithoutResponse for Client {
         packet: NymPacket,
         packet_type: PacketType,
     ) -> io::Result<()> {
-        trace!("Sending packet to {:?}", address);
-        let framed_packet =
-            FramedNymPacket::new(packet, packet_type, self.config.use_legacy_version);
+        trace!("Sending packet to {address:?}");
+        let framed_packet = FramedNymPacket::new(packet, packet_type);
 
         if let Some(sender) = self.conn_new.get_mut(&address) {
             if let Err(err) = sender.channel.try_send(framed_packet) {
@@ -260,7 +257,6 @@ mod tests {
             maximum_reconnection_backoff: Duration::from_millis(300_000),
             initial_connection_timeout: Duration::from_millis(1_500),
             maximum_connection_buffer_size: 128,
-            use_legacy_version: false,
         })
     }
 

common/client-libs/mixnet-client/src/forwarder.rs

@@ -1,77 +1,72 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::client::{Client, Config, SendWithoutResponse};
 use futures::channel::mpsc;
-use futures::StreamExt;
-use log::*;
+use futures::channel::mpsc::SendError;
 use nym_sphinx::forwarding::packet::MixPacket;
-use std::time::Duration;
+use tokio::time::Instant;
 
-pub type MixForwardingSender = mpsc::UnboundedSender<MixPacket>;
-type MixForwardingReceiver = mpsc::UnboundedReceiver<MixPacket>;
-
-/// A specialisation of client such that it forwards any received packets on the channel into the
-/// mix network immediately, i.e. will not try to listen for any responses.
-pub struct PacketForwarder {
-    mixnet_client: Client,
-    packet_receiver: MixForwardingReceiver,
-    shutdown: nym_task::TaskClient,
+pub fn mix_forwarding_channels() -> (MixForwardingSender, MixForwardingReceiver) {
+    let (tx, rx) = mpsc::unbounded();
+    (tx.into(), rx)
 }
 
-impl PacketForwarder {
-    pub fn new(
-        initial_reconnection_backoff: Duration,
-        maximum_reconnection_backoff: Duration,
-        initial_connection_timeout: Duration,
-        maximum_connection_buffer_size: usize,
-        use_legacy_version: bool,
-        shutdown: nym_task::TaskClient,
-    ) -> (PacketForwarder, MixForwardingSender) {
-        let client_config = Config::new(
-            initial_reconnection_backoff,
-            maximum_reconnection_backoff,
-            initial_connection_timeout,
-            maximum_connection_buffer_size,
-            use_legacy_version,
-        );
+#[derive(Clone)]
+pub struct MixForwardingSender(mpsc::UnboundedSender<PacketToForward>);
 
-        let (packet_sender, packet_receiver) = mpsc::unbounded();
+impl From<mpsc::UnboundedSender<PacketToForward>> for MixForwardingSender {
+    fn from(tx: mpsc::UnboundedSender<PacketToForward>) -> Self {
+        MixForwardingSender(tx)
+    }
+}
 
-        (
-            PacketForwarder {
-                mixnet_client: Client::new(client_config),
-                packet_receiver,
-                shutdown,
-            },
-            packet_sender,
-        )
+impl MixForwardingSender {
+    pub fn forward_packet(&self, packet: impl Into<PacketToForward>) -> Result<(), SendError> {
+        self.0
+            .unbounded_send(packet.into())
+            .map_err(|err| err.into_send_error())
     }
 
-    pub async fn run(&mut self) {
-        while !self.shutdown.is_shutdown() {
-            tokio::select! {
-                biased;
-                _ = self.shutdown.recv() => {
-                    log::trace!("PacketForwarder: Received shutdown");
-                }
-                Some(mix_packet) = self.packet_receiver.next() => {
-                     trace!("Going to forward packet to {}", mix_packet.next_hop());
+    #[allow(clippy::len_without_is_empty)]
+    pub fn len(&self) -> usize {
+        self.0.len()
+    }
+}
 
-                    let next_hop = mix_packet.next_hop();
-                    let packet_type = mix_packet.packet_type();
-                    let packet = mix_packet.into_packet();
-                    // we don't care about responses, we just want to fire packets
-                    // as quickly as possible
+pub type MixForwardingReceiver = mpsc::UnboundedReceiver<PacketToForward>;
 
-                    if let Err(err) =
-                        self.mixnet_client
-                            .send_without_response(next_hop, packet, packet_type)
-                    {
-                        debug!("failed to forward the packet - {err}")
-                    }
-                }
-            }
+pub struct PacketToForward {
+    pub packet: MixPacket,
+    pub forward_delay_target: Option<Instant>,
+}
+
+impl From<MixPacket> for PacketToForward {
+    fn from(packet: MixPacket) -> Self {
+        PacketToForward::new_no_delay(packet)
+    }
+}
+
+impl From<(MixPacket, Option<Instant>)> for PacketToForward {
+    fn from((packet, delay_until): (MixPacket, Option<Instant>)) -> Self {
+        PacketToForward::new(packet, delay_until)
+    }
+}
+
+impl From<(MixPacket, Instant)> for PacketToForward {
+    fn from((packet, delay_until): (MixPacket, Instant)) -> Self {
+        PacketToForward::new(packet, Some(delay_until))
+    }
+}
+
+impl PacketToForward {
+    pub fn new(packet: MixPacket, forward_delay_target: Option<Instant>) -> Self {
+        PacketToForward {
+            packet,
+            forward_delay_target,
         }
     }
+
+    pub fn new_no_delay(packet: MixPacket) -> Self {
+        Self::new(packet, None)
+    }
 }

common/client-libs/mixnet-client/src/lib.rs

@@ -1,7 +1,9 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
+#[cfg(feature = "client")]
 pub mod client;
 pub mod forwarder;
 
+#[cfg(feature = "client")]
 pub use client::{Client, Config, SendWithoutResponse};

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

@@ -19,8 +19,8 @@ use nym_api_requests::ecash::{
     PartialExpirationDateSignatureResponse, VerificationKeyResponse,
 };
 use nym_api_requests::models::{
-    ApiHealthResponse, GatewayBondAnnotated, GatewayCoreStatusResponse, MixnodeCoreStatusResponse,
-    MixnodeStatusResponse, NymNodeDescription, RewardEstimationResponse, StakeSaturationResponse,
+    ApiHealthResponse, GatewayCoreStatusResponse, MixnodeCoreStatusResponse, MixnodeStatusResponse,
+    NymNodeDescription, RewardEstimationResponse, StakeSaturationResponse,
 };
 use nym_api_requests::models::{LegacyDescribedGateway, MixNodeBondAnnotated};
 use nym_api_requests::nym_nodes::SkimmedNode;
@@ -257,13 +257,6 @@ impl<C, S> Client<C, S> {
         Ok(self.nym_api.get_gateways().await?)
     }
 
-    #[deprecated]
-    pub async fn get_cached_gateways_detailed_unfiltered(
-        &self,
-    ) -> Result<Vec<GatewayBondAnnotated>, ValidatorClientError> {
-        Ok(self.nym_api.get_gateways_detailed_unfiltered().await?)
-    }
-
     // TODO: combine with NymApiClient...
     pub async fn get_all_cached_described_nodes(
         &self,
@@ -358,19 +351,34 @@ impl NymApiClient {
     }
 
     #[deprecated(note = "use get_all_basic_active_mixing_assigned_nodes instead")]
-    pub async fn get_basic_mixnodes(&self) -> Result<Vec<SkimmedNode>, ValidatorClientError> {
-        Ok(self.nym_api.get_basic_mixnodes().await?.nodes)
+    pub async fn get_basic_mixnodes(
+        &self,
+        semver_compatibility: Option<String>,
+    ) -> Result<Vec<SkimmedNode>, ValidatorClientError> {
+        Ok(self
+            .nym_api
+            .get_basic_mixnodes(semver_compatibility)
+            .await?
+            .nodes)
     }
 
     #[deprecated(note = "use get_all_basic_entry_assigned_nodes instead")]
-    pub async fn get_basic_gateways(&self) -> Result<Vec<SkimmedNode>, ValidatorClientError> {
-        Ok(self.nym_api.get_basic_gateways().await?.nodes)
+    pub async fn get_basic_gateways(
+        &self,
+        semver_compatibility: Option<String>,
+    ) -> Result<Vec<SkimmedNode>, ValidatorClientError> {
+        Ok(self
+            .nym_api
+            .get_basic_gateways(semver_compatibility)
+            .await?
+            .nodes)
     }
 
     /// retrieve basic information for nodes are capable of operating as an entry gateway
     /// this includes legacy gateways and nym-nodes
     pub async fn get_all_basic_entry_assigned_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;
@@ -379,7 +387,12 @@ impl NymApiClient {
         loop {
             let mut res = self
                 .nym_api
-                .get_basic_entry_assigned_nodes(false, Some(page), None)
+                .get_basic_entry_assigned_nodes(
+                    semver_compatibility.clone(),
+                    false,
+                    Some(page),
+                    None,
+                )
                 .await?;
 
             nodes.append(&mut res.nodes.data);
@@ -397,6 +410,7 @@ impl NymApiClient {
     /// this includes legacy mixnodes and nym-nodes
     pub async fn get_all_basic_active_mixing_assigned_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;
@@ -405,7 +419,12 @@ impl NymApiClient {
         loop {
             let mut res = self
                 .nym_api
-                .get_basic_active_mixing_assigned_nodes(false, Some(page), None)
+                .get_basic_active_mixing_assigned_nodes(
+                    semver_compatibility.clone(),
+                    false,
+                    Some(page),
+                    None,
+                )
                 .await?;
 
             nodes.append(&mut res.nodes.data);
@@ -423,6 +442,7 @@ impl NymApiClient {
     /// 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;
@@ -431,7 +451,12 @@ impl NymApiClient {
         loop {
             let mut res = self
                 .nym_api
-                .get_basic_mixing_capable_nodes(false, Some(page), None)
+                .get_basic_mixing_capable_nodes(
+                    semver_compatibility.clone(),
+                    false,
+                    Some(page),
+                    None,
+                )
                 .await?;
 
             nodes.append(&mut res.nodes.data);
@@ -446,7 +471,10 @@ impl NymApiClient {
     }
 
     /// retrieve basic information for all bonded nodes on the network
-    pub async fn get_all_basic_nodes(&self) -> Result<Vec<SkimmedNode>, ValidatorClientError> {
+    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();
@@ -454,7 +482,7 @@ impl NymApiClient {
         loop {
             let mut res = self
                 .nym_api
-                .get_basic_nodes(false, Some(page), None)
+                .get_basic_nodes(semver_compatibility.clone(), false, Some(page), None)
                 .await?;
 
             nodes.append(&mut res.nodes.data);

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

@@ -102,23 +102,6 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    #[deprecated]
-    #[instrument(level = "debug", skip(self))]
-    async fn get_gateways_detailed_unfiltered(
-        &self,
-    ) -> Result<Vec<GatewayBondAnnotated>, NymAPIError> {
-        self.get_json(
-            &[
-                routes::API_VERSION,
-                routes::STATUS,
-                routes::GATEWAYS,
-                routes::DETAILED_UNFILTERED,
-            ],
-            NO_PARAMS,
-        )
-        .await
-    }
-
     #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn get_mixnodes_detailed_unfiltered(
@@ -205,7 +188,16 @@ pub trait NymApiClientExt: ApiClient {
 
     #[deprecated]
     #[tracing::instrument(level = "debug", skip_all)]
-    async fn get_basic_mixnodes(&self) -> Result<CachedNodesResponse<SkimmedNode>, NymAPIError> {
+    async fn get_basic_mixnodes(
+        &self,
+        semver_compatibility: Option<String>,
+    ) -> Result<CachedNodesResponse<SkimmedNode>, NymAPIError> {
+        let params = if let Some(semver_compatibility) = &semver_compatibility {
+            vec![("semver_compatibility", semver_compatibility.as_str())]
+        } else {
+            vec![]
+        };
+
         self.get_json(
             &[
                 routes::API_VERSION,
@@ -214,14 +206,23 @@ pub trait NymApiClientExt: ApiClient {
                 "mixnodes",
                 "skimmed",
             ],
-            NO_PARAMS,
+            &params,
         )
         .await
     }
 
     #[deprecated]
     #[instrument(level = "debug", skip(self))]
-    async fn get_basic_gateways(&self) -> Result<CachedNodesResponse<SkimmedNode>, NymAPIError> {
+    async fn get_basic_gateways(
+        &self,
+        semver_compatibility: Option<String>,
+    ) -> Result<CachedNodesResponse<SkimmedNode>, NymAPIError> {
+        let params = if let Some(semver_compatibility) = &semver_compatibility {
+            vec![("semver_compatibility", semver_compatibility.as_str())]
+        } else {
+            vec![]
+        };
+
         self.get_json(
             &[
                 routes::API_VERSION,
@@ -230,7 +231,7 @@ pub trait NymApiClientExt: ApiClient {
                 "gateways",
                 "skimmed",
             ],
-            NO_PARAMS,
+            &params,
         )
         .await
     }
@@ -240,12 +241,17 @@ pub trait NymApiClientExt: ApiClient {
     #[instrument(level = "debug", skip(self))]
     async fn get_basic_entry_assigned_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()))
         }
@@ -277,12 +283,17 @@ pub trait NymApiClientExt: ApiClient {
     #[instrument(level = "debug", skip(self))]
     async fn get_basic_active_mixing_assigned_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()))
         }
@@ -314,12 +325,17 @@ pub trait NymApiClientExt: ApiClient {
     #[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()))
         }
@@ -349,12 +365,17 @@ pub trait NymApiClientExt: ApiClient {
     #[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()))
         }

common/client-libs/validator-client/src/nyxd/contract_traits/mixnet_query_client.rs

@@ -26,11 +26,10 @@ use nym_mixnet_contract_common::{
     reward_params::{Performance, RewardingParams},
     rewarding::{EstimatedCurrentEpochRewardResponse, PendingRewardResponse},
     ContractBuildInformation, ContractState, ContractStateParams, CurrentIntervalResponse,
-    CurrentNymNodeVersionResponse, Delegation, EpochEventId, EpochStatus, GatewayBond,
-    GatewayBondResponse, GatewayOwnershipResponse, HistoricalNymNodeVersionEntry, IdentityKey,
-    IdentityKeyRef, IntervalEventId, MixNodeBond, MixNodeDetails, MixOwnershipResponse,
-    MixnodeDetailsByIdentityResponse, MixnodeDetailsResponse, NodeId,
-    NumberOfPendingEventsResponse, NymNodeBond, NymNodeDetails, NymNodeVersionHistoryResponse,
+    Delegation, EpochEventId, EpochStatus, GatewayBond, GatewayBondResponse,
+    GatewayOwnershipResponse, IdentityKey, IdentityKeyRef, IntervalEventId, MixNodeBond,
+    MixNodeDetails, MixOwnershipResponse, MixnodeDetailsByIdentityResponse, MixnodeDetailsResponse,
+    NodeId, NumberOfPendingEventsResponse, NymNodeBond, NymNodeDetails,
     PagedAllDelegationsResponse, PagedDelegatorDelegationsResponse, PagedGatewayResponse,
     PagedMixnodeBondsResponse, PagedNodeDelegationsResponse, PendingEpochEvent,
     PendingEpochEventResponse, PendingEpochEventsResponse, PendingIntervalEvent,
@@ -72,22 +71,6 @@ pub trait MixnetQueryClient {
             .await
     }
 
-    async fn get_nym_node_version_history_paged(
-        &self,
-        start_after: Option<u32>,
-        limit: Option<u32>,
-    ) -> Result<NymNodeVersionHistoryResponse, NyxdError> {
-        self.query_mixnet_contract(MixnetQueryMsg::GetNymNodeVersionHistory { limit, start_after })
-            .await
-    }
-
-    async fn get_current_nym_node_version(
-        &self,
-    ) -> Result<CurrentNymNodeVersionResponse, NyxdError> {
-        self.query_mixnet_contract(MixnetQueryMsg::GetCurrentNymNodeVersion {})
-            .await
-    }
-
     async fn get_mixnet_contract_state(&self) -> Result<ContractState, NyxdError> {
         self.query_mixnet_contract(MixnetQueryMsg::GetState {})
             .await
@@ -655,12 +638,6 @@ pub trait PagedMixnetQueryClient: MixnetQueryClient {
     ) -> Result<Vec<PendingIntervalEvent>, NyxdError> {
         collect_paged!(self, get_pending_interval_events_paged, events)
     }
-
-    async fn get_full_nym_node_version_history(
-        &self,
-    ) -> Result<Vec<HistoricalNymNodeVersionEntry>, NyxdError> {
-        collect_paged!(self, get_nym_node_version_history_paged, history)
-    }
 }
 
 #[async_trait]
@@ -747,7 +724,6 @@ where
 mod tests {
     use super::*;
     use crate::nyxd::contract_traits::tests::IgnoreValue;
-    use nym_mixnet_contract_common::QueryMsg;
 
     // it's enough that this compiles and clippy is happy about it
     #[allow(dead_code)]
@@ -948,10 +924,6 @@ mod tests {
             MixnetQueryMsg::GetRewardedSetMetadata {} => {
                 client.get_rewarded_set_metadata().ignore()
             }
-            QueryMsg::GetCurrentNymNodeVersion {} => client.get_current_nym_node_version().ignore(),
-            QueryMsg::GetNymNodeVersionHistory { limit, start_after } => client
-                .get_nym_node_version_history_paged(start_after, limit)
-                .ignore(),
         }
     }
 }

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

@@ -13,44 +13,6 @@ use tracing::error;
 
 pub use cosmrs::abci::MsgResponse;
 
-pub fn parse_singleton_u32_from_contract_response(b: Vec<u8>) -> Result<u32, NyxdError> {
-    if b.len() != 4 {
-        return Err(NyxdError::MalformedResponseData {
-            got: b.len(),
-            expected: 4,
-        });
-    }
-    Ok(u32::from_be_bytes([b[0], b[1], b[2], b[3]]))
-}
-
-pub fn parse_singleton_u64_from_contract_response(b: Vec<u8>) -> Result<u64, NyxdError> {
-    if b.len() != 8 {
-        return Err(NyxdError::MalformedResponseData {
-            got: b.len(),
-            expected: 8,
-        });
-    }
-    Ok(u64::from_be_bytes([
-        b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7],
-    ]))
-}
-
-#[derive(Debug, Clone)]
-pub struct ParsedContractResponse {
-    pub message_index: usize,
-    pub response: Vec<u8>,
-}
-
-impl ParsedContractResponse {
-    pub fn parse_singleton_u32_contract_data(self) -> Result<u32, NyxdError> {
-        parse_singleton_u32_from_contract_response(self.response)
-    }
-
-    pub fn parse_singleton_u64_contract_data(self) -> Result<u64, NyxdError> {
-        parse_singleton_u64_from_contract_response(self.response)
-    }
-}
-
 pub fn parse_msg_responses(data: Bytes) -> Vec<MsgResponse> {
     // it seems that currently, on wasmd 0.43 + tendermint-rs 0.37 + cosmrs 0.17.0-pre
     // the data is left in undecoded base64 form, but I'd imagine this might change so if the decoding fails,
@@ -72,25 +34,35 @@ pub fn parse_msg_responses(data: Bytes) -> Vec<MsgResponse> {
 }
 
 // requires there's a single response message
-pub trait ContractResponseData: Sized {
+pub trait ToSingletonContractData: Sized {
     fn parse_singleton_u32_contract_data(&self) -> Result<u32, NyxdError> {
         let b = self.to_singleton_contract_data()?;
-        parse_singleton_u32_from_contract_response(b)
+        if b.len() != 4 {
+            return Err(NyxdError::MalformedResponseData {
+                got: b.len(),
+                expected: 4,
+            });
+        }
+        Ok(u32::from_be_bytes([b[0], b[1], b[2], b[3]]))
     }
 
     fn parse_singleton_u64_contract_data(&self) -> Result<u64, NyxdError> {
         let b = self.to_singleton_contract_data()?;
-        parse_singleton_u64_from_contract_response(b)
+        if b.len() != 8 {
+            return Err(NyxdError::MalformedResponseData {
+                got: b.len(),
+                expected: 8,
+            });
+        }
+        Ok(u64::from_be_bytes([
+            b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7],
+        ]))
     }
 
     fn to_singleton_contract_data(&self) -> Result<Vec<u8>, NyxdError>;
-
-    fn to_unchecked_contract_data(&self) -> Result<Vec<Vec<u8>>, NyxdError>;
-
-    fn to_contract_data(&self) -> Result<Vec<ParsedContractResponse>, NyxdError>;
 }
 
-impl ContractResponseData for ExecuteResult {
+impl ToSingletonContractData for ExecuteResult {
     fn to_singleton_contract_data(&self) -> Result<Vec<u8>, NyxdError> {
         if self.msg_responses.len() != 1 {
             return Err(NyxdError::UnexpectedNumberOfMsgResponses {
@@ -100,30 +72,6 @@ impl ContractResponseData for ExecuteResult {
 
         self.msg_responses[0].to_contract_response_data()
     }
-
-    fn to_unchecked_contract_data(&self) -> Result<Vec<Vec<u8>>, NyxdError> {
-        self.msg_responses
-            .iter()
-            .map(ToContractResponseData::to_contract_response_data)
-            .collect()
-    }
-
-    fn to_contract_data(&self) -> Result<Vec<ParsedContractResponse>, NyxdError> {
-        let mut response = Vec::new();
-
-        for (message_index, msg) in self.msg_responses.iter().enumerate() {
-            // unfortunately `Name` trait has not been derived for `MsgExecuteContractResponse`,
-            // so we have to make an explicit string comparison instead
-            if msg.type_url == "/cosmwasm.wasm.v1.MsgExecuteContractResponse" {
-                response.push(ParsedContractResponse {
-                    message_index,
-                    response: msg.to_contract_response_data()?,
-                })
-            }
-        }
-
-        Ok(response)
-    }
 }
 
 pub trait ToContractResponseData: Sized {

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

@@ -23,7 +23,7 @@ use tendermint_rpc::endpoint::*;
 use tendermint_rpc::query::Query;
 use tendermint_rpc::{Error as TendermintRpcError, Order, Paging, SimpleRequest};
 
-pub use helpers::{ContractResponseData, ToContractResponseData};
+pub use helpers::{ToContractResponseData, ToSingletonContractData};
 
 #[cfg(feature = "http-client")]
 use crate::http_client;

common/commands/Cargo.toml

@@ -48,6 +48,7 @@ nym-vesting-contract-common = { path = "../cosmwasm-smart-contracts/vesting-cont
 nym-coconut-dkg-common = { path = "../cosmwasm-smart-contracts/coconut-dkg" }
 nym-multisig-contract-common = { path = "../cosmwasm-smart-contracts/multisig-contract" }
 nym-ecash-contract-common = { path = "../cosmwasm-smart-contracts/ecash-contract" }
+nym-ecash-time = { path = "../../common/ecash-time" }
 nym-sphinx = { path = "../../common/nymsphinx" }
 nym-client-core = { path = "../../common/client-core" }
 nym-config = { path = "../../common/config" }
@@ -56,6 +57,7 @@ nym-credentials-interface = { path = "../../common/credentials-interface" }
 nym-credential-storage = { path = "../../common/credential-storage" }
 nym-credential-utils = { path = "../../common/credential-utils" }
 nym-id = { path = "../nym-id" }
+nym-credential-proxy-requests = { path = "../../nym-credential-proxy/nym-credential-proxy-requests" }
 
 nym-pemstore = { path = "../../common/pemstore", version = "0.3.0" }
 nym-types = { path = "../../common/types" }

common/commands/src/internal/ecash/generate_keypair/mod.rs

@@ -0,0 +1,41 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::Parser;
+use log::trace;
+use nym_credentials_interface::{generate_keypair_user, generate_keypair_user_from_seed, Base58};
+use serde::{Deserialize, Serialize};
+use std::io::stdout;
+
+#[derive(Serialize, Deserialize)]
+pub struct Bs58EncodedKeys {
+    pub secret_key: String,
+    pub public_key: String,
+}
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    /// Secret value that's used for deriving underlying ecash keypair
+    #[clap(long)]
+    pub(crate) bs58_encoded_client_secret: Option<String>,
+}
+
+pub fn generate_ecash_keypair(args: Args) -> anyhow::Result<()> {
+    trace!("args: {args:?}");
+
+    let keypair = if let Some(secret) = args.bs58_encoded_client_secret {
+        let seed = bs58::decode(&secret).into_vec()?;
+        generate_keypair_user_from_seed(&seed)
+    } else {
+        generate_keypair_user()
+    };
+
+    let encoded = Bs58EncodedKeys {
+        secret_key: keypair.secret_key().to_bs58(),
+        public_key: keypair.public_key().to_bs58(),
+    };
+
+    serde_json::to_writer_pretty(stdout(), &encoded)?;
+
+    Ok(())
+}

common/commands/src/internal/ecash/mod.rs

@@ -0,0 +1,23 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::{Args, Subcommand};
+
+pub mod generate_keypair;
+pub mod withdrawal_request;
+
+#[derive(Debug, Args)]
+#[clap(args_conflicts_with_subcommands = true, subcommand_required = true)]
+pub struct InternalEcash {
+    #[clap(subcommand)]
+    pub command: InternalEcashCommands,
+}
+
+#[derive(Debug, Subcommand)]
+pub enum InternalEcashCommands {
+    /// Generate a dummy withdrawal request
+    GenerateWithdrawalRequest(withdrawal_request::Args),
+
+    /// Generate dummy ecash keypair
+    GenerateKeypair(generate_keypair::Args),
+}

common/commands/src/internal/ecash/withdrawal_request.rs

@@ -0,0 +1,78 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::Parser;
+use log::trace;
+use nym_credential_proxy_requests::api::v1::ticketbook::models::TicketbookRequest;
+use nym_credentials_interface::{
+    generate_keypair_user, withdrawal_request, Base58, SecretKeyUser, TicketType,
+};
+use nym_ecash_time::{ecash_default_expiration_date, EcashTime};
+use serde::{Deserialize, Serialize};
+use std::io::stdout;
+use time::macros::format_description;
+use time::Date;
+use zeroize::Zeroizing;
+
+fn parse_date(raw: &str) -> Result<Date, time::error::Parse> {
+    let format = format_description!("[year]-[month]-[day]");
+    Date::parse(raw, &format)
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct Bs58EncodedOutput {
+    pub ecash_proxy_request: TicketbookRequest,
+    pub ecash_secret: String,
+
+    /// Needed to later unblind shares
+    pub ecash_request_info_bs58: String,
+}
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    /// Specify which type of ticketbook
+    #[clap(long, default_value_t = TicketType::V1MixnetEntry)]
+    pub(crate) ticketbook_type: TicketType,
+
+    /// Set expiration date for the ticketbook
+    #[clap(long, value_parser = parse_date, default_value_t = ecash_default_expiration_date())]
+    pub(crate) expiration_date: Date,
+
+    /// Provide ecash secret key (or generate a fresh one)
+    #[clap(long)]
+    pub(crate) ecash_secret_key_bs58: Option<String>,
+}
+
+pub async fn generate_withdrawal_request(args: Args) -> anyhow::Result<()> {
+    trace!("args: {args:?}");
+
+    let ecash_keypair = if let Some(secret_key) = args.ecash_secret_key_bs58 {
+        let secret_key = Zeroizing::new(bs58::decode(Zeroizing::new(secret_key)).into_vec()?);
+        let sk = SecretKeyUser::from_bytes(&secret_key)?;
+        sk.into()
+    } else {
+        generate_keypair_user()
+    };
+
+    let (withdrawal_request, request_info) = withdrawal_request(
+        ecash_keypair.secret_key(),
+        args.expiration_date.ecash_unix_timestamp(),
+        args.ticketbook_type.encode(),
+    )?;
+
+    let encoded = Bs58EncodedOutput {
+        ecash_proxy_request: TicketbookRequest {
+            withdrawal_request: withdrawal_request.into(),
+            ecash_pubkey: ecash_keypair.public_key(),
+            expiration_date: args.expiration_date,
+            ticketbook_type: args.ticketbook_type,
+            is_freepass_request: false,
+        },
+        ecash_secret: ecash_keypair.secret_key().to_bs58(),
+        ecash_request_info_bs58: request_info.to_bs58(),
+    };
+
+    serde_json::to_writer_pretty(stdout(), &encoded)?;
+
+    Ok(())
+}

common/commands/src/internal/mod.rs

@@ -0,0 +1,19 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::{Args, Subcommand};
+
+pub mod ecash;
+
+#[derive(Debug, Args)]
+#[clap(args_conflicts_with_subcommands = true, subcommand_required = true)]
+pub struct Internal {
+    #[clap(subcommand)]
+    pub command: InternalCommands,
+}
+
+#[derive(Debug, Subcommand)]
+pub enum InternalCommands {
+    /// Ecash related internal commands
+    Ecash(ecash::InternalEcash),
+}

common/commands/src/lib.rs

@@ -3,5 +3,6 @@
 
 pub mod context;
 pub mod ecash;
+pub mod internal;
 pub mod utils;
 pub mod validator;

common/cosmwasm-smart-contracts/mixnet-contract/src/config_score.rs

@@ -1,673 +0,0 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use cosmwasm_schema::cw_serde;
-use cosmwasm_std::Decimal;
-use std::cmp::Ordering;
-use std::ops::{Add, Sub};
-
-#[cw_serde]
-pub struct HistoricalNymNodeVersion {
-    /// Version of the nym node that is going to be used for determining the version score of a node.
-    /// note: value stored here is pre-validated `semver::Version`
-    pub semver: String,
-
-    /// Block height of when this version has been added to the contract
-    pub introduced_at_height: u64,
-
-    /// The absolute version difference as compared against the first version introduced into the contract.
-    pub difference_since_genesis: TotalVersionDifference,
-}
-
-impl HistoricalNymNodeVersion {
-    pub fn genesis(semver: String, height: u64) -> HistoricalNymNodeVersion {
-        HistoricalNymNodeVersion {
-            semver,
-            introduced_at_height: height,
-            difference_since_genesis: Default::default(),
-        }
-    }
-
-    // SAFETY: the value stored in the contract is always valid
-    // if you manually construct that struct with invalid value, it's on you.
-    #[allow(clippy::unwrap_used)]
-    pub fn semver_unchecked(&self) -> semver::Version {
-        self.semver.parse().unwrap()
-    }
-
-    /// Return [`TotalVersionDifference`] for a new release version that is going to be pushed right after this one
-    /// this function cannot be called against 2 arbitrary versions
-    #[inline]
-    pub fn cumulative_difference_since_genesis(
-        &self,
-        new_version: &semver::Version,
-    ) -> TotalVersionDifference {
-        let self_semver = self.semver_unchecked();
-        let mut new_absolute = self.difference_since_genesis;
-        if new_version.major > self_semver.major {
-            new_absolute.major += (new_version.major - self_semver.major) as u32
-        } else if new_version.minor > self_semver.minor {
-            new_absolute.minor += (new_version.minor - self_semver.minor) as u32
-        } else if new_version.patch > self_semver.patch {
-            new_absolute.patch += (new_version.patch - self_semver.patch) as u32
-        } else if new_version.pre != self_semver.pre {
-            new_absolute.prerelease += 1
-        }
-        new_absolute
-    }
-
-    pub fn relative_difference(&self, other: &Self) -> TotalVersionDifference {
-        if self.difference_since_genesis > other.difference_since_genesis {
-            self.difference_since_genesis - other.difference_since_genesis
-        } else {
-            other.difference_since_genesis - self.difference_since_genesis
-        }
-    }
-
-    pub fn difference_against_legacy(
-        &self,
-        legacy_version: &semver::Version,
-    ) -> TotalVersionDifference {
-        let current = self.semver_unchecked();
-        let major_diff = (current.major as i64 - legacy_version.major as i64).unsigned_abs() as u32;
-        let minor_diff = (current.minor as i64 - legacy_version.minor as i64).unsigned_abs() as u32;
-        let patch_diff = (current.patch as i64 - legacy_version.patch as i64).unsigned_abs() as u32;
-        let prerelease_diff = if current.pre == legacy_version.pre {
-            0
-        } else {
-            1
-        };
-
-        let mut diff = TotalVersionDifference::default();
-        // if there's a major increase, ignore minor and patch and treat it as 0
-        if major_diff != 0 {
-            diff.major += major_diff;
-            return diff;
-        }
-
-        // if there's a minor increase, ignore patch and treat is as 0
-        if minor_diff != 0 {
-            diff.minor += minor_diff;
-            return diff;
-        }
-
-        diff.patch = patch_diff;
-        diff.prerelease = prerelease_diff;
-        diff
-    }
-}
-
-#[cw_serde]
-#[derive(Default, Copy, PartialOrd, Ord, Eq)]
-pub struct TotalVersionDifference {
-    pub major: u32,
-    pub minor: u32,
-    pub patch: u32,
-    pub prerelease: u32,
-}
-
-impl Add for TotalVersionDifference {
-    type Output = TotalVersionDifference;
-    fn add(self, rhs: TotalVersionDifference) -> Self::Output {
-        TotalVersionDifference {
-            major: self.major.add(rhs.major),
-            minor: self.minor.add(rhs.minor),
-            patch: self.patch.add(rhs.patch),
-            prerelease: self.prerelease.add(rhs.prerelease),
-        }
-    }
-}
-
-impl Sub for TotalVersionDifference {
-    type Output = TotalVersionDifference;
-    fn sub(self, rhs: TotalVersionDifference) -> Self::Output {
-        TotalVersionDifference {
-            major: self.major.saturating_sub(rhs.major),
-            minor: self.minor.saturating_sub(rhs.minor),
-            patch: self.patch.saturating_sub(rhs.patch),
-            prerelease: self.prerelease.saturating_sub(rhs.prerelease),
-        }
-    }
-}
-
-#[cw_serde]
-pub struct HistoricalNymNodeVersionEntry {
-    /// The unique, ordered, id of this particular entry
-    pub id: u32,
-
-    /// Data associated with this particular version
-    pub version_information: HistoricalNymNodeVersion,
-}
-
-impl From<(u32, HistoricalNymNodeVersion)> for HistoricalNymNodeVersionEntry {
-    fn from((id, version_information): (u32, HistoricalNymNodeVersion)) -> Self {
-        HistoricalNymNodeVersionEntry {
-            id,
-            version_information,
-        }
-    }
-}
-
-impl PartialOrd for HistoricalNymNodeVersionEntry {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        // we only care about id for the purposes of ordering as they should have unique data
-        self.id.partial_cmp(&other.id)
-    }
-}
-
-#[cw_serde]
-pub struct NymNodeVersionHistoryResponse {
-    pub history: Vec<HistoricalNymNodeVersionEntry>,
-
-    /// Field indicating paging information for the following queries if the caller wishes to get further entries.
-    pub start_next_after: Option<u32>,
-}
-
-#[cw_serde]
-pub struct CurrentNymNodeVersionResponse {
-    pub version: Option<HistoricalNymNodeVersionEntry>,
-}
-
-#[cw_serde]
-pub struct ConfigScoreParams {
-    /// Defines weights for calculating numbers of versions behind the current release.
-    pub version_weights: OutdatedVersionWeights,
-
-    /// Defines the parameters of the formula for calculating the version score
-    pub version_score_formula_params: VersionScoreFormulaParams,
-}
-
-/// Defines weights for calculating numbers of versions behind the current release.
-#[cw_serde]
-#[derive(Copy)]
-pub struct OutdatedVersionWeights {
-    pub major: u32,
-    pub minor: u32,
-    pub patch: u32,
-    pub prerelease: u32,
-}
-
-fn is_one_semver_difference(this: &semver::Version, other: &semver::Version) -> bool {
-    let major_diff = (this.major as i64 - other.major as i64).unsigned_abs() as u32;
-    let minor_diff = (this.minor as i64 - other.minor as i64).unsigned_abs() as u32;
-    let patch_diff = (this.patch as i64 - other.patch as i64).unsigned_abs() as u32;
-    let prerelease_diff = if this.pre == other.pre { 0 } else { 1 };
-
-    if major_diff == 1 {
-        return true;
-    }
-
-    if major_diff == 0 && minor_diff == 1 {
-        return true;
-    }
-
-    if major_diff == 0 && minor_diff == 0 && patch_diff == 1 {
-        return true;
-    }
-
-    prerelease_diff == 1
-}
-
-impl OutdatedVersionWeights {
-    pub fn difference_to_versions_behind_factor(&self, diff: TotalVersionDifference) -> u32 {
-        diff.major * self.major
-            + diff.minor * self.minor
-            + diff.patch * self.patch
-            + diff.prerelease * self.prerelease
-    }
-
-    // INVARIANT: release chain is sorted
-    // do NOT call this method directly from inside the contract. it's too inefficient
-    // it relies on some external caching.
-    pub fn versions_behind_factor(
-        &self,
-        node_version: &semver::Version,
-        release_chain: &[HistoricalNymNodeVersionEntry],
-    ) -> u32 {
-        let Some(latest) = release_chain.last() else {
-            return 0;
-        };
-
-        let latest_semver = latest.version_information.semver_unchecked();
-
-        // if you're more recent than the latest, you get the benefit of the doubt, the release might have not yet been commited to the chain
-        // but only if you're only a single semver ahead, otherwise you get penalty equivalent of being major version behind for cheating
-        if node_version > &latest_semver {
-            return if is_one_semver_difference(node_version, &latest_semver) {
-                0
-            } else {
-                self.major
-            };
-        }
-
-        // find your position in the release chain, if we fail, we assume that the node comes from before the changes were introduced
-        // in which case we simply calculate the absolute difference between the genesis entry and add up the total difference
-        let version_diff = match release_chain
-            .iter()
-            .rfind(|h| &h.version_information.semver_unchecked() <= node_version)
-        {
-            Some(h) => {
-                // first chain entry that is smaller (or equal) to the provided node version
-                // now, calculate the difference to the genesis version and ultimately against the current head
-                let diff_since_genesis = if h.version_information.semver == node_version.to_string()
-                {
-                    h.version_information.difference_since_genesis
-                } else {
-                    h.version_information
-                        .cumulative_difference_since_genesis(node_version)
-                };
-                latest.version_information.difference_since_genesis - diff_since_genesis
-            }
-            None => {
-                // SAFETY: since we managed to get 'last' entry, it means the release chain is not empty,
-                // so we must be able to obtain the first entry
-                #[allow(clippy::unwrap_used)]
-                let genesis = release_chain.first().unwrap();
-
-                let difference_from_genesis = genesis
-                    .version_information
-                    .difference_against_legacy(node_version);
-                difference_from_genesis + latest.version_information.difference_since_genesis
-            }
-        };
-
-        self.difference_to_versions_behind_factor(version_diff)
-    }
-}
-
-impl Default for OutdatedVersionWeights {
-    fn default() -> Self {
-        OutdatedVersionWeights {
-            major: 100,
-            minor: 10,
-            patch: 1,
-            prerelease: 1,
-        }
-    }
-}
-
-/// Given the formula of version_score = penalty ^ (versions_behind_factor ^ penalty_scaling)
-/// define the relevant parameters
-#[cw_serde]
-#[derive(Copy)]
-pub struct VersionScoreFormulaParams {
-    pub penalty: Decimal,
-    pub penalty_scaling: Decimal,
-}
-
-impl Default for VersionScoreFormulaParams {
-    fn default() -> Self {
-        #[allow(clippy::unwrap_used)]
-        VersionScoreFormulaParams {
-            penalty: "0.995".parse().unwrap(),
-            penalty_scaling: "1.65".parse().unwrap(),
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::ops::Deref;
-
-    // simple wrapper for tests
-    struct ReleaseChain {
-        inner: Vec<HistoricalNymNodeVersionEntry>,
-    }
-
-    impl Deref for ReleaseChain {
-        type Target = [HistoricalNymNodeVersionEntry];
-        fn deref(&self) -> &Self::Target {
-            self.inner.deref()
-        }
-    }
-
-    impl ReleaseChain {
-        fn new(initial: &str) -> Self {
-            ReleaseChain {
-                inner: vec![HistoricalNymNodeVersionEntry {
-                    id: 0,
-                    version_information: HistoricalNymNodeVersion {
-                        semver: initial.to_string(),
-                        introduced_at_height: 123,
-                        difference_since_genesis: TotalVersionDifference::default(),
-                    },
-                }],
-            }
-        }
-
-        fn with_release(mut self, raw: &str) -> Self {
-            self.push_new(raw);
-            self
-        }
-
-        fn push_new(&mut self, raw: &str) {
-            let latest = self.inner.last().unwrap();
-            let new_version: semver::Version = raw.parse().unwrap();
-
-            let new_absolute = latest
-                .version_information
-                .cumulative_difference_since_genesis(&new_version);
-
-            self.inner.push(HistoricalNymNodeVersionEntry {
-                id: latest.id + 1,
-                version_information: HistoricalNymNodeVersion {
-                    semver: new_version.to_string(),
-                    introduced_at_height: latest.version_information.introduced_at_height + 1,
-                    difference_since_genesis: new_absolute,
-                },
-            })
-        }
-    }
-
-    #[test]
-    fn versions_behind_factor() {
-        // helper to compact the parsing
-        fn s(raw: &str) -> semver::Version {
-            raw.parse().unwrap()
-        }
-
-        let weights = OutdatedVersionWeights::default();
-
-        // no releases:
-        let res = weights.versions_behind_factor(&s("1.1.13"), &[]);
-        assert_eq!(0, res);
-
-        // ###############################
-        // single released version (1.1.13)
-        // ###############################
-        let mut release_chain = ReleaseChain::new("1.1.13");
-
-        // "legacy" versions
-        let res = weights.versions_behind_factor(&s("1.0.12"), &release_chain);
-        assert_eq!(10, res);
-        let res = weights.versions_behind_factor(&s("1.0.4"), &release_chain);
-        assert_eq!(10, res);
-        let res = weights.versions_behind_factor(&s("1.0.1"), &release_chain);
-        assert_eq!(10, res);
-        let res = weights.versions_behind_factor(&s("0.1.12"), &release_chain);
-        assert_eq!(100, res);
-
-        let res = weights.versions_behind_factor(&s("1.1.12"), &release_chain);
-        assert_eq!(1, res);
-        let res = weights.versions_behind_factor(&s("1.1.11"), &release_chain);
-        assert_eq!(2, res);
-        let res = weights.versions_behind_factor(&s("1.1.9"), &release_chain);
-        assert_eq!(4, res);
-
-        // current version
-        let res = weights.versions_behind_factor(&s("1.1.13"), &release_chain);
-        assert_eq!(0, res);
-
-        // "ahead" versions
-        let res = weights.versions_behind_factor(&s("1.1.14"), &release_chain);
-        assert_eq!(0, res);
-        let res = weights.versions_behind_factor(&s("1.2.0"), &release_chain);
-        assert_eq!(0, res);
-        let res = weights.versions_behind_factor(&s("2.0.0"), &release_chain);
-        assert_eq!(0, res);
-
-        // cheating ahead:
-        let res = weights.versions_behind_factor(&s("1.1.15"), &release_chain);
-        assert_eq!(100, res);
-        let res = weights.versions_behind_factor(&s("1.3.0"), &release_chain);
-        assert_eq!(100, res);
-        let res = weights.versions_behind_factor(&s("3.0.0"), &release_chain);
-        assert_eq!(100, res);
-
-        // ###############################
-        // small patch release chain (1.1.13 => 1.1.14 => 1.1.15 => 1.1.16)
-        // ###############################
-        release_chain.push_new("1.1.14");
-        release_chain.push_new("1.1.15");
-        release_chain.push_new("1.1.16");
-
-        // "legacy" versions
-        let res = weights.versions_behind_factor(&s("1.0.12"), &release_chain);
-        assert_eq!(13, res);
-        let res = weights.versions_behind_factor(&s("1.0.4"), &release_chain);
-        assert_eq!(13, res);
-        let res = weights.versions_behind_factor(&s("1.0.1"), &release_chain);
-        assert_eq!(13, res);
-        let res = weights.versions_behind_factor(&s("0.1.12"), &release_chain);
-        assert_eq!(103, res);
-
-        let res = weights.versions_behind_factor(&s("1.1.12"), &release_chain);
-        assert_eq!(4, res);
-        let res = weights.versions_behind_factor(&s("1.1.11"), &release_chain);
-        assert_eq!(5, res);
-        let res = weights.versions_behind_factor(&s("1.1.9"), &release_chain);
-        assert_eq!(7, res);
-
-        // current version
-        let res = weights.versions_behind_factor(&s("1.1.16"), &release_chain);
-        assert_eq!(0, res);
-
-        // present in the chain
-        let res = weights.versions_behind_factor(&s("1.1.15"), &release_chain);
-        assert_eq!(1, res);
-        let res = weights.versions_behind_factor(&s("1.1.14"), &release_chain);
-        assert_eq!(2, res);
-        let res = weights.versions_behind_factor(&s("1.1.13"), &release_chain);
-        assert_eq!(3, res);
-
-        // "ahead" versions
-        let res = weights.versions_behind_factor(&s("1.1.17"), &release_chain);
-        assert_eq!(0, res);
-        let res = weights.versions_behind_factor(&s("1.2.0"), &release_chain);
-        assert_eq!(0, res);
-        let res = weights.versions_behind_factor(&s("2.0.0"), &release_chain);
-        assert_eq!(0, res);
-
-        // cheating ahead:
-        let res = weights.versions_behind_factor(&s("1.1.18"), &release_chain);
-        assert_eq!(100, res);
-        let res = weights.versions_behind_factor(&s("1.3.0"), &release_chain);
-        assert_eq!(100, res);
-        let res = weights.versions_behind_factor(&s("3.0.0"), &release_chain);
-        assert_eq!(100, res);
-
-        // ###############################
-        // small minor release chain (1.2.0 => 1.3.0 => 1.4.0)
-        // ###############################
-        let release_chain = ReleaseChain::new("1.2.0")
-            .with_release("1.3.0")
-            .with_release("1.4.0");
-
-        // "legacy" versions
-        let res = weights.versions_behind_factor(&s("1.0.12"), &release_chain);
-        assert_eq!(40, res);
-        let res = weights.versions_behind_factor(&s("1.0.4"), &release_chain);
-        assert_eq!(40, res);
-        let res = weights.versions_behind_factor(&s("1.0.1"), &release_chain);
-        assert_eq!(40, res);
-        let res = weights.versions_behind_factor(&s("0.1.12"), &release_chain);
-        assert_eq!(120, res);
-
-        let res = weights.versions_behind_factor(&s("1.1.12"), &release_chain);
-        assert_eq!(30, res);
-        let res = weights.versions_behind_factor(&s("1.1.11"), &release_chain);
-        assert_eq!(30, res);
-        let res = weights.versions_behind_factor(&s("1.1.9"), &release_chain);
-        assert_eq!(30, res);
-
-        // current version
-        let res = weights.versions_behind_factor(&s("1.4.0"), &release_chain);
-        assert_eq!(0, res);
-
-        // present in the chain
-        let res = weights.versions_behind_factor(&s("1.2.0"), &release_chain);
-        assert_eq!(20, res);
-        let res = weights.versions_behind_factor(&s("1.3.0"), &release_chain);
-        assert_eq!(10, res);
-
-        // weird in between
-        let res = weights.versions_behind_factor(&s("1.2.1"), &release_chain);
-        assert_eq!(20, res);
-        let res = weights.versions_behind_factor(&s("1.3.3"), &release_chain);
-        assert_eq!(10, res);
-
-        // "ahead" versions
-        let res = weights.versions_behind_factor(&s("1.4.1"), &release_chain);
-        assert_eq!(0, res);
-        let res = weights.versions_behind_factor(&s("1.5.0"), &release_chain);
-        assert_eq!(0, res);
-        let res = weights.versions_behind_factor(&s("2.0.0"), &release_chain);
-        assert_eq!(0, res);
-
-        // cheating ahead:
-        let res = weights.versions_behind_factor(&s("1.4.2"), &release_chain);
-        assert_eq!(100, res);
-        let res = weights.versions_behind_factor(&s("1.6.0"), &release_chain);
-        assert_eq!(100, res);
-        let res = weights.versions_behind_factor(&s("3.0.0"), &release_chain);
-        assert_eq!(100, res);
-
-        // ###############################
-        // mixed release chain (1.1.13 => 1.2.0 => 1.2.1 => 1.3.0 => 1.3.1 => 1.3.2 => 1.4.0)
-        // ###############################
-        let release_chain = ReleaseChain::new("1.1.13")
-            .with_release("1.2.0")
-            .with_release("1.2.1")
-            .with_release("1.3.0")
-            .with_release("1.3.1-importantpre")
-            .with_release("1.3.1")
-            .with_release("1.3.2")
-            .with_release("1.4.0");
-
-        // "legacy" versions
-        let res = weights.versions_behind_factor(&s("1.0.12"), &release_chain);
-        assert_eq!(44, res);
-        let res = weights.versions_behind_factor(&s("1.0.4"), &release_chain);
-        assert_eq!(44, res);
-        let res = weights.versions_behind_factor(&s("1.0.1"), &release_chain);
-        assert_eq!(44, res);
-        let res = weights.versions_behind_factor(&s("0.1.12"), &release_chain);
-        assert_eq!(134, res);
-
-        let res = weights.versions_behind_factor(&s("1.1.12"), &release_chain);
-        assert_eq!(35, res);
-        let res = weights.versions_behind_factor(&s("1.1.11"), &release_chain);
-        assert_eq!(36, res);
-        let res = weights.versions_behind_factor(&s("1.1.9"), &release_chain);
-        assert_eq!(38, res);
-
-        // current version
-        let res = weights.versions_behind_factor(&s("1.4.0"), &release_chain);
-        assert_eq!(0, res);
-
-        // present in the chain
-        let res = weights.versions_behind_factor(&s("1.1.13"), &release_chain);
-        assert_eq!(34, res);
-        let res = weights.versions_behind_factor(&s("1.2.0"), &release_chain);
-        assert_eq!(24, res);
-        let res = weights.versions_behind_factor(&s("1.2.1"), &release_chain);
-        assert_eq!(23, res);
-        let res = weights.versions_behind_factor(&s("1.3.0"), &release_chain);
-        assert_eq!(13, res);
-        let res = weights.versions_behind_factor(&s("1.3.1-importantpre"), &release_chain);
-        assert_eq!(12, res);
-        let res = weights.versions_behind_factor(&s("1.3.1"), &release_chain);
-        assert_eq!(11, res);
-        let res = weights.versions_behind_factor(&s("1.3.2"), &release_chain);
-        assert_eq!(10, res);
-
-        // weird in between
-        let res = weights.versions_behind_factor(&s("1.2.3"), &release_chain);
-        assert_eq!(21, res);
-        let res = weights.versions_behind_factor(&s("1.3.69"), &release_chain);
-        assert_eq!(10, res);
-
-        // "ahead" versions
-        let res = weights.versions_behind_factor(&s("1.4.1"), &release_chain);
-        assert_eq!(0, res);
-        let res = weights.versions_behind_factor(&s("1.5.0"), &release_chain);
-        assert_eq!(0, res);
-        let res = weights.versions_behind_factor(&s("2.0.0"), &release_chain);
-        assert_eq!(0, res);
-
-        // cheating ahead:
-        let res = weights.versions_behind_factor(&s("1.4.2"), &release_chain);
-        assert_eq!(100, res);
-        let res = weights.versions_behind_factor(&s("1.6.0"), &release_chain);
-        assert_eq!(100, res);
-        let res = weights.versions_behind_factor(&s("3.0.0"), &release_chain);
-        assert_eq!(100, res);
-
-        // ###############################
-        // skipped patch chain (1.1.13 => 1.2.0 => 1.2.1 => 1.2.4 => [1.3.0])
-        // ###############################
-        let mut release_chain = ReleaseChain::new("1.1.13")
-            .with_release("1.2.0")
-            .with_release("1.2.1")
-            .with_release("1.2.4");
-
-        // current
-        let res = weights.versions_behind_factor(&s("1.2.4"), &release_chain);
-        assert_eq!(0, res);
-
-        // on 'skipped' version
-        let res = weights.versions_behind_factor(&s("1.2.2"), &release_chain);
-        assert_eq!(2, res);
-
-        // on version before the skip
-        let res = weights.versions_behind_factor(&s("1.2.1"), &release_chain);
-        assert_eq!(3, res);
-
-        release_chain.push_new("1.3.0");
-        // current
-        let res = weights.versions_behind_factor(&s("1.3.0"), &release_chain);
-        assert_eq!(0, res);
-
-        // on 'skipped' version
-        let res = weights.versions_behind_factor(&s("1.2.2"), &release_chain);
-        assert_eq!(12, res);
-
-        // on version before the skip
-        let res = weights.versions_behind_factor(&s("1.2.1"), &release_chain);
-        assert_eq!(13, res);
-
-        // ###############################
-        // skipped minor chain (1.1.13 => 1.2.0 => 1.2.1 => 1.4.0 => [1.5.0])
-        // ###############################
-        let mut release_chain = ReleaseChain::new("1.1.13")
-            .with_release("1.2.0")
-            .with_release("1.2.1")
-            .with_release("1.4.0");
-
-        // current
-        let res = weights.versions_behind_factor(&s("1.4.0"), &release_chain);
-        assert_eq!(0, res);
-
-        // on 'skipped' version
-        let res = weights.versions_behind_factor(&s("1.3.0"), &release_chain);
-        assert_eq!(10, res);
-
-        // on version before the skip
-        let res = weights.versions_behind_factor(&s("1.2.1"), &release_chain);
-        assert_eq!(20, res);
-
-        let res = weights.versions_behind_factor(&s("1.2.0"), &release_chain);
-        assert_eq!(21, res);
-
-        release_chain.push_new("1.5.0");
-
-        // current
-        let res = weights.versions_behind_factor(&s("1.5.0"), &release_chain);
-        assert_eq!(0, res);
-
-        let res = weights.versions_behind_factor(&s("1.4.0"), &release_chain);
-        assert_eq!(10, res);
-
-        // on 'skipped' version
-        let res = weights.versions_behind_factor(&s("1.3.0"), &release_chain);
-        assert_eq!(20, res);
-
-        // on version before the skip
-        let res = weights.versions_behind_factor(&s("1.2.1"), &release_chain);
-        assert_eq!(30, res);
-
-        let res = weights.versions_behind_factor(&s("1.2.0"), &release_chain);
-        assert_eq!(31, res);
-    }
-}

common/cosmwasm-smart-contracts/mixnet-contract/src/error.rs

@@ -275,9 +275,6 @@ pub enum MixnetContractError {
 
     #[error("the provided nym-node version is not a valid semver. got: {provided}")]
     InvalidNymNodeSemver { provided: String },
-
-    #[error("the provided nym-node version is not greater than the current one. got: {provided}. current: {current}")]
-    NonIncreasingSemver { provided: String, current: String },
 }
 
 impl MixnetContractError {

common/cosmwasm-smart-contracts/mixnet-contract/src/events.rs

@@ -141,7 +141,6 @@ pub const NEW_INTERVAL_OPERATING_COST_RANGE_KEY: &str = "new_interval_operating_
 pub const NEW_VERSION_WEIGHTS_RANGE_KEY: &str = "new_version_weights_range";
 pub const NEW_VERSION_SCORE_FORMULA_PARAMS_KEY: &str = "new_version_score_formula_params";
 pub const NYM_NODE_CURRENT_SEMVER_KEY: &str = "new_current_semver";
-pub const NYM_NODE_CURRENT_SEMVER_ID_KEY: &str = "new_current_semver_id";
 
 pub const OLD_REWARDING_VALIDATOR_ADDRESS_KEY: &str = "old_rewarding_validator_address";
 pub const NEW_REWARDING_VALIDATOR_ADDRESS_KEY: &str = "new_rewarding_validator_address";
@@ -482,6 +481,12 @@ pub fn new_settings_update_event(update: &ContractStateParamsUpdate) -> Event {
 
     // check for config score params updates
     if let Some(config_score_update) = &update.config_score_params {
+        if let Some(current_nym_node_semver) = &config_score_update.current_nym_node_semver {
+            event.attributes.push(attr(
+                NYM_NODE_CURRENT_SEMVER_KEY,
+                current_nym_node_semver.to_string(),
+            ))
+        }
         if let Some(version_weights) = &config_score_update.version_weights {
             event.attributes.push(attr(
                 NEW_VERSION_WEIGHTS_RANGE_KEY,
@@ -501,10 +506,9 @@ pub fn new_settings_update_event(update: &ContractStateParamsUpdate) -> Event {
     event
 }
 
-pub fn new_update_nym_node_semver_event(new_version: &str, new_id: u32) -> Event {
+pub fn new_update_nym_node_semver_event(new_version: &str) -> Event {
     Event::new(MixnetEventType::NymNodeSemverUpdate)
         .add_attribute(NYM_NODE_CURRENT_SEMVER_KEY, new_version)
-        .add_attribute(NYM_NODE_CURRENT_SEMVER_ID_KEY, new_id.to_string())
 }
 
 pub fn new_not_found_node_operator_rewarding_event(interval: Interval, node_id: NodeId) -> Event {

common/cosmwasm-smart-contracts/mixnet-contract/src/lib.rs

@@ -5,7 +5,6 @@
 #![warn(clippy::unwrap_used)]
 #![warn(clippy::todo)]
 
-mod config_score;
 pub mod constants;
 pub mod delegation;
 pub mod error;
@@ -22,7 +21,6 @@ pub mod rewarding;
 pub mod signing_types;
 pub mod types;
 
-pub use config_score::*;
 pub use constants::*;
 pub use contracts_common::types::*;
 pub use cosmwasm_std::{Addr, Coin, Decimal, Fraction};

common/cosmwasm-smart-contracts/mixnet-contract/src/msg.rs

@@ -25,7 +25,6 @@ use std::time::Duration;
 
 #[cfg(feature = "schema")]
 use crate::{
-    config_score::{CurrentNymNodeVersionResponse, NymNodeVersionHistoryResponse},
     delegation::{
         NodeDelegationResponse, PagedAllDelegationsResponse, PagedDelegatorDelegationsResponse,
         PagedNodeDelegationsResponse,
@@ -424,20 +423,6 @@ pub enum QueryMsg {
     #[cfg_attr(feature = "schema", returns(ContractState))]
     GetState {},
 
-    /// Get the current expected version of a Nym Node.
-    #[cfg_attr(feature = "schema", returns(CurrentNymNodeVersionResponse))]
-    GetCurrentNymNodeVersion {},
-
-    /// Get the version history of Nym Node.
-    #[cfg_attr(feature = "schema", returns(NymNodeVersionHistoryResponse))]
-    GetNymNodeVersionHistory {
-        /// Controls the maximum number of entries returned by the query. Note that too large values will be overwritten by a saner default.
-        limit: Option<u32>,
-
-        /// Pagination control for the values returned by the query. Note that the provided value itself will **not** be used for the response.
-        start_after: Option<u32>,
-    },
-
     /// Gets the current parameters used for reward calculation.
     #[cfg_attr(feature = "schema", returns(RewardingParams))]
     GetRewardingParams {},

common/cosmwasm-smart-contracts/mixnet-contract/src/types.rs

@@ -1,12 +1,11 @@
 // Copyright 2021-2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::config_score::{ConfigScoreParams, OutdatedVersionWeights, VersionScoreFormulaParams};
 use crate::nym_node::Role;
 use contracts_common::Percent;
 use cosmwasm_schema::cw_serde;
-use cosmwasm_std::Coin;
 use cosmwasm_std::{Addr, Uint128};
+use cosmwasm_std::{Coin, Decimal};
 use std::fmt::{Display, Formatter};
 
 // type aliases for better reasoning about available data
@@ -222,14 +221,96 @@ impl OperatorsParamsUpdate {
     }
 }
 
+#[cw_serde]
+pub struct ConfigScoreParams {
+    /// Current version of the nym node that is going to be used for determining the version score of a node.
+    /// note: value stored here is pre-validated `semver::Version`
+    pub current_nym_node_semver: String,
+
+    /// Defines weights for calculating numbers of versions behind the current release.
+    pub version_weights: OutdatedVersionWeights,
+
+    /// Defines the parameters of the formula for calculating the version score
+    pub version_score_formula_params: VersionScoreFormulaParams,
+}
+
+impl ConfigScoreParams {
+    // SAFETY: the value stored in the contract is always valid
+    #[allow(clippy::unwrap_used)]
+    pub fn unchecked_nym_node_version(&self) -> semver::Version {
+        self.current_nym_node_semver.parse().unwrap()
+    }
+
+    pub fn versions_behind(&self, node_semver: &semver::Version) -> u32 {
+        let expected = self.unchecked_nym_node_version();
+
+        let major_diff = (node_semver.major as i64 - expected.major as i64).unsigned_abs() as u32;
+        let minor_diff = (node_semver.minor as i64 - expected.minor as i64).unsigned_abs() as u32;
+        let patch_diff = (node_semver.patch as i64 - expected.patch as i64).unsigned_abs() as u32;
+        let prerelease_diff = if node_semver.pre == expected.pre {
+            0
+        } else {
+            1
+        };
+
+        major_diff * self.version_weights.major
+            + minor_diff * self.version_weights.minor
+            + patch_diff * self.version_weights.patch
+            + prerelease_diff * self.version_weights.prerelease
+    }
+}
+
+/// Defines weights for calculating numbers of versions behind the current release.
+#[cw_serde]
+#[derive(Copy)]
+pub struct OutdatedVersionWeights {
+    pub major: u32,
+    pub minor: u32,
+    pub patch: u32,
+    pub prerelease: u32,
+}
+
+impl Default for OutdatedVersionWeights {
+    fn default() -> Self {
+        OutdatedVersionWeights {
+            major: 100,
+            minor: 10,
+            patch: 1,
+            prerelease: 1,
+        }
+    }
+}
+
+/// Given the formula of version_score = penalty ^ (num_versions_behind ^ penalty_scaling)
+/// define the relevant parameters
+#[cw_serde]
+#[derive(Copy)]
+pub struct VersionScoreFormulaParams {
+    pub penalty: Decimal,
+    pub penalty_scaling: Decimal,
+}
+
+impl Default for VersionScoreFormulaParams {
+    fn default() -> Self {
+        #[allow(clippy::unwrap_used)]
+        VersionScoreFormulaParams {
+            penalty: "0.8".parse().unwrap(),
+            penalty_scaling: "2.0".parse().unwrap(),
+        }
+    }
+}
+
 #[cw_serde]
 pub struct ConfigScoreParamsUpdate {
+    pub current_nym_node_semver: Option<String>,
     pub version_weights: Option<OutdatedVersionWeights>,
     pub version_score_formula_params: Option<VersionScoreFormulaParams>,
 }
 
 impl ConfigScoreParamsUpdate {
     pub fn contains_updates(&self) -> bool {
-        self.version_weights.is_some() || self.version_score_formula_params.is_some()
+        self.current_nym_node_semver.is_some()
+            || self.version_weights.is_some()
+            || self.version_score_formula_params.is_some()
     }
 }

common/credential-verification/src/bandwidth_storage_manager.rs

@@ -7,7 +7,7 @@ use crate::ClientBandwidth;
 use nym_credentials::ecash::utils::ecash_today;
 use nym_credentials_interface::Bandwidth;
 use nym_gateway_requests::ServerResponse;
-use nym_gateway_storage::Storage;
+use nym_gateway_storage::GatewayStorage;
 use si_scale::helpers::bibytes2;
 use time::OffsetDateTime;
 use tracing::*;
@@ -15,17 +15,17 @@ use tracing::*;
 const FREE_TESTNET_BANDWIDTH_VALUE: Bandwidth = Bandwidth::new_unchecked(64 * 1024 * 1024 * 1024); // 64GB
 
 #[derive(Clone)]
-pub struct BandwidthStorageManager<S> {
-    pub(crate) storage: S,
+pub struct BandwidthStorageManager {
+    pub(crate) storage: GatewayStorage,
     pub(crate) client_bandwidth: ClientBandwidth,
     pub(crate) client_id: i64,
     pub(crate) bandwidth_cfg: BandwidthFlushingBehaviourConfig,
     pub(crate) only_coconut_credentials: bool,
 }
 
-impl<S: Storage + Clone + 'static> BandwidthStorageManager<S> {
+impl BandwidthStorageManager {
     pub fn new(
-        storage: S,
+        storage: GatewayStorage,
         client_bandwidth: ClientBandwidth,
         client_id: i64,
         bandwidth_cfg: BandwidthFlushingBehaviourConfig,

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

@@ -13,12 +13,11 @@ use nym_api_requests::constants::MIN_BATCH_REDEMPTION_DELAY;
 use nym_api_requests::ecash::models::{BatchRedeemTicketsBody, VerifyEcashTicketBody};
 use nym_credentials_interface::Bandwidth;
 use nym_credentials_interface::{ClientTicket, TicketType};
-use nym_gateway_storage::Storage;
 use nym_validator_client::nym_api::EpochId;
 use nym_validator_client::nyxd::contract_traits::{
     EcashSigningClient, MultisigQueryClient, MultisigSigningClient, PagedMultisigQueryClient,
 };
-use nym_validator_client::nyxd::cosmwasm_client::ContractResponseData;
+use nym_validator_client::nyxd::cosmwasm_client::ToSingletonContractData;
 use nym_validator_client::nyxd::cw3::Status;
 use nym_validator_client::nyxd::AccountId;
 use nym_validator_client::EcashApiClient;
@@ -126,21 +125,18 @@ pub struct CredentialHandlerConfig {
     pub maximum_time_between_redemption: Duration,
 }
 
-pub(crate) struct CredentialHandler<St: Storage> {
+pub(crate) struct CredentialHandler {
     config: CredentialHandlerConfig,
     multisig_threshold: f32,
     ticket_receiver: UnboundedReceiver<ClientTicket>,
-    shared_state: SharedState<St>,
+    shared_state: SharedState,
     pending_tickets: Vec<PendingVerification>,
     pending_redemptions: Vec<PendingRedemptionVote>,
 }
 
-impl<St> CredentialHandler<St>
-where
-    St: Storage + Clone + 'static,
-{
+impl CredentialHandler {
     async fn rebuild_pending_tickets(
-        shared_state: &SharedState<St>,
+        shared_state: &SharedState,
     ) -> Result<Vec<PendingVerification>, EcashTicketError> {
         // 1. get all tickets that were not fully verified
         let unverified = shared_state.storage.get_all_unverified_tickets().await?;
@@ -188,7 +184,7 @@ where
     }
 
     async fn rebuild_pending_votes(
-        shared_state: &SharedState<St>,
+        shared_state: &SharedState,
     ) -> Result<Vec<PendingRedemptionVote>, EcashTicketError> {
         // 1. get all tickets that were not fully verified
         let unverified = shared_state.storage.get_all_unresolved_proposals().await?;
@@ -259,7 +255,7 @@ where
     pub(crate) async fn new(
         config: CredentialHandlerConfig,
         ticket_receiver: UnboundedReceiver<ClientTicket>,
-        shared_state: SharedState<St>,
+        shared_state: SharedState,
     ) -> Result<Self, Error> {
         let multisig_threshold = shared_state
             .nyxd_client

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

@@ -1,7 +1,7 @@
 // Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use nym_gateway_storage::error::StorageError;
+use nym_gateway_storage::error::GatewayStorageError;
 use nym_validator_client::coconut::EcashApiError;
 use nym_validator_client::nym_api::EpochId;
 use nym_validator_client::nyxd::error::NyxdError;
@@ -37,7 +37,7 @@ pub enum EcashTicketError {
     #[error("could not handle the ecash ticket due to internal storage failure: {source}")]
     InternalStorageFailure {
         #[from]
-        source: StorageError,
+        source: GatewayStorageError,
     },
 
     #[error("failed to create ticket redemption proposal: {source}")]

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

@@ -8,7 +8,7 @@ use error::EcashTicketError;
 use futures::channel::mpsc::{self, UnboundedSender};
 use nym_credentials::CredentialSpendingData;
 use nym_credentials_interface::{ClientTicket, CompactEcashError, NymPayInfo, VerificationKeyAuth};
-use nym_gateway_storage::Storage;
+use nym_gateway_storage::GatewayStorage;
 use nym_validator_client::nym_api::EpochId;
 use nym_validator_client::DirectSigningHttpRpcNyxdClient;
 use state::SharedState;
@@ -23,24 +23,21 @@ mod state;
 
 pub const TIME_RANGE_SEC: i64 = 30;
 
-pub struct EcashManager<S> {
-    shared_state: SharedState<S>,
+pub struct EcashManager {
+    shared_state: SharedState,
 
     pk_bytes: [u8; 32], // bytes representation of a pub key representing the verifier
     pay_infos: Mutex<Vec<NymPayInfo>>,
     cred_sender: UnboundedSender<ClientTicket>,
 }
 
-impl<S> EcashManager<S>
-where
-    S: Storage + Clone + 'static,
-{
+impl EcashManager {
     pub async fn new(
         credential_handler_cfg: CredentialHandlerConfig,
         nyxd_client: DirectSigningHttpRpcNyxdClient,
         pk_bytes: [u8; 32],
         shutdown: nym_task::TaskClient,
-        storage: S,
+        storage: GatewayStorage,
     ) -> Result<Self, Error> {
         let shared_state = SharedState::new(nyxd_client, storage).await?;
 
@@ -66,7 +63,7 @@ where
         self.shared_state.verification_key(epoch_id).await
     }
 
-    pub fn storage(&self) -> &S {
+    pub fn storage(&self) -> &GatewayStorage {
         &self.shared_state.storage
     }
 

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

@@ -6,7 +6,7 @@ use crate::Error;
 use cosmwasm_std::{from_binary, CosmosMsg, WasmMsg};
 use nym_credentials_interface::VerificationKeyAuth;
 use nym_ecash_contract_common::msg::ExecuteMsg;
-use nym_gateway_storage::Storage;
+use nym_gateway_storage::GatewayStorage;
 use nym_validator_client::coconut::all_ecash_api_clients;
 use nym_validator_client::nym_api::EpochId;
 use nym_validator_client::nyxd::contract_traits::{
@@ -23,20 +23,17 @@ use tracing::{error, trace, warn};
 
 // state shared by different subtasks dealing with credentials
 #[derive(Clone)]
-pub(crate) struct SharedState<S> {
+pub(crate) struct SharedState {
     pub(crate) nyxd_client: Arc<RwLock<DirectSigningHttpRpcNyxdClient>>,
     pub(crate) address: AccountId,
     pub(crate) epoch_data: Arc<RwLock<BTreeMap<EpochId, EpochState>>>,
-    pub(crate) storage: S,
+    pub(crate) storage: GatewayStorage,
 }
 
-impl<S> SharedState<S>
-where
-    S: Storage + Clone,
-{
+impl SharedState {
     pub(crate) async fn new(
         nyxd_client: DirectSigningHttpRpcNyxdClient,
-        storage: S,
+        storage: GatewayStorage,
     ) -> Result<Self, Error> {
         let address = nyxd_client.address();
 

common/credential-verification/src/error.rs

@@ -39,7 +39,7 @@ pub enum Error {
     OutOfBandwidth { required: i64, available: i64 },
 
     #[error("Internal gateway storage error")]
-    StorageError(#[from] nym_gateway_storage::error::StorageError),
+    StorageError(#[from] nym_gateway_storage::error::GatewayStorageError),
 
     #[error("{0}")]
     UnknownTicketType(#[from] nym_credentials_interface::UnknownTicketType),

common/credential-verification/src/lib.rs

@@ -2,17 +2,15 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use bandwidth_storage_manager::BandwidthStorageManager;
+use ecash::EcashManager;
+use nym_credentials::ecash::utils::{cred_exp_date, ecash_today, EcashTime};
+use nym_credentials_interface::{Bandwidth, ClientTicket, TicketType};
+use nym_gateway_requests::models::CredentialSpendingRequest;
 use std::sync::Arc;
 use time::{Date, OffsetDateTime};
 use tracing::*;
 
-use nym_credentials::ecash::utils::{cred_exp_date, ecash_today, EcashTime};
-use nym_credentials_interface::{Bandwidth, ClientTicket, TicketType};
-use nym_gateway_requests::models::CredentialSpendingRequest;
-use nym_gateway_storage::Storage;
-
 pub use client_bandwidth::*;
-use ecash::EcashManager;
 pub use error::*;
 
 pub mod bandwidth_storage_manager;
@@ -20,17 +18,17 @@ mod client_bandwidth;
 pub mod ecash;
 pub mod error;
 
-pub struct CredentialVerifier<S> {
+pub struct CredentialVerifier {
     credential: CredentialSpendingRequest,
-    ecash_verifier: Arc<EcashManager<S>>,
-    bandwidth_storage_manager: BandwidthStorageManager<S>,
+    ecash_verifier: Arc<EcashManager>,
+    bandwidth_storage_manager: BandwidthStorageManager,
 }
 
-impl<S: Storage + Clone + 'static> CredentialVerifier<S> {
+impl CredentialVerifier {
     pub fn new(
         credential: CredentialSpendingRequest,
-        ecash_verifier: Arc<EcashManager<S>>,
-        bandwidth_storage_manager: BandwidthStorageManager<S>,
+        ecash_verifier: Arc<EcashManager>,
+        bandwidth_storage_manager: BandwidthStorageManager,
     ) -> Self {
         CredentialVerifier {
             credential,

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

@@ -6,7 +6,6 @@ use ed25519_dalek::{Signer, SigningKey};
 pub use ed25519_dalek::{Verifier, PUBLIC_KEY_LENGTH, SECRET_KEY_LENGTH, SIGNATURE_LENGTH};
 use nym_pemstore::traits::{PemStorableKey, PemStorableKeyPair};
 use std::fmt::{self, Debug, Display, Formatter};
-use std::hash::{Hash, Hasher};
 use std::str::FromStr;
 use thiserror::Error;
 use zeroize::{Zeroize, ZeroizeOnDrop};
@@ -123,14 +122,6 @@ impl PemStorableKeyPair for KeyPair {
 #[derive(Copy, Clone, Eq, PartialEq)]
 pub struct PublicKey(ed25519_dalek::VerifyingKey);
 
-impl Hash for PublicKey {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        // each public key has unique bytes representation which can be used
-        // for the hash implementation
-        self.to_bytes().hash(state)
-    }
-}
-
 impl Display for PublicKey {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         Display::fmt(&self.to_base58_string(), f)

common/gateway-stats-storage/Cargo.toml

@@ -16,12 +16,15 @@ sqlx = { workspace = true, features = [
     "migrate",
     "time",
 ] }
+strum = { workspace = true }
 time = { workspace = true }
 thiserror = { workspace = true }
 tracing = { workspace = true }
 
 nym-sphinx = { path = "../nymsphinx" }
 nym-credentials-interface = { path = "../credentials-interface" }
+nym-node-metrics = { path = "../../nym-node/nym-node-metrics" }
+nym-statistics-common = { path = "../statistics" }
 
 
 [build-dependencies]

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

@@ -2,7 +2,8 @@
 // SPDX-License-Identifier: GPL-3.0-only
 
 use error::StatsStorageError;
-use models::{ActiveSession, FinishedSession, SessionType, StoredFinishedSession};
+use models::StoredFinishedSession;
+use nym_node_metrics::entry::{ActiveSession, FinishedSession, SessionType};
 use nym_sphinx::DestinationAddressBytes;
 use sessions::SessionManager;
 use sqlx::ConnectOptions;
@@ -70,8 +71,8 @@ impl PersistentStatsStorage {
             .session_manager
             .insert_finished_session(
                 date,
-                session.duration.whole_milliseconds() as i64,
-                session.typ.to_string().into(),
+                session.duration.as_millis() as i64,
+                session.typ.to_string(),
             )
             .await?)
     }
@@ -125,7 +126,7 @@ impl PersistentStatsStorage {
             .insert_active_session(
                 client_address.as_base58_string(),
                 session.start,
-                session.typ.to_string().into(),
+                session.typ.to_string(),
             )
             .await?)
     }
@@ -137,10 +138,7 @@ impl PersistentStatsStorage {
     ) -> Result<(), StatsStorageError> {
         Ok(self
             .session_manager
-            .update_active_session_type(
-                client_address.as_base58_string(),
-                session_type.to_string().into(),
-            )
+            .update_active_session_type(client_address.as_base58_string(), session_type.to_string())
             .await?)
     }
 

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

@@ -1,9 +1,11 @@
 // Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: GPL-3.0-only
 
-use nym_credentials_interface::TicketType;
+use nym_node_metrics::entry::{ActiveSession, FinishedSession, SessionType};
 use sqlx::prelude::FromRow;
-use time::{Duration, OffsetDateTime};
+use time::OffsetDateTime;
+
+pub use nym_credentials_interface::TicketType;
 
 #[derive(FromRow)]
 pub struct StoredFinishedSession {
@@ -11,52 +13,26 @@ pub struct StoredFinishedSession {
     typ: String,
 }
 
-impl StoredFinishedSession {
-    pub fn serialize(&self) -> (u64, String) {
-        (
-            self.duration_ms as u64, //we are sure that it fits in a u64, see `fn end_at`
-            self.typ.clone(),
-        )
+impl From<StoredFinishedSession> for FinishedSession {
+    fn from(value: StoredFinishedSession) -> Self {
+        FinishedSession {
+            duration: std::time::Duration::from_millis(value.duration_ms as u64),
+            typ: SessionType::from_string(value.typ),
+        }
     }
 }
 
-pub struct FinishedSession {
-    pub duration: Duration,
-    pub typ: SessionType,
+pub trait ToSessionType {
+    fn to_session_type(&self) -> SessionType;
 }
 
-#[derive(PartialEq)]
-pub enum SessionType {
-    Vpn,
-    Mixnet,
-    Unknown,
-}
-
-impl SessionType {
-    pub fn to_string(&self) -> &str {
+impl ToSessionType for TicketType {
+    fn to_session_type(&self) -> SessionType {
         match self {
-            Self::Vpn => "vpn",
-            Self::Mixnet => "mixnet",
-            Self::Unknown => "unknown",
-        }
-    }
-
-    pub fn from_string(s: &str) -> Self {
-        match s {
-            "vpn" => Self::Vpn,
-            "mixnet" => Self::Mixnet,
-            _ => Self::Unknown,
-        }
-    }
-}
-
-impl From<TicketType> for SessionType {
-    fn from(value: TicketType) -> Self {
-        match value {
-            TicketType::V1MixnetEntry => Self::Mixnet,
-            TicketType::V1MixnetExit => Self::Mixnet,
-            TicketType::V1WireguardEntry => Self::Vpn,
-            TicketType::V1WireguardExit => Self::Vpn,
+            TicketType::V1MixnetEntry => SessionType::Mixnet,
+            TicketType::V1MixnetExit => SessionType::Mixnet,
+            TicketType::V1WireguardEntry => SessionType::Vpn,
+            TicketType::V1WireguardExit => SessionType::Vpn,
         }
     }
 }
@@ -67,38 +43,6 @@ pub(crate) struct StoredActiveSession {
     typ: String,
 }
 
-pub struct ActiveSession {
-    pub start: OffsetDateTime,
-    pub typ: SessionType,
-}
-
-impl ActiveSession {
-    pub fn new(start_time: OffsetDateTime) -> Self {
-        ActiveSession {
-            start: start_time,
-            typ: SessionType::Unknown,
-        }
-    }
-
-    pub fn set_type(&mut self, ticket_type: TicketType) {
-        self.typ = ticket_type.into();
-    }
-
-    pub fn end_at(self, stop_time: OffsetDateTime) -> Option<FinishedSession> {
-        let session_duration = stop_time - self.start;
-        //ensure duration is positive to fit in a u64
-        //u64::max milliseconds is 500k millenia so no overflow issue
-        if session_duration > Duration::ZERO {
-            Some(FinishedSession {
-                duration: session_duration,
-                typ: self.typ,
-            })
-        } else {
-            None
-        }
-    }
-}
-
 impl From<StoredActiveSession> for ActiveSession {
     fn from(value: StoredActiveSession) -> Self {
         ActiveSession {

common/gateway-storage/Cargo.toml

@@ -9,7 +9,6 @@ edition.workspace = true
 license.workspace = true
 
 [dependencies]
-async-trait = { workspace = true }
 bincode = { workspace = true }
 defguard_wireguard_rs = { workspace = true }
 log = { workspace = true }

common/gateway-storage/src/error.rs

@@ -4,7 +4,7 @@
 use thiserror::Error;
 
 #[derive(Error, Debug)]
-pub enum StorageError {
+pub enum GatewayStorageError {
     #[error("Database experienced an internal error: {0}")]
     InternalDatabaseError(#[from] sqlx::Error),
 

common/gateway-storage/src/lib.rs

@@ -1,10 +1,8 @@
 // Copyright 2020 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: GPL-3.0-only
 
-use async_trait::async_trait;
 use bandwidth::BandwidthManager;
 use clients::{ClientManager, ClientType};
-use error::StorageError;
 use inboxes::InboxManager;
 use models::{
     Client, PersistedBandwidth, PersistedSharedKeys, RedemptionProposal, StoredMessage,
@@ -29,237 +27,11 @@ mod shared_keys;
 mod tickets;
 mod wireguard_peers;
 
-#[async_trait]
-pub trait Storage: Send + Sync {
-    async fn get_mixnet_client_id(
-        &self,
-        client_address: DestinationAddressBytes,
-    ) -> Result<i64, StorageError>;
-
-    /// Inserts provided derived shared keys into the database.
-    /// If keys previously existed for the provided client, they are overwritten with the new data.
-    ///
-    /// # Arguments
-    ///
-    /// * `client_address`: base58-encoded address of the client
-    /// * `shared_keys`:
-    ///     - legacy: shared encryption (AES128CTR) and mac (hmac-blake3) derived shared keys to store.
-    ///     - current: shared AES256-GCM-SIV keys
-    async fn insert_shared_keys(
-        &self,
-        client_address: DestinationAddressBytes,
-        shared_keys: &SharedGatewayKey,
-    ) -> Result<i64, StorageError>;
-
-    /// Tries to retrieve shared keys stored for the particular client.
-    ///
-    /// # Arguments
-    ///
-    /// * `client_address`: address of the client
-    async fn get_shared_keys(
-        &self,
-        client_address: DestinationAddressBytes,
-    ) -> Result<Option<PersistedSharedKeys>, StorageError>;
-
-    /// Removes from the database shared keys derived with the particular client.
-    ///
-    /// # Arguments
-    ///
-    /// * `client_address`: address of the client
-    // currently there is no code flow that causes removal (not overwriting)
-    // of the stored keys. However, retain the function for consistency and completion sake
-    #[allow(dead_code)]
-    async fn remove_shared_keys(
-        &self,
-        client_address: DestinationAddressBytes,
-    ) -> Result<(), StorageError>;
-
-    /// Tries to retrieve a particular client.
-    ///
-    /// # Arguments
-    ///
-    /// * `client_id`: id of the client
-    #[allow(dead_code)]
-    async fn get_client(&self, client_id: i64) -> Result<Option<Client>, StorageError>;
-
-    /// Inserts new message to the storage for an offline client for future retrieval.
-    ///
-    /// # Arguments
-    ///
-    /// * `client_address`: address of the client
-    /// * `message`: raw message to store.
-    async fn store_message(
-        &self,
-        client_address: DestinationAddressBytes,
-        message: Vec<u8>,
-    ) -> Result<(), StorageError>;
-
-    /// Retrieves messages stored for the particular client specified by the provided address.
-    ///
-    /// # Arguments
-    ///
-    /// * `client_address`: address of the client
-    /// * `start_after`: optional starting id of the messages to grab
-    ///
-    /// returns the retrieved messages alongside optional id of the last message retrieved if
-    /// there are more messages to retrieve.
-    async fn retrieve_messages(
-        &self,
-        client_address: DestinationAddressBytes,
-        start_after: Option<i64>,
-    ) -> Result<(Vec<StoredMessage>, Option<i64>), StorageError>;
-
-    /// Removes messages with the specified ids
-    ///
-    /// # Arguments
-    ///
-    /// * `ids`: ids of the messages to remove
-    async fn remove_messages(&self, ids: Vec<i64>) -> Result<(), StorageError>;
-
-    /// Creates a new bandwidth entry for the particular client.
-    async fn create_bandwidth_entry(&self, client_id: i64) -> Result<(), StorageError>;
-
-    /// Set the freepass expiration date of the particular client to the provided date.
-    ///
-    /// # Arguments
-    ///
-    /// * `client_address`: address of the client
-    /// * `expiration`: the expiration date of the associated free pass.
-    async fn set_expiration(
-        &self,
-        client_id: i64,
-        expiration: OffsetDateTime,
-    ) -> Result<(), StorageError>;
-
-    /// Reset all the bandwidth
-    ///
-    /// # Arguments
-    ///
-    /// * `client_address`: address of the client
-    async fn reset_bandwidth(&self, client_id: i64) -> Result<(), StorageError>;
-
-    /// Tries to retrieve available bandwidth for the particular client.
-    async fn get_available_bandwidth(
-        &self,
-        client_id: i64,
-    ) -> Result<Option<PersistedBandwidth>, StorageError>;
-
-    /// Increases specified client's bandwidth by the provided amount and returns the current value.
-    async fn increase_bandwidth(&self, client_id: i64, amount: i64) -> Result<i64, StorageError>;
-
-    async fn revoke_ticket_bandwidth(
-        &self,
-        ticket_id: i64,
-        amount: i64,
-    ) -> Result<(), StorageError>;
-
-    #[allow(dead_code)]
-    /// Decreases specified client's bandwidth by the provided amount and returns the current value.
-    async fn decrease_bandwidth(&self, client_id: i64, amount: i64) -> Result<i64, StorageError>;
-
-    async fn insert_epoch_signers(
-        &self,
-        epoch_id: i64,
-        signer_ids: Vec<i64>,
-    ) -> Result<(), StorageError>;
-
-    async fn insert_received_ticket(
-        &self,
-        client_id: i64,
-        received_at: OffsetDateTime,
-        serial_number: Vec<u8>,
-        data: Vec<u8>,
-    ) -> Result<i64, StorageError>;
-
-    // note: this only checks very recent tickets that haven't yet been redeemed
-    // (but it's better than nothing)
-    /// Check if the ticket with the provided serial number if already present in the storage.
-    ///
-    /// # Arguments
-    ///
-    /// * `serial_number`: the unique serial number embedded in the ticket
-    async fn contains_ticket(&self, serial_number: &[u8]) -> Result<bool, StorageError>;
-
-    async fn insert_ticket_verification(
-        &self,
-        ticket_id: i64,
-        signer_id: i64,
-        verified_at: OffsetDateTime,
-        accepted: bool,
-    ) -> Result<(), StorageError>;
-
-    async fn update_rejected_ticket(&self, ticket_id: i64) -> Result<(), StorageError>;
-
-    async fn update_verified_ticket(&self, ticket_id: i64) -> Result<(), StorageError>;
-
-    async fn remove_verified_ticket_binary_data(&self, ticket_id: i64) -> Result<(), StorageError>;
-
-    async fn get_all_verified_tickets_with_sn(&self) -> Result<Vec<VerifiedTicket>, StorageError>;
-    async fn get_all_proposed_tickets_with_sn(
-        &self,
-        proposal_id: u32,
-    ) -> Result<Vec<VerifiedTicket>, StorageError>;
-
-    async fn insert_redemption_proposal(
-        &self,
-        tickets: &[VerifiedTicket],
-        proposal_id: u32,
-        created_at: OffsetDateTime,
-    ) -> Result<(), StorageError>;
-
-    async fn clear_post_proposal_data(
-        &self,
-        proposal_id: u32,
-        resolved_at: OffsetDateTime,
-        rejected: bool,
-    ) -> Result<(), StorageError>;
-
-    async fn latest_proposal(&self) -> Result<Option<RedemptionProposal>, StorageError>;
-
-    async fn get_all_unverified_tickets(&self) -> Result<Vec<ClientTicket>, StorageError>;
-    async fn get_all_unresolved_proposals(&self) -> Result<Vec<i64>, StorageError>;
-    async fn get_votes(&self, ticket_id: i64) -> Result<Vec<i64>, StorageError>;
-
-    async fn get_signers(&self, epoch_id: i64) -> Result<Vec<i64>, StorageError>;
-
-    /// Insert a wireguard peer in the storage.
-    ///
-    /// # Arguments
-    ///
-    /// * `peer`: wireguard peer data to be stored
-    /// * `with_client_id`: if the peer should have a corresponding client_id
-    ///   (created with entry wireguard ticket) or live without one (or with an
-    ///   exiting one), for temporary backwards compatibility.
-    async fn insert_wireguard_peer(
-        &self,
-        peer: &defguard_wireguard_rs::host::Peer,
-        with_client_id: bool,
-    ) -> Result<Option<i64>, StorageError>;
-
-    /// Tries to retrieve available bandwidth for the particular peer.
-    ///
-    /// # Arguments
-    ///
-    /// * `peer_public_key`: wireguard public key of the peer to be retrieved.
-    async fn get_wireguard_peer(
-        &self,
-        peer_public_key: &str,
-    ) -> Result<Option<WireguardPeer>, StorageError>;
-
-    /// Retrieves all wireguard peers.
-    async fn get_all_wireguard_peers(&self) -> Result<Vec<WireguardPeer>, StorageError>;
-
-    /// Remove a wireguard peer from the storage.
-    ///
-    /// # Arguments
-    ///
-    /// * `peer_public_key`: wireguard public key of the peer to be removed.
-    async fn remove_wireguard_peer(&self, peer_public_key: &str) -> Result<(), StorageError>;
-}
+pub use error::GatewayStorageError;
 
 // note that clone here is fine as upon cloning the same underlying pool will be used
 #[derive(Clone)]
-pub struct PersistentStorage {
+pub struct GatewayStorage {
     client_manager: ClientManager,
     shared_key_manager: SharedKeysManager,
     inbox_manager: InboxManager,
@@ -268,7 +40,7 @@ pub struct PersistentStorage {
     wireguard_peer_manager: wireguard_peers::WgPeerManager,
 }
 
-impl PersistentStorage {
+impl GatewayStorage {
     /// Initialises `PersistentStorage` using the provided path.
     ///
     /// # Arguments
@@ -278,7 +50,7 @@ impl PersistentStorage {
     pub async fn init<P: AsRef<Path> + Send>(
         database_path: P,
         message_retrieval_limit: i64,
-    ) -> Result<Self, StorageError> {
+    ) -> Result<Self, GatewayStorageError> {
         debug!(
             "Attempting to connect to database {:?}",
             database_path.as_ref().as_os_str()
@@ -307,7 +79,7 @@ impl PersistentStorage {
         }
 
         // the cloning here are cheap as connection pool is stored behind an Arc
-        Ok(PersistentStorage {
+        Ok(GatewayStorage {
             client_manager: clients::ClientManager::new(connection_pool.clone()),
             wireguard_peer_manager: wireguard_peers::WgPeerManager::new(connection_pool.clone()),
             shared_key_manager: SharedKeysManager::new(connection_pool.clone()),
@@ -318,23 +90,22 @@ impl PersistentStorage {
     }
 }
 
-#[async_trait]
-impl Storage for PersistentStorage {
-    async fn get_mixnet_client_id(
+impl GatewayStorage {
+    pub async fn get_mixnet_client_id(
         &self,
         client_address: DestinationAddressBytes,
-    ) -> Result<i64, StorageError> {
+    ) -> Result<i64, GatewayStorageError> {
         Ok(self
             .shared_key_manager
             .client_id(&client_address.as_base58_string())
             .await?)
     }
 
-    async fn insert_shared_keys(
+    pub async fn insert_shared_keys(
         &self,
         client_address: DestinationAddressBytes,
         shared_keys: &SharedGatewayKey,
-    ) -> Result<i64, StorageError> {
+    ) -> Result<i64, GatewayStorageError> {
         let client_address_bs58 = client_address.as_base58_string();
         let client_id = match self
             .shared_key_manager
@@ -359,10 +130,10 @@ impl Storage for PersistentStorage {
         Ok(client_id)
     }
 
-    async fn get_shared_keys(
+    pub async fn get_shared_keys(
         &self,
         client_address: DestinationAddressBytes,
-    ) -> Result<Option<PersistedSharedKeys>, StorageError> {
+    ) -> Result<Option<PersistedSharedKeys>, GatewayStorageError> {
         let keys = self
             .shared_key_manager
             .get_shared_keys(&client_address.as_base58_string())
@@ -371,37 +142,37 @@ impl Storage for PersistentStorage {
     }
 
     #[allow(dead_code)]
-    async fn remove_shared_keys(
+    pub async fn remove_shared_keys(
         &self,
         client_address: DestinationAddressBytes,
-    ) -> Result<(), StorageError> {
+    ) -> Result<(), GatewayStorageError> {
         self.shared_key_manager
             .remove_shared_keys(&client_address.as_base58_string())
             .await?;
         Ok(())
     }
 
-    async fn get_client(&self, client_id: i64) -> Result<Option<Client>, StorageError> {
+    pub async fn get_client(&self, client_id: i64) -> Result<Option<Client>, GatewayStorageError> {
         let client = self.client_manager.get_client(client_id).await?;
         Ok(client)
     }
 
-    async fn store_message(
+    pub async fn store_message(
         &self,
         client_address: DestinationAddressBytes,
         message: Vec<u8>,
-    ) -> Result<(), StorageError> {
+    ) -> Result<(), GatewayStorageError> {
         self.inbox_manager
             .insert_message(&client_address.as_base58_string(), message)
             .await?;
         Ok(())
     }
 
-    async fn retrieve_messages(
+    pub async fn retrieve_messages(
         &self,
         client_address: DestinationAddressBytes,
         start_after: Option<i64>,
-    ) -> Result<(Vec<StoredMessage>, Option<i64>), StorageError> {
+    ) -> Result<(Vec<StoredMessage>, Option<i64>), GatewayStorageError> {
         let messages = self
             .inbox_manager
             .get_messages(&client_address.as_base58_string(), start_after)
@@ -409,87 +180,95 @@ impl Storage for PersistentStorage {
         Ok(messages)
     }
 
-    async fn remove_messages(&self, ids: Vec<i64>) -> Result<(), StorageError> {
+    pub async fn remove_messages(&self, ids: Vec<i64>) -> Result<(), GatewayStorageError> {
         for id in ids {
             self.inbox_manager.remove_message(id).await?;
         }
         Ok(())
     }
 
-    async fn create_bandwidth_entry(&self, client_id: i64) -> Result<(), StorageError> {
+    pub async fn create_bandwidth_entry(&self, client_id: i64) -> Result<(), GatewayStorageError> {
         self.bandwidth_manager.insert_new_client(client_id).await?;
         Ok(())
     }
 
-    async fn set_expiration(
+    pub async fn set_expiration(
         &self,
         client_id: i64,
         expiration: OffsetDateTime,
-    ) -> Result<(), StorageError> {
+    ) -> Result<(), GatewayStorageError> {
         self.bandwidth_manager
             .set_expiration(client_id, expiration)
             .await?;
         Ok(())
     }
 
-    async fn reset_bandwidth(&self, client_id: i64) -> Result<(), StorageError> {
+    pub async fn reset_bandwidth(&self, client_id: i64) -> Result<(), GatewayStorageError> {
         self.bandwidth_manager.reset_bandwidth(client_id).await?;
         Ok(())
     }
 
-    async fn get_available_bandwidth(
+    pub async fn get_available_bandwidth(
         &self,
         client_id: i64,
-    ) -> Result<Option<PersistedBandwidth>, StorageError> {
+    ) -> Result<Option<PersistedBandwidth>, GatewayStorageError> {
         Ok(self
             .bandwidth_manager
             .get_available_bandwidth(client_id)
             .await?)
     }
 
-    async fn increase_bandwidth(&self, client_id: i64, amount: i64) -> Result<i64, StorageError> {
+    pub async fn increase_bandwidth(
+        &self,
+        client_id: i64,
+        amount: i64,
+    ) -> Result<i64, GatewayStorageError> {
         Ok(self
             .bandwidth_manager
             .increase_bandwidth(client_id, amount)
             .await?)
     }
 
-    async fn revoke_ticket_bandwidth(
+    pub async fn revoke_ticket_bandwidth(
         &self,
         ticket_id: i64,
         amount: i64,
-    ) -> Result<(), StorageError> {
+    ) -> Result<(), GatewayStorageError> {
         Ok(self
             .bandwidth_manager
             .revoke_ticket_bandwidth(ticket_id, amount)
             .await?)
     }
 
-    async fn decrease_bandwidth(&self, client_id: i64, amount: i64) -> Result<i64, StorageError> {
+    pub async fn decrease_bandwidth(
+        &self,
+        client_id: i64,
+        amount: i64,
+    ) -> Result<i64, GatewayStorageError> {
         Ok(self
             .bandwidth_manager
             .decrease_bandwidth(client_id, amount)
             .await?)
     }
 
-    async fn insert_epoch_signers(
+    pub async fn insert_epoch_signers(
         &self,
         epoch_id: i64,
         signer_ids: Vec<i64>,
-    ) -> Result<(), StorageError> {
+    ) -> Result<(), GatewayStorageError> {
         self.ticket_manager
             .insert_ecash_signers(epoch_id, signer_ids)
             .await?;
         Ok(())
     }
 
-    async fn insert_received_ticket(
+    pub async fn insert_received_ticket(
         &self,
         client_id: i64,
         received_at: OffsetDateTime,
         serial_number: Vec<u8>,
         data: Vec<u8>,
-    ) -> Result<i64, StorageError> {
+    ) -> Result<i64, GatewayStorageError> {
         // technically if we crash between those 2 calls we'll have a bit of data inconsistency,
         // but nothing too tragic. we just won't get paid for a single ticket
         let ticket_id = self
@@ -503,24 +282,24 @@ impl Storage for PersistentStorage {
         Ok(ticket_id)
     }
 
-    async fn contains_ticket(&self, serial_number: &[u8]) -> Result<bool, StorageError> {
+    pub async fn contains_ticket(&self, serial_number: &[u8]) -> Result<bool, GatewayStorageError> {
         Ok(self.ticket_manager.has_ticket_data(serial_number).await?)
     }
 
-    async fn insert_ticket_verification(
+    pub async fn insert_ticket_verification(
         &self,
         ticket_id: i64,
         signer_id: i64,
         verified_at: OffsetDateTime,
         accepted: bool,
-    ) -> Result<(), StorageError> {
+    ) -> Result<(), GatewayStorageError> {
         self.ticket_manager
             .insert_ticket_verification(ticket_id, signer_id, verified_at, accepted)
             .await?;
         Ok(())
     }
 
-    async fn update_rejected_ticket(&self, ticket_id: i64) -> Result<(), StorageError> {
+    pub async fn update_rejected_ticket(&self, ticket_id: i64) -> Result<(), GatewayStorageError> {
         // set the ticket as rejected
         self.ticket_manager.set_rejected_ticket(ticket_id).await?;
 
@@ -531,7 +310,7 @@ impl Storage for PersistentStorage {
         Ok(())
     }
 
-    async fn update_verified_ticket(&self, ticket_id: i64) -> Result<(), StorageError> {
+    pub async fn update_verified_ticket(&self, ticket_id: i64) -> Result<(), GatewayStorageError> {
         // 1. insert into verified table
         self.ticket_manager
             .insert_verified_ticket(ticket_id)
@@ -545,36 +324,41 @@ impl Storage for PersistentStorage {
         Ok(())
     }
 
-    async fn remove_verified_ticket_binary_data(&self, ticket_id: i64) -> Result<(), StorageError> {
+    pub async fn remove_verified_ticket_binary_data(
+        &self,
+        ticket_id: i64,
+    ) -> Result<(), GatewayStorageError> {
         self.ticket_manager
             .remove_binary_ticket_data(ticket_id)
             .await?;
         Ok(())
     }
 
-    async fn get_all_verified_tickets_with_sn(&self) -> Result<Vec<VerifiedTicket>, StorageError> {
+    pub async fn get_all_verified_tickets_with_sn(
+        &self,
+    ) -> Result<Vec<VerifiedTicket>, GatewayStorageError> {
         Ok(self
             .ticket_manager
             .get_all_verified_tickets_with_sn()
             .await?)
     }
 
-    async fn get_all_proposed_tickets_with_sn(
+    pub async fn get_all_proposed_tickets_with_sn(
         &self,
         proposal_id: u32,
-    ) -> Result<Vec<VerifiedTicket>, StorageError> {
+    ) -> Result<Vec<VerifiedTicket>, GatewayStorageError> {
         Ok(self
             .ticket_manager
             .get_all_proposed_tickets_with_sn(proposal_id as i64)
             .await?)
     }
 
-    async fn insert_redemption_proposal(
+    pub async fn insert_redemption_proposal(
         &self,
         tickets: &[VerifiedTicket],
         proposal_id: u32,
         created_at: OffsetDateTime,
-    ) -> Result<(), StorageError> {
+    ) -> Result<(), GatewayStorageError> {
         // if we crash between those, there might a bit of an issue. we should revisit it later
 
         // 1. insert the actual proposal
@@ -592,12 +376,12 @@ impl Storage for PersistentStorage {
         Ok(())
     }
 
-    async fn clear_post_proposal_data(
+    pub async fn clear_post_proposal_data(
         &self,
         proposal_id: u32,
         resolved_at: OffsetDateTime,
         rejected: bool,
-    ) -> Result<(), StorageError> {
+    ) -> Result<(), GatewayStorageError> {
         // 1. update proposal metadata
         self.ticket_manager
             .update_redemption_proposal(proposal_id as i64, resolved_at, rejected)
@@ -616,11 +400,13 @@ impl Storage for PersistentStorage {
         Ok(())
     }
 
-    async fn latest_proposal(&self) -> Result<Option<RedemptionProposal>, StorageError> {
+    pub async fn latest_proposal(&self) -> Result<Option<RedemptionProposal>, GatewayStorageError> {
         Ok(self.ticket_manager.get_latest_redemption_proposal().await?)
     }
 
-    async fn get_all_unverified_tickets(&self) -> Result<Vec<ClientTicket>, StorageError> {
+    pub async fn get_all_unverified_tickets(
+        &self,
+    ) -> Result<Vec<ClientTicket>, GatewayStorageError> {
         self.ticket_manager
             .get_unverified_tickets()
             .await?
@@ -629,29 +415,37 @@ impl Storage for PersistentStorage {
             .collect()
     }
 
-    async fn get_all_unresolved_proposals(&self) -> Result<Vec<i64>, StorageError> {
+    pub async fn get_all_unresolved_proposals(&self) -> Result<Vec<i64>, GatewayStorageError> {
         Ok(self
             .ticket_manager
             .get_all_unresolved_redemption_proposal_ids()
             .await?)
     }
 
-    async fn get_votes(&self, ticket_id: i64) -> Result<Vec<i64>, StorageError> {
+    pub async fn get_votes(&self, ticket_id: i64) -> Result<Vec<i64>, GatewayStorageError> {
         Ok(self
             .ticket_manager
             .get_verification_votes(ticket_id)
             .await?)
     }
 
-    async fn get_signers(&self, epoch_id: i64) -> Result<Vec<i64>, StorageError> {
+    pub async fn get_signers(&self, epoch_id: i64) -> Result<Vec<i64>, GatewayStorageError> {
         Ok(self.ticket_manager.get_epoch_signers(epoch_id).await?)
     }
 
-    async fn insert_wireguard_peer(
+    /// Insert a wireguard peer in the storage.
+    ///
+    /// # Arguments
+    ///
+    /// * `peer`: wireguard peer data to be stored
+    /// * `with_client_id`: if the peer should have a corresponding client_id
+    ///   (created with entry wireguard ticket) or live without one (or with an
+    ///   exiting one), for temporary backwards compatibility.
+    pub async fn insert_wireguard_peer(
         &self,
         peer: &defguard_wireguard_rs::host::Peer,
         with_client_id: bool,
-    ) -> Result<Option<i64>, StorageError> {
+    ) -> Result<Option<i64>, GatewayStorageError> {
         let client_id = match self
             .wireguard_peer_manager
             .retrieve_peer(&peer.public_key.to_string())
@@ -676,10 +470,15 @@ impl Storage for PersistentStorage {
         Ok(client_id)
     }
 
-    async fn get_wireguard_peer(
+    /// Tries to retrieve available bandwidth for the particular peer.
+    ///
+    /// # Arguments
+    ///
+    /// * `peer_public_key`: wireguard public key of the peer to be retrieved.
+    pub async fn get_wireguard_peer(
         &self,
         peer_public_key: &str,
-    ) -> Result<Option<WireguardPeer>, StorageError> {
+    ) -> Result<Option<WireguardPeer>, GatewayStorageError> {
         let peer = self
             .wireguard_peer_manager
             .retrieve_peer(peer_public_key)
@@ -687,12 +486,21 @@ impl Storage for PersistentStorage {
         Ok(peer)
     }
 
-    async fn get_all_wireguard_peers(&self) -> Result<Vec<WireguardPeer>, StorageError> {
+    /// Retrieves all wireguard peers.
+    pub async fn get_all_wireguard_peers(&self) -> Result<Vec<WireguardPeer>, GatewayStorageError> {
         let ret = self.wireguard_peer_manager.retrieve_all_peers().await?;
         Ok(ret)
     }
 
-    async fn remove_wireguard_peer(&self, peer_public_key: &str) -> Result<(), StorageError> {
+    /// Remove a wireguard peer from the storage.
+    ///
+    /// # Arguments
+    ///
+    /// * `peer_public_key`: wireguard public key of the peer to be removed.
+    pub async fn remove_wireguard_peer(
+        &self,
+        peer_public_key: &str,
+    ) -> Result<(), GatewayStorageError> {
         self.wireguard_peer_manager
             .remove_peer(peer_public_key)
             .await?;

common/gateway-storage/src/models.rs

@@ -1,7 +1,7 @@
 // Copyright 2021-2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: GPL-3.0-only
 
-use crate::error::StorageError;
+use crate::error::GatewayStorageError;
 use nym_credentials_interface::{AvailableBandwidth, ClientTicket, CredentialSpendingData};
 use nym_gateway_requests::shared_key::{LegacySharedKeys, SharedGatewayKey, SharedSymmetricKey};
 use sqlx::FromRow;
@@ -24,24 +24,24 @@ pub struct PersistedSharedKeys {
 }
 
 impl TryFrom<PersistedSharedKeys> for SharedGatewayKey {
-    type Error = StorageError;
+    type Error = GatewayStorageError;
 
     fn try_from(value: PersistedSharedKeys) -> Result<Self, Self::Error> {
         match (
             &value.derived_aes256_gcm_siv_key,
             &value.derived_aes128_ctr_blake3_hmac_keys_bs58,
         ) {
-            (None, None) => Err(StorageError::MissingSharedKey {
+            (None, None) => Err(GatewayStorageError::MissingSharedKey {
                 id: value.client_id,
             }),
             (Some(aes256gcm_siv), _) => {
                 let current_key = SharedSymmetricKey::try_from_bytes(aes256gcm_siv)
-                    .map_err(|source| StorageError::DataCorruption(source.to_string()))?;
+                    .map_err(|source| GatewayStorageError::DataCorruption(source.to_string()))?;
                 Ok(SharedGatewayKey::Current(current_key))
             }
             (None, Some(aes128ctr_hmac)) => {
                 let legacy_key = LegacySharedKeys::try_from_base58_string(aes128ctr_hmac)
-                    .map_err(|source| StorageError::DataCorruption(source.to_string()))?;
+                    .map_err(|source| GatewayStorageError::DataCorruption(source.to_string()))?;
                 Ok(SharedGatewayKey::Legacy(legacy_key))
             }
         }
@@ -91,12 +91,12 @@ pub struct UnverifiedTicketData {
 }
 
 impl TryFrom<UnverifiedTicketData> for ClientTicket {
-    type Error = StorageError;
+    type Error = GatewayStorageError;
 
     fn try_from(value: UnverifiedTicketData) -> Result<Self, Self::Error> {
         Ok(ClientTicket {
             spending_data: CredentialSpendingData::try_from_bytes(&value.data).map_err(|_| {
-                StorageError::MalformedStoredTicketData {
+                GatewayStorageError::MalformedStoredTicketData {
                     ticket_id: value.ticket_id,
                 }
             })?,
@@ -152,7 +152,7 @@ impl From<defguard_wireguard_rs::host::Peer> for WireguardPeer {
 }
 
 impl TryFrom<WireguardPeer> for defguard_wireguard_rs::host::Peer {
-    type Error = crate::error::StorageError;
+    type Error = crate::error::GatewayStorageError;
 
     fn try_from(value: WireguardPeer) -> Result<Self, Self::Error> {
         Ok(Self {

common/http-api-common/Cargo.toml

@@ -15,15 +15,12 @@ axum-client-ip.workspace = true
 axum.workspace = true
 bytes = { workspace = true }
 colored.workspace = true
-futures = { workspace = true }
 mime = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 serde_json.workspace = true
 serde_yaml = { workspace = true }
-tower = { workspace = true }
 tracing.workspace = true
 utoipa = { workspace = true, optional = true }
-zeroize = { workspace = true }
 
 [features]
 utoipa = ["dep:utoipa"]

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

@@ -7,7 +7,7 @@ use axum::Json;
 use bytes::{BufMut, BytesMut};
 use serde::{Deserialize, Serialize};
 
-pub mod middleware;
+pub mod logging;
 
 #[derive(Debug, Clone)]
 #[cfg_attr(feature = "utoipa", derive(utoipa::ToSchema))]

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

@@ -1,5 +1,5 @@
 // Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: GPL-3.0-only
 
 use axum::extract::Request;
 use axum::http::header::{HOST, USER_AGENT};
@@ -11,7 +11,6 @@ use colored::Colorize;
 use std::time::Instant;
 use tracing::info;
 
-/// Simple logger for requests
 pub async fn logger(
     InsecureClientIp(addr): InsecureClientIp,
     request: Request,

common/mixnode-common/Cargo.toml

@@ -26,7 +26,7 @@ url = { workspace = true }
 time.workspace = true
 thiserror = { workspace = true }
 
-nym-crypto = { path = "../crypto" }
+nym-crypto = { path = "../crypto", features = ["asymmetric"] }
 nym-network-defaults = { path = "../network-defaults" }
 nym-sphinx-acknowledgements = { path = "../nymsphinx/acknowledgements" }
 nym-sphinx-addressing = { path = "../nymsphinx/addressing" }
@@ -35,7 +35,5 @@ nym-sphinx-framing = { path = "../nymsphinx/framing" }
 nym-sphinx-params = { path = "../nymsphinx/params" }
 nym-sphinx-types = { path = "../nymsphinx/types" }
 nym-task = { path = "../task" }
-nym-validator-client = { path = "../client-libs/validator-client" }
-nym-bin-common = { path = "../bin-common" }
 nym-metrics = { path = "../nym-metrics" }
-nym-node-http-api = { path = "../../nym-node/nym-node-http-api" } 
+

common/mixnode-common/src/lib.rs

@@ -1,4 +1,4 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
+
 pub mod packet_processor;
-pub mod verloc;

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

@@ -1,81 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use std::fmt::{self, Display, Formatter};
-use std::io;
-
-#[derive(Debug)]
-pub enum RttError {
-    UnexpectedEchoPacketSize,
-    UnexpectedReplyPacketSize,
-
-    MalformedSenderIdentity,
-
-    MalformedEchoSignature,
-    MalformedReplySignature,
-
-    InvalidEchoSignature,
-    InvalidReplySignature,
-
-    UnreachableNode(String, io::Error),
-    UnexpectedConnectionFailureWrite(String, io::Error),
-    UnexpectedConnectionFailureRead(String, io::Error),
-    ConnectionReadTimeout(String),
-    ConnectionWriteTimeout(String),
-
-    UnexpectedReplySequence,
-
-    ShutdownReceived,
-}
-
-impl Display for RttError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        match self {
-            RttError::UnexpectedEchoPacketSize => {
-                write!(f, "The received echo packet had unexpected size")
-            }
-            RttError::UnexpectedReplyPacketSize => {
-                write!(f, "The received reply packet had unexpected size")
-            }
-            RttError::MalformedSenderIdentity => {
-                write!(f, "The received echo packet had malformed sender")
-            }
-            RttError::MalformedEchoSignature => {
-                write!(f, "The received echo packet had malformed signature")
-            }
-            RttError::MalformedReplySignature => {
-                write!(f, "The received reply packet had malformed signature")
-            }
-            RttError::InvalidEchoSignature => {
-                write!(f, "The received echo packet had invalid signature")
-            }
-            RttError::InvalidReplySignature => {
-                write!(f, "The received reply packet had invalid signature")
-            }
-            RttError::UnreachableNode(id, err) => {
-                write!(f, "Could not establish connection to {id} - {err}")
-            }
-            RttError::UnexpectedConnectionFailureWrite(id, err) => {
-                write!(f, "Failed to write echo packet to {id} - {err}")
-            }
-            RttError::UnexpectedConnectionFailureRead(id, err) => {
-                write!(f, "Failed to read reply packet from {id} - {err}")
-            }
-            RttError::ConnectionReadTimeout(id) => {
-                write!(f, "Timed out while trying to read reply packet from {id}")
-            }
-            RttError::ConnectionWriteTimeout(id) => {
-                write!(f, "Timed out while trying to write echo packet to {id}")
-            }
-            RttError::UnexpectedReplySequence => write!(
-                f,
-                "The received reply packet had an unexpected sequence number"
-            ),
-            RttError::ShutdownReceived => {
-                write!(f, "Shutdown signal received")
-            }
-        }
-    }
-}
-
-impl std::error::Error for RttError {}

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

@@ -1,35 +0,0 @@
-// Copyright 2021-2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use nym_node_http_api::state::metrics::{SharedVerlocStats, VerlocNodeResult};
-use std::mem;
-use time::OffsetDateTime;
-
-pub(crate) trait VerlocStatsUpdateExt {
-    async fn start_new_measurements(&self, nodes_to_test: usize);
-
-    async fn append_measurement_results(&self, new_data: Vec<VerlocNodeResult>);
-
-    async fn finish_measurements(&self);
-}
-
-impl VerlocStatsUpdateExt for SharedVerlocStats {
-    async fn start_new_measurements(&self, nodes_to_test: usize) {
-        let mut guard = self.write().await;
-        guard.previous_run_data = mem::take(&mut guard.current_run_data);
-        guard.current_run_data.nodes_tested = nodes_to_test;
-    }
-
-    async fn append_measurement_results(&self, mut new_data: Vec<VerlocNodeResult>) {
-        let mut write_permit = self.write().await;
-        write_permit.current_run_data.results.append(&mut new_data);
-        // make sure the data always stays in order.
-        // TODO: considering the front of the results is guaranteed to be sorted, should perhaps
-        // a non-default sorting algorithm be used?
-        write_permit.current_run_data.results.sort()
-    }
-
-    async fn finish_measurements(&self) {
-        self.write().await.current_run_data.run_finished = Some(OffsetDateTime::now_utc())
-    }
-}

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

@@ -1,370 +0,0 @@
-// Copyright 2021-2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::verloc::listener::PacketListener;
-use crate::verloc::sender::{PacketSender, TestedNode};
-use futures::stream::FuturesUnordered;
-use futures::StreamExt;
-use log::*;
-use nym_crypto::asymmetric::identity;
-use nym_network_defaults::mainnet::NYM_API;
-use nym_node_http_api::state::metrics::{SharedVerlocStats, VerlocNodeResult};
-use nym_task::TaskClient;
-use rand::seq::SliceRandom;
-use rand::thread_rng;
-use std::net::SocketAddr;
-use std::sync::Arc;
-use std::time::Duration;
-use tokio::task::JoinHandle;
-use tokio::time::sleep;
-use url::Url;
-
-use measurement::VerlocStatsUpdateExt;
-
-// pub use crate::verloc::measurement::{AtomicVerlocResult, Verloc, VerlocResult};
-
-pub mod error;
-pub(crate) mod listener;
-pub(crate) mod measurement;
-pub(crate) mod packet;
-pub(crate) mod sender;
-
-// by default all of those are overwritten by config data from mixnodes directly
-const DEFAULT_VERLOC_PORT: u16 = 1790;
-const DEFAULT_PACKETS_PER_NODE: usize = 100;
-const DEFAULT_PACKET_TIMEOUT: Duration = Duration::from_millis(1500);
-const DEFAULT_CONNECTION_TIMEOUT: Duration = Duration::from_millis(5000);
-const DEFAULT_DELAY_BETWEEN_PACKETS: Duration = Duration::from_millis(50);
-const DEFAULT_BATCH_SIZE: usize = 50;
-const DEFAULT_TESTING_INTERVAL: Duration = Duration::from_secs(60 * 60 * 12);
-const DEFAULT_RETRY_TIMEOUT: Duration = Duration::from_secs(60 * 30);
-
-#[derive(Clone, Debug)]
-pub struct Config {
-    /// Socket address of this node on which it will be listening for the measurement packets.
-    listening_address: SocketAddr,
-
-    /// Specifies number of echo packets sent to each node during a measurement run.
-    packets_per_node: usize,
-
-    /// Specifies maximum amount of time to wait for the reply packet to arrive before abandoning the test.
-    packet_timeout: Duration,
-
-    /// Specifies maximum amount of time to wait for the connection to get established.
-    connection_timeout: Duration,
-
-    /// Specifies delay between subsequent test packets being sent (after receiving a reply).
-    delay_between_packets: Duration,
-
-    /// Specifies number of nodes being tested at once.
-    tested_nodes_batch_size: usize,
-
-    /// Specifies delay between subsequent test runs.
-    testing_interval: Duration,
-
-    /// Specifies delay between attempting to run the measurement again if the previous run failed
-    /// due to being unable to get the list of nodes.
-    retry_timeout: Duration,
-
-    /// URLs to the nym apis for obtaining network topology.
-    nym_api_urls: Vec<Url>,
-}
-
-impl Config {
-    pub fn build() -> ConfigBuilder {
-        ConfigBuilder::new()
-    }
-}
-
-#[must_use]
-pub struct ConfigBuilder(Config);
-
-impl ConfigBuilder {
-    pub fn new() -> ConfigBuilder {
-        Self::default()
-    }
-
-    pub fn listening_address(mut self, listening_address: SocketAddr) -> Self {
-        self.0.listening_address = listening_address;
-        self
-    }
-
-    pub fn packets_per_node(mut self, packets_per_node: usize) -> Self {
-        self.0.packets_per_node = packets_per_node;
-        self
-    }
-
-    pub fn packet_timeout(mut self, packet_timeout: Duration) -> Self {
-        self.0.packet_timeout = packet_timeout;
-        self
-    }
-
-    pub fn connection_timeout(mut self, connection_timeout: Duration) -> Self {
-        self.0.connection_timeout = connection_timeout;
-        self
-    }
-
-    pub fn delay_between_packets(mut self, delay_between_packets: Duration) -> Self {
-        self.0.delay_between_packets = delay_between_packets;
-        self
-    }
-
-    pub fn tested_nodes_batch_size(mut self, tested_nodes_batch_size: usize) -> Self {
-        self.0.tested_nodes_batch_size = tested_nodes_batch_size;
-        self
-    }
-
-    pub fn testing_interval(mut self, testing_interval: Duration) -> Self {
-        self.0.testing_interval = testing_interval;
-        self
-    }
-
-    pub fn retry_timeout(mut self, retry_timeout: Duration) -> Self {
-        self.0.retry_timeout = retry_timeout;
-        self
-    }
-
-    pub fn nym_api_urls(mut self, nym_api_urls: Vec<Url>) -> Self {
-        self.0.nym_api_urls = nym_api_urls;
-        self
-    }
-
-    pub fn build(self) -> Config {
-        // panics here are fine as those are only ever constructed at the initial setup
-        assert!(
-            !self.0.nym_api_urls.is_empty(),
-            "at least one validator endpoint must be provided",
-        );
-        self.0
-    }
-}
-
-impl Default for ConfigBuilder {
-    fn default() -> Self {
-        ConfigBuilder(Config {
-            listening_address: format!("[::]:{DEFAULT_VERLOC_PORT}").parse().unwrap(),
-            packets_per_node: DEFAULT_PACKETS_PER_NODE,
-            packet_timeout: DEFAULT_PACKET_TIMEOUT,
-            connection_timeout: DEFAULT_CONNECTION_TIMEOUT,
-            delay_between_packets: DEFAULT_DELAY_BETWEEN_PACKETS,
-            tested_nodes_batch_size: DEFAULT_BATCH_SIZE,
-            testing_interval: DEFAULT_TESTING_INTERVAL,
-            retry_timeout: DEFAULT_RETRY_TIMEOUT,
-            nym_api_urls: vec![NYM_API.parse().expect("Invalid default API URL")],
-        })
-    }
-}
-
-pub struct VerlocMeasurer {
-    config: Config,
-    packet_sender: Arc<PacketSender>,
-    packet_listener: Arc<PacketListener>,
-    shutdown_listener: TaskClient,
-
-    currently_used_api: usize,
-
-    // Note: this client is only fine here as it does not maintain constant connection to the validator.
-    // It only does bunch of REST queries. If we update it at some point to a more sophisticated (maybe signing) client,
-    // then it definitely cannot be constructed here and probably will need to be passed from outside,
-    // as mixnodes/gateways would already be using an instance of said client.
-    validator_client: nym_validator_client::NymApiClient,
-    state: SharedVerlocStats,
-}
-
-impl VerlocMeasurer {
-    pub fn new(
-        mut config: Config,
-        identity: Arc<identity::KeyPair>,
-        shutdown_listener: TaskClient,
-    ) -> Self {
-        config.nym_api_urls.shuffle(&mut thread_rng());
-
-        VerlocMeasurer {
-            packet_sender: Arc::new(PacketSender::new(
-                Arc::clone(&identity),
-                config.packets_per_node,
-                config.packet_timeout,
-                config.connection_timeout,
-                config.delay_between_packets,
-                shutdown_listener.clone().named("VerlocPacketSender"),
-            )),
-            packet_listener: Arc::new(PacketListener::new(
-                config.listening_address,
-                Arc::clone(&identity),
-                shutdown_listener.clone().named("VerlocPacketListener"),
-            )),
-            shutdown_listener,
-            currently_used_api: 0,
-            validator_client: nym_validator_client::NymApiClient::new(
-                config.nym_api_urls[0].clone(),
-            ),
-            config,
-            state: SharedVerlocStats::default(),
-        }
-    }
-
-    pub fn set_shared_state(&mut self, state: SharedVerlocStats) {
-        self.state = state;
-    }
-
-    fn use_next_nym_api(&mut self) {
-        if self.config.nym_api_urls.len() == 1 {
-            warn!("There's only a single validator API available - it won't be possible to use a different one");
-            return;
-        }
-
-        self.currently_used_api = (self.currently_used_api + 1) % self.config.nym_api_urls.len();
-        self.validator_client
-            .change_nym_api(self.config.nym_api_urls[self.currently_used_api].clone())
-    }
-
-    fn start_listening(&self) -> JoinHandle<()> {
-        let packet_listener = Arc::clone(&self.packet_listener);
-        tokio::spawn(packet_listener.run())
-    }
-
-    async fn perform_measurement(&self, nodes_to_test: Vec<TestedNode>) -> MeasurementOutcome {
-        log::trace!("Performing measurements");
-        if nodes_to_test.is_empty() {
-            log::debug!("there are no nodes to measure");
-            return MeasurementOutcome::Done;
-        }
-
-        let mut shutdown_listener = self.shutdown_listener.clone().named("VerlocMeasurement");
-        shutdown_listener.disarm();
-
-        for chunk in nodes_to_test.chunks(self.config.tested_nodes_batch_size) {
-            let mut chunk_results = Vec::with_capacity(chunk.len());
-
-            let mut measurement_chunk = chunk
-                .iter()
-                .map(|node| {
-                    let node = *node;
-                    let packet_sender = Arc::clone(&self.packet_sender);
-                    // TODO: there's a potential issue here. if we make the measurement go into separate
-                    // task, we risk biasing results with the bunch of context switches overhead
-                    // but if we don't do it, it will take ages to complete
-
-                    // TODO: check performance difference when it's not spawned as a separate task
-                    tokio::spawn(async move {
-                        (
-                            packet_sender.send_packets_to_node(node).await,
-                            node.identity,
-                        )
-                    })
-                })
-                .collect::<FuturesUnordered<_>>();
-
-            // exhaust the results
-            while !shutdown_listener.is_shutdown() {
-                tokio::select! {
-                    measurement_result = measurement_chunk.next() => {
-                        let Some(result) = measurement_result else {
-                            // if the stream has finished, it means we got everything we could have gotten
-                            break
-                        };
-
-                        // if we receive JoinError it means the task failed to get executed, so either there's a bigger issue with tokio
-                        // or there was a panic inside the task itself. In either case, we should just terminate ourselves.
-                        let execution_result = result.expect("the measurement task panicked!");
-                        let identity = execution_result.1;
-
-                        let measurement_result = match execution_result.0 {
-                            Err(err) => {
-                                debug!("Failed to perform measurement for {identity}: {err}");
-                                None
-                            }
-                            Ok(result) => Some(result),
-                        };
-                        chunk_results.push(VerlocNodeResult::new(identity, measurement_result));
-                    },
-                    _ = shutdown_listener.recv() => {
-                        trace!("Shutdown received while measuring");
-                        return MeasurementOutcome::Shutdown;
-                    }
-                }
-            }
-
-            // update the results vector with chunks as they become available (by default every 50 nodes)
-            self.state.append_measurement_results(chunk_results).await;
-        }
-
-        MeasurementOutcome::Done
-    }
-
-    pub async fn run(&mut self) {
-        self.start_listening();
-
-        while !self.shutdown_listener.is_shutdown() {
-            info!("Starting verloc measurements");
-            // TODO: should we also measure gateways?
-
-            let all_mixes = match self.validator_client.get_all_described_nodes().await {
-                Ok(nodes) => nodes,
-                Err(err) => {
-                    error!(
-                        "failed to obtain list of mixnodes from the validator - {}. Going to attempt to use another validator API in the next run",
-                        err
-                    );
-                    self.use_next_nym_api();
-                    sleep(self.config.retry_timeout).await;
-                    continue;
-                }
-            };
-            if all_mixes.is_empty() {
-                warn!("There does not seem there are any nodes to measure...")
-            }
-
-            // 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 ip = node.description.host_information.ip_address.first()?;
-                    let verloc_port = node.description.verloc_port();
-                    let verloc_host = SocketAddr::new(*ip, verloc_port);
-
-                    // 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
-                    // However, maybe it's not a problem as if they are misconfigured, they will eventually be
-                    // pushed out of the network and on top of that, verloc is done in separate task that runs
-                    // only every few hours.
-                    Some(TestedNode::new(verloc_host, node_identity))
-                })
-                .collect::<Vec<_>>();
-
-            // on start of each run remove old results
-            self.state.start_new_measurements(tested_nodes.len()).await;
-
-            if let MeasurementOutcome::Shutdown = self.perform_measurement(tested_nodes).await {
-                log::trace!("Shutting down after aborting measurements");
-                break;
-            }
-
-            // write current time to "run finished" field
-            self.state.finish_measurements().await;
-
-            info!(
-                "Finished performing verloc measurements. The next one will happen in {:?}",
-                self.config.testing_interval
-            );
-
-            tokio::select! {
-                _ = sleep(self.config.testing_interval) => {},
-                _ = self.shutdown_listener.recv() => {
-                    log::trace!("Shutdown received while sleeping");
-                }
-            }
-        }
-
-        log::trace!("Verloc: Exiting");
-    }
-}
-
-enum MeasurementOutcome {
-    Done,
-    Shutdown,
-}

common/models/Cargo.toml

@@ -1,17 +0,0 @@
-[package]
-name = "nym-common-models"
-version = "0.1.0"
-authors.workspace = true
-repository.workspace = true
-homepage.workspace = true
-documentation.workspace = true
-edition.workspace = true
-license.workspace = true
-rust-version.workspace = true
-readme.workspace = true
-
-[dependencies]
-anyhow = { workspace = true }
-bincode = { workspace = true }
-nym-crypto = { path = "../crypto", features = ["asymmetric", "serde"] }
-serde = { workspace = true, features = ["derive"] }

common/models/src/lib.rs

@@ -1 +0,0 @@
-pub mod ns_api;

common/nym_offline_compact_ecash/src/scheme/keygen.rs

@@ -530,6 +530,15 @@ impl From<KeyPairUser> for SecretKeyUser {
     }
 }
 
+impl From<SecretKeyUser> for KeyPairUser {
+    fn from(value: SecretKeyUser) -> Self {
+        KeyPairUser {
+            public_key: value.public_key(),
+            secret_key: value,
+        }
+    }
+}
+
 impl KeyPairUser {
     #[allow(clippy::new_without_default)]
     pub fn new() -> Self {

common/nymsphinx/addressing/src/nodes.rs

@@ -1,12 +1,13 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-//! Encodoing and decoding node routing information.
+//! Encoding and decoding node routing information.
 //!
 //! This module is responsible for encoding and decoding node routing information, so that
 //! they could be later put into an appropriate field in a sphinx header.
 //! Currently, that routing information is an IP address, but in principle it can be anything
 //!  for as long as it's going to fit in the field.
+
 use nym_crypto::asymmetric::identity;
 use nym_sphinx_types::{NodeAddressBytes, NODE_ADDRESS_LENGTH};
 

common/nymsphinx/framing/src/packet.rs

@@ -18,19 +18,13 @@ pub struct FramedNymPacket {
 }
 
 impl FramedNymPacket {
-    pub fn new(packet: NymPacket, packet_type: PacketType, use_legacy_version: bool) -> Self {
+    pub fn new(packet: NymPacket, packet_type: PacketType) -> Self {
         // If this fails somebody is using the library in a super incorrect way, because they
         // already managed to somehow create a sphinx packet
         let packet_size = PacketSize::get_type(packet.len()).unwrap();
 
-        let use_legacy = if packet_type == PacketType::Outfox {
-            false
-        } else {
-            use_legacy_version
-        };
-
         let header = Header {
-            packet_version: PacketVersion::new(use_legacy),
+            packet_version: PacketVersion::new(),
             packet_size,
             packet_type,
         };

common/nymsphinx/params/src/packet_version.rs

@@ -13,12 +13,8 @@ pub enum PacketVersion {
 }
 
 impl PacketVersion {
-    pub fn new(use_legacy: bool) -> Self {
-        if use_legacy {
-            Self::new_legacy()
-        } else {
-            Self::new_versioned(CURRENT_PACKET_VERSION_NUMBER)
-        }
+    pub fn new() -> Self {
+        Self::new_versioned(CURRENT_PACKET_VERSION_NUMBER)
     }
 
     pub fn new_legacy() -> Self {

common/statistics/Cargo.toml

@@ -26,3 +26,4 @@ nym-sphinx = { path = "../nymsphinx" }
 nym-credentials-interface = { path = "../credentials-interface" }
 nym-metrics = { path = "../nym-metrics" }
 nym-task = { path = "../task" }
+

common/statistics/src/gateways.rs

@@ -31,40 +31,12 @@ impl GatewayStatsReporter {
 /// 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,
-        })
-    }
+    SessionStatsEvent(GatewaySessionEvent),
 }
 
 /// Events in the lifecycle of an established client tunnel
-pub enum SessionEvent {
+#[derive(Debug, Clone, Copy)]
+pub enum GatewaySessionEvent {
     /// A new session between this gateway and the client remote has successfully opened
     SessionStart {
         /// The timestamp of the session open event
@@ -87,3 +59,32 @@ pub enum SessionEvent {
         client: DestinationAddressBytes,
     },
 }
+
+impl GatewaySessionEvent {
+    /// A new session between this gateway and the client remote has successfully opened
+    pub fn new_session_start(client: DestinationAddressBytes) -> GatewaySessionEvent {
+        GatewaySessionEvent::SessionStart {
+            start_time: OffsetDateTime::now_utc(),
+            client,
+        }
+    }
+
+    /// An existing session with the client remote has ended
+    pub fn new_session_stop(client: DestinationAddressBytes) -> GatewaySessionEvent {
+        GatewaySessionEvent::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,
+    ) -> GatewaySessionEvent {
+        GatewaySessionEvent::EcashTicket {
+            ticket_type,
+            client,
+        }
+    }
+}

common/statistics/src/lib.rs

@@ -12,7 +12,7 @@
 #![warn(clippy::dbg_macro)]
 
 use nym_crypto::asymmetric::ed25519;
-use sha2::Digest;
+use sha2::{Digest, Sha256};
 
 /// Client specific statistics interfaces and events.
 pub mod clients;
@@ -36,3 +36,7 @@ fn generate_stats_id<M: AsRef<[u8]>>(prefix: &str, id_seed: M) -> String {
     let output = hasher.finalize();
     format!("{:x}", output)
 }
+
+pub fn hash_identifier<M: AsRef<[u8]>>(identifier: M) -> String {
+    format!("{:x}", Sha256::digest(identifier))
+}

common/task/src/manager.rs

@@ -455,6 +455,10 @@ impl TaskClient {
         self.mode.set_should_not_signal_on_drop();
     }
 
+    pub fn rearm(&mut self) {
+        self.mode.set_should_signal_on_drop();
+    }
+
     pub fn send_we_stopped(&mut self, err: SentError) {
         if self.mode.is_dummy() {
             return;
@@ -482,7 +486,7 @@ impl Drop for TaskClient {
         if !self.mode.should_signal_on_drop() {
             self.log(
                 Level::Trace,
-                "the task client is getting dropped but inststructed to not signal: this is expected during client shutdown",
+                "the task client is getting dropped but instructed to not signal: this is expected during client shutdown",
             );
             return;
         } else {
@@ -527,6 +531,14 @@ impl ClientOperatingMode {
         }
     }
 
+    fn set_should_signal_on_drop(&mut self) {
+        use ClientOperatingMode::{Dummy, Listening, ListeningButDontReportHalt};
+        *self = match &self {
+            ListeningButDontReportHalt | Listening => Listening,
+            Dummy => Dummy,
+        };
+    }
+
     fn set_should_not_signal_on_drop(&mut self) {
         use ClientOperatingMode::{Dummy, Listening, ListeningButDontReportHalt};
         *self = match &self {

common/topology/src/filter.rs

@@ -0,0 +1,55 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use nym_bin_common::version_checker;
+use std::collections::{BTreeMap, HashMap};
+use std::hash::Hash;
+
+pub trait Versioned: Clone {
+    fn version(&self) -> String;
+}
+
+pub trait VersionFilterable<T> {
+    #[must_use]
+    fn filter_by_version(&self, expected_version: &str) -> Self;
+}
+
+impl<T> VersionFilterable<T> for Vec<T>
+where
+    T: Versioned,
+{
+    fn filter_by_version(&self, expected_version: &str) -> Self {
+        self.iter()
+            .filter(|node| {
+                version_checker::is_minor_version_compatible(&node.version(), expected_version)
+            })
+            .cloned()
+            .collect()
+    }
+}
+
+impl<T, K, V> VersionFilterable<T> for HashMap<K, V>
+where
+    K: Eq + Hash + Clone,
+    V: VersionFilterable<T>,
+    T: Versioned,
+{
+    fn filter_by_version(&self, expected_version: &str) -> Self {
+        self.iter()
+            .map(|(k, v)| (k.clone(), v.filter_by_version(expected_version)))
+            .collect()
+    }
+}
+
+impl<T, K, V> VersionFilterable<T> for BTreeMap<K, V>
+where
+    K: Eq + Ord + Clone,
+    V: VersionFilterable<T>,
+    T: Versioned,
+{
+    fn filter_by_version(&self, expected_version: &str) -> Self {
+        self.iter()
+            .map(|(k, v)| (k.clone(), v.filter_by_version(expected_version)))
+            .collect()
+    }
+}

common/topology/src/gateway.rs

@@ -1,7 +1,7 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::{NetworkAddress, NodeVersion};
+use crate::{filter, NetworkAddress, NodeVersion};
 use nym_api_requests::nym_nodes::SkimmedNode;
 use nym_crypto::asymmetric::{encryption, identity};
 use nym_mixnet_contract_common::NodeId;
@@ -126,6 +126,13 @@ impl fmt::Display for LegacyNode {
     }
 }
 
+impl filter::Versioned for LegacyNode {
+    fn version(&self) -> String {
+        // TODO: return semver instead
+        self.version.to_string()
+    }
+}
+
 impl<'a> From<&'a LegacyNode> for SphinxNode {
     fn from(node: &'a LegacyNode) -> Self {
         let node_address_bytes = NymNodeRoutingAddress::from(node.mix_host)

common/topology/src/lib.rs

@@ -4,6 +4,7 @@
 #![allow(unknown_lints)]
 // clippy::to_string_trait_impl is not on stable as of 1.77
 
+use crate::filter::VersionFilterable;
 pub use error::NymTopologyError;
 use log::{debug, info, warn};
 use nym_api_requests::nym_nodes::{CachedNodesResponse, SkimmedNode};
@@ -24,6 +25,7 @@ use std::str::FromStr;
 use ::serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 pub mod error;
+pub mod filter;
 pub mod gateway;
 pub mod mix;
 pub mod random_route_provider;
@@ -463,6 +465,19 @@ impl NymTopology {
 
         Ok(())
     }
+
+    #[must_use]
+    pub fn filter_system_version(&self, expected_version: &str) -> Self {
+        self.filter_node_versions(expected_version)
+    }
+
+    #[must_use]
+    pub fn filter_node_versions(&self, expected_mix_version: &str) -> Self {
+        NymTopology {
+            mixes: self.mixes.filter_by_version(expected_mix_version),
+            gateways: self.gateways.clone(),
+        }
+    }
 }
 
 #[cfg(feature = "serializable")]

common/topology/src/mix.rs

@@ -1,7 +1,7 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::{NetworkAddress, NodeVersion};
+use crate::{filter, NetworkAddress, NodeVersion};
 use nym_api_requests::nym_nodes::{NodeRole, SkimmedNode};
 use nym_crypto::asymmetric::{encryption, identity};
 pub use nym_mixnet_contract_common::LegacyMixLayer;
@@ -89,6 +89,13 @@ impl LegacyNode {
     }
 }
 
+impl filter::Versioned for LegacyNode {
+    fn version(&self) -> String {
+        // TODO: return semver instead
+        self.version.to_string()
+    }
+}
+
 impl<'a> From<&'a LegacyNode> for SphinxNode {
     fn from(node: &'a LegacyNode) -> Self {
         let node_address_bytes = NymNodeRoutingAddress::from(node.mix_host)

common/verloc/Cargo.toml

@@ -0,0 +1,27 @@
+[package]
+name = "nym-verloc"
+version = "0.1.0"
+authors.workspace = true
+repository.workspace = true
+homepage.workspace = true
+documentation.workspace = true
+edition.workspace = true
+license.workspace = true
+rust-version.workspace = true
+readme.workspace = true
+
+[dependencies]
+bytes = { workspace = true }
+futures = { workspace = true }
+humantime = { workspace = true }
+tracing = { workspace = true }
+time = { workspace = true }
+tokio = { workspace = true, features = ["sync", "net", "rt-multi-thread", "io-util"] }
+tokio-util = { workspace = true, features = ["codec"] }
+thiserror = { workspace = true }
+rand = { workspace = true }
+url = { workspace = true }
+
+nym-crypto = { path = "../crypto", features = ["asymmetric"] }
+nym-task = { path = "../task" }
+nym-validator-client = { path = "../client-libs/validator-client" }

common/verloc/src/error.rs

@@ -0,0 +1,72 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use std::io;
+use std::net::SocketAddr;
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum VerlocError {
+    #[error("the received echo packet had unexpected size")]
+    UnexpectedEchoPacketSize,
+
+    #[error("the received reply packet had unexpected size")]
+    UnexpectedReplyPacketSize,
+
+    #[error("the received echo packet had malformed sender")]
+    MalformedSenderIdentity,
+
+    #[error("the received echo packet had malformed signature")]
+    MalformedEchoSignature,
+
+    #[error("the received reply packet had malformed signature")]
+    MalformedReplySignature,
+
+    #[error("the received echo packet had invalid signature")]
+    InvalidEchoSignature,
+
+    #[error("the received reply packet had invalid signature")]
+    InvalidReplySignature,
+
+    #[error("could not establish connection to {identity} on {address}: {err}")]
+    UnreachableNode {
+        identity: String,
+        address: SocketAddr,
+        #[source]
+        err: io::Error,
+    },
+
+    #[error("failed to write echo packet to {identity} on {address}: {err}")]
+    UnexpectedConnectionFailureWrite {
+        identity: String,
+        address: SocketAddr,
+        #[source]
+        err: io::Error,
+    },
+
+    #[error("failed to read reply packet from {identity} on {address}: {err}")]
+    UnexpectedConnectionFailureRead {
+        identity: String,
+        address: SocketAddr,
+        #[source]
+        err: io::Error,
+    },
+
+    #[error("timed out while trying to read reply packet from {identity} on {address}")]
+    ConnectionReadTimeout {
+        identity: String,
+        address: SocketAddr,
+    },
+
+    #[error("timed out while trying to write echo packet to {identity} on {address}")]
+    ConnectionWriteTimeout {
+        identity: String,
+        address: SocketAddr,
+    },
+
+    #[error("the received reply packet had an unexpected sequence number")]
+    UnexpectedReplySequence,
+
+    #[error("shutdown signal received")]
+    ShutdownReceived,
+}

common/verloc/src/lib.rs

@@ -0,0 +1,11 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+#![warn(clippy::expect_used)]
+#![warn(clippy::unwrap_used)]
+#![warn(clippy::todo)]
+#![warn(clippy::dbg_macro)]
+
+pub mod error;
+pub mod measurements;
+pub mod models;

common/verloc/src/measurements/config.rs

@@ -0,0 +1,135 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use nym_validator_client::UserAgent;
+use std::net::{IpAddr, Ipv6Addr, SocketAddr};
+use std::time::Duration;
+use url::Url;
+
+// by default all of those are overwritten by config data from nym-node directly
+const DEFAULT_VERLOC_PORT: u16 = 1790;
+const DEFAULT_PACKETS_PER_NODE: usize = 100;
+const DEFAULT_PACKET_TIMEOUT: Duration = Duration::from_millis(1500);
+const DEFAULT_CONNECTION_TIMEOUT: Duration = Duration::from_millis(5000);
+const DEFAULT_DELAY_BETWEEN_PACKETS: Duration = Duration::from_millis(50);
+const DEFAULT_BATCH_SIZE: usize = 50;
+const DEFAULT_TESTING_INTERVAL: Duration = Duration::from_secs(60 * 60 * 12);
+const DEFAULT_RETRY_TIMEOUT: Duration = Duration::from_secs(60 * 30);
+
+#[derive(Clone, Debug)]
+pub struct Config {
+    /// Socket address of this node on which it will be listening for the measurement packets.
+    pub listening_address: SocketAddr,
+
+    /// Specifies number of echo packets sent to each node during a measurement run.
+    pub packets_per_node: usize,
+
+    /// Specifies maximum amount of time to wait for the reply packet to arrive before abandoning the test.
+    pub packet_timeout: Duration,
+
+    /// Specifies maximum amount of time to wait for the connection to get established.
+    pub connection_timeout: Duration,
+
+    /// Specifies delay between subsequent test packets being sent (after receiving a reply).
+    pub delay_between_packets: Duration,
+
+    /// Specifies number of nodes being tested at once.
+    pub tested_nodes_batch_size: usize,
+
+    /// Specifies delay between subsequent test runs.
+    pub testing_interval: Duration,
+
+    /// Specifies delay between attempting to run the measurement again if the previous run failed
+    /// due to being unable to get the list of nodes.
+    pub retry_timeout: Duration,
+
+    /// URLs to the nym apis for obtaining network topology.
+    pub nym_api_urls: Vec<Url>,
+
+    /// User agent used for querying the nym-api
+    pub user_agent: UserAgent,
+}
+
+impl Config {
+    pub fn build(nym_api_urls: Vec<Url>, user_agent: impl Into<UserAgent>) -> ConfigBuilder {
+        ConfigBuilder::new(nym_api_urls, user_agent)
+    }
+}
+
+#[must_use]
+pub struct ConfigBuilder(Config);
+
+impl ConfigBuilder {
+    pub fn new(nym_api_urls: Vec<Url>, user_agent: impl Into<UserAgent>) -> ConfigBuilder {
+        ConfigBuilder(Config {
+            // '[::]:port'
+            listening_address: SocketAddr::new(
+                IpAddr::V6(Ipv6Addr::UNSPECIFIED),
+                DEFAULT_VERLOC_PORT,
+            ),
+            packets_per_node: DEFAULT_PACKETS_PER_NODE,
+            packet_timeout: DEFAULT_PACKET_TIMEOUT,
+            connection_timeout: DEFAULT_CONNECTION_TIMEOUT,
+            delay_between_packets: DEFAULT_DELAY_BETWEEN_PACKETS,
+            tested_nodes_batch_size: DEFAULT_BATCH_SIZE,
+            testing_interval: DEFAULT_TESTING_INTERVAL,
+            retry_timeout: DEFAULT_RETRY_TIMEOUT,
+            nym_api_urls,
+            user_agent: user_agent.into(),
+        })
+    }
+
+    pub fn listening_address(mut self, listening_address: SocketAddr) -> Self {
+        self.0.listening_address = listening_address;
+        self
+    }
+
+    pub fn packets_per_node(mut self, packets_per_node: usize) -> Self {
+        self.0.packets_per_node = packets_per_node;
+        self
+    }
+
+    pub fn packet_timeout(mut self, packet_timeout: Duration) -> Self {
+        self.0.packet_timeout = packet_timeout;
+        self
+    }
+
+    pub fn connection_timeout(mut self, connection_timeout: Duration) -> Self {
+        self.0.connection_timeout = connection_timeout;
+        self
+    }
+
+    pub fn delay_between_packets(mut self, delay_between_packets: Duration) -> Self {
+        self.0.delay_between_packets = delay_between_packets;
+        self
+    }
+
+    pub fn tested_nodes_batch_size(mut self, tested_nodes_batch_size: usize) -> Self {
+        self.0.tested_nodes_batch_size = tested_nodes_batch_size;
+        self
+    }
+
+    pub fn testing_interval(mut self, testing_interval: Duration) -> Self {
+        self.0.testing_interval = testing_interval;
+        self
+    }
+
+    pub fn retry_timeout(mut self, retry_timeout: Duration) -> Self {
+        self.0.retry_timeout = retry_timeout;
+        self
+    }
+
+    pub fn nym_api_urls(mut self, nym_api_urls: Vec<Url>) -> Self {
+        self.0.nym_api_urls = nym_api_urls;
+        self
+    }
+
+    pub fn build(self) -> Config {
+        // panics here are fine as those are only ever constructed at the initial setup
+        assert!(
+            !self.0.nym_api_urls.is_empty(),
+            "at least one validator endpoint must be provided",
+        );
+        self.0
+    }
+}

common/verloc/src/measurements/listener.rs

@@ -1,29 +1,29 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::verloc::error::RttError;
-use crate::verloc::packet::{EchoPacket, ReplyPacket};
+use crate::error::VerlocError;
+use crate::measurements::packet::{EchoPacket, ReplyPacket};
 use bytes::{BufMut, BytesMut};
 use futures::StreamExt;
-use log::*;
 use nym_crypto::asymmetric::identity;
 use nym_task::TaskClient;
-use std::fmt::{Display, Formatter};
 use std::net::SocketAddr;
 use std::sync::Arc;
-use std::{fmt, io, process};
+use std::{io, process};
+use thiserror::Error;
 use tokio::io::AsyncWriteExt;
 use tokio::net::{TcpListener, TcpStream};
 use tokio_util::codec::{Decoder, Encoder, Framed};
+use tracing::{debug, error, info, trace, warn};
 
-pub(crate) struct PacketListener {
+pub struct PacketListener {
     address: SocketAddr,
     connection_handler: Arc<ConnectionHandler>,
     shutdown: TaskClient,
 }
 
 impl PacketListener {
-    pub(crate) fn new(
+    pub fn new(
         address: SocketAddr,
         identity: Arc<identity::KeyPair>,
         shutdown: TaskClient,
@@ -37,13 +37,13 @@ impl PacketListener {
 }
 
 impl PacketListener {
-    pub(super) async fn run(self: Arc<Self>) {
+    pub async fn run(self: Arc<Self>) {
         let listener = match TcpListener::bind(self.address).await {
             Ok(listener) => listener,
             Err(err) => {
                 error!(
-                    "Failed to bind to {} - {}. Are you sure nothing else is running on the specified port and your user has sufficient permission to bind to the requested address?",
-                    self.address, err
+                    "Failed to bind to {}: {err}. Are you sure nothing else is running on the specified port and your user has sufficient permission to bind to the requested address?",
+                    self.address
                 );
                 process::exit(1);
             }
@@ -71,7 +71,7 @@ impl PacketListener {
                     }
                 },
                 _ = shutdown_listener.recv() => {
-                    log::trace!("PacketListener: Received shutdown");
+                    trace!("PacketListener: Received shutdown");
                 }
             }
         }
@@ -137,28 +137,18 @@ impl ConnectionHandler {
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Error)]
 enum EchoPacketCodecError {
-    IoError(io::Error),
-    PacketRecoveryError(RttError),
+    #[error("encountered io error {0}")]
+    IoError(#[from] io::Error),
+
+    #[error("failed to correctly decode an echo packet: {0}")]
+    PacketRecoveryError(Box<VerlocError>),
 }
 
-impl Display for EchoPacketCodecError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        match self {
-            EchoPacketCodecError::IoError(err) => write!(f, "encountered io error - {err}"),
-            EchoPacketCodecError::PacketRecoveryError(err) => {
-                write!(f, "failed to correctly decode an echo packet - {err}")
-            }
-        }
-    }
-}
-
-impl std::error::Error for EchoPacketCodecError {}
-
-impl From<io::Error> for EchoPacketCodecError {
-    fn from(err: io::Error) -> Self {
-        EchoPacketCodecError::IoError(err)
+impl From<VerlocError> for EchoPacketCodecError {
+    fn from(value: VerlocError) -> Self {
+        EchoPacketCodecError::PacketRecoveryError(Box::new(value))
     }
 }
 
@@ -188,10 +178,7 @@ impl Decoder for EchoPacketCodec {
 
         let packet_bytes = src.split_to(EchoPacket::SIZE);
 
-        let echo_packet = match EchoPacket::try_from_bytes(&packet_bytes) {
-            Ok(packet) => packet,
-            Err(err) => return Err(EchoPacketCodecError::PacketRecoveryError(err)),
-        };
+        let echo_packet = EchoPacket::try_from_bytes(&packet_bytes)?;
 
         // reserve enough bytes for the next frame
         src.reserve(EchoPacket::SIZE);

common/verloc/src/measurements/measurer.rs

@@ -0,0 +1,225 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::measurements::metrics::SharedVerlocStats;
+use crate::measurements::sender::TestedNode;
+use crate::measurements::{Config, PacketListener, PacketSender};
+use crate::models::VerlocNodeResult;
+use futures::stream::FuturesUnordered;
+use futures::StreamExt;
+use nym_crypto::asymmetric::identity;
+use nym_task::TaskClient;
+use nym_validator_client::models::NymNodeDescription;
+use nym_validator_client::NymApiClient;
+use rand::prelude::SliceRandom;
+use rand::thread_rng;
+use std::net::SocketAddr;
+use std::sync::Arc;
+use tokio::task::JoinHandle;
+use tokio::time::sleep;
+use tracing::{debug, error, info, trace, warn};
+
+pub struct VerlocMeasurer {
+    config: Config,
+    packet_sender: Arc<PacketSender>,
+    packet_listener: Arc<PacketListener>,
+    shutdown_listener: TaskClient,
+    state: SharedVerlocStats,
+}
+
+impl VerlocMeasurer {
+    pub fn new(
+        config: Config,
+        identity: Arc<identity::KeyPair>,
+        shutdown_listener: TaskClient,
+    ) -> Self {
+        VerlocMeasurer {
+            packet_sender: Arc::new(PacketSender::new(
+                Arc::clone(&identity),
+                config.packets_per_node,
+                config.packet_timeout,
+                config.connection_timeout,
+                config.delay_between_packets,
+                shutdown_listener.clone().named("VerlocPacketSender"),
+            )),
+            packet_listener: Arc::new(PacketListener::new(
+                config.listening_address,
+                Arc::clone(&identity),
+                shutdown_listener.clone().named("VerlocPacketListener"),
+            )),
+            shutdown_listener,
+            config,
+            state: SharedVerlocStats::default(),
+        }
+    }
+
+    pub fn set_shared_state(&mut self, state: SharedVerlocStats) {
+        self.state = state;
+    }
+
+    fn start_listening(&self) -> JoinHandle<()> {
+        let packet_listener = Arc::clone(&self.packet_listener);
+        tokio::spawn(packet_listener.run())
+    }
+
+    async fn perform_measurement(&self, nodes_to_test: Vec<TestedNode>) -> MeasurementOutcome {
+        trace!("Performing measurements");
+        if nodes_to_test.is_empty() {
+            debug!("there are no nodes to measure");
+            return MeasurementOutcome::Done;
+        }
+
+        let mut shutdown_listener = self.shutdown_listener.clone().named("VerlocMeasurement");
+        shutdown_listener.disarm();
+
+        for chunk in nodes_to_test.chunks(self.config.tested_nodes_batch_size) {
+            let mut chunk_results = Vec::with_capacity(chunk.len());
+
+            let mut measurement_chunk = chunk
+                .iter()
+                .map(|node| {
+                    let node = *node;
+                    let packet_sender = Arc::clone(&self.packet_sender);
+                    // TODO: there's a potential issue here. if we make the measurement go into separate
+                    // task, we risk biasing results with the bunch of context switches overhead
+                    // but if we don't do it, it will take ages to complete
+
+                    // TODO: check performance difference when it's not spawned as a separate task
+                    tokio::spawn(async move {
+                        (
+                            packet_sender.send_packets_to_node(node).await,
+                            node.identity,
+                        )
+                    })
+                })
+                .collect::<FuturesUnordered<_>>();
+
+            // exhaust the results
+            while !shutdown_listener.is_shutdown() {
+                tokio::select! {
+                    measurement_result = measurement_chunk.next() => {
+                        let Some(result) = measurement_result else {
+                            // if the stream has finished, it means we got everything we could have gotten
+                            break
+                        };
+
+                        // if we receive JoinError it means the task failed to get executed, so either there's a bigger issue with tokio
+                        // or there was a panic inside the task itself. In either case, we should just terminate ourselves.
+                        let Ok(execution_result) = result else {
+                            error!("the verloc measurer has panicked!");
+                            continue
+                        };
+                        let identity = execution_result.1;
+
+                        let measurement_result = match execution_result.0 {
+                            Err(err) => {
+                                debug!("Failed to perform measurement for {identity}: {err}");
+                                None
+                            }
+                            Ok(result) => Some(result),
+                        };
+                        chunk_results.push(VerlocNodeResult::new(identity, measurement_result));
+                    },
+                    _ = shutdown_listener.recv() => {
+                        trace!("Shutdown received while measuring");
+                        return MeasurementOutcome::Shutdown;
+                    }
+                }
+            }
+
+            // update the results vector with chunks as they become available (by default every 50 nodes)
+            self.state.append_measurement_results(chunk_results).await;
+        }
+
+        MeasurementOutcome::Done
+    }
+
+    async fn get_list_of_nodes(&self) -> Option<Vec<NymNodeDescription>> {
+        let mut api_endpoints = self.config.nym_api_urls.clone();
+        api_endpoints.shuffle(&mut thread_rng());
+        for api_endpoint in api_endpoints {
+            let client = NymApiClient::new_with_user_agent(
+                api_endpoint.clone(),
+                self.config.user_agent.clone(),
+            );
+            match client.get_all_described_nodes().await {
+                Ok(res) => return Some(res),
+                Err(err) => {
+                    warn!("failed to get described nodes from {api_endpoint}: {err}")
+                }
+            }
+        }
+        None
+    }
+
+    pub async fn run(&mut self) {
+        self.start_listening();
+
+        while !self.shutdown_listener.is_shutdown() {
+            info!("Starting verloc measurements");
+            // TODO: should we also measure gateways?
+
+            let Some(all_nodes) = self.get_list_of_nodes().await else {
+                error!("failed to obtain list of all nodes from any available api endpoint");
+                sleep(self.config.retry_timeout).await;
+                continue;
+            };
+
+            if all_nodes.is_empty() {
+                warn!("it does not seem there are any nodes to measure...");
+                sleep(self.config.retry_timeout).await;
+                continue;
+            }
+
+            // we only care about address and identity
+            let tested_nodes = all_nodes
+                .into_iter()
+                .filter_map(|node| {
+                    // try to parse the identity and host
+                    let node_identity = node.ed25519_identity_key();
+
+                    let ip = node.description.host_information.ip_address.first()?;
+                    let verloc_port = node.description.verloc_port();
+                    let verloc_host = SocketAddr::new(*ip, verloc_port);
+
+                    // 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
+                    // However, maybe it's not a problem as if they are misconfigured, they will eventually be
+                    // pushed out of the network and on top of that, verloc is done in separate task that runs
+                    // only every few hours.
+                    Some(TestedNode::new(verloc_host, node_identity))
+                })
+                .collect::<Vec<_>>();
+
+            // on start of each run remove old results
+            self.state.start_new_measurements(tested_nodes.len()).await;
+
+            if let MeasurementOutcome::Shutdown = self.perform_measurement(tested_nodes).await {
+                trace!("Shutting down after aborting measurements");
+                break;
+            }
+
+            // write current time to "run finished" field
+            self.state.finish_measurements().await;
+
+            info!(
+                "Finished performing verloc measurements. The next one will happen in {:?}",
+                self.config.testing_interval
+            );
+
+            tokio::select! {
+                _ = sleep(self.config.testing_interval) => {},
+                _ = self.shutdown_listener.recv() => {
+                    trace!("Shutdown received while sleeping");
+                }
+            }
+        }
+
+        trace!("Verloc: Exiting");
+    }
+}
+
+enum MeasurementOutcome {
+    Done,
+    Shutdown,
+}

common/verloc/src/measurements/metrics.rs

@@ -0,0 +1,50 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::models::{VerlocNodeResult, VerlocResultData};
+use std::mem;
+use std::sync::Arc;
+use time::OffsetDateTime;
+use tokio::sync::{RwLock, RwLockReadGuard, RwLockWriteGuard};
+
+#[derive(Clone, Debug, Default)]
+pub struct SharedVerlocStats {
+    inner: Arc<RwLock<VerlocStatsState>>,
+}
+
+impl SharedVerlocStats {
+    pub(crate) async fn start_new_measurements(&self, nodes_to_test: usize) {
+        let mut guard = self.write().await;
+        guard.previous_run_data = mem::take(&mut guard.current_run_data);
+        guard.current_run_data.nodes_tested = nodes_to_test;
+    }
+
+    pub(crate) async fn append_measurement_results(&self, mut new_data: Vec<VerlocNodeResult>) {
+        let mut write_permit = self.write().await;
+        write_permit.current_run_data.results.append(&mut new_data);
+        // make sure the data always stays in order.
+        // TODO: considering the front of the results is guaranteed to be sorted, should perhaps
+        // a non-default sorting algorithm be used?
+        write_permit.current_run_data.results.sort()
+    }
+
+    pub(crate) async fn finish_measurements(&self) {
+        self.write().await.current_run_data.run_finished = Some(OffsetDateTime::now_utc())
+    }
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct VerlocStatsState {
+    pub current_run_data: VerlocResultData,
+    pub previous_run_data: VerlocResultData,
+}
+
+impl SharedVerlocStats {
+    pub async fn read(&self) -> RwLockReadGuard<'_, VerlocStatsState> {
+        self.inner.read().await
+    }
+
+    pub async fn write(&self) -> RwLockWriteGuard<'_, VerlocStatsState> {
+        self.inner.write().await
+    }
+}

common/verloc/src/measurements/mod.rs

@@ -0,0 +1,16 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+pub mod config;
+pub mod listener;
+pub mod measurer;
+pub mod metrics;
+pub mod packet;
+pub mod sender;
+
+pub use config::{Config, ConfigBuilder};
+pub use listener::PacketListener;
+pub use measurer::VerlocMeasurer;
+pub use metrics::{SharedVerlocStats, VerlocStatsState};
+pub use packet::{EchoPacket, ReplyPacket};
+pub use sender::PacketSender;

common/verloc/src/measurements/packet.rs

@@ -1,20 +1,20 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::verloc::error::RttError;
-use nym_crypto::asymmetric::identity::{self, PUBLIC_KEY_LENGTH, SIGNATURE_LENGTH};
+use crate::error::VerlocError;
+use nym_crypto::asymmetric::ed25519::{self, PUBLIC_KEY_LENGTH, SIGNATURE_LENGTH};
 
-pub(crate) struct EchoPacket {
+pub struct EchoPacket {
     sequence_number: u64,
-    sender: identity::PublicKey,
+    sender: ed25519::PublicKey,
 
-    signature: identity::Signature,
+    signature: ed25519::Signature,
 }
 
 impl EchoPacket {
     pub(crate) const SIZE: usize = 8 + PUBLIC_KEY_LENGTH + SIGNATURE_LENGTH;
 
-    pub(crate) fn new(sequence_number: u64, keys: &identity::KeyPair) -> Self {
+    pub(crate) fn new(sequence_number: u64, keys: &ed25519::KeyPair) -> Self {
         let bytes_to_sign = sequence_number
             .to_be_bytes()
             .iter()
@@ -42,20 +42,22 @@ impl EchoPacket {
             .collect()
     }
 
-    pub(crate) fn try_from_bytes(bytes: &[u8]) -> Result<Self, RttError> {
+    pub(crate) fn try_from_bytes(bytes: &[u8]) -> Result<Self, VerlocError> {
         if bytes.len() != Self::SIZE {
-            return Err(RttError::UnexpectedEchoPacketSize);
+            return Err(VerlocError::UnexpectedEchoPacketSize);
         }
 
+        // SAFETY: we have ensured our packet has correct size
+        #[allow(clippy::unwrap_used)]
         let sequence_number = u64::from_be_bytes(bytes[..8].try_into().unwrap());
-        let sender = identity::PublicKey::from_bytes(&bytes[8..8 + PUBLIC_KEY_LENGTH])
-            .map_err(|_| RttError::MalformedSenderIdentity)?;
-        let signature = identity::Signature::from_bytes(&bytes[8 + PUBLIC_KEY_LENGTH..])
-            .map_err(|_| RttError::MalformedEchoSignature)?;
+        let sender = ed25519::PublicKey::from_bytes(&bytes[8..8 + PUBLIC_KEY_LENGTH])
+            .map_err(|_| VerlocError::MalformedSenderIdentity)?;
+        let signature = ed25519::Signature::from_bytes(&bytes[8 + PUBLIC_KEY_LENGTH..])
+            .map_err(|_| VerlocError::MalformedEchoSignature)?;
 
         sender
             .verify(&bytes[..Self::SIZE - SIGNATURE_LENGTH], &signature)
-            .map_err(|_| RttError::InvalidEchoSignature)?;
+            .map_err(|_| VerlocError::InvalidEchoSignature)?;
 
         Ok(EchoPacket {
             sequence_number,
@@ -64,7 +66,7 @@ impl EchoPacket {
         })
     }
 
-    pub(crate) fn construct_reply(self, private_key: &identity::PrivateKey) -> ReplyPacket {
+    pub(crate) fn construct_reply(self, private_key: &ed25519::PrivateKey) -> ReplyPacket {
         let bytes = self.to_bytes();
         let signature = private_key.sign(bytes);
         ReplyPacket {
@@ -74,9 +76,9 @@ impl EchoPacket {
     }
 }
 
-pub(crate) struct ReplyPacket {
+pub struct ReplyPacket {
     base_packet: EchoPacket,
-    signature: identity::Signature,
+    signature: ed25519::Signature,
 }
 
 impl ReplyPacket {
@@ -96,21 +98,21 @@ impl ReplyPacket {
 
     pub(crate) fn try_from_bytes(
         bytes: &[u8],
-        remote_identity: &identity::PublicKey,
-    ) -> Result<Self, RttError> {
+        remote_ed25519: &ed25519::PublicKey,
+    ) -> Result<Self, VerlocError> {
         if bytes.len() != Self::SIZE {
-            return Err(RttError::UnexpectedReplyPacketSize);
+            return Err(VerlocError::UnexpectedReplyPacketSize);
         }
 
         let base_packet =
             EchoPacket::try_from_bytes(&bytes[..8 + PUBLIC_KEY_LENGTH + SIGNATURE_LENGTH])?;
         let signature =
-            identity::Signature::from_bytes(&bytes[8 + PUBLIC_KEY_LENGTH + SIGNATURE_LENGTH..])
-                .map_err(|_| RttError::MalformedReplySignature)?;
+            ed25519::Signature::from_bytes(&bytes[8 + PUBLIC_KEY_LENGTH + SIGNATURE_LENGTH..])
+                .map_err(|_| VerlocError::MalformedReplySignature)?;
 
-        remote_identity
+        remote_ed25519
             .verify(&bytes[..Self::SIZE - SIGNATURE_LENGTH], &signature)
-            .map_err(|_| RttError::InvalidReplySignature)?;
+            .map_err(|_| VerlocError::InvalidReplySignature)?;
 
         Ok(ReplyPacket {
             base_packet,

common/verloc/src/measurements/sender.rs

@@ -1,11 +1,10 @@
 // Copyright 2021-2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::verloc::error::RttError;
-use crate::verloc::packet::{EchoPacket, ReplyPacket};
-use log::*;
-use nym_crypto::asymmetric::identity;
-use nym_node_http_api::state::metrics::VerlocMeasurement;
+use crate::error::VerlocError;
+use crate::measurements::packet::{EchoPacket, ReplyPacket};
+use crate::models::VerlocMeasurement;
+use nym_crypto::asymmetric::ed25519;
 use nym_task::TaskClient;
 use rand::{thread_rng, Rng};
 use std::net::SocketAddr;
@@ -15,15 +14,16 @@ use std::{fmt, io};
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use tokio::net::TcpStream;
 use tokio::time::sleep;
+use tracing::{debug, trace};
 
 #[derive(Copy, Clone)]
 pub(crate) struct TestedNode {
     pub(crate) address: SocketAddr,
-    pub(crate) identity: identity::PublicKey,
+    pub(crate) identity: ed25519::PublicKey,
 }
 
 impl TestedNode {
-    pub(crate) fn new(address: SocketAddr, identity: identity::PublicKey) -> Self {
+    pub(crate) fn new(address: SocketAddr, identity: ed25519::PublicKey) -> Self {
         TestedNode { address, identity }
     }
 }
@@ -38,8 +38,8 @@ impl fmt::Display for TestedNode {
     }
 }
 
-pub(crate) struct PacketSender {
-    identity: Arc<identity::KeyPair>,
+pub struct PacketSender {
+    identity: Arc<ed25519::KeyPair>,
     // timeout for receiving before sending new one
     packets_per_node: usize,
     packet_timeout: Duration,
@@ -49,8 +49,8 @@ pub(crate) struct PacketSender {
 }
 
 impl PacketSender {
-    pub(super) fn new(
-        identity: Arc<identity::KeyPair>,
+    pub fn new(
+        identity: Arc<ed25519::KeyPair>,
         packets_per_node: usize,
         packet_timeout: Duration,
         connection_timeout: Duration,
@@ -82,7 +82,7 @@ impl PacketSender {
     pub(super) async fn send_packets_to_node(
         self: Arc<Self>,
         tested_node: TestedNode,
-    ) -> Result<VerlocMeasurement, RttError> {
+    ) -> Result<VerlocMeasurement, VerlocError> {
         let mut shutdown_listener = self.shutdown_listener.fork(tested_node.address.to_string());
         shutdown_listener.disarm();
 
@@ -93,16 +93,18 @@ impl PacketSender {
         .await
         {
             Err(_timeout) => {
-                return Err(RttError::UnreachableNode(
-                    tested_node.identity.to_base58_string(),
-                    io::ErrorKind::TimedOut.into(),
-                ))
+                return Err(VerlocError::UnreachableNode {
+                    identity: tested_node.identity.to_string(),
+                    err: io::ErrorKind::TimedOut.into(),
+                    address: tested_node.address,
+                })
             }
             Ok(Err(err)) => {
-                return Err(RttError::UnreachableNode(
-                    tested_node.identity.to_base58_string(),
+                return Err(VerlocError::UnreachableNode {
+                    identity: tested_node.identity.to_string(),
                     err,
-                ))
+                    address: tested_node.address,
+                })
             }
             Ok(Ok(conn)) => conn,
         };
@@ -121,33 +123,34 @@ impl PacketSender {
                 write = tokio::time::timeout(self.packet_timeout, conn.write_all(packet_bytes.as_ref())) => {
                     match write {
                         Err(_timeout) => {
-                            let identity_string = tested_node.identity.to_base58_string();
+                            let identity = tested_node.identity;
                             debug!(
-                                "failed to write echo packet to {} within {:?}. Stopping the test.",
-                                identity_string, self.packet_timeout
+                                "failed to write echo packet to {identity} within {:?}. Stopping the test.",
+                                self.packet_timeout
                             );
-                            return Err(RttError::UnexpectedConnectionFailureWrite(
-                                identity_string,
-                                io::ErrorKind::TimedOut.into(),
-                            ));
+                            return Err(VerlocError::UnexpectedConnectionFailureWrite{
+                                identity: identity.to_string(),
+                                err:io::ErrorKind::TimedOut.into(),
+                                address: tested_node.address
+                            });
                         }
                         Ok(Err(err)) => {
-                            let identity_string = tested_node.identity.to_base58_string();
+                            let identity = tested_node.identity;
                             debug!(
-                                "failed to write echo packet to {} - {}. Stopping the test.",
-                                identity_string, err
+                                "failed to write echo packet to {identity}: {err}. Stopping the test.",
                             );
-                            return Err(RttError::UnexpectedConnectionFailureWrite(
-                                identity_string,
+                            return Err(VerlocError::UnexpectedConnectionFailureWrite{
+                                identity: identity.to_string(),
                                 err,
-                            ));
+                                address: tested_node.address
+                            });
                         }
                         Ok(Ok(_)) => {}
                         }
                 },
                 _ = shutdown_listener.recv() => {
-                    log::trace!("PacketSender: Received shutdown while sending");
-                    return Err(RttError::ShutdownReceived);
+                    trace!("PacketSender: Received shutdown while sending");
+                    return Err(VerlocError::ShutdownReceived);
                 },
             }
 
@@ -156,15 +159,15 @@ impl PacketSender {
             let reply_packet_future = async {
                 let mut buf = [0u8; ReplyPacket::SIZE];
                 if let Err(err) = conn.read_exact(&mut buf).await {
+                    let identity = tested_node.identity;
                     debug!(
-                        "failed to read reply packet from {} - {}. Stopping the test.",
-                        tested_node.identity.to_base58_string(),
-                        err
+                        "failed to read reply packet from {identity}: {err}. Stopping the test.",
                     );
-                    return Err(RttError::UnexpectedConnectionFailureRead(
-                        tested_node.identity.to_base58_string(),
+                    return Err(VerlocError::UnexpectedConnectionFailureRead {
+                        identity: identity.to_string(),
                         err,
-                    ));
+                        address: tested_node.address,
+                    });
                 }
                 ReplyPacket::try_from_bytes(&buf, &tested_node.identity)
             };
@@ -180,15 +183,16 @@ impl PacketSender {
                                 "failed to receive reply to our echo packet within {:?}. Stopping the test",
                                 self.packet_timeout
                             );
-                            return Err(RttError::ConnectionReadTimeout(
-                                tested_node.identity.to_base58_string(),
-                            ));
+                            return Err(VerlocError::ConnectionReadTimeout{
+                                identity: tested_node.identity.to_string(),
+                                address: tested_node.address
+                            });
                         }
                     }
                 },
                 _ = shutdown_listener.recv() => {
-                    log::trace!("PacketSender: Received shutdown while waiting for reply");
-                    return Err(RttError::ShutdownReceived);
+                    trace!("PacketSender: Received shutdown while waiting for reply");
+                    return Err(VerlocError::ShutdownReceived);
                 }
             };
 
@@ -198,7 +202,7 @@ impl PacketSender {
             // we have received the previous one
             if reply_packet.base_sequence_number() != seq {
                 debug!("Received reply packet with invalid sequence number! Got {} expected {}. Stopping the test", reply_packet.base_sequence_number(), seq);
-                return Err(RttError::UnexpectedReplySequence);
+                return Err(VerlocError::UnexpectedReplySequence);
             }
 
             let time_taken = tokio::time::Instant::now().duration_since(start);

common/verloc/src/models.rs

@@ -0,0 +1,225 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use nym_crypto::asymmetric::ed25519::{self};
+use std::cmp::Ordering;
+use std::fmt;
+use std::fmt::{Display, Formatter};
+use std::time::Duration;
+use time::OffsetDateTime;
+
+#[derive(Debug, Clone)]
+pub struct VerlocResultData {
+    pub nodes_tested: usize,
+
+    pub run_started: OffsetDateTime,
+
+    pub run_finished: Option<OffsetDateTime>,
+
+    pub results: Vec<VerlocNodeResult>,
+}
+
+impl Default for VerlocResultData {
+    fn default() -> Self {
+        VerlocResultData {
+            nodes_tested: 0,
+            run_started: OffsetDateTime::now_utc(),
+            run_finished: None,
+            results: vec![],
+        }
+    }
+}
+
+impl VerlocResultData {
+    pub fn run_finished(&self) -> bool {
+        self.run_finished.is_some()
+    }
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+pub struct VerlocNodeResult {
+    pub node_identity: ed25519::PublicKey,
+
+    pub latest_measurement: Option<VerlocMeasurement>,
+}
+
+impl VerlocNodeResult {
+    pub fn new(
+        node_identity: ed25519::PublicKey,
+        latest_measurement: Option<VerlocMeasurement>,
+    ) -> Self {
+        VerlocNodeResult {
+            node_identity,
+            latest_measurement,
+        }
+    }
+}
+
+impl PartialOrd for VerlocNodeResult {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for VerlocNodeResult {
+    fn cmp(&self, other: &Self) -> Ordering {
+        // if both have measurement, compare measurements
+        // then if only one have measurement, prefer that one
+        // completely ignore identity as it makes no sense to order by it
+        if let Some(self_measurement) = &self.latest_measurement {
+            if let Some(other_measurement) = &other.latest_measurement {
+                self_measurement.cmp(other_measurement)
+            } else {
+                Ordering::Less
+            }
+        } else if other.latest_measurement.is_some() {
+            Ordering::Greater
+        } else {
+            Ordering::Equal
+        }
+    }
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct VerlocMeasurement {
+    /// Minimum RTT duration it took to receive an echo packet.
+    pub minimum: Duration,
+
+    /// Average RTT duration it took to receive the echo packets.
+    pub mean: Duration,
+
+    /// Maximum RTT duration it took to receive an echo packet.
+    pub maximum: Duration,
+
+    /// The standard deviation of the RTT duration it took to receive the echo packets.
+    pub standard_deviation: Duration,
+}
+
+impl VerlocMeasurement {
+    pub fn new(raw_results: &[Duration]) -> Self {
+        let minimum = raw_results.iter().min().copied().unwrap_or_default();
+        let maximum = raw_results.iter().max().copied().unwrap_or_default();
+
+        let mean = Self::duration_mean(raw_results);
+        let standard_deviation = Self::duration_standard_deviation(raw_results, mean);
+
+        VerlocMeasurement {
+            minimum,
+            mean,
+            maximum,
+            standard_deviation,
+        }
+    }
+
+    fn duration_mean(data: &[Duration]) -> Duration {
+        if data.is_empty() {
+            return Default::default();
+        }
+
+        let sum = data.iter().sum::<Duration>();
+        let count = data.len() as u32;
+
+        sum / count
+    }
+
+    fn duration_standard_deviation(data: &[Duration], mean: Duration) -> Duration {
+        if data.is_empty() {
+            return Default::default();
+        }
+
+        let variance_micros = data
+            .iter()
+            .map(|&value| {
+                // make sure we don't underflow
+                let diff = if mean > value {
+                    mean - value
+                } else {
+                    value - mean
+                };
+                // we don't need nanos precision
+                let diff_micros = diff.as_micros();
+                diff_micros * diff_micros
+            })
+            .sum::<u128>()
+            / data.len() as u128;
+
+        // we shouldn't really overflow as our differences shouldn't be larger than couple seconds at the worst possible case scenario
+        let std_deviation_micros = (variance_micros as f64).sqrt() as u64;
+        Duration::from_micros(std_deviation_micros)
+    }
+}
+
+impl Display for VerlocMeasurement {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "rtt min/avg/max/mdev = {} / {} / {} / {}",
+            humantime::format_duration(self.minimum),
+            humantime::format_duration(self.mean),
+            humantime::format_duration(self.maximum),
+            humantime::format_duration(self.standard_deviation)
+        )
+    }
+}
+
+impl PartialOrd for VerlocMeasurement {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for VerlocMeasurement {
+    fn cmp(&self, other: &Self) -> Ordering {
+        // minimum value is most important, then look at standard deviation, then mean and finally maximum
+        let min_cmp = self.minimum.cmp(&other.minimum);
+        if min_cmp != Ordering::Equal {
+            return min_cmp;
+        }
+        let std_dev_cmp = self.standard_deviation.cmp(&other.standard_deviation);
+        if std_dev_cmp != Ordering::Equal {
+            return std_dev_cmp;
+        }
+        let std_dev_cmp = self.mean.cmp(&other.mean);
+        if std_dev_cmp != Ordering::Equal {
+            return std_dev_cmp;
+        }
+        self.maximum.cmp(&other.maximum)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn sorting_vec_of_verlocs() {
+        let some_identity =
+            ed25519::PublicKey::from_base58_string("Be9wH7xuXBRJAuV1pC7MALZv6a61RvWQ3SypsNarqTt")
+                .unwrap();
+        let no_measurement = VerlocNodeResult::new(some_identity, None);
+        let low_min = VerlocNodeResult::new(
+            some_identity,
+            Some(VerlocMeasurement {
+                minimum: Duration::from_millis(42),
+                mean: Duration::from_millis(43),
+                maximum: Duration::from_millis(44),
+                standard_deviation: Duration::from_millis(45),
+            }),
+        );
+        let higher_min = VerlocNodeResult::new(
+            some_identity,
+            Some(VerlocMeasurement {
+                minimum: Duration::from_millis(420),
+                mean: Duration::from_millis(430),
+                maximum: Duration::from_millis(440),
+                standard_deviation: Duration::from_millis(450),
+            }),
+        );
+
+        let mut vec_verloc = vec![no_measurement, low_min, no_measurement, higher_min];
+        vec_verloc.sort();
+
+        let expected_sorted = vec![low_min, higher_min, no_measurement, no_measurement];
+        assert_eq!(expected_sorted, vec_verloc);
+    }
+}

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

@@ -68,9 +68,9 @@ pub async fn current_network_topology_async(
 
     let api_client = NymApiClient::new(url);
     let mixnodes = api_client
-        .get_all_basic_active_mixing_assigned_nodes()
+        .get_all_basic_active_mixing_assigned_nodes(None)
         .await?;
-    let gateways = api_client.get_all_basic_entry_assigned_nodes().await?;
+    let gateways = api_client.get_all_basic_entry_assigned_nodes(None).await?;
 
     Ok(NymTopology::from_basic(&mixnodes, &gateways).into())
 }

common/wireguard/Cargo.toml

@@ -27,6 +27,7 @@ thiserror = { workspace = true }
 tokio = { workspace = true, features = ["rt-multi-thread", "net", "io-util"] }
 tokio-stream = { workspace = true }
 time = { workspace = true }
+tracing = { workspace = true }
 
 nym-authenticator-requests = { path = "../authenticator-requests" }
 nym-credential-verification = { path = "../credential-verification" }

common/wireguard/src/error.rs

@@ -16,7 +16,7 @@ pub enum Error {
     MissingClientBandwidthEntry,
 
     #[error("{0}")]
-    GatewayStorage(#[from] nym_gateway_storage::error::StorageError),
+    GatewayStorage(#[from] nym_gateway_storage::error::GatewayStorageError),
 
     #[error("{0}")]
     SystemTime(#[from] std::time::SystemTimeError),

common/wireguard/src/lib.rs

@@ -7,16 +7,18 @@
 // #![warn(clippy::unwrap_used)]
 
 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};
 
+#[cfg(target_os = "linux")]
+use defguard_wireguard_rs::{host::Peer, key::Key, net::IpAddrMask};
+
+#[cfg(target_os = "linux")]
+use nym_network_defaults::constants::WG_TUN_BASE_NAME;
+
 pub(crate) mod error;
 pub mod peer_controller;
 pub mod peer_handle;
@@ -81,8 +83,8 @@ pub struct WireguardData {
 
 /// Start wireguard device
 #[cfg(target_os = "linux")]
-pub async fn start_wireguard<St: nym_gateway_storage::Storage + Clone + 'static>(
-    storage: St,
+pub async fn start_wireguard(
+    storage: nym_gateway_storage::GatewayStorage,
     all_peers: Vec<nym_gateway_storage::models::WireguardPeer>,
     task_client: nym_task::TaskClient,
     wireguard_data: WireguardData,
@@ -93,6 +95,7 @@ pub async fn start_wireguard<St: nym_gateway_storage::Storage + Clone + 'static>
     use peer_controller::PeerController;
     use std::collections::HashMap;
     use tokio::sync::RwLock;
+    use tracing::info;
 
     let ifname = String::from(WG_TUN_BASE_NAME);
     let wg_api = defguard_wireguard_rs::WGApi::new(ifname.clone(), false)?;
@@ -121,6 +124,7 @@ pub async fn start_wireguard<St: nym_gateway_storage::Storage + Clone + 'static>
             .await?;
         peer_bandwidth_managers.insert(peer.public_key.clone(), (bandwidth_manager, peer.clone()));
     }
+
     wg_api.create_interface()?;
     let interface_config = InterfaceConfiguration {
         name: ifname.clone(),
@@ -130,6 +134,11 @@ pub async fn start_wireguard<St: nym_gateway_storage::Storage + Clone + 'static>
         peers,
         mtu: None,
     };
+    info!(
+        "attempting to configure wireguard interface '{ifname}': address={}, port={}",
+        interface_config.address, interface_config.port
+    );
+
     wg_api.configure_interface(&interface_config)?;
     std::process::Command::new("ip")
         .args([

common/wireguard/src/peer_controller.rs

@@ -7,6 +7,7 @@ use defguard_wireguard_rs::{
     WireguardInterfaceApi,
 };
 use futures::channel::oneshot;
+use log::info;
 use nym_authenticator_requests::latest::registration::{
     RemainingBandwidthData, BANDWIDTH_CAP_PER_DAY,
 };
@@ -14,7 +15,7 @@ use nym_credential_verification::{
     bandwidth_storage_manager::BandwidthStorageManager, BandwidthFlushingBehaviourConfig,
     ClientBandwidth,
 };
-use nym_gateway_storage::Storage;
+use nym_gateway_storage::GatewayStorage;
 use nym_wireguard_types::DEFAULT_PEER_TIMEOUT_CHECK;
 use std::{collections::HashMap, sync::Arc};
 use tokio::sync::{mpsc, RwLock};
@@ -62,24 +63,24 @@ pub struct QueryBandwidthControlResponse {
     pub bandwidth_data: Option<RemainingBandwidthData>,
 }
 
-pub struct PeerController<St: Storage + Clone + 'static> {
-    storage: St,
+pub struct PeerController {
+    storage: GatewayStorage,
     // used to receive commands from individual handles too
     request_tx: mpsc::Sender<PeerControlRequest>,
     request_rx: mpsc::Receiver<PeerControlRequest>,
     wg_api: Arc<WgApiWrapper>,
     host_information: Arc<RwLock<Host>>,
-    bw_storage_managers: HashMap<Key, Option<SharedBandwidthStorageManager<St>>>,
+    bw_storage_managers: HashMap<Key, Option<SharedBandwidthStorageManager>>,
     timeout_check_interval: IntervalStream,
     task_client: nym_task::TaskClient,
 }
 
-impl<St: Storage + Clone + 'static> PeerController<St> {
+impl PeerController {
     pub fn new(
-        storage: St,
+        storage: GatewayStorage,
         wg_api: Arc<WgApiWrapper>,
         initial_host_information: Host,
-        bw_storage_managers: HashMap<Key, (Option<SharedBandwidthStorageManager<St>>, Peer)>,
+        bw_storage_managers: HashMap<Key, (Option<SharedBandwidthStorageManager>, Peer)>,
         request_tx: mpsc::Sender<PeerControlRequest>,
         request_rx: mpsc::Receiver<PeerControlRequest>,
         task_client: nym_task::TaskClient,
@@ -158,9 +159,9 @@ impl<St: Storage + Clone + 'static> PeerController<St> {
     }
 
     pub async fn generate_bandwidth_manager(
-        storage: St,
+        storage: GatewayStorage,
         public_key: &Key,
-    ) -> Result<Option<BandwidthStorageManager<St>>, Error> {
+    ) -> Result<Option<BandwidthStorageManager>, Error> {
         if let Some(client_id) = storage
             .get_wireguard_peer(&public_key.to_string())
             .await?
@@ -257,6 +258,7 @@ impl<St: Storage + Clone + 'static> PeerController<St> {
     }
 
     pub async fn run(&mut self) {
+        info!("started wireguard peer controller");
         loop {
             tokio::select! {
                 _ = self.timeout_check_interval.next() => {