Add query message wrapper

.github/workflows/ci-build.yml

@@ -34,7 +34,6 @@ 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/ci-contracts-schema.yml

@@ -11,7 +11,7 @@ on:
 jobs:
   check-schema:
     name: Generate and check schema
-    runs-on: ubuntu-20.04
+    runs-on: arc-ubuntu-20.04
     env:
       CARGO_TERM_COLOR: always
     steps:

.github/workflows/ci-contracts.yml

@@ -13,7 +13,7 @@ on:
 
 jobs:
   matrix_prep:
-    runs-on: ubuntu-20.04
+    runs-on: arc-ubuntu-20.04
     outputs:
       matrix: ${{ steps.set-matrix.outputs.matrix }}
     steps:

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

@@ -55,7 +55,6 @@ jobs:
         uses: actions-rs/toolchain@v1
         with:
           toolchain: stable
-          override: true
 
       - name: Build all binaries
         uses: actions-rs/cargo@v1

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

@@ -14,14 +14,13 @@ jobs:
       - name: Install Rust stable
         uses: actions-rs/toolchain@v1
         with:
-          toolchain: 1.77
+          toolchain: stable
           target: wasm32-unknown-unknown
           override: true
+          components: rustfmt, clippy
 
       - name: Install wasm-opt
-        uses: ./.github/actions/install-wasm-opt
-        with:
-          version: '114'
+        run: cargo install --version 0.114.0 wasm-opt
 
       - name: Build release contracts
         run: make contracts

.github/workflows/push-credential-proxy.yaml

@@ -26,7 +26,7 @@ jobs:
           git config --global user.name "Lawrence Stalder"
 
       - name: Get version from cargo.toml
-        uses: mikefarah/yq@v4.44.6
+        uses: mikefarah/yq@v4.44.3
         id: get_version
         with:
           cmd: yq -oy '.package.version' ${{ env.WORKING_DIRECTORY }}/nym-credential-proxy/Cargo.toml

.github/workflows/push-data-observatory.yaml

@@ -26,7 +26,7 @@ jobs:
           git config --global user.name "Lawrence Stalder"
 
       - name: Get version from cargo.toml
-        uses: mikefarah/yq@v4.44.6
+        uses: mikefarah/yq@v4.44.3
         id: get_version
         with:
           cmd: yq -oy '.package.version' ${{ env.WORKING_DIRECTORY }}/Cargo.toml

.github/workflows/push-network-monitor.yaml

@@ -25,27 +25,31 @@ jobs:
           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.6
+      - name: Get version from package.json
+        uses: sergeysova/jq-action@v2
         id: get_version
         with:
-          cmd: yq -oy '.package.version' ${{ env.WORKING_DIRECTORY }}/nym-network-monitor/Cargo.toml
-          
+          cmd: jq -r '.version' ${{ env.WORKING_DIRECTORY }}/package.json
+
+      - 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: |
-          echo "Checking if tag ${{ env.CONTAINER_NAME }}-${{ steps.get_version.outputs.result }} exists..."
-          if git rev-parse ${{ env.CONTAINER_NAME }}-${{ steps.get_version.outputs.result }} >/dev/null 2>&1; then
-            echo "Tag ${{ env.CONTAINER_NAME }}-${{ steps.get_version.outputs.result }} already exists"
-            git push --delete origin ${{ env.CONTAINER_NAME }}-${{ steps.get_version.outputs.result }}
-            git tag -d ${{ env.CONTAINER_NAME }}-${{ steps.get_version.outputs.result }}
+          if git rev-parse ${{ steps.get_version.outputs.value }} >/dev/null 2>&1; then
+            git push --delete origin ${{ steps.get_version.outputs.value }}
+            git tag -d ${{ steps.get_version.outputs.value }}
           fi
 
       - name: Create tag
         run: |
-          git tag -a ${{ env.CONTAINER_NAME }}-${{ steps.get_version.outputs.result }} -m "Version ${{ steps.get_version.outputs.result }}"
-          git push origin ${{ env.CONTAINER_NAME }}-${{ steps.get_version.outputs.result }}
-          
+          git tag -a ${{ steps.get_version.outputs.value }} -m "Version ${{ steps.get_version.outputs.value }}"
+          git push origin ${{ steps.get_version.outputs.value }}
+
       - name: BuildAndPushImageOnHarbor
         run: |
-          docker build -f nym-network-monitor.dockerfile ${{ env.WORKING_DIRECTORY }} -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
+          docker build -f nym-network-monitor.dockerfile ${{ env.WORKING_DIRECTORY }} -t harbor.nymte.ch/nym/${{ env.CONTAINER_NAME }}:${{ steps.get_version.outputs.value }} -t harbor.nymte.ch/nym/${{ env.CONTAINER_NAME }}:latest
+          docker push harbor.nymte.ch/nym/${{ env.CONTAINER_NAME }} --all-tags

.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-api/nym-node-status-agent"
+  WORKING_DIRECTORY: "nym-node-status-agent"
   CONTAINER_NAME: "node-status-agent"
 
 jobs:
@@ -31,7 +31,7 @@ jobs:
           git config --global user.name "Lawrence Stalder"
 
       - name: Get version from cargo.toml
-        uses: mikefarah/yq@v4.44.6
+        uses: mikefarah/yq@v4.44.3
         id: get_version
         with:
           cmd: yq -oy '.package.version' ${{ env.WORKING_DIRECTORY }}/Cargo.toml

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

@@ -3,7 +3,7 @@ on:
   workflow_dispatch:
 
 env:
-  WORKING_DIRECTORY: "nym-node-status-api/nym-node-status-api"
+  WORKING_DIRECTORY: "nym-node-status-api"
   CONTAINER_NAME: "node-status-api"
 
 jobs:
@@ -26,7 +26,7 @@ jobs:
           git config --global user.name "Lawrence Stalder"
 
       - name: Get version from cargo.toml
-        uses: mikefarah/yq@v4.44.6
+        uses: mikefarah/yq@v4.44.3
         id: get_version
         with:
           cmd: yq -oy '.package.version' ${{ env.WORKING_DIRECTORY }}/Cargo.toml

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

@@ -26,7 +26,7 @@ jobs:
           git config --global user.name "Lawrence Stalder"
 
       - name: Get version from cargo.toml
-        uses: mikefarah/yq@v4.44.6
+        uses: mikefarah/yq@v4.44.3
         id: get_version
         with:
           cmd: yq -oy '.package.version' ${{ env.WORKING_DIRECTORY }}/Cargo.toml

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

@@ -1,55 +0,0 @@
-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.6
-        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

@@ -26,10 +26,10 @@ jobs:
           git config --global user.name "Lawrence Stalder"
 
       - name: Get version from cargo.toml
-        uses: mikefarah/yq@v4.44.6
+        uses: mikefarah/yq@v4.44.3
         id: get_version
         with:
-          cmd: yq -oy '.package.version' ${{ env.WORKING_DIRECTORY }}/Cargo.toml
+          cmd: yq -oy '.package.version' ${{ env.WORKING_DIRECTORY }}/nym-credential-proxy/Cargo.toml
 
       - name: Remove existing tag if exists
         run: |

CHANGELOG.md

@@ -4,208 +4,6 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://
 
 ## [Unreleased]
 
-## [2024.13-magura-drift] (2024-11-29)
-
-- Optimised syncing bandwidth information to storage
-
-## [2024.13-magura-patched] (2024-11-22)
-
-- [experimental] allow clients to change between deterministic route selection based on packet headers and a pseudorandom distribution
-- Introduced a configurable limit on retransmission frequency of packets if ACKs are not received
-- Filtered out invalid IP addresses on nym-api
-
-## [2024.13-magura] (2024-11-18)
-
-- Limit race probability ([#5145])
-- bugifx: assign 'node_id' when converting from 'GatewayDetails' to 'TestNode' ([#5143])
-- bugfix: make sure to assign correct node_id and identity during 'gateway_details' table migration ([#5142])
-- Respond to auth messages with same version ([#5140])
-- Pain/polyfill deprecated endpoints ([#5131])
-- change: dont select mixnodes bonded with vested tokens into the rewarded set ([#5129])
-- nym-credential-proxy-requests: reqwest use rustls-tls ([#5116])
-- bugfix: preserve as much as possible of the rewarded set during migration ([#5103])
-- Feature/force refresh node ([#5101])
-- Add NYM_VPN_API to env files ([#5099])
-- bugfix: fixed historical uptimes for nodes ([#5097])
-- Remove old use of 1GB constant ([#5096])
-- Graceful agent 1.1.5 ([#5093])
-- Add more translations from v2 to v3 authenticator ([#5091])
-- Nym node - Fix claim delegator rewards ([#5090])
-- Make 250 GB/30 days for free ride mode ([#5083])
-- Don't increase bandwidth two times ([#5081])
-- Fix expiration date as today + 7 days ([#5076])
-- Fix gateway decreasing bandwidth ([#5075])
-- Allow custom http port to be reset ([#5073])
-- bugfix: additional checks inside credential proxy ([#5072])
-- chore: deprecated old nym-api client methods and replaced them when possible ([#5069])
-- NS API with directory v2 (#5058) ([#5068])
-- bugfix: credential-proxy obtain-async ([#5067])
-- Allow nym node config updates ([#5066])
-- bugfix: use corrext axum extractors for ecash route arguments ([#5065])
-- Merge2/release/2024.13 magura ([#5063])
-- bugfix/feature: added NymApiClient method to get all skimmed nodes ([#5062])
-- Merge1/release/2024.13 magura ([#5061])
-- added hacky routes to return nymnodes alongside legacy nodes ([#5051])
-- bugfix: mark migrated gateways as rewarded in the previous epoch in case theyre in the rewarded set ([#5049])
-- bugfix: adjust runtime storage migration ([#5047])
-- bugfix: supersede 'cb13be27f8f61d9ae74d924e85d2e6787895eb14' by using… ([#5046])
-- bugfix: restore default http port for nym-api ([#5045])
-- bugfix: fix ecash handlers routes ([#5043])
-- bugfix: don't assign exit gateways to standby set ([#5041])
-- bugfix: make sure nym-nodes are also tested by network monitor ([#5040])
-- bugfix: use bonded nym-nodes for determining initial network monitor … ([#5039])
-- bugfix: make gateways insert themselves into [local] topology ([#5038])
-- Pass poisson flag  ([#5037])
-- bugfix: use human readable roles for annotations ([#5036])
-- bugfix: use old name for 'epoch_role' in SkimmedNode ([#5034])
-- bugfix: make sure to use correct highest node id when assigning role ([#5032])
-- feature: use axum_client_ip for attempting to extract source ip ([#5031])
-- bugfix: fixed backwards incompatibility for /gateways/described endpoint ([#5030])
-- bugfix: verifying signed information of legacy nodes ([#5029])
-- bugfix: introduce 'LegacyPendingMixNodeChanges' that does not contain 'cost_params_change' ([#5028])
-- bugfix: missing #[serde(default)] for announce port ([#5024])
-- bugfix: directory v2.1 `get_all_avg_gateway_reliability_in_interval` query ([#5023])
-- added 'get_all_described_nodes' to NymApiClient and adjusted return t… ([#5016])
-- Reapply fixes to new branch ([#5014])
-- Consume only positive bandwidth ([#5013])
-- feature: adjusted ticket sizes to the agreed amounts ([#5009])
-- Push private ip before inserting ([#5008])
-- chore: update itertools in compact ecash ([#4994])
-- feature: make accepting t&c a hard requirement for rewarded set selection ([#4993])
-- Fix rustfmt in nym-credential-proxy ([#4992])
-- bugfix: client memory leak ([#4991])
-- Eliminate 0 bandwidth race check ([#4988])
-- [DOCs;/operators]: Release notes for v2024.12 aero ([#4984])
-- Add topup req constructor ([#4983])
-- Fix critical issues SI86 and SI87 from Cure53 ([#4982])
-- Rename nym-vpn-api to nym-credential-proxy ([#4981])
-- enable global ecash routes even if api is not a signer ([#4980])
-- resolve beta clippy issues in contracts ([#4978])
-- Re-enable vested delegation migration ([#4977])
-- feature: require reporting using nym-node binary for rewarded set selection ([#4976])
-- Top up bandwidth ([#4975])
-- [Product Data] Add session type based on ecash ticket received ([#4974])
-- Bugfix/additional directory fixes ([#4973])
-- feat: add Dockerfile for nym node ([#4972])
-- chore: remove unused rocket code ([#4968])
-- Import nym-vpn-api crates ([#4967])
-- feature: importer-cli to correctly handle mixnet/vesting import ([#4966])
-- bugfix: fix expected return type on /v1/gateways endpoint ([#4965])
-- [Product Data] First step in gateway usage data collection ([#4963])
-- Bump sqlx to 0.7.4 ([#4959])
-- Add env feature to clap and make clap parameters available as env variables ([#4957])
-- Feature/contract state tools ([#4954])
-- expose authenticator address along other address in node-details ([#4953])
-- Extract packet processing from mixnode-common ([#4949])
-- nym-api container ([#4948])
-- Ticket type storage ([#4947])
-- Add "utoipa" feature to nym-node ([#4945])
-- build(deps): bump the patch-updates group across 1 directory with 9 updates ([#4944])
-- V2 performance monitoring feature flag ([#4943])
-- Bugfix/rewarder post pruning adjustments ([#4942])
-- Switch over the last set of jobs to arc runners ([#4938])
-- Fix broken build after merge ([#4937])
-- bugfix: correctly paginate through 'search_tx' endpoint ([#4936])
-- Add more conversions for responses of authenticator messages ([#4929])
-- Directory Sevices v2.1 ([#4903])
-- Migrate Legacy Node (Frontend)  ([#4826])
-- Fix critical issues SI84 and SI85 from Cure53 ([#4758])
-
-[#5145]: https://github.com/nymtech/nym/pull/5145
-[#5143]: https://github.com/nymtech/nym/pull/5143
-[#5142]: https://github.com/nymtech/nym/pull/5142
-[#5140]: https://github.com/nymtech/nym/pull/5140
-[#5131]: https://github.com/nymtech/nym/pull/5131
-[#5129]: https://github.com/nymtech/nym/pull/5129
-[#5116]: https://github.com/nymtech/nym/pull/5116
-[#5103]: https://github.com/nymtech/nym/pull/5103
-[#5101]: https://github.com/nymtech/nym/pull/5101
-[#5099]: https://github.com/nymtech/nym/pull/5099
-[#5097]: https://github.com/nymtech/nym/pull/5097
-[#5096]: https://github.com/nymtech/nym/pull/5096
-[#5093]: https://github.com/nymtech/nym/pull/5093
-[#5091]: https://github.com/nymtech/nym/pull/5091
-[#5090]: https://github.com/nymtech/nym/pull/5090
-[#5083]: https://github.com/nymtech/nym/pull/5083
-[#5081]: https://github.com/nymtech/nym/pull/5081
-[#5076]: https://github.com/nymtech/nym/pull/5076
-[#5075]: https://github.com/nymtech/nym/pull/5075
-[#5073]: https://github.com/nymtech/nym/pull/5073
-[#5072]: https://github.com/nymtech/nym/pull/5072
-[#5069]: https://github.com/nymtech/nym/pull/5069
-[#5068]: https://github.com/nymtech/nym/pull/5068
-[#5067]: https://github.com/nymtech/nym/pull/5067
-[#5066]: https://github.com/nymtech/nym/pull/5066
-[#5065]: https://github.com/nymtech/nym/pull/5065
-[#5063]: https://github.com/nymtech/nym/pull/5063
-[#5062]: https://github.com/nymtech/nym/pull/5062
-[#5061]: https://github.com/nymtech/nym/pull/5061
-[#5051]: https://github.com/nymtech/nym/pull/5051
-[#5049]: https://github.com/nymtech/nym/pull/5049
-[#5047]: https://github.com/nymtech/nym/pull/5047
-[#5046]: https://github.com/nymtech/nym/pull/5046
-[#5045]: https://github.com/nymtech/nym/pull/5045
-[#5043]: https://github.com/nymtech/nym/pull/5043
-[#5041]: https://github.com/nymtech/nym/pull/5041
-[#5040]: https://github.com/nymtech/nym/pull/5040
-[#5039]: https://github.com/nymtech/nym/pull/5039
-[#5038]: https://github.com/nymtech/nym/pull/5038
-[#5037]: https://github.com/nymtech/nym/pull/5037
-[#5036]: https://github.com/nymtech/nym/pull/5036
-[#5034]: https://github.com/nymtech/nym/pull/5034
-[#5032]: https://github.com/nymtech/nym/pull/5032
-[#5031]: https://github.com/nymtech/nym/pull/5031
-[#5030]: https://github.com/nymtech/nym/pull/5030
-[#5029]: https://github.com/nymtech/nym/pull/5029
-[#5028]: https://github.com/nymtech/nym/pull/5028
-[#5024]: https://github.com/nymtech/nym/pull/5024
-[#5023]: https://github.com/nymtech/nym/pull/5023
-[#5016]: https://github.com/nymtech/nym/pull/5016
-[#5014]: https://github.com/nymtech/nym/pull/5014
-[#5013]: https://github.com/nymtech/nym/pull/5013
-[#5009]: https://github.com/nymtech/nym/pull/5009
-[#5008]: https://github.com/nymtech/nym/pull/5008
-[#4994]: https://github.com/nymtech/nym/pull/4994
-[#4993]: https://github.com/nymtech/nym/pull/4993
-[#4992]: https://github.com/nymtech/nym/pull/4992
-[#4991]: https://github.com/nymtech/nym/pull/4991
-[#4988]: https://github.com/nymtech/nym/pull/4988
-[#4984]: https://github.com/nymtech/nym/pull/4984
-[#4983]: https://github.com/nymtech/nym/pull/4983
-[#4982]: https://github.com/nymtech/nym/pull/4982
-[#4981]: https://github.com/nymtech/nym/pull/4981
-[#4980]: https://github.com/nymtech/nym/pull/4980
-[#4978]: https://github.com/nymtech/nym/pull/4978
-[#4977]: https://github.com/nymtech/nym/pull/4977
-[#4976]: https://github.com/nymtech/nym/pull/4976
-[#4975]: https://github.com/nymtech/nym/pull/4975
-[#4974]: https://github.com/nymtech/nym/pull/4974
-[#4973]: https://github.com/nymtech/nym/pull/4973
-[#4972]: https://github.com/nymtech/nym/pull/4972
-[#4968]: https://github.com/nymtech/nym/pull/4968
-[#4967]: https://github.com/nymtech/nym/pull/4967
-[#4966]: https://github.com/nymtech/nym/pull/4966
-[#4965]: https://github.com/nymtech/nym/pull/4965
-[#4963]: https://github.com/nymtech/nym/pull/4963
-[#4959]: https://github.com/nymtech/nym/pull/4959
-[#4957]: https://github.com/nymtech/nym/pull/4957
-[#4954]: https://github.com/nymtech/nym/pull/4954
-[#4953]: https://github.com/nymtech/nym/pull/4953
-[#4949]: https://github.com/nymtech/nym/pull/4949
-[#4948]: https://github.com/nymtech/nym/pull/4948
-[#4947]: https://github.com/nymtech/nym/pull/4947
-[#4945]: https://github.com/nymtech/nym/pull/4945
-[#4944]: https://github.com/nymtech/nym/pull/4944
-[#4943]: https://github.com/nymtech/nym/pull/4943
-[#4942]: https://github.com/nymtech/nym/pull/4942
-[#4938]: https://github.com/nymtech/nym/pull/4938
-[#4937]: https://github.com/nymtech/nym/pull/4937
-[#4936]: https://github.com/nymtech/nym/pull/4936
-[#4929]: https://github.com/nymtech/nym/pull/4929
-[#4903]: https://github.com/nymtech/nym/pull/4903
-[#4826]: https://github.com/nymtech/nym/pull/4826
-[#4758]: https://github.com/nymtech/nym/pull/4758
-
 ## [2024.12-aero] (2024-10-17)
 
 - nym-node: don't use bloomfilters for double spending checks ([#4960])

Cargo.toml

@@ -61,6 +61,7 @@ members = [
     "common/ip-packet-requests",
     "common/ledger",
     "common/mixnode-common",
+    "common/models",
     "common/network-defaults",
     "common/node-tester-utils",
     "common/nonexhaustive-delayqueue",
@@ -104,6 +105,7 @@ members = [
     "explorer-api/explorer-client",
     "gateway",
     "integrations/bity",
+    "mixnode",
     "sdk/ffi/cpp",
     "sdk/ffi/go",
     "sdk/ffi/shared",
@@ -122,11 +124,10 @@ members = [
     "nym-data-observatory",
     "nym-network-monitor",
     "nym-node",
+    "nym-node/nym-node-http-api",
     "nym-node/nym-node-requests",
-    "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-node-status-api",
+    "nym-node-status-agent",
     "nym-outfox",
     "nym-validator-rewarder",
     "tools/echo-server",
@@ -148,20 +149,23 @@ members = [
     "tools/internal/contract-state-importer/importer-cli",
     "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",
+    "tools/internal/testnet-manager/dkg-bypass-contract",
 ]
 
 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-agent",
-    "nym-node-status-api/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",
@@ -260,7 +264,6 @@ 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"
@@ -311,7 +314,7 @@ serde = "1.0.211"
 serde_bytes = "0.11.15"
 serde_derive = "1.0"
 serde_json = "1.0.132"
-serde_json_path = "0.7.1"
+serde_json_path = "0.6.7"
 serde_repr = "0.1"
 serde_with = "3.9.0"
 serde_yaml = "0.9.25"
@@ -326,7 +329,7 @@ syn = "1"
 sysinfo = "0.30.13"
 tap = "1.0.1"
 tar = "0.4.42"
-tempfile = "3.14"
+tempfile = "3.5.0"
 thiserror = "1.0.64"
 time = "0.3.30"
 tokio = "1.39"

SECURITY.md

@@ -3,23 +3,37 @@ 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@nym.com
+security@nymte.ch
 ```
 
 Encrypted with our public key which is available below in plain text and also on keyservers:
 
 ```
-sec   rsa4096/7C3C727F05090550 2023-10-30 [SC] [expire : 2026-10-29]
+pub   rsa4096 2023-10-30 [SC] [expire : 2026-10-29]
       24B2592E801A5AAA8666C8BA7C3C727F05090550
-uid                [  ultime ] Security Nym Technologies <security@nym.com>
-ssb   rsa4096/ACD0FBD79DC70ACC 2023-10-30 [E] [expire : 2026-10-29]
+uid          [  ultime ] Security Nym Technologies <security@nymte.ch>
+sub   rsa4096 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-----
 
@@ -34,69 +48,43 @@ vMFUIzBMHOPXH16036zGyFMC1esRd2qqil4b9KtLgCOkrD1VgpjcveoA0VyMJCN6
 LmKTrVjwjjDMxby+d49BolRWGnCofXozXwvNQx+CYv8M2WPErTpyYoofYFtpqr7A
 fIufc/e0+um3zoGIbHejrhsbuH9Qf+MKsI+Ng93bdDtjeHz6MEgAlsTm0qeizYpj
 IyKZIObPmfvrAm08hFZ8JnGk+XuooF36XWbJYjCCy0bOyMw1r7ZG99TcSwARAQAB
-tCxTZWN1cml0eSBOeW0gVGVjaG5vbG9naWVzIDxzZWN1cml0eUBueW0uY29tPokC
-VAQTAQoAPhYhBCSyWS6AGlqqhmbIunw8cn8FCQVQBQJnSd5VAhsDBQkFo5qABQsJ
-CAcDBRUKCQgLBRYCAwEAAh4BAheAAAoJEHw8cn8FCQVQPPIP/ipGz2zLAjE2dSE3
-VcqOvras0DfqIL9HDm26Dg6QO2D/4YRntw0RqVyuy+zFnRUm+RZCKLPLUzbQ9Wjb
-G/Og5ttQVYQMu5eKu7OMvXkrbRo3teZFU+8IL08zIW6pyf9haxO6YMhLRy6cLYwW
-0EYC6Qzn5gz3kI7VkI8fWfs2Dk4XEV3D+SVtBoF6KRxMXT6HZvpzoMSEJZBoNj8S
-jw0TF8TFUQf49jUQbIHumukMswolrHi8a5ej8DSfNwSgz+Tt8oh5lu01kyUJiHn7
-nuHaY4Y9cHUVAOSwq/hovG52+ZE1r3aiswvle/B19o9pKeWWVvacSptGxDQagBtQ
-igoNLdRvY0XN2TEyX9pOHR0AoVOxtIW11CpkKuDbQG9vPwovqJ2L6+Fh3pzHYzcI
-2GIShNm/Z2SZBiUqbljJe9H4UAT/aHgMINkEG8qzUKwO42MA5HJT7YbHTR17/QSF
-Il5dhneRzmSbNcW2rdRwx/BmzrcsFJfqCt4JG/WDF293xSOjhFqQYvU4gCO+OB7o
-KXjX907XXDjS2KEJ71OGqVfk/P7BqEfQNfrLtb02TyXJAPQXHhybv23c4E7zUs9V
-lMjNizzxYB96uwJb0LAB2ijzEwoP91uGT2tFjk6F08x2QiArmXUdgrv44b39Stia
-gJS0GYKqSzyr10xHhUuDA+GKYtcitC1TZWN1cml0eSBOeW0gVGVjaG5vbG9naWVz
-IDxzZWN1cml0eUBueW10ZS5jaD6JAjYEMAEKACAWIQQkslkugBpaqoZmyLp8PHJ/
-BQkFUAUCZ0nftQIdIAAKCRB8PHJ/BQkFUFHDEACtyNuUEjKCLAT5mSfow85PjFgo
-o8kHjQr/IIQ7ZbBOHeJJcrxDuypssiLh5XUjF3x5BiBfZ6vCxSb81RRwsDMp0mA1
-qzv9G8sgW0HTQUnZ9oH6CYut2NgzAnQpmuacrunm9Zy0FJ3ejbmwUY/NqK6gJkle
-66duHKhAy7DWjj7amd0C8bPDR+PA44fI3MezDHkQNaauKZTRqd1TqH8Qk5PAl4cB
-o5gVzeZh/U7/usvtGhazAIUF5BqK6bTmDnYopg+2x8jjwrG4+08GrttZkNjBLXeA
-Y/2U064yMz12LPv01qqAFdZ+coRy/ps/gOQTz34/VeW0CFy7TMqs4t3vSBWTqU7w
-hnw/qj6cM33fdxctj6KDgJSCkZdx2fvwXgxiPqUa5+j9FlFBeD5RDAl6g6t8N1/K
-Xca+zNYuSZgc297q1D+mtSD1C7uJNPxoAl+Bv5KNKpsjfQ+m04++CIFtGyX22aCA
-h2/tHwQZIXhOiMAKOoupidDVDhgxtCJ3Ps416xL0sTZfsPfg+j1Uv/Em9pzPClEl
-fX6+1O4DdSyZUQ4VsjMu/H5W/NQdbHgmqFrxQ6WX/0s5GMwO6GMDiPe8sOrwz9wD
-WYtyjafxXOHEZ1OjYX5gr7bGaG4oKc2btTJN0B3Phg4dStnHCNjEYccxuV3507fj
-HnNotkpXF2nGLxy+PYkCVAQTAQoAPhYhBCSyWS6AGlqqhmbIunw8cn8FCQVQBQJl
-P16XAhsDBQkFo5qABQsJCAcDBRUKCQgLBRYCAwEAAh4BAheAAAoJEHw8cn8FCQVQ
-vt0P/3M7ve4jlVH5JbE8WYlb71Cw+JBtVG8bA1m6ty2ZDazY97S8dEQsV6oPmhi9
-LHYt6q7civ7Of8LeQMyQ2zjShtIvqMIGIs+TERjQmrM8z2NmvsSO+WJtZXd/oPGi
-hEioTJ83nsjc4EaWpkTQzHuxC4JyBq7wLvQMX3nZCEpTBcLZyamYModUQSiKjXEZ
-IPh1CEZqkIHfZFAa2do4Z8A71x6U0y9KrQun5onF4AKZYVjlPj/Lv0k9xPm9Kz/I
-QhGZof9+famLBoUGwiqAckkzE7fvjQ/WEXyPspZShSh+4VoQAscGkSmNZM6Px6PX
-CYWW77kX6NJWhzvzVZtlle7Thw4FecZOiDNLEykF71O0tvbzN3pbMWi0LbkpMjem
-eAzNexAYsks7C+hkqJIsWM9GODWvChuYHdDcnZbkZhK96JrQIOxkY/6DzsZVV/+g
-PYOOlrrzHJVjAhh4DpPcM11LvuoeJG4aJLiRZfJWMOo4gJuhHi4K+3T3OWQG4sN1
-NapZgBFS9mO2OzjD86Wt2sEjcDzy2Lx9GV1ho2m7XswTWKWk3jjIqgm2qJZzdOKy
-Tx5gt/HpzsVAXc+tG9qavsVm+EWxgwvkJ40UdMTM3pjeOMo3/rQO8J+h1adYUrjt
-PGSXxQBcZjZb0HR9apDBRWvy4u4zLIyIpt6i5+LusY6PoAwSuQINBGU/XpcBEADw
-UaYPkne0zUE4zWeInFklN0Jq7MS3ESgEvRG6oYGRHxTb2xEzoPC7ONTs/CxwWcFo
-bJT55TvcbAaQfejMV8W2WViFCuE/+SQ37SsQ7leL6dH7gkIVGqt/eclcAA9+KSxR
-Eynx6vV1Q5jb97VlKgu1L6fNSK9XwJ8T6mCP/li0bA8L4pgcsBOQqQwQsKttbhQ7
-TpVY6pCy+vqSK9e4lBAt0QAykGUAOZcUbjkOY8pDOwFZSC9PDIbLctfSfKzxyCl7
-H0EfyGGvTVCYbI/jr2w3dw2u0W67xTpECyIIP/yaUG4PcRARTlIXSVzuQIgIBmT7
-ASWZeeKYSLRM5ixvPqT3SW16JxfvSsD0Y17Ijvof5VI5i9amRHBokCBR3OsAzWj1
-IcBKr5xnqcPzk5mKhCQNYzr5D6x/ah6fSomecaZSv3eQkgLQ8h2CtdGu2I195FrV
-n8fQuZETLIQygWJWK+fPW9WTzk6rpJ/eW1TC+YPO64k62ynZCnr7HpKef/Ipq4ji
-5/gJ//ApRyHivoHCCDkPDj2TLuXCWcAuKjgYhWgYukt5/3fBagOangqXKHdk9/ac
-HRT3W7dsdFSjub4PtAn3xzIq2osvOODuzMZ/rSkhY1ZGxp1hBPdtKdzKeqScCM5X
-cEK/Hr+K+yemP/9CNhEe2+JQBxDUMEHpQLqrbcUizQARAQABiQI8BBgBCgAmFiEE
-JLJZLoAaWqqGZsi6fDxyfwUJBVAFAmU/XpcCGwwFCQWjmoAACgkQfDxyfwUJBVDO
-6Q/+IvGM7FP5Sk9H/9ymsNVIuQ/ikXlubDfpTTuO+qlL78pNezGKJCV599Fps6k0
-tx34rW55q/K32ecjAce0dL2Qz0DsMHDcuekRteSLjpAMIIjqeIaKOUs4R4Baqehz
-Aw1NPTnBVWAK07cNA/YyhIJyoelcMKG87Kvl3nGNgtUmGVy0gxKiZxXMavKOSc+7
-RiP9OQL/hz6bzplZBQMeowdAi6IR6e9vrb8Xhzk4khFk8SfvTB112SAm4lTd4d0e
-ue6EKSMIL3cZAZsaPTdmqizrr33LqGY94PdTkhS/y6PBlhUIK4ObyAl+undHpYt9
-5l4r1aZNUGkLOwODd9WFLCY6TqmnwMCrX8N6/fJGQWCAITIYrpz1v5rQJEGdyXx7
-lDRBAjM2JL+4TFA/eH4Qsmzc/Qws/7oVaE1SvLT2feWdaSvWFj6/UzQYDFt92/+2
-wI3U+r9VATP4JOperJp+1aV04dbDoeH6C3DFweMbgwE6s7mggJDeWHaEbBDnxwOB
-lhIr84aAn0GCAWXUJwzS4YLT9NEIjXO3/jL7t59JlAxmQejtUL/cwVunaFw16Olb
-4HFW7ApO6cW9YrdMuGqxKVDnLKGpyGih6mwUer1uiwoWMskLTW6msG/WuKeg1247
-LjcVvJLsk9FGykA03RGILakxtZ0TRlNBoWrq08iDTnymOqI=
-=QPTf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+=nqgX
 -----END PGP PUBLIC KEY BLOCK-----
-
 ```

clients/native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nym-client"
-version = "1.1.45"
+version = "1.1.42"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>", "Jędrzej Stuczyński <andrew@nymtech.net>"]
 description = "Implementation of the Nym Client"
 edition = "2021"

clients/socks5/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nym-socks5-client"
-version = "1.1.45"
+version = "1.1.42"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
 description = "A SOCKS5 localhost proxy that converts incoming messages to Sphinx and sends them to a Nym address"
 edition = "2021"

common/authenticator-requests/src/error.rs

@@ -22,7 +22,4 @@ pub enum Error {
 
     #[error("conversion: {0}")]
     Conversion(String),
-
-    #[error("failed to serialize response packet: {source}")]
-    FailedToSerializeResponsePacket { source: Box<bincode::ErrorKind> },
 }

common/authenticator-requests/src/lib.rs

@@ -1,7 +1,6 @@
 // Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-pub mod traits;
 pub mod v1;
 pub mod v2;
 pub mod v3;

common/authenticator-requests/src/traits.rs

@@ -1,343 +0,0 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use nym_credentials_interface::CredentialSpendingData;
-use nym_crypto::asymmetric::x25519::PrivateKey;
-use nym_service_provider_requests_common::{Protocol, ServiceProviderType};
-use nym_sphinx::addressing::clients::Recipient;
-use nym_wireguard_types::PeerPublicKey;
-
-use crate::{
-    v1, v2, v3,
-    v4::{self, registration::IpPair},
-    Error,
-};
-
-#[derive(Copy, Clone, Debug)]
-pub enum AuthenticatorVersion {
-    V1,
-    V2,
-    V3,
-    V4,
-    UNKNOWN,
-}
-
-impl From<Protocol> for AuthenticatorVersion {
-    fn from(value: Protocol) -> Self {
-        if value.service_provider_type != ServiceProviderType::Authenticator {
-            AuthenticatorVersion::UNKNOWN
-        } else if value.version == v1::VERSION {
-            AuthenticatorVersion::V1
-        } else if value.version == v2::VERSION {
-            AuthenticatorVersion::V2
-        } else if value.version == v3::VERSION {
-            AuthenticatorVersion::V3
-        } else if value.version == v4::VERSION {
-            AuthenticatorVersion::V4
-        } else {
-            AuthenticatorVersion::UNKNOWN
-        }
-    }
-}
-
-pub trait InitMessage {
-    fn pub_key(&self) -> PeerPublicKey;
-}
-
-impl InitMessage for v1::registration::InitMessage {
-    fn pub_key(&self) -> PeerPublicKey {
-        self.pub_key
-    }
-}
-
-impl InitMessage for v2::registration::InitMessage {
-    fn pub_key(&self) -> PeerPublicKey {
-        self.pub_key
-    }
-}
-
-impl InitMessage for v3::registration::InitMessage {
-    fn pub_key(&self) -> PeerPublicKey {
-        self.pub_key
-    }
-}
-
-impl InitMessage for v4::registration::InitMessage {
-    fn pub_key(&self) -> PeerPublicKey {
-        self.pub_key
-    }
-}
-
-pub trait FinalMessage {
-    fn pub_key(&self) -> PeerPublicKey;
-    fn verify(&self, private_key: &PrivateKey, nonce: u64) -> Result<(), Error>;
-    fn private_ips(&self) -> IpPair;
-    fn credential(&self) -> Option<CredentialSpendingData>;
-}
-
-impl FinalMessage for v1::GatewayClient {
-    fn pub_key(&self) -> PeerPublicKey {
-        self.pub_key
-    }
-
-    fn verify(&self, private_key: &PrivateKey, nonce: u64) -> Result<(), Error> {
-        self.verify(private_key, nonce)
-    }
-
-    fn private_ips(&self) -> IpPair {
-        self.private_ip.into()
-    }
-
-    fn credential(&self) -> Option<CredentialSpendingData> {
-        None
-    }
-}
-
-impl FinalMessage for v2::registration::FinalMessage {
-    fn pub_key(&self) -> PeerPublicKey {
-        self.gateway_client.pub_key
-    }
-
-    fn verify(&self, private_key: &PrivateKey, nonce: u64) -> Result<(), Error> {
-        self.gateway_client.verify(private_key, nonce)
-    }
-
-    fn private_ips(&self) -> IpPair {
-        self.gateway_client.private_ip.into()
-    }
-
-    fn credential(&self) -> Option<CredentialSpendingData> {
-        self.credential.clone()
-    }
-}
-
-impl FinalMessage for v3::registration::FinalMessage {
-    fn pub_key(&self) -> PeerPublicKey {
-        self.gateway_client.pub_key
-    }
-
-    fn verify(&self, private_key: &PrivateKey, nonce: u64) -> Result<(), Error> {
-        self.gateway_client.verify(private_key, nonce)
-    }
-
-    fn private_ips(&self) -> IpPair {
-        self.gateway_client.private_ip.into()
-    }
-
-    fn credential(&self) -> Option<CredentialSpendingData> {
-        self.credential.clone()
-    }
-}
-
-impl FinalMessage for v4::registration::FinalMessage {
-    fn pub_key(&self) -> PeerPublicKey {
-        self.gateway_client.pub_key
-    }
-
-    fn verify(&self, private_key: &PrivateKey, nonce: u64) -> Result<(), Error> {
-        self.gateway_client.verify(private_key, nonce)
-    }
-
-    fn private_ips(&self) -> IpPair {
-        self.gateway_client.private_ips
-    }
-
-    fn credential(&self) -> Option<CredentialSpendingData> {
-        self.credential.clone()
-    }
-}
-
-pub trait QueryBandwidthMessage {
-    fn pub_key(&self) -> PeerPublicKey;
-}
-
-impl QueryBandwidthMessage for PeerPublicKey {
-    fn pub_key(&self) -> PeerPublicKey {
-        *self
-    }
-}
-
-pub trait TopUpMessage {
-    fn pub_key(&self) -> PeerPublicKey;
-    fn credential(&self) -> CredentialSpendingData;
-}
-
-impl TopUpMessage for v3::topup::TopUpMessage {
-    fn pub_key(&self) -> PeerPublicKey {
-        self.pub_key
-    }
-
-    fn credential(&self) -> CredentialSpendingData {
-        self.credential.clone()
-    }
-}
-
-impl TopUpMessage for v4::topup::TopUpMessage {
-    fn pub_key(&self) -> PeerPublicKey {
-        self.pub_key
-    }
-
-    fn credential(&self) -> CredentialSpendingData {
-        self.credential.clone()
-    }
-}
-
-pub enum AuthenticatorRequest {
-    Initial {
-        msg: Box<dyn InitMessage + Send + Sync + 'static>,
-        protocol: Protocol,
-        reply_to: Recipient,
-        request_id: u64,
-    },
-    Final {
-        msg: Box<dyn FinalMessage + Send + Sync + 'static>,
-        protocol: Protocol,
-        reply_to: Recipient,
-        request_id: u64,
-    },
-    QueryBandwidth {
-        msg: Box<dyn QueryBandwidthMessage + Send + Sync + 'static>,
-        protocol: Protocol,
-        reply_to: Recipient,
-        request_id: u64,
-    },
-    TopUpBandwidth {
-        msg: Box<dyn TopUpMessage + Send + Sync + 'static>,
-        protocol: Protocol,
-        reply_to: Recipient,
-        request_id: u64,
-    },
-}
-
-impl From<v1::request::AuthenticatorRequest> for AuthenticatorRequest {
-    fn from(value: v1::request::AuthenticatorRequest) -> Self {
-        match value.data {
-            v1::request::AuthenticatorRequestData::Initial(init_message) => Self::Initial {
-                msg: Box::new(init_message),
-                protocol: Protocol {
-                    version: value.version,
-                    service_provider_type: ServiceProviderType::Authenticator,
-                },
-                reply_to: value.reply_to,
-                request_id: value.request_id,
-            },
-            v1::request::AuthenticatorRequestData::Final(gateway_client) => Self::Final {
-                msg: Box::new(gateway_client),
-                protocol: Protocol {
-                    version: value.version,
-                    service_provider_type: ServiceProviderType::Authenticator,
-                },
-                reply_to: value.reply_to,
-                request_id: value.request_id,
-            },
-            v1::request::AuthenticatorRequestData::QueryBandwidth(peer_public_key) => {
-                Self::QueryBandwidth {
-                    msg: Box::new(peer_public_key),
-                    protocol: Protocol {
-                        version: value.version,
-                        service_provider_type: ServiceProviderType::Authenticator,
-                    },
-                    reply_to: value.reply_to,
-                    request_id: value.request_id,
-                }
-            }
-        }
-    }
-}
-
-impl From<v2::request::AuthenticatorRequest> for AuthenticatorRequest {
-    fn from(value: v2::request::AuthenticatorRequest) -> Self {
-        match value.data {
-            v2::request::AuthenticatorRequestData::Initial(init_message) => Self::Initial {
-                msg: Box::new(init_message),
-                protocol: value.protocol,
-                reply_to: value.reply_to,
-                request_id: value.request_id,
-            },
-            v2::request::AuthenticatorRequestData::Final(final_message) => Self::Final {
-                msg: final_message,
-                protocol: value.protocol,
-                reply_to: value.reply_to,
-                request_id: value.request_id,
-            },
-            v2::request::AuthenticatorRequestData::QueryBandwidth(peer_public_key) => {
-                Self::QueryBandwidth {
-                    msg: Box::new(peer_public_key),
-                    protocol: value.protocol,
-                    reply_to: value.reply_to,
-                    request_id: value.request_id,
-                }
-            }
-        }
-    }
-}
-
-impl From<v3::request::AuthenticatorRequest> for AuthenticatorRequest {
-    fn from(value: v3::request::AuthenticatorRequest) -> Self {
-        match value.data {
-            v3::request::AuthenticatorRequestData::Initial(init_message) => Self::Initial {
-                msg: Box::new(init_message),
-                protocol: value.protocol,
-                reply_to: value.reply_to,
-                request_id: value.request_id,
-            },
-            v3::request::AuthenticatorRequestData::Final(final_message) => Self::Final {
-                msg: final_message,
-                protocol: value.protocol,
-                reply_to: value.reply_to,
-                request_id: value.request_id,
-            },
-            v3::request::AuthenticatorRequestData::QueryBandwidth(peer_public_key) => {
-                Self::QueryBandwidth {
-                    msg: Box::new(peer_public_key),
-                    protocol: value.protocol,
-                    reply_to: value.reply_to,
-                    request_id: value.request_id,
-                }
-            }
-            v3::request::AuthenticatorRequestData::TopUpBandwidth(top_up_message) => {
-                Self::TopUpBandwidth {
-                    msg: top_up_message,
-                    protocol: value.protocol,
-                    reply_to: value.reply_to,
-                    request_id: value.request_id,
-                }
-            }
-        }
-    }
-}
-
-impl From<v4::request::AuthenticatorRequest> for AuthenticatorRequest {
-    fn from(value: v4::request::AuthenticatorRequest) -> Self {
-        match value.data {
-            v4::request::AuthenticatorRequestData::Initial(init_message) => Self::Initial {
-                msg: Box::new(init_message),
-                protocol: value.protocol,
-                reply_to: value.reply_to,
-                request_id: value.request_id,
-            },
-            v4::request::AuthenticatorRequestData::Final(final_message) => Self::Final {
-                msg: final_message,
-                protocol: value.protocol,
-                reply_to: value.reply_to,
-                request_id: value.request_id,
-            },
-            v4::request::AuthenticatorRequestData::QueryBandwidth(peer_public_key) => {
-                Self::QueryBandwidth {
-                    msg: Box::new(peer_public_key),
-                    protocol: value.protocol,
-                    reply_to: value.reply_to,
-                    request_id: value.request_id,
-                }
-            }
-            v4::request::AuthenticatorRequestData::TopUpBandwidth(top_up_message) => {
-                Self::TopUpBandwidth {
-                    msg: top_up_message,
-                    protocol: value.protocol,
-                    reply_to: value.reply_to,
-                    request_id: value.request_id,
-                }
-            }
-        }
-    }
-}

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

@@ -17,6 +17,11 @@ fn generate_random() -> u64 {
     rng.next_u64()
 }
 
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct QueryMessage {
+    pub pub_key: PeerPublicKey,
+}
+
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct AuthenticatorRequest {
     pub protocol: Protocol,
@@ -65,7 +70,7 @@ impl AuthenticatorRequest {
         )
     }
 
-    pub fn new_query_request(peer_public_key: PeerPublicKey, reply_to: Recipient) -> (Self, u64) {
+    pub fn new_query_request(query_message: QueryMessage, reply_to: Recipient) -> (Self, u64) {
         let request_id = generate_random();
         (
             Self {
@@ -73,7 +78,7 @@ impl AuthenticatorRequest {
                     service_provider_type: ServiceProviderType::Authenticator,
                     version: VERSION,
                 },
-                data: AuthenticatorRequestData::QueryBandwidth(peer_public_key),
+                data: AuthenticatorRequestData::QueryBandwidth(query_message.pub_key),
                 reply_to,
                 request_id,
             },

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

@@ -98,16 +98,6 @@ impl TryFrom<v3::response::AuthenticatorResponse> for v2::response::Authenticato
     }
 }
 
-impl From<v2::response::AuthenticatorResponse> for v3::response::AuthenticatorResponse {
-    fn from(value: v2::response::AuthenticatorResponse) -> Self {
-        Self {
-            protocol: value.protocol,
-            data: value.data.into(),
-            reply_to: value.reply_to,
-        }
-    }
-}
-
 impl TryFrom<v3::response::AuthenticatorResponseData> for v2::response::AuthenticatorResponseData {
     type Error = crate::Error;
 
@@ -139,22 +129,6 @@ impl TryFrom<v3::response::AuthenticatorResponseData> for v2::response::Authenti
     }
 }
 
-impl From<v2::response::AuthenticatorResponseData> for v3::response::AuthenticatorResponseData {
-    fn from(value: v2::response::AuthenticatorResponseData) -> Self {
-        match value {
-            v2::response::AuthenticatorResponseData::PendingRegistration(
-                pending_registration_response,
-            ) => Self::PendingRegistration(pending_registration_response.into()),
-            v2::response::AuthenticatorResponseData::Registered(registered_response) => {
-                Self::Registered(registered_response.into())
-            }
-            v2::response::AuthenticatorResponseData::RemainingBandwidth(
-                remaining_bandwidth_response,
-            ) => Self::RemainingBandwidth(remaining_bandwidth_response.into()),
-        }
-    }
-}
-
 impl From<v3::response::PendingRegistrationResponse> for v2::response::PendingRegistrationResponse {
     fn from(value: v3::response::PendingRegistrationResponse) -> Self {
         Self {
@@ -165,16 +139,6 @@ impl From<v3::response::PendingRegistrationResponse> for v2::response::PendingRe
     }
 }
 
-impl From<v2::response::PendingRegistrationResponse> for v3::response::PendingRegistrationResponse {
-    fn from(value: v2::response::PendingRegistrationResponse) -> Self {
-        Self {
-            request_id: value.request_id,
-            reply_to: value.reply_to,
-            reply: value.reply.into(),
-        }
-    }
-}
-
 impl From<v3::response::RegisteredResponse> for v2::response::RegisteredResponse {
     fn from(value: v3::response::RegisteredResponse) -> Self {
         Self {
@@ -185,16 +149,6 @@ impl From<v3::response::RegisteredResponse> for v2::response::RegisteredResponse
     }
 }
 
-impl From<v2::response::RegisteredResponse> for v3::response::RegisteredResponse {
-    fn from(value: v2::response::RegisteredResponse) -> Self {
-        Self {
-            request_id: value.request_id,
-            reply_to: value.reply_to,
-            reply: value.reply.into(),
-        }
-    }
-}
-
 impl From<v3::response::RemainingBandwidthResponse> for v2::response::RemainingBandwidthResponse {
     fn from(value: v3::response::RemainingBandwidthResponse) -> Self {
         Self {
@@ -205,16 +159,6 @@ impl From<v3::response::RemainingBandwidthResponse> for v2::response::RemainingB
     }
 }
 
-impl From<v2::response::RemainingBandwidthResponse> for v3::response::RemainingBandwidthResponse {
-    fn from(value: v2::response::RemainingBandwidthResponse) -> Self {
-        Self {
-            request_id: value.request_id,
-            reply_to: value.reply_to,
-            reply: value.reply.map(Into::into),
-        }
-    }
-}
-
 impl From<v3::registration::RegistrationData> for v2::registration::RegistrationData {
     fn from(value: v3::registration::RegistrationData) -> Self {
         Self {
@@ -225,16 +169,6 @@ impl From<v3::registration::RegistrationData> for v2::registration::Registration
     }
 }
 
-impl From<v2::registration::RegistrationData> for v3::registration::RegistrationData {
-    fn from(value: v2::registration::RegistrationData) -> Self {
-        Self {
-            nonce: value.nonce,
-            gateway_data: value.gateway_data.into(),
-            wg_port: value.wg_port,
-        }
-    }
-}
-
 impl From<v3::registration::RegistredData> for v2::registration::RegistredData {
     fn from(value: v3::registration::RegistredData) -> Self {
         Self {
@@ -245,16 +179,6 @@ impl From<v3::registration::RegistredData> for v2::registration::RegistredData {
     }
 }
 
-impl From<v2::registration::RegistredData> for v3::registration::RegistredData {
-    fn from(value: v2::registration::RegistredData) -> Self {
-        Self {
-            pub_key: value.pub_key,
-            private_ip: value.private_ip,
-            wg_port: value.wg_port,
-        }
-    }
-}
-
 impl From<v3::registration::RemainingBandwidthData> for v2::registration::RemainingBandwidthData {
     fn from(value: v3::registration::RemainingBandwidthData) -> Self {
         Self {
@@ -262,11 +186,3 @@ impl From<v3::registration::RemainingBandwidthData> for v2::registration::Remain
         }
     }
 }
-
-impl From<v2::registration::RemainingBandwidthData> for v3::registration::RemainingBandwidthData {
-    fn from(value: v2::registration::RemainingBandwidthData) -> Self {
-        Self {
-            available_bandwidth: value.available_bandwidth,
-        }
-    }
-}

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

@@ -27,7 +27,7 @@ pub type HmacSha256 = Hmac<Sha256>;
 pub type Nonce = u64;
 pub type Taken = Option<SystemTime>;
 
-pub const BANDWIDTH_CAP_PER_DAY: u64 = 250 * 1024 * 1024 * 1024; // 250 GB
+pub const BANDWIDTH_CAP_PER_DAY: u64 = 1024 * 1024 * 1024; // 1 GB
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct InitMessage {

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

@@ -20,6 +20,11 @@ fn generate_random() -> u64 {
     rng.next_u64()
 }
 
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct QueryMessage {
+    pub pub_key: PeerPublicKey,
+}
+
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct AuthenticatorRequest {
     pub protocol: Protocol,
@@ -68,7 +73,7 @@ impl AuthenticatorRequest {
         )
     }
 
-    pub fn new_query_request(peer_public_key: PeerPublicKey, reply_to: Recipient) -> (Self, u64) {
+    pub fn new_query_request(query_message: QueryMessage, reply_to: Recipient) -> (Self, u64) {
         let request_id = generate_random();
         (
             Self {
@@ -76,7 +81,7 @@ impl AuthenticatorRequest {
                     service_provider_type: ServiceProviderType::Authenticator,
                     version: VERSION,
                 },
-                data: AuthenticatorRequestData::QueryBandwidth(peer_public_key),
+                data: AuthenticatorRequestData::QueryBandwidth(query_message.pub_key),
                 reply_to,
                 request_id,
             },

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

@@ -3,7 +3,7 @@
 
 use nym_service_provider_requests_common::{Protocol, ServiceProviderType};
 
-use crate::{v2, v3, v4};
+use crate::{v3, v4};
 
 impl From<v3::request::AuthenticatorRequest> for v4::request::AuthenticatorRequest {
     fn from(authenticator_request: v3::request::AuthenticatorRequest) -> Self {
@@ -64,16 +64,6 @@ impl From<Box<v3::topup::TopUpMessage>> for Box<v4::topup::TopUpMessage> {
     }
 }
 
-impl From<v2::registration::GatewayClient> for v4::registration::GatewayClient {
-    fn from(gw_client: v2::registration::GatewayClient) -> Self {
-        Self {
-            pub_key: gw_client.pub_key,
-            private_ips: gw_client.private_ip.into(),
-            mac: gw_client.mac.into(),
-        }
-    }
-}
-
 impl From<v3::registration::GatewayClient> for v4::registration::GatewayClient {
     fn from(gw_client: v3::registration::GatewayClient) -> Self {
         Self {
@@ -94,22 +84,6 @@ impl From<v4::registration::GatewayClient> for v3::registration::GatewayClient {
     }
 }
 
-impl From<v4::registration::GatewayClient> for v2::registration::GatewayClient {
-    fn from(gw_client: v4::registration::GatewayClient) -> Self {
-        Self {
-            pub_key: gw_client.pub_key,
-            private_ip: gw_client.private_ips.ipv4.into(),
-            mac: gw_client.mac.into(),
-        }
-    }
-}
-
-impl From<v2::registration::ClientMac> for v4::registration::ClientMac {
-    fn from(mac: v2::registration::ClientMac) -> Self {
-        Self::new(mac.to_vec())
-    }
-}
-
 impl From<v3::registration::ClientMac> for v4::registration::ClientMac {
     fn from(mac: v3::registration::ClientMac) -> Self {
         Self::new(mac.to_vec())
@@ -122,12 +96,6 @@ impl From<v4::registration::ClientMac> for v3::registration::ClientMac {
     }
 }
 
-impl From<v4::registration::ClientMac> for v2::registration::ClientMac {
-    fn from(mac: v4::registration::ClientMac) -> Self {
-        Self::new(mac.to_vec())
-    }
-}
-
 impl TryFrom<v4::response::AuthenticatorResponse> for v3::response::AuthenticatorResponse {
     type Error = crate::Error;
 

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

@@ -42,12 +42,6 @@ impl IpPair {
     }
 }
 
-impl From<(Ipv4Addr, Ipv6Addr)> for IpPair {
-    fn from((ipv4, ipv6): (Ipv4Addr, Ipv6Addr)) -> Self {
-        IpPair { ipv4, ipv6 }
-    }
-}
-
 impl fmt::Display for IpPair {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "({}, {})", self.ipv4, self.ipv6)

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

@@ -20,6 +20,11 @@ fn generate_random() -> u64 {
     rng.next_u64()
 }
 
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct QueryMessage {
+    pub pub_key: PeerPublicKey,
+}
+
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct AuthenticatorRequest {
     pub protocol: Protocol,
@@ -68,7 +73,7 @@ impl AuthenticatorRequest {
         )
     }
 
-    pub fn new_query_request(peer_public_key: PeerPublicKey, reply_to: Recipient) -> (Self, u64) {
+    pub fn new_query_request(query_message: QueryMessage, reply_to: Recipient) -> (Self, u64) {
         let request_id = generate_random();
         (
             Self {
@@ -76,7 +81,7 @@ impl AuthenticatorRequest {
                     service_provider_type: ServiceProviderType::Authenticator,
                     version: VERSION,
                 },
-                data: AuthenticatorRequestData::QueryBandwidth(peer_public_key),
+                data: AuthenticatorRequestData::QueryBandwidth(query_message.pub_key),
                 reply_to,
                 request_id,
             },

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

@@ -47,7 +47,6 @@ pub fn setup_logging() {
 #[cfg(feature = "basic_tracing")]
 pub fn setup_tracing_logger() {
     let log_builder = tracing_subscriber::fmt()
-        .with_writer(std::io::stderr)
         // Use a more compact, abbreviated log format
         .compact()
         // Display source code file paths

common/client-core/Cargo.toml

@@ -46,7 +46,6 @@ 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/config-types/src/lib.rs

@@ -393,20 +393,13 @@ pub struct Traffic {
     /// poisson distribution.
     pub disable_main_poisson_packet_distribution: bool,
 
-    /// Specify whether route selection should be determined by the packet header.
-    pub deterministic_route_selection: bool,
-
-    /// Specify how many times particular packet can be retransmitted
-    /// None - no limit
-    pub maximum_number_of_retransmissions: Option<u32>,
-
     /// Specifies the packet size used for sent messages.
     /// Do not override it unless you understand the consequences of that change.
     pub primary_packet_size: PacketSize,
 
     /// Specifies the optional auxiliary packet size for optimizing message streams.
     /// Note that its use decreases overall anonymity.
-    /// Do not set it unless you understand the consequences of that change.
+    /// Do not set it it unless you understand the consequences of that change.
     pub secondary_packet_size: Option<PacketSize>,
 
     pub packet_type: PacketType,
@@ -431,8 +424,6 @@ impl Default for Traffic {
             average_packet_delay: DEFAULT_AVERAGE_PACKET_DELAY,
             message_sending_average_delay: DEFAULT_MESSAGE_STREAM_AVERAGE_DELAY,
             disable_main_poisson_packet_distribution: false,
-            deterministic_route_selection: false,
-            maximum_number_of_retransmissions: None,
             primary_packet_size: PacketSize::RegularPacket,
             secondary_packet_size: None,
             packet_type: PacketType::Mix,

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

@@ -111,7 +111,6 @@ impl From<ConfigV5> for Config {
                     primary_packet_size: value.debug.traffic.primary_packet_size,
                     secondary_packet_size: value.debug.traffic.secondary_packet_size,
                     packet_type: value.debug.traffic.packet_type,
-                    ..Default::default()
                 },
                 cover_traffic: CoverTraffic {
                     loop_cover_traffic_average_delay: value

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::oneshot;
+use futures::channel::{mpsc, 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: nym_mixnet_client::forwarder::MixForwardingSender,
+    packet_forwarder: mpsc::UnboundedSender<MixPacket>,
 
     // '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: nym_mixnet_client::forwarder::MixForwardingSender,
+        packet_forwarder: mpsc::UnboundedSender<MixPacket>,
         packet_router_tx: oneshot::Sender<PacketRouter>,
     ) -> Self {
         LocalGateway {
@@ -208,7 +208,8 @@ mod nonwasm_sealed {
     impl GatewaySender for LocalGateway {
         async fn send_mix_packet(&mut self, packet: MixPacket) -> Result<(), ErasedGatewayError> {
             self.packet_forwarder
-                .forward_packet(packet)
+                .unbounded_send(packet)
+                .map_err(|err| err.into_send_error())
                 .map_err(erase_err)
         }
     }

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

@@ -30,8 +30,7 @@ pub(crate) enum Action {
     InsertPending(Vec<PendingAcknowledgement>),
 
     /// Removes given `PendingAcknowledgement` from the 'shared' state. Also cancels the retransmission timer.
-    /// Initiated by `AcknowledgementListener` upon receiving the acknowledgement. Also by `RetransmissionRequestListener`
-    /// upon deciding to abandon the data.
+    /// Initiated by `AcknowledgementListener`
     RemovePending(FragmentIdentifier),
 
     /// Starts the retransmission timer on given `PendingAcknowledgement` with the `Duration` based on
@@ -42,7 +41,7 @@ pub(crate) enum Action {
 
     /// Updates the expected delay of given `PendingAcknowledgement` with the new provided `SphinxDelay`.
     /// Initiated by `RetransmissionRequestListener`
-    UpdatePendingAck(FragmentIdentifier, SphinxDelay),
+    UpdateDelay(FragmentIdentifier, SphinxDelay),
 }
 
 impl Action {
@@ -58,8 +57,8 @@ impl Action {
         Action::StartTimer(frag_id)
     }
 
-    pub(crate) fn new_update_pending_ack(frag_id: FragmentIdentifier, delay: SphinxDelay) -> Self {
-        Action::UpdatePendingAck(frag_id, delay)
+    pub(crate) fn new_update_delay(frag_id: FragmentIdentifier, delay: SphinxDelay) -> Self {
+        Action::UpdateDelay(frag_id, delay)
     }
 }
 
@@ -136,7 +135,7 @@ impl ActionController {
     }
 
     fn handle_start_timer(&mut self, frag_id: FragmentIdentifier) {
-        trace!("{frag_id} is starting its timer");
+        trace!("{} is starting its timer", frag_id);
 
         if let Some((pending_ack_data, queue_key)) = self.pending_acks_data.get_mut(&frag_id) {
             // the fact that this branch is now POSSIBLE is a sign of a need to refactor this whole
@@ -194,7 +193,7 @@ impl ActionController {
 
     // initiated basically as a first step of retransmission. At first data has its delay updated
     // (as new sphinx packet was created with new expected delivery time)
-    fn handle_update_pending_ack(&mut self, frag_id: FragmentIdentifier, delay: SphinxDelay) {
+    fn handle_update_delay(&mut self, frag_id: FragmentIdentifier, delay: SphinxDelay) {
         trace!("{} is updating its delay", frag_id);
         // TODO: is it possible to solve this without either locking or temporarily removing the value?
         if let Some((pending_ack_data, queue_key)) = self.pending_acks_data.remove(&frag_id) {
@@ -203,7 +202,7 @@ impl ActionController {
             // reference to this Arc. HOWEVER, before the Action was pushed onto the queue, the reference
             // was dropped hence this unwrap is safe.
             let mut inner_data = Arc::try_unwrap(pending_ack_data).unwrap();
-            inner_data.update_retransmitted(delay);
+            inner_data.update_delay(delay);
 
             self.pending_acks_data
                 .insert(frag_id, (Arc::new(inner_data), queue_key));
@@ -226,7 +225,7 @@ impl ActionController {
         // about it. Perhaps just reschedule it at later point?
         let frag_id = expired_ack.into_inner();
 
-        trace!("{frag_id} has expired");
+        trace!("{} has expired", frag_id);
 
         if let Some((pending_ack_data, queue_key)) = self.pending_acks_data.get_mut(&frag_id) {
             if queue_key.is_none() {
@@ -259,9 +258,7 @@ impl ActionController {
             Action::InsertPending(pending_acks) => self.handle_insert(pending_acks),
             Action::RemovePending(frag_id) => self.handle_remove(frag_id),
             Action::StartTimer(frag_id) => self.handle_start_timer(frag_id),
-            Action::UpdatePendingAck(frag_id, delay) => {
-                self.handle_update_pending_ack(frag_id, delay)
-            }
+            Action::UpdateDelay(frag_id, delay) => self.handle_update_delay(frag_id, delay),
         }
     }
 

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

@@ -71,7 +71,6 @@ pub(crate) struct PendingAcknowledgement {
     delay: SphinxDelay,
     destination: PacketDestination,
     mix_hops: Option<u8>,
-    retransmissions: u32,
 }
 
 impl PendingAcknowledgement {
@@ -87,7 +86,6 @@ impl PendingAcknowledgement {
             delay,
             destination: PacketDestination::KnownRecipient(recipient.into()),
             mix_hops,
-            retransmissions: 0,
         }
     }
 
@@ -107,7 +105,6 @@ impl PendingAcknowledgement {
             // Messages sent using SURBs are using the number of mix hops set by the recipient when
             // they provided the SURBs, so it doesn't make sense to include it here.
             mix_hops: None,
-            retransmissions: 0,
         }
     }
 
@@ -119,9 +116,8 @@ impl PendingAcknowledgement {
         self.message_chunk.clone()
     }
 
-    fn update_retransmitted(&mut self, new_delay: SphinxDelay) {
+    fn update_delay(&mut self, new_delay: SphinxDelay) {
         self.delay = new_delay;
-        self.retransmissions += 1;
     }
 }
 
@@ -167,9 +163,6 @@ impl AcknowledgementControllerConnectors {
 
 /// Configurable parameters of the `AcknowledgementController`
 pub(super) struct Config {
-    /// Specify how many times particular packet can be retransmitted
-    maximum_retransmissions: Option<u32>,
-
     /// Given ack timeout in the form a * BASE_DELAY + b, it specifies the additive part `b`
     ack_wait_addition: Duration,
 
@@ -181,13 +174,8 @@ pub(super) struct Config {
 }
 
 impl Config {
-    pub(super) fn new(
-        maximum_retransmissions: Option<u32>,
-        ack_wait_addition: Duration,
-        ack_wait_multiplier: f64,
-    ) -> Self {
+    pub(super) fn new(ack_wait_addition: Duration, ack_wait_multiplier: f64) -> Self {
         Config {
-            maximum_retransmissions,
             ack_wait_addition,
             ack_wait_multiplier,
             packet_size: Default::default(),
@@ -250,7 +238,6 @@ where
 
         // will listen for any ack timeouts and trigger retransmission
         let retransmission_request_listener = RetransmissionRequestListener::new(
-            config.maximum_retransmissions,
             connectors.ack_action_sender.clone(),
             message_handler,
             retransmission_rx,

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

@@ -20,7 +20,6 @@ use std::sync::{Arc, Weak};
 
 // responsible for packet retransmission upon fired timer
 pub(super) struct RetransmissionRequestListener<R> {
-    maximum_retransmissions: Option<u32>,
     action_sender: AckActionSender,
     message_handler: MessageHandler<R>,
     request_receiver: RetransmissionRequestReceiver,
@@ -32,14 +31,12 @@ where
     R: CryptoRng + Rng,
 {
     pub(super) fn new(
-        maximum_retransmissions: Option<u32>,
         action_sender: AckActionSender,
         message_handler: MessageHandler<R>,
         request_receiver: RetransmissionRequestReceiver,
         reply_controller_sender: ReplyControllerSender,
     ) -> Self {
         RetransmissionRequestListener {
-            maximum_retransmissions,
             action_sender,
             message_handler,
             request_receiver,
@@ -80,18 +77,6 @@ where
             }
         };
 
-        let frag_id = timed_out_ack.message_chunk.fragment_identifier();
-
-        if let Some(limit) = self.maximum_retransmissions {
-            if timed_out_ack.retransmissions >= limit {
-                warn!("reached maximum number of allowed retransmissions for the packet");
-                self.action_sender
-                    .unbounded_send(Action::new_remove(frag_id))
-                    .unwrap();
-                return;
-            }
-        }
-
         let maybe_prepared_fragment = match &timed_out_ack.destination {
             PacketDestination::Anonymous {
                 recipient_tag,
@@ -116,6 +101,8 @@ where
             }
         };
 
+        let frag_id = timed_out_ack.message_chunk.fragment_identifier();
+
         let prepared_fragment = match maybe_prepared_fragment {
             Ok(prepared_fragment) => prepared_fragment,
             Err(err) => {
@@ -149,7 +136,7 @@ where
         // with the additional poisson delay.
         // And since Actions are executed in order `UpdateTimer` will HAVE TO be executed before `StartTimer`
         self.action_sender
-            .unbounded_send(Action::new_update_pending_ack(frag_id, new_delay))
+            .unbounded_send(Action::new_update_delay(frag_id, new_delay))
             .unwrap();
 
         // send to `OutQueueControl` to eventually send to the mix network

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

@@ -91,9 +91,6 @@ pub(crate) struct Config {
     /// and surb-based are going to be sent.
     sender_address: Recipient,
 
-    /// Specify whether route selection should be determined by the packet header.
-    deterministic_route_selection: bool,
-
     /// Average delay a data packet is going to get delay at a single mixnode.
     average_packet_delay: Duration,
 
@@ -117,12 +114,10 @@ impl Config {
         sender_address: Recipient,
         average_packet_delay: Duration,
         average_ack_delay: Duration,
-        deterministic_route_selection: bool,
     ) -> Self {
         Config {
             ack_key,
             sender_address,
-            deterministic_route_selection,
             average_packet_delay,
             average_ack_delay,
             num_mix_hops: DEFAULT_NUM_MIX_HOPS,
@@ -181,7 +176,6 @@ where
     {
         let message_preparer = MessagePreparer::new(
             rng,
-            config.deterministic_route_selection,
             config.sender_address,
             config.average_packet_delay,
             config.average_ack_delay,
@@ -640,7 +634,7 @@ where
 
     pub(crate) fn update_ack_delay(&self, id: FragmentIdentifier, new_delay: Delay) {
         self.action_sender
-            .unbounded_send(Action::UpdatePendingAck(id, new_delay))
+            .unbounded_send(Action::UpdateDelay(id, new_delay))
             .expect("action control task has died")
     }
 

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

@@ -65,7 +65,6 @@ pub struct Config {
 impl<'a> From<&'a Config> for acknowledgement_control::Config {
     fn from(cfg: &'a Config) -> Self {
         acknowledgement_control::Config::new(
-            cfg.traffic.maximum_number_of_retransmissions,
             cfg.acks.ack_wait_addition,
             cfg.acks.ack_wait_multiplier,
         )
@@ -98,7 +97,6 @@ impl<'a> From<&'a Config> for message_handler::Config {
             cfg.self_recipient,
             cfg.traffic.average_packet_delay,
             cfg.acks.average_ack_delay,
-            cfg.traffic.deterministic_route_selection,
         )
         .with_custom_primary_packet_size(cfg.traffic.primary_packet_size)
         .with_custom_secondary_packet_size(cfg.traffic.secondary_packet_size)

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

@@ -38,7 +38,7 @@ pub struct TopologyReadPermit<'a> {
     permit: RwLockReadGuard<'a, Option<NymTopology>>,
 }
 
-impl Deref for TopologyReadPermit<'_> {
+impl<'a> Deref for TopologyReadPermit<'a> {
     type Target = Option<NymTopology>;
 
     fn deref(&self) -> &Self::Target {

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

@@ -46,8 +46,7 @@ pub(crate) fn ws_fd(_conn: &WsConn) -> Option<RawFd> {
     #[cfg(unix)]
     match _conn.get_ref() {
         MaybeTlsStream::Plain(stream) => Some(stream.as_raw_fd()),
-        MaybeTlsStream::Rustls(tls_stream) => Some(tls_stream.as_raw_fd()),
-        _ => None,
+        &_ => None,
     }
     #[cfg(not(unix))]
     None

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

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

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

@@ -3,6 +3,7 @@
 
 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;
@@ -17,14 +18,13 @@ 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,12 +33,14 @@ 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,
         }
     }
 }
@@ -198,8 +200,9 @@ impl SendWithoutResponse for Client {
         packet: NymPacket,
         packet_type: PacketType,
     ) -> io::Result<()> {
-        trace!("Sending packet to {address:?}");
-        let framed_packet = FramedNymPacket::new(packet, packet_type);
+        trace!("Sending packet to {:?}", address);
+        let framed_packet =
+            FramedNymPacket::new(packet, packet_type, self.config.use_legacy_version);
 
         if let Some(sender) = self.conn_new.get_mut(&address) {
             if let Err(err) = sender.channel.try_send(framed_packet) {
@@ -257,6 +260,7 @@ 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,72 +1,77 @@
 // 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::channel::mpsc::SendError;
+use futures::StreamExt;
+use log::*;
 use nym_sphinx::forwarding::packet::MixPacket;
-use tokio::time::Instant;
+use std::time::Duration;
 
-pub fn mix_forwarding_channels() -> (MixForwardingSender, MixForwardingReceiver) {
-    let (tx, rx) = mpsc::unbounded();
-    (tx.into(), rx)
+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,
 }
 
-#[derive(Clone)]
-pub struct MixForwardingSender(mpsc::UnboundedSender<PacketToForward>);
+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,
+        );
 
-impl From<mpsc::UnboundedSender<PacketToForward>> for MixForwardingSender {
-    fn from(tx: mpsc::UnboundedSender<PacketToForward>) -> Self {
-        MixForwardingSender(tx)
-    }
-}
+        let (packet_sender, packet_receiver) = mpsc::unbounded();
 
-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())
+        (
+            PacketForwarder {
+                mixnet_client: Client::new(client_config),
+                packet_receiver,
+                shutdown,
+            },
+            packet_sender,
+        )
     }
 
-    #[allow(clippy::len_without_is_empty)]
-    pub fn len(&self) -> usize {
-        self.0.len()
-    }
-}
+    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());
 
-pub type MixForwardingReceiver = mpsc::UnboundedReceiver<PacketToForward>;
+                    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 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,
+                    if let Err(err) =
+                        self.mixnet_client
+                            .send_without_response(next_hop, packet, packet_type)
+                    {
+                        debug!("failed to forward the packet - {err}")
+                    }
+                }
+            }
         }
     }
-
-    pub fn new_no_delay(packet: MixPacket) -> Self {
-        Self::new(packet, None)
-    }
 }

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

@@ -1,9 +1,7 @@
 // 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

@@ -1,6 +1,7 @@
 // Copyright 2021-2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
+pub use crate::nym_api::NymApiClientExt;
 use crate::nyxd::{self, NyxdClient};
 use crate::signing::direct_wallet::DirectSecp256k1HdWallet;
 use crate::signing::signer::{NoSigner, OfflineSigner};
@@ -31,7 +32,6 @@ use nym_network_defaults::NymNetworkDetails;
 use time::Date;
 use url::Url;
 
-pub use crate::nym_api::NymApiClientExt;
 pub use nym_mixnet_contract_common::{
     mixnode::MixNodeDetails, GatewayBond, IdentityKey, IdentityKeyRef, NodeId, NymNodeDetails,
 };
@@ -332,10 +332,10 @@ impl NymApiClient {
         NymApiClient { nym_api }
     }
 
-    pub fn new_with_user_agent(api_url: Url, user_agent: impl Into<UserAgent>) -> Self {
+    pub fn new_with_user_agent(api_url: Url, user_agent: UserAgent) -> Self {
         let nym_api = nym_api::Client::builder::<_, ValidatorClientError>(api_url)
             .expect("invalid api url")
-            .with_user_agent(user_agent.into())
+            .with_user_agent(user_agent)
             .build::<ValidatorClientError>()
             .expect("failed to build nym api client");
 

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

@@ -13,7 +13,7 @@ use nym_api_requests::ecash::models::{
 use nym_api_requests::ecash::VerificationKeyResponse;
 use nym_api_requests::models::{
     AnnotationResponse, ApiHealthResponse, LegacyDescribedMixNode, NodePerformanceResponse,
-    NodeRefreshBody, NymNodeDescription,
+    NymNodeDescription,
 };
 use nym_api_requests::nym_nodes::PaginatedCachedNodesResponse;
 use nym_api_requests::pagination::PaginatedResponse;
@@ -695,32 +695,16 @@ pub trait NymApiClientExt: ApiClient {
         &self,
         node_id: NodeId,
     ) -> Result<NodePerformanceResponse, NymAPIError> {
-        self.get_json(
-            &[
-                routes::API_VERSION,
-                "nym-nodes",
-                "performance",
-                &node_id.to_string(),
-            ],
-            NO_PARAMS,
-        )
-        .await
+        self.get_json_from(format!("/v1/nym-nodes/performance/{node_id}"))
+            .await
     }
 
     async fn get_node_annotation(
         &self,
         node_id: NodeId,
     ) -> Result<AnnotationResponse, NymAPIError> {
-        self.get_json(
-            &[
-                routes::API_VERSION,
-                "nym-nodes",
-                "annotation",
-                &node_id.to_string(),
-            ],
-            NO_PARAMS,
-        )
-        .await
+        self.get_json_from(format!("/v1/nym-nodes/annotation/{node_id}"))
+            .await
     }
 
     #[deprecated]
@@ -933,18 +917,6 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    async fn force_refresh_describe_cache(
-        &self,
-        request: &NodeRefreshBody,
-    ) -> Result<(), NymAPIError> {
-        self.post_json(
-            &[routes::API_VERSION, "nym-nodes", "refresh-described"],
-            NO_PARAMS,
-            request,
-        )
-        .await
-    }
-
     async fn issued_ticketbooks_for(
         &self,
         expiration_date: Date,

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

@@ -32,7 +32,7 @@ impl Div<GasPrice> for Coin {
     }
 }
 
-impl Div<GasPrice> for &Coin {
+impl<'a> Div<GasPrice> for &'a Coin {
     type Output = Gas;
 
     fn div(self, rhs: GasPrice) -> Self::Output {

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

@@ -10,10 +10,10 @@ use cosmrs::AccountId;
 use nym_contracts_common::signing::Nonce;
 use nym_mixnet_contract_common::gateway::{PreassignedGatewayIdsResponse, PreassignedId};
 use nym_mixnet_contract_common::nym_node::{
-    EpochAssignmentResponse, NodeDetailsByIdentityResponse, NodeDetailsResponse,
-    NodeOwnershipResponse, NodeRewardingDetailsResponse, PagedNymNodeBondsResponse,
-    PagedNymNodeDetailsResponse, PagedUnbondedNymNodesResponse, Role, RolesMetadataResponse,
-    StakeSaturationResponse, UnbondedNodeResponse, UnbondedNymNode,
+    EpochAssignmentResponse, NodeDetailsByIdentityResponse, NodeOwnershipResponse,
+    NodeRewardingDetailsResponse, PagedNymNodeBondsResponse, PagedNymNodeDetailsResponse,
+    PagedUnbondedNymNodesResponse, Role, RolesMetadataResponse, StakeSaturationResponse,
+    UnbondedNodeResponse, UnbondedNymNode,
 };
 use nym_mixnet_contract_common::reward_params::WorkFactor;
 use nym_mixnet_contract_common::{
@@ -311,7 +311,10 @@ pub trait MixnetQueryClient {
         .await
     }
 
-    async fn get_nymnode_details(&self, node_id: NodeId) -> Result<NodeDetailsResponse, NyxdError> {
+    async fn get_nymnode_details(
+        &self,
+        node_id: NodeId,
+    ) -> Result<NodeOwnershipResponse, NyxdError> {
         self.query_mixnet_contract(MixnetQueryMsg::GetNymNodeDetails { node_id })
             .await
     }

common/client-libs/validator-client/src/nyxd/fee/gas_price.rs

@@ -22,7 +22,7 @@ pub struct GasPrice {
     pub denom: String,
 }
 
-impl Mul<Gas> for &GasPrice {
+impl<'a> Mul<Gas> for &'a GasPrice {
     type Output = Coin;
 
     fn mul(self, gas_limit: Gas) -> Self::Output {

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

@@ -98,13 +98,6 @@ impl DirectSecp256k1HdWallet {
         Ok((private_key, public_key))
     }
 
-    pub fn derive_extended_private_key(
-        &self,
-        hd_path: &DerivationPath,
-    ) -> Result<XPrv, DirectSecp256k1HdWalletError> {
-        Ok(XPrv::derive_from_path(self.seed, hd_path)?)
-    }
-
     pub fn try_derive_accounts(&self) -> Result<Vec<AccountData>, DirectSecp256k1HdWalletError> {
         let mut accounts = Vec::with_capacity(self.accounts.len());
         for derivation_info in &self.accounts {

common/commands/Cargo.toml

@@ -48,7 +48,6 @@ 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" }
@@ -57,7 +56,6 @@ 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

@@ -1,41 +0,0 @@
-// 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

@@ -1,23 +0,0 @@
-// 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

@@ -1,78 +0,0 @@
-// 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

@@ -1,19 +0,0 @@
-// 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,6 +3,5 @@
 
 pub mod context;
 pub mod ecash;
-pub mod internal;
 pub mod utils;
 pub mod validator;

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

@@ -32,7 +32,7 @@ pub(crate) mod string_rfc3339_offset_date_time {
 
     struct Rfc3339OffsetDateTimeVisitor;
 
-    impl Visitor<'_> for Rfc3339OffsetDateTimeVisitor {
+    impl<'de> Visitor<'de> for Rfc3339OffsetDateTimeVisitor {
         type Value = OffsetDateTime;
 
         fn expecting(&self, formatter: &mut Formatter<'_>) -> std::fmt::Result {

common/cosmwasm-smart-contracts/vesting-contract/Cargo.toml

@@ -15,9 +15,7 @@ mixnet-contract-common = { path = "../mixnet-contract", package = "nym-mixnet-co
 contracts-common = { path = "../contracts-common", package = "nym-contracts-common", version = "0.5.0" }
 serde = { workspace = true, features = ["derive"] }
 thiserror = { workspace = true }
-# without this feature, cargo clippy emits a ton of incompatibility warnings
-# https://docs.rs/ts-rs/latest/ts_rs/#serde-compatability
-ts-rs = { workspace = true, optional = true, features = ["no-serde-warnings"] }
+ts-rs = { workspace = true, optional = true}
 
 [features]
 schema = ["cw2"]

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::GatewayStorage;
+use nym_gateway_storage::Storage;
 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 {
-    pub(crate) storage: GatewayStorage,
+pub struct BandwidthStorageManager<S> {
+    pub(crate) storage: S,
     pub(crate) client_bandwidth: ClientBandwidth,
     pub(crate) client_id: i64,
     pub(crate) bandwidth_cfg: BandwidthFlushingBehaviourConfig,
     pub(crate) only_coconut_credentials: bool,
 }
 
-impl BandwidthStorageManager {
+impl<S: Storage + Clone + 'static> BandwidthStorageManager<S> {
     pub fn new(
-        storage: GatewayStorage,
+        storage: S,
         client_bandwidth: ClientBandwidth,
         client_id: i64,
         bandwidth_cfg: BandwidthFlushingBehaviourConfig,
@@ -111,7 +111,7 @@ impl BandwidthStorageManager {
     }
 
     #[instrument(level = "trace", skip_all)]
-    pub async fn sync_storage_bandwidth(&mut self) -> Result<()> {
+    async fn sync_storage_bandwidth(&mut self) -> Result<()> {
         trace!("syncing client bandwidth with the underlying storage");
         let updated = self
             .storage

common/credential-verification/src/client_bandwidth.rs

@@ -8,8 +8,8 @@ use std::time::Duration;
 use time::OffsetDateTime;
 use tokio::sync::RwLock;
 
-const DEFAULT_CLIENT_BANDWIDTH_MAX_FLUSHING_RATE: Duration = Duration::from_secs(5 * 60); // 5 minutes
-const DEFAULT_CLIENT_BANDWIDTH_MAX_DELTA_FLUSHING_AMOUNT: i64 = 5 * 1024 * 1024; // 5MB
+const DEFAULT_CLIENT_BANDWIDTH_MAX_FLUSHING_RATE: Duration = Duration::from_millis(5);
+const DEFAULT_CLIENT_BANDWIDTH_MAX_DELTA_FLUSHING_AMOUNT: i64 = 512 * 1024; // 512kB
 
 #[derive(Debug, Clone, Copy)]
 pub struct BandwidthFlushingBehaviourConfig {

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

@@ -13,6 +13,7 @@ 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,
@@ -125,18 +126,21 @@ pub struct CredentialHandlerConfig {
     pub maximum_time_between_redemption: Duration,
 }
 
-pub(crate) struct CredentialHandler {
+pub(crate) struct CredentialHandler<St: Storage> {
     config: CredentialHandlerConfig,
     multisig_threshold: f32,
     ticket_receiver: UnboundedReceiver<ClientTicket>,
-    shared_state: SharedState,
+    shared_state: SharedState<St>,
     pending_tickets: Vec<PendingVerification>,
     pending_redemptions: Vec<PendingRedemptionVote>,
 }
 
-impl CredentialHandler {
+impl<St> CredentialHandler<St>
+where
+    St: Storage + Clone + 'static,
+{
     async fn rebuild_pending_tickets(
-        shared_state: &SharedState,
+        shared_state: &SharedState<St>,
     ) -> Result<Vec<PendingVerification>, EcashTicketError> {
         // 1. get all tickets that were not fully verified
         let unverified = shared_state.storage.get_all_unverified_tickets().await?;
@@ -184,7 +188,7 @@ impl CredentialHandler {
     }
 
     async fn rebuild_pending_votes(
-        shared_state: &SharedState,
+        shared_state: &SharedState<St>,
     ) -> Result<Vec<PendingRedemptionVote>, EcashTicketError> {
         // 1. get all tickets that were not fully verified
         let unverified = shared_state.storage.get_all_unresolved_proposals().await?;
@@ -255,7 +259,7 @@ impl CredentialHandler {
     pub(crate) async fn new(
         config: CredentialHandlerConfig,
         ticket_receiver: UnboundedReceiver<ClientTicket>,
-        shared_state: SharedState,
+        shared_state: SharedState<St>,
     ) -> 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::GatewayStorageError;
+use nym_gateway_storage::error::StorageError;
 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: GatewayStorageError,
+        source: StorageError,
     },
 
     #[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::GatewayStorage;
+use nym_gateway_storage::Storage;
 use nym_validator_client::nym_api::EpochId;
 use nym_validator_client::DirectSigningHttpRpcNyxdClient;
 use state::SharedState;
@@ -23,21 +23,24 @@ mod state;
 
 pub const TIME_RANGE_SEC: i64 = 30;
 
-pub struct EcashManager {
-    shared_state: SharedState,
+pub struct EcashManager<S> {
+    shared_state: SharedState<S>,
 
     pk_bytes: [u8; 32], // bytes representation of a pub key representing the verifier
     pay_infos: Mutex<Vec<NymPayInfo>>,
     cred_sender: UnboundedSender<ClientTicket>,
 }
 
-impl EcashManager {
+impl<S> EcashManager<S>
+where
+    S: Storage + Clone + 'static,
+{
     pub async fn new(
         credential_handler_cfg: CredentialHandlerConfig,
         nyxd_client: DirectSigningHttpRpcNyxdClient,
         pk_bytes: [u8; 32],
         shutdown: nym_task::TaskClient,
-        storage: GatewayStorage,
+        storage: S,
     ) -> Result<Self, Error> {
         let shared_state = SharedState::new(nyxd_client, storage).await?;
 
@@ -63,7 +66,7 @@ impl EcashManager {
         self.shared_state.verification_key(epoch_id).await
     }
 
-    pub fn storage(&self) -> &GatewayStorage {
+    pub fn storage(&self) -> &S {
         &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::GatewayStorage;
+use nym_gateway_storage::Storage;
 use nym_validator_client::coconut::all_ecash_api_clients;
 use nym_validator_client::nym_api::EpochId;
 use nym_validator_client::nyxd::contract_traits::{
@@ -23,17 +23,20 @@ use tracing::{error, trace, warn};
 
 // state shared by different subtasks dealing with credentials
 #[derive(Clone)]
-pub(crate) struct SharedState {
+pub(crate) struct SharedState<S> {
     pub(crate) nyxd_client: Arc<RwLock<DirectSigningHttpRpcNyxdClient>>,
     pub(crate) address: AccountId,
     pub(crate) epoch_data: Arc<RwLock<BTreeMap<EpochId, EpochState>>>,
-    pub(crate) storage: GatewayStorage,
+    pub(crate) storage: S,
 }
 
-impl SharedState {
+impl<S> SharedState<S>
+where
+    S: Storage + Clone,
+{
     pub(crate) async fn new(
         nyxd_client: DirectSigningHttpRpcNyxdClient,
-        storage: GatewayStorage,
+        storage: S,
     ) -> 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::GatewayStorageError),
+    StorageError(#[from] nym_gateway_storage::error::StorageError),
 
     #[error("{0}")]
     UnknownTicketType(#[from] nym_credentials_interface::UnknownTicketType),

common/credential-verification/src/lib.rs

@@ -2,15 +2,17 @@
 // 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;
@@ -18,17 +20,17 @@ mod client_bandwidth;
 pub mod ecash;
 pub mod error;
 
-pub struct CredentialVerifier {
+pub struct CredentialVerifier<S> {
     credential: CredentialSpendingRequest,
-    ecash_verifier: Arc<EcashManager>,
-    bandwidth_storage_manager: BandwidthStorageManager,
+    ecash_verifier: Arc<EcashManager<S>>,
+    bandwidth_storage_manager: BandwidthStorageManager<S>,
 }
 
-impl CredentialVerifier {
+impl<S: Storage + Clone + 'static> CredentialVerifier<S> {
     pub fn new(
         credential: CredentialSpendingRequest,
-        ecash_verifier: Arc<EcashManager>,
-        bandwidth_storage_manager: BandwidthStorageManager,
+        ecash_verifier: Arc<EcashManager<S>>,
+        bandwidth_storage_manager: BandwidthStorageManager<S>,
     ) -> Self {
         CredentialVerifier {
             credential,

common/credentials-interface/src/lib.rs

@@ -221,17 +221,7 @@ impl From<PayInfo> for NymPayInfo {
 }
 
 #[derive(
-    Copy,
-    Clone,
-    Debug,
-    PartialEq,
-    Eq,
-    Serialize,
-    Deserialize,
-    Hash,
-    strum::Display,
-    strum::EnumString,
-    strum::EnumIter,
+    Copy, Clone, Debug, PartialEq, Serialize, Deserialize, strum::Display, strum::EnumString,
 )]
 #[serde(rename_all = "kebab-case")]
 #[strum(serialize_all = "kebab-case")]

common/crypto/Cargo.toml

@@ -41,6 +41,6 @@ aead = ["dep:aead", "aead/std", "aes-gcm-siv", "generic-array"]
 serde = ["dep:serde", "serde_bytes", "ed25519-dalek/serde", "x25519-dalek/serde"]
 asymmetric = ["x25519-dalek", "ed25519-dalek", "zeroize"]
 hashing = ["blake3", "digest", "hkdf", "hmac", "generic-array"]
-stream_cipher = ["aes", "ctr", "cipher", "cipher/zeroize", "generic-array"]
+stream_cipher = ["aes", "ctr", "cipher", "generic-array"]
 sphinx = ["nym-sphinx-types/sphinx"]
 outfox = ["nym-sphinx-types/outfox"]

common/dkg/src/bte/proof_chunking.rs

@@ -26,8 +26,9 @@ const PARALLEL_RUNS: usize = 32;
 /// `lambda` ($\lambda$) in the DKG paper
 const SECURITY_PARAMETER: usize = 256;
 
+// note: ceiling in integer division can be achieved via q = (x + y - 1) / y;
 /// ceil(SECURITY_PARAMETER / PARALLEL_RUNS) in the paper
-const NUM_CHALLENGE_BITS: usize = SECURITY_PARAMETER.div_ceil(PARALLEL_RUNS);
+const NUM_CHALLENGE_BITS: usize = (SECURITY_PARAMETER + PARALLEL_RUNS - 1) / PARALLEL_RUNS;
 
 // type alias for ease of use
 type FirstChallenge = Vec<Vec<Vec<u64>>>;

common/dkg/src/interpolation/polynomial.rs

@@ -196,7 +196,7 @@ impl<'b> Add<&'b Polynomial> for Polynomial {
     }
 }
 
-impl Add<Polynomial> for &Polynomial {
+impl<'a> Add<Polynomial> for &'a Polynomial {
     type Output = Polynomial;
 
     fn add(self, rhs: Polynomial) -> Polynomial {
@@ -212,10 +212,10 @@ impl Add<Polynomial> for Polynomial {
     }
 }
 
-impl<'a> Add<&'a Polynomial> for &Polynomial {
+impl<'a, 'b> Add<&'b Polynomial> for &'a Polynomial {
     type Output = Polynomial;
 
-    fn add(self, rhs: &'a Polynomial) -> Self::Output {
+    fn add(self, rhs: &'b Polynomial) -> Self::Output {
         let len = self.coefficients.len();
         let rhs_len = rhs.coefficients.len();
 

common/gateway-requests/src/registration/handshake/mod.rs

@@ -37,7 +37,7 @@ pub struct GatewayHandshake<'a> {
     handshake_future: BoxFuture<'a, Result<SharedGatewayKey, HandshakeError>>,
 }
 
-impl Future for GatewayHandshake<'_> {
+impl<'a> Future for GatewayHandshake<'a> {
     type Output = Result<SharedGatewayKey, HandshakeError>;
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {

common/gateway-stats-storage/Cargo.toml

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

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

@@ -1,11 +1,9 @@
 // Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: GPL-3.0-only
 
-use nym_node_metrics::entry::{ActiveSession, FinishedSession, SessionType};
+use nym_credentials_interface::TicketType;
 use sqlx::prelude::FromRow;
-use time::OffsetDateTime;
-
-pub use nym_credentials_interface::TicketType;
+use time::{Duration, OffsetDateTime};
 
 #[derive(FromRow)]
 pub struct StoredFinishedSession {
@@ -13,26 +11,52 @@ pub struct StoredFinishedSession {
     typ: String,
 }
 
-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),
+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(),
+        )
+    }
+}
+
+pub struct FinishedSession {
+    pub duration: Duration,
+    pub typ: SessionType,
+}
+
+#[derive(PartialEq)]
+pub enum SessionType {
+    Vpn,
+    Mixnet,
+    Unknown,
+}
+
+impl SessionType {
+    pub fn to_string(&self) -> &str {
+        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,
         }
     }
 }
 
-pub trait ToSessionType {
-    fn to_session_type(&self) -> SessionType;
-}
-
-impl ToSessionType for TicketType {
-    fn to_session_type(&self) -> SessionType {
-        match self {
-            TicketType::V1MixnetEntry => SessionType::Mixnet,
-            TicketType::V1MixnetExit => SessionType::Mixnet,
-            TicketType::V1WireguardEntry => SessionType::Vpn,
-            TicketType::V1WireguardExit => SessionType::Vpn,
+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,
         }
     }
 }
@@ -43,6 +67,38 @@ 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,6 +9,7 @@ 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 GatewayStorageError {
+pub enum StorageError {
     #[error("Database experienced an internal error: {0}")]
     InternalDatabaseError(#[from] sqlx::Error),
 

common/gateway-storage/src/lib.rs

@@ -1,8 +1,10 @@
 // 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,
@@ -27,11 +29,237 @@ mod shared_keys;
 mod tickets;
 mod wireguard_peers;
 
-pub use error::GatewayStorageError;
+#[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>;
+}
 
 // note that clone here is fine as upon cloning the same underlying pool will be used
 #[derive(Clone)]
-pub struct GatewayStorage {
+pub struct PersistentStorage {
     client_manager: ClientManager,
     shared_key_manager: SharedKeysManager,
     inbox_manager: InboxManager,
@@ -40,7 +268,7 @@ pub struct GatewayStorage {
     wireguard_peer_manager: wireguard_peers::WgPeerManager,
 }
 
-impl GatewayStorage {
+impl PersistentStorage {
     /// Initialises `PersistentStorage` using the provided path.
     ///
     /// # Arguments
@@ -50,7 +278,7 @@ impl GatewayStorage {
     pub async fn init<P: AsRef<Path> + Send>(
         database_path: P,
         message_retrieval_limit: i64,
-    ) -> Result<Self, GatewayStorageError> {
+    ) -> Result<Self, StorageError> {
         debug!(
             "Attempting to connect to database {:?}",
             database_path.as_ref().as_os_str()
@@ -79,7 +307,7 @@ impl GatewayStorage {
         }
 
         // the cloning here are cheap as connection pool is stored behind an Arc
-        Ok(GatewayStorage {
+        Ok(PersistentStorage {
             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()),
@@ -90,22 +318,23 @@ impl GatewayStorage {
     }
 }
 
-impl GatewayStorage {
-    pub async fn get_mixnet_client_id(
+#[async_trait]
+impl Storage for PersistentStorage {
+    async fn get_mixnet_client_id(
         &self,
         client_address: DestinationAddressBytes,
-    ) -> Result<i64, GatewayStorageError> {
+    ) -> Result<i64, StorageError> {
         Ok(self
             .shared_key_manager
             .client_id(&client_address.as_base58_string())
             .await?)
     }
 
-    pub async fn insert_shared_keys(
+    async fn insert_shared_keys(
         &self,
         client_address: DestinationAddressBytes,
         shared_keys: &SharedGatewayKey,
-    ) -> Result<i64, GatewayStorageError> {
+    ) -> Result<i64, StorageError> {
         let client_address_bs58 = client_address.as_base58_string();
         let client_id = match self
             .shared_key_manager
@@ -130,10 +359,10 @@ impl GatewayStorage {
         Ok(client_id)
     }
 
-    pub async fn get_shared_keys(
+    async fn get_shared_keys(
         &self,
         client_address: DestinationAddressBytes,
-    ) -> Result<Option<PersistedSharedKeys>, GatewayStorageError> {
+    ) -> Result<Option<PersistedSharedKeys>, StorageError> {
         let keys = self
             .shared_key_manager
             .get_shared_keys(&client_address.as_base58_string())
@@ -142,37 +371,37 @@ impl GatewayStorage {
     }
 
     #[allow(dead_code)]
-    pub async fn remove_shared_keys(
+    async fn remove_shared_keys(
         &self,
         client_address: DestinationAddressBytes,
-    ) -> Result<(), GatewayStorageError> {
+    ) -> Result<(), StorageError> {
         self.shared_key_manager
             .remove_shared_keys(&client_address.as_base58_string())
             .await?;
         Ok(())
     }
 
-    pub async fn get_client(&self, client_id: i64) -> Result<Option<Client>, GatewayStorageError> {
+    async fn get_client(&self, client_id: i64) -> Result<Option<Client>, StorageError> {
         let client = self.client_manager.get_client(client_id).await?;
         Ok(client)
     }
 
-    pub async fn store_message(
+    async fn store_message(
         &self,
         client_address: DestinationAddressBytes,
         message: Vec<u8>,
-    ) -> Result<(), GatewayStorageError> {
+    ) -> Result<(), StorageError> {
         self.inbox_manager
             .insert_message(&client_address.as_base58_string(), message)
             .await?;
         Ok(())
     }
 
-    pub async fn retrieve_messages(
+    async fn retrieve_messages(
         &self,
         client_address: DestinationAddressBytes,
         start_after: Option<i64>,
-    ) -> Result<(Vec<StoredMessage>, Option<i64>), GatewayStorageError> {
+    ) -> Result<(Vec<StoredMessage>, Option<i64>), StorageError> {
         let messages = self
             .inbox_manager
             .get_messages(&client_address.as_base58_string(), start_after)
@@ -180,95 +409,87 @@ impl GatewayStorage {
         Ok(messages)
     }
 
-    pub async fn remove_messages(&self, ids: Vec<i64>) -> Result<(), GatewayStorageError> {
+    async fn remove_messages(&self, ids: Vec<i64>) -> Result<(), StorageError> {
         for id in ids {
             self.inbox_manager.remove_message(id).await?;
         }
         Ok(())
     }
 
-    pub async fn create_bandwidth_entry(&self, client_id: i64) -> Result<(), GatewayStorageError> {
+    async fn create_bandwidth_entry(&self, client_id: i64) -> Result<(), StorageError> {
         self.bandwidth_manager.insert_new_client(client_id).await?;
         Ok(())
     }
 
-    pub async fn set_expiration(
+    async fn set_expiration(
         &self,
         client_id: i64,
         expiration: OffsetDateTime,
-    ) -> Result<(), GatewayStorageError> {
+    ) -> Result<(), StorageError> {
         self.bandwidth_manager
             .set_expiration(client_id, expiration)
             .await?;
         Ok(())
     }
 
-    pub async fn reset_bandwidth(&self, client_id: i64) -> Result<(), GatewayStorageError> {
+    async fn reset_bandwidth(&self, client_id: i64) -> Result<(), StorageError> {
         self.bandwidth_manager.reset_bandwidth(client_id).await?;
         Ok(())
     }
 
-    pub async fn get_available_bandwidth(
+    async fn get_available_bandwidth(
         &self,
         client_id: i64,
-    ) -> Result<Option<PersistedBandwidth>, GatewayStorageError> {
+    ) -> Result<Option<PersistedBandwidth>, StorageError> {
         Ok(self
             .bandwidth_manager
             .get_available_bandwidth(client_id)
             .await?)
     }
 
-    pub async fn increase_bandwidth(
-        &self,
-        client_id: i64,
-        amount: i64,
-    ) -> Result<i64, GatewayStorageError> {
+    async fn increase_bandwidth(&self, client_id: i64, amount: i64) -> Result<i64, StorageError> {
         Ok(self
             .bandwidth_manager
             .increase_bandwidth(client_id, amount)
             .await?)
     }
 
-    pub async fn revoke_ticket_bandwidth(
+    async fn revoke_ticket_bandwidth(
         &self,
         ticket_id: i64,
         amount: i64,
-    ) -> Result<(), GatewayStorageError> {
+    ) -> Result<(), StorageError> {
         Ok(self
             .bandwidth_manager
             .revoke_ticket_bandwidth(ticket_id, amount)
             .await?)
     }
 
-    pub async fn decrease_bandwidth(
-        &self,
-        client_id: i64,
-        amount: i64,
-    ) -> Result<i64, GatewayStorageError> {
+    async fn decrease_bandwidth(&self, client_id: i64, amount: i64) -> Result<i64, StorageError> {
         Ok(self
             .bandwidth_manager
             .decrease_bandwidth(client_id, amount)
             .await?)
     }
 
-    pub async fn insert_epoch_signers(
+    async fn insert_epoch_signers(
         &self,
         epoch_id: i64,
         signer_ids: Vec<i64>,
-    ) -> Result<(), GatewayStorageError> {
+    ) -> Result<(), StorageError> {
         self.ticket_manager
             .insert_ecash_signers(epoch_id, signer_ids)
             .await?;
         Ok(())
     }
 
-    pub async fn insert_received_ticket(
+    async fn insert_received_ticket(
         &self,
         client_id: i64,
         received_at: OffsetDateTime,
         serial_number: Vec<u8>,
         data: Vec<u8>,
-    ) -> Result<i64, GatewayStorageError> {
+    ) -> Result<i64, StorageError> {
         // 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
@@ -282,24 +503,24 @@ impl GatewayStorage {
         Ok(ticket_id)
     }
 
-    pub async fn contains_ticket(&self, serial_number: &[u8]) -> Result<bool, GatewayStorageError> {
+    async fn contains_ticket(&self, serial_number: &[u8]) -> Result<bool, StorageError> {
         Ok(self.ticket_manager.has_ticket_data(serial_number).await?)
     }
 
-    pub async fn insert_ticket_verification(
+    async fn insert_ticket_verification(
         &self,
         ticket_id: i64,
         signer_id: i64,
         verified_at: OffsetDateTime,
         accepted: bool,
-    ) -> Result<(), GatewayStorageError> {
+    ) -> Result<(), StorageError> {
         self.ticket_manager
             .insert_ticket_verification(ticket_id, signer_id, verified_at, accepted)
             .await?;
         Ok(())
     }
 
-    pub async fn update_rejected_ticket(&self, ticket_id: i64) -> Result<(), GatewayStorageError> {
+    async fn update_rejected_ticket(&self, ticket_id: i64) -> Result<(), StorageError> {
         // set the ticket as rejected
         self.ticket_manager.set_rejected_ticket(ticket_id).await?;
 
@@ -310,7 +531,7 @@ impl GatewayStorage {
         Ok(())
     }
 
-    pub async fn update_verified_ticket(&self, ticket_id: i64) -> Result<(), GatewayStorageError> {
+    async fn update_verified_ticket(&self, ticket_id: i64) -> Result<(), StorageError> {
         // 1. insert into verified table
         self.ticket_manager
             .insert_verified_ticket(ticket_id)
@@ -324,41 +545,36 @@ impl GatewayStorage {
         Ok(())
     }
 
-    pub async fn remove_verified_ticket_binary_data(
-        &self,
-        ticket_id: i64,
-    ) -> Result<(), GatewayStorageError> {
+    async fn remove_verified_ticket_binary_data(&self, ticket_id: i64) -> Result<(), StorageError> {
         self.ticket_manager
             .remove_binary_ticket_data(ticket_id)
             .await?;
         Ok(())
     }
 
-    pub async fn get_all_verified_tickets_with_sn(
-        &self,
-    ) -> Result<Vec<VerifiedTicket>, GatewayStorageError> {
+    async fn get_all_verified_tickets_with_sn(&self) -> Result<Vec<VerifiedTicket>, StorageError> {
         Ok(self
             .ticket_manager
             .get_all_verified_tickets_with_sn()
             .await?)
     }
 
-    pub async fn get_all_proposed_tickets_with_sn(
+    async fn get_all_proposed_tickets_with_sn(
         &self,
         proposal_id: u32,
-    ) -> Result<Vec<VerifiedTicket>, GatewayStorageError> {
+    ) -> Result<Vec<VerifiedTicket>, StorageError> {
         Ok(self
             .ticket_manager
             .get_all_proposed_tickets_with_sn(proposal_id as i64)
             .await?)
     }
 
-    pub async fn insert_redemption_proposal(
+    async fn insert_redemption_proposal(
         &self,
         tickets: &[VerifiedTicket],
         proposal_id: u32,
         created_at: OffsetDateTime,
-    ) -> Result<(), GatewayStorageError> {
+    ) -> Result<(), StorageError> {
         // if we crash between those, there might a bit of an issue. we should revisit it later
 
         // 1. insert the actual proposal
@@ -376,12 +592,12 @@ impl GatewayStorage {
         Ok(())
     }
 
-    pub async fn clear_post_proposal_data(
+    async fn clear_post_proposal_data(
         &self,
         proposal_id: u32,
         resolved_at: OffsetDateTime,
         rejected: bool,
-    ) -> Result<(), GatewayStorageError> {
+    ) -> Result<(), StorageError> {
         // 1. update proposal metadata
         self.ticket_manager
             .update_redemption_proposal(proposal_id as i64, resolved_at, rejected)
@@ -400,13 +616,11 @@ impl GatewayStorage {
         Ok(())
     }
 
-    pub async fn latest_proposal(&self) -> Result<Option<RedemptionProposal>, GatewayStorageError> {
+    async fn latest_proposal(&self) -> Result<Option<RedemptionProposal>, StorageError> {
         Ok(self.ticket_manager.get_latest_redemption_proposal().await?)
     }
 
-    pub async fn get_all_unverified_tickets(
-        &self,
-    ) -> Result<Vec<ClientTicket>, GatewayStorageError> {
+    async fn get_all_unverified_tickets(&self) -> Result<Vec<ClientTicket>, StorageError> {
         self.ticket_manager
             .get_unverified_tickets()
             .await?
@@ -415,37 +629,29 @@ impl GatewayStorage {
             .collect()
     }
 
-    pub async fn get_all_unresolved_proposals(&self) -> Result<Vec<i64>, GatewayStorageError> {
+    async fn get_all_unresolved_proposals(&self) -> Result<Vec<i64>, StorageError> {
         Ok(self
             .ticket_manager
             .get_all_unresolved_redemption_proposal_ids()
             .await?)
     }
 
-    pub async fn get_votes(&self, ticket_id: i64) -> Result<Vec<i64>, GatewayStorageError> {
+    async fn get_votes(&self, ticket_id: i64) -> Result<Vec<i64>, StorageError> {
         Ok(self
             .ticket_manager
             .get_verification_votes(ticket_id)
             .await?)
     }
 
-    pub async fn get_signers(&self, epoch_id: i64) -> Result<Vec<i64>, GatewayStorageError> {
+    async fn get_signers(&self, epoch_id: i64) -> Result<Vec<i64>, StorageError> {
         Ok(self.ticket_manager.get_epoch_signers(epoch_id).await?)
     }
 
-    /// 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(
+    async fn insert_wireguard_peer(
         &self,
         peer: &defguard_wireguard_rs::host::Peer,
         with_client_id: bool,
-    ) -> Result<Option<i64>, GatewayStorageError> {
+    ) -> Result<Option<i64>, StorageError> {
         let client_id = match self
             .wireguard_peer_manager
             .retrieve_peer(&peer.public_key.to_string())
@@ -470,15 +676,10 @@ impl GatewayStorage {
         Ok(client_id)
     }
 
-    /// 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(
+    async fn get_wireguard_peer(
         &self,
         peer_public_key: &str,
-    ) -> Result<Option<WireguardPeer>, GatewayStorageError> {
+    ) -> Result<Option<WireguardPeer>, StorageError> {
         let peer = self
             .wireguard_peer_manager
             .retrieve_peer(peer_public_key)
@@ -486,21 +687,12 @@ impl GatewayStorage {
         Ok(peer)
     }
 
-    /// Retrieves all wireguard peers.
-    pub async fn get_all_wireguard_peers(&self) -> Result<Vec<WireguardPeer>, GatewayStorageError> {
+    async fn get_all_wireguard_peers(&self) -> Result<Vec<WireguardPeer>, StorageError> {
         let ret = self.wireguard_peer_manager.retrieve_all_peers().await?;
         Ok(ret)
     }
 
-    /// 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> {
+    async fn remove_wireguard_peer(&self, peer_public_key: &str) -> Result<(), StorageError> {
         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::GatewayStorageError;
+use crate::error::StorageError;
 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 = GatewayStorageError;
+    type Error = StorageError;
 
     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(GatewayStorageError::MissingSharedKey {
+            (None, None) => Err(StorageError::MissingSharedKey {
                 id: value.client_id,
             }),
             (Some(aes256gcm_siv), _) => {
                 let current_key = SharedSymmetricKey::try_from_bytes(aes256gcm_siv)
-                    .map_err(|source| GatewayStorageError::DataCorruption(source.to_string()))?;
+                    .map_err(|source| StorageError::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| GatewayStorageError::DataCorruption(source.to_string()))?;
+                    .map_err(|source| StorageError::DataCorruption(source.to_string()))?;
                 Ok(SharedGatewayKey::Legacy(legacy_key))
             }
         }
@@ -91,12 +91,12 @@ pub struct UnverifiedTicketData {
 }
 
 impl TryFrom<UnverifiedTicketData> for ClientTicket {
-    type Error = GatewayStorageError;
+    type Error = StorageError;
 
     fn try_from(value: UnverifiedTicketData) -> Result<Self, Self::Error> {
         Ok(ClientTicket {
             spending_data: CredentialSpendingData::try_from_bytes(&value.data).map_err(|_| {
-                GatewayStorageError::MalformedStoredTicketData {
+                StorageError::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::GatewayStorageError;
+    type Error = crate::error::StorageError;
 
     fn try_from(value: WireguardPeer) -> Result<Self, Self::Error> {
         Ok(Self {

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

@@ -282,48 +282,6 @@ impl Client {
         }
     }
 
-    pub async fn create_delete_request<K, V>(
-        &self,
-        path: PathSegments<'_>,
-        params: Params<'_, K, V>,
-    ) -> RequestBuilder
-    where
-        K: AsRef<str>,
-        V: AsRef<str>,
-    {
-        let url = sanitize_url(&self.base_url, path, params);
-        self.reqwest_client.delete(url)
-    }
-
-    pub async fn send_delete_request<K, V, E>(
-        &self,
-        path: PathSegments<'_>,
-        params: Params<'_, K, V>,
-    ) -> Result<Response, HttpClientError<E>>
-    where
-        K: AsRef<str>,
-        V: AsRef<str>,
-        E: Display,
-    {
-        tracing::trace!("Sending DELETE request");
-        let url = sanitize_url(&self.base_url, path, params);
-
-        #[cfg(target_arch = "wasm32")]
-        {
-            Ok(wasmtimer::tokio::timeout(
-                self.request_timeout,
-                self.reqwest_client.delete(url).send(),
-            )
-            .await
-            .map_err(|_timeout| HttpClientError::RequestTimeout)??)
-        }
-
-        #[cfg(not(target_arch = "wasm32"))]
-        {
-            Ok(self.reqwest_client.delete(url).send().await?)
-        }
-    }
-
     #[instrument(level = "debug", skip_all)]
     pub async fn get_json<T, K, V, E>(
         &self,
@@ -357,22 +315,6 @@ impl Client {
         parse_response(res, true).await
     }
 
-    pub async fn delete_json<T, K, V, E>(
-        &self,
-        path: PathSegments<'_>,
-        params: Params<'_, K, V>,
-    ) -> Result<T, HttpClientError<E>>
-    where
-        for<'a> T: Deserialize<'a>,
-        K: AsRef<str>,
-        V: AsRef<str>,
-        E: Display + DeserializeOwned,
-    {
-        let res = self.send_delete_request(path, params).await?;
-        parse_response(res, false).await
-    }
-
-    #[instrument(level = "debug", skip_all)]
     pub async fn get_json_endpoint<T, S, E>(&self, endpoint: S) -> Result<T, HttpClientError<E>>
     where
         for<'a> T: Deserialize<'a>,
@@ -437,35 +379,6 @@ impl Client {
 
         parse_response(res, true).await
     }
-
-    pub async fn delete_json_endpoint<T, S, E>(&self, endpoint: S) -> Result<T, HttpClientError<E>>
-    where
-        for<'a> T: Deserialize<'a>,
-        E: Display + DeserializeOwned,
-        S: AsRef<str>,
-    {
-        #[cfg(target_arch = "wasm32")]
-        let res = {
-            wasmtimer::tokio::timeout(
-                self.request_timeout,
-                self.reqwest_client
-                    .delete(self.base_url.join(endpoint.as_ref())?)
-                    .send(),
-            )
-            .await
-            .map_err(|_timeout| HttpClientError::RequestTimeout)??
-        };
-
-        #[cfg(not(target_arch = "wasm32"))]
-        let res = {
-            self.reqwest_client
-                .delete(self.base_url.join(endpoint.as_ref())?)
-                .send()
-                .await?
-        };
-
-        parse_response(res, false).await
-    }
 }
 
 // define those methods on the trait for nicer extensions (and not having to type the thing twice)
@@ -498,17 +411,6 @@ pub trait ApiClient {
         V: AsRef<str> + Sync,
         E: Display + DeserializeOwned;
 
-    async fn delete_json<T, K, V, E>(
-        &self,
-        path: PathSegments<'_>,
-        params: Params<'_, K, V>,
-    ) -> Result<T, HttpClientError<E>>
-    where
-        for<'a> T: Deserialize<'a>,
-        K: AsRef<str> + Sync,
-        V: AsRef<str> + Sync,
-        E: Display + DeserializeOwned;
-
     /// `get` json data from the provided absolute endpoint, i.e. for example `"/api/v1/mixnodes?since=12345"`
     async fn get_json_from<T, S, E>(&self, endpoint: S) -> Result<T, HttpClientError<E>>
     where
@@ -526,12 +428,6 @@ pub trait ApiClient {
         for<'a> T: Deserialize<'a>,
         E: Display + DeserializeOwned,
         S: AsRef<str> + Sync + Send;
-
-    async fn delete_json_from<T, S, E>(&self, endpoint: S) -> Result<T, HttpClientError<E>>
-    where
-        for<'a> T: Deserialize<'a>,
-        E: Display + DeserializeOwned,
-        S: AsRef<str> + Sync + Send;
 }
 
 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
@@ -567,20 +463,6 @@ impl ApiClient for Client {
         self.post_json(path, params, json_body).await
     }
 
-    async fn delete_json<T, K, V, E>(
-        &self,
-        path: PathSegments<'_>,
-        params: Params<'_, K, V>,
-    ) -> Result<T, HttpClientError<E>>
-    where
-        for<'a> T: Deserialize<'a>,
-        K: AsRef<str> + Sync,
-        V: AsRef<str> + Sync,
-        E: Display + DeserializeOwned,
-    {
-        self.delete_json(path, params).await
-    }
-
     async fn get_json_from<T, S, E>(&self, endpoint: S) -> Result<T, HttpClientError<E>>
     where
         for<'a> T: Deserialize<'a>,
@@ -603,15 +485,6 @@ impl ApiClient for Client {
     {
         self.post_json_endpoint(endpoint, json_body).await
     }
-
-    async fn delete_json_from<T, S, E>(&self, endpoint: S) -> Result<T, HttpClientError<E>>
-    where
-        for<'a> T: Deserialize<'a>,
-        E: Display + DeserializeOwned,
-        S: AsRef<str> + Sync + Send,
-    {
-        self.delete_json_endpoint(endpoint).await
-    }
 }
 
 // utility function that should solve the double slash problem in API urls forever.

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

@@ -1,13 +1,12 @@
 // Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use std::{fmt, str::FromStr};
+use std::fmt;
 
 use http::HeaderValue;
 use nym_bin_common::build_information::{BinaryBuildInformation, BinaryBuildInformationOwned};
-use serde::{Deserialize, Serialize};
 
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
+#[derive(Clone, Debug)]
 pub struct UserAgent {
     pub application: String,
     pub version: String,
@@ -15,36 +14,6 @@ pub struct UserAgent {
     pub git_commit: String,
 }
 
-#[derive(Clone, Debug, thiserror::Error)]
-#[error("invalid user agent string: {0}")]
-pub struct UserAgentError(String);
-
-impl FromStr for UserAgent {
-    type Err = UserAgentError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let parts: Vec<&str> = s.split('/').collect();
-        if parts.len() != 4 {
-            return Err(UserAgentError(s.to_string()));
-        }
-
-        Ok(UserAgent {
-            application: parts[0].to_string(),
-            version: parts[1].to_string(),
-            platform: parts[2].to_string(),
-            git_commit: parts[3].to_string(),
-        })
-    }
-}
-
-impl TryFrom<&str> for UserAgent {
-    type Error = UserAgentError;
-
-    fn try_from(s: &str) -> Result<Self, Self::Error> {
-        UserAgent::from_str(s)
-    }
-}
-
 impl fmt::Display for UserAgent {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let abbreviated_commit = self.git_commit.chars().take(7).collect::<String>();
@@ -85,85 +54,3 @@ impl From<BinaryBuildInformationOwned> for UserAgent {
         }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn parsing_valid_user_agent() {
-        let user_agent = "nym-mixnode/0.11.0/x86_64-unknown-linux-gnu/abcdefg";
-        let parsed = UserAgent::from_str(user_agent).unwrap();
-        assert_eq!(
-            parsed,
-            UserAgent {
-                application: "nym-mixnode".to_string(),
-                version: "0.11.0".to_string(),
-                platform: "x86_64-unknown-linux-gnu".to_string(),
-                git_commit: "abcdefg".to_string()
-            }
-        );
-    }
-
-    #[test]
-    fn parsing_invalid_user_agent() {
-        let user_agent = "nym-mixnode/0.11.0/x86_64-unknown-linux-gnu";
-        assert!(UserAgent::from_str(user_agent).is_err());
-    }
-
-    #[test]
-    fn converting_user_agent_to_string() {
-        let user_agent = UserAgent {
-            application: "nym-mixnode".to_string(),
-            version: "0.11.0".to_string(),
-            platform: "x86_64-unknown-linux-gnu".to_string(),
-            git_commit: "abcdefg".to_string(),
-        };
-
-        assert_eq!(
-            user_agent.to_string(),
-            "nym-mixnode/0.11.0/x86_64-unknown-linux-gnu/abcdefg"
-        );
-    }
-
-    #[test]
-    fn converting_user_agent_to_display() {
-        let user_agent = UserAgent {
-            application: "nym-mixnode".to_string(),
-            version: "0.11.0".to_string(),
-            platform: "x86_64-unknown-linux-gnu".to_string(),
-            git_commit: "abcdefg".to_string(),
-        };
-
-        assert_eq!(
-            format!("{}", user_agent),
-            "nym-mixnode/0.11.0/x86_64-unknown-linux-gnu/abcdefg"
-        );
-    }
-
-    #[test]
-    fn converting_user_agent_to_header_value_fails() {
-        let user_agent = UserAgent {
-            application: "nym-mixnode".to_string(),
-            version: "0.11.0".to_string(),
-            platform: "x86_64-unknown-linux-gnu".to_string(),
-            git_commit: "abcdefg".to_string(),
-        };
-
-        let header_value: Result<HeaderValue, _> = user_agent.clone().try_into();
-        assert!(header_value.is_ok());
-    }
-
-    #[test]
-    fn converting_user_agent_to_header_value_has_same_string_representation() {
-        let user_agent = UserAgent {
-            application: "nym-mixnode".to_string(),
-            version: "0.11.0".to_string(),
-            platform: "x86_64-unknown-linux-gnu".to_string(),
-            git_commit: "abcdefg".to_string(),
-        };
-
-        let header_value: HeaderValue = user_agent.clone().try_into().unwrap();
-        assert_eq!(header_value.to_str().unwrap(), user_agent.to_string());
-    }
-}

common/mixnode-common/Cargo.toml

@@ -26,7 +26,7 @@ url = { workspace = true }
 time.workspace = true
 thiserror = { workspace = true }
 
-nym-crypto = { path = "../crypto", features = ["asymmetric"] }
+nym-crypto = { path = "../crypto" }
 nym-network-defaults = { path = "../network-defaults" }
 nym-sphinx-acknowledgements = { path = "../nymsphinx/acknowledgements" }
 nym-sphinx-addressing = { path = "../nymsphinx/addressing" }
@@ -35,5 +35,7 @@ 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

@@ -0,0 +1,81 @@
+// 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/listener.rs

@@ -1,29 +1,29 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::error::VerlocError;
-use crate::measurements::packet::{EchoPacket, ReplyPacket};
+use crate::verloc::error::RttError;
+use crate::verloc::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::{io, process};
-use thiserror::Error;
+use std::{fmt, io, process};
 use tokio::io::AsyncWriteExt;
 use tokio::net::{TcpListener, TcpStream};
 use tokio_util::codec::{Decoder, Encoder, Framed};
-use tracing::{debug, error, info, trace, warn};
 
-pub struct PacketListener {
+pub(crate) struct PacketListener {
     address: SocketAddr,
     connection_handler: Arc<ConnectionHandler>,
     shutdown: TaskClient,
 }
 
 impl PacketListener {
-    pub fn new(
+    pub(crate) fn new(
         address: SocketAddr,
         identity: Arc<identity::KeyPair>,
         shutdown: TaskClient,
@@ -37,13 +37,13 @@ impl PacketListener {
 }
 
 impl PacketListener {
-    pub async fn run(self: Arc<Self>) {
+    pub(super) async fn run(self: Arc<Self>) {
         let listener = match TcpListener::bind(self.address).await {
             Ok(listener) => listener,
             Err(err) => {
                 error!(
-                    "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
+                    "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
                 );
                 process::exit(1);
             }
@@ -71,7 +71,7 @@ impl PacketListener {
                     }
                 },
                 _ = shutdown_listener.recv() => {
-                    trace!("PacketListener: Received shutdown");
+                    log::trace!("PacketListener: Received shutdown");
                 }
             }
         }
@@ -137,18 +137,28 @@ impl ConnectionHandler {
     }
 }
 
-#[derive(Debug, Error)]
+#[derive(Debug)]
 enum EchoPacketCodecError {
-    #[error("encountered io error {0}")]
-    IoError(#[from] io::Error),
-
-    #[error("failed to correctly decode an echo packet: {0}")]
-    PacketRecoveryError(Box<VerlocError>),
+    IoError(io::Error),
+    PacketRecoveryError(RttError),
 }
 
-impl From<VerlocError> for EchoPacketCodecError {
-    fn from(value: VerlocError) -> Self {
-        EchoPacketCodecError::PacketRecoveryError(Box::new(value))
+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)
     }
 }
 
@@ -178,7 +188,10 @@ impl Decoder for EchoPacketCodec {
 
         let packet_bytes = src.split_to(EchoPacket::SIZE);
 
-        let echo_packet = EchoPacket::try_from_bytes(&packet_bytes)?;
+        let echo_packet = match EchoPacket::try_from_bytes(&packet_bytes) {
+            Ok(packet) => packet,
+            Err(err) => return Err(EchoPacketCodecError::PacketRecoveryError(err)),
+        };
 
         // reserve enough bytes for the next frame
         src.reserve(EchoPacket::SIZE);

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

@@ -0,0 +1,35 @@
+// 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

@@ -0,0 +1,383 @@
+// 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_bin_common::version_checker::{self, parse_version};
+use nym_crypto::asymmetric::identity;
+use nym_network_defaults::mainnet::NYM_API;
+use nym_node_http_api::state::metrics::{SharedVerlocStats, VerlocNodeResult};
+use nym_task::TaskClient;
+use rand::seq::SliceRandom;
+use rand::thread_rng;
+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;
+
+// TODO: MUST BE UPDATED BEFORE ACTUAL RELEASE!!
+pub const MINIMUM_NODE_VERSION: &str = "0.10.1";
+
+// 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 {
+    /// Minimum semver version of a node (gateway or mixnode) that is capable of replying to echo packets.
+    minimum_compatible_node_version: version_checker::Version,
+
+    /// 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 minimum_compatible_node_version(mut self, version: version_checker::Version) -> Self {
+        self.0.minimum_compatible_node_version = version;
+        self
+    }
+
+    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 {
+            minimum_compatible_node_version: parse_version(MINIMUM_NODE_VERSION).unwrap(),
+            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/mixnode-common/src/verloc/packet.rs

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

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

@@ -1,10 +1,11 @@
 // Copyright 2021-2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::error::VerlocError;
-use crate::measurements::packet::{EchoPacket, ReplyPacket};
-use crate::models::VerlocMeasurement;
-use nym_crypto::asymmetric::ed25519;
+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 nym_task::TaskClient;
 use rand::{thread_rng, Rng};
 use std::net::SocketAddr;
@@ -14,16 +15,15 @@ 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: ed25519::PublicKey,
+    pub(crate) identity: identity::PublicKey,
 }
 
 impl TestedNode {
-    pub(crate) fn new(address: SocketAddr, identity: ed25519::PublicKey) -> Self {
+    pub(crate) fn new(address: SocketAddr, identity: identity::PublicKey) -> Self {
         TestedNode { address, identity }
     }
 }
@@ -38,8 +38,8 @@ impl fmt::Display for TestedNode {
     }
 }
 
-pub struct PacketSender {
-    identity: Arc<ed25519::KeyPair>,
+pub(crate) struct PacketSender {
+    identity: Arc<identity::KeyPair>,
     // timeout for receiving before sending new one
     packets_per_node: usize,
     packet_timeout: Duration,
@@ -49,8 +49,8 @@ pub struct PacketSender {
 }
 
 impl PacketSender {
-    pub fn new(
-        identity: Arc<ed25519::KeyPair>,
+    pub(super) fn new(
+        identity: Arc<identity::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, VerlocError> {
+    ) -> Result<VerlocMeasurement, RttError> {
         let mut shutdown_listener = self.shutdown_listener.fork(tested_node.address.to_string());
         shutdown_listener.disarm();
 
@@ -93,18 +93,16 @@ impl PacketSender {
         .await
         {
             Err(_timeout) => {
-                return Err(VerlocError::UnreachableNode {
-                    identity: tested_node.identity.to_string(),
-                    err: io::ErrorKind::TimedOut.into(),
-                    address: tested_node.address,
-                })
+                return Err(RttError::UnreachableNode(
+                    tested_node.identity.to_base58_string(),
+                    io::ErrorKind::TimedOut.into(),
+                ))
             }
             Ok(Err(err)) => {
-                return Err(VerlocError::UnreachableNode {
-                    identity: tested_node.identity.to_string(),
+                return Err(RttError::UnreachableNode(
+                    tested_node.identity.to_base58_string(),
                     err,
-                    address: tested_node.address,
-                })
+                ))
             }
             Ok(Ok(conn)) => conn,
         };
@@ -123,34 +121,33 @@ impl PacketSender {
                 write = tokio::time::timeout(self.packet_timeout, conn.write_all(packet_bytes.as_ref())) => {
                     match write {
                         Err(_timeout) => {
-                            let identity = tested_node.identity;
+                            let identity_string = tested_node.identity.to_base58_string();
                             debug!(
-                                "failed to write echo packet to {identity} within {:?}. Stopping the test.",
-                                self.packet_timeout
+                                "failed to write echo packet to {} within {:?}. Stopping the test.",
+                                identity_string, self.packet_timeout
                             );
-                            return Err(VerlocError::UnexpectedConnectionFailureWrite{
-                                identity: identity.to_string(),
-                                err:io::ErrorKind::TimedOut.into(),
-                                address: tested_node.address
-                            });
+                            return Err(RttError::UnexpectedConnectionFailureWrite(
+                                identity_string,
+                                io::ErrorKind::TimedOut.into(),
+                            ));
                         }
                         Ok(Err(err)) => {
-                            let identity = tested_node.identity;
+                            let identity_string = tested_node.identity.to_base58_string();
                             debug!(
-                                "failed to write echo packet to {identity}: {err}. Stopping the test.",
+                                "failed to write echo packet to {} - {}. Stopping the test.",
+                                identity_string, err
                             );
-                            return Err(VerlocError::UnexpectedConnectionFailureWrite{
-                                identity: identity.to_string(),
+                            return Err(RttError::UnexpectedConnectionFailureWrite(
+                                identity_string,
                                 err,
-                                address: tested_node.address
-                            });
+                            ));
                         }
                         Ok(Ok(_)) => {}
                         }
                 },
                 _ = shutdown_listener.recv() => {
-                    trace!("PacketSender: Received shutdown while sending");
-                    return Err(VerlocError::ShutdownReceived);
+                    log::trace!("PacketSender: Received shutdown while sending");
+                    return Err(RttError::ShutdownReceived);
                 },
             }
 
@@ -159,15 +156,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 {identity}: {err}. Stopping the test.",
+                        "failed to read reply packet from {} - {}. Stopping the test.",
+                        tested_node.identity.to_base58_string(),
+                        err
                     );
-                    return Err(VerlocError::UnexpectedConnectionFailureRead {
-                        identity: identity.to_string(),
+                    return Err(RttError::UnexpectedConnectionFailureRead(
+                        tested_node.identity.to_base58_string(),
                         err,
-                        address: tested_node.address,
-                    });
+                    ));
                 }
                 ReplyPacket::try_from_bytes(&buf, &tested_node.identity)
             };
@@ -183,16 +180,15 @@ impl PacketSender {
                                 "failed to receive reply to our echo packet within {:?}. Stopping the test",
                                 self.packet_timeout
                             );
-                            return Err(VerlocError::ConnectionReadTimeout{
-                                identity: tested_node.identity.to_string(),
-                                address: tested_node.address
-                            });
+                            return Err(RttError::ConnectionReadTimeout(
+                                tested_node.identity.to_base58_string(),
+                            ));
                         }
                     }
                 },
                 _ = shutdown_listener.recv() => {
-                    trace!("PacketSender: Received shutdown while waiting for reply");
-                    return Err(VerlocError::ShutdownReceived);
+                    log::trace!("PacketSender: Received shutdown while waiting for reply");
+                    return Err(RttError::ShutdownReceived);
                 }
             };
 
@@ -202,7 +198,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(VerlocError::UnexpectedReplySequence);
+                return Err(RttError::UnexpectedReplySequence);
             }
 
             let time_taken = tokio::time::Instant::now().duration_since(start);

common/models/Cargo.toml

@@ -0,0 +1,14 @@
+[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]
+serde = { workspace = true, features = ["derive"] }

common/models/src/lib.rs

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

common/models/src/ns_api.rs

@@ -0,0 +1,7 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct TestrunAssignment {
+    pub testrun_id: i64,
+    pub gateway_identity_key: String,
+}

common/network-defaults/src/network.rs

@@ -157,46 +157,6 @@ impl NymNetworkDetails {
         }
     }
 
-    #[rustfmt::skip]
-    #[cfg(feature = "env")]
-    pub fn export_to_env(self) {
-        use crate::var_names;
-        use std::env::set_var;
-
-        fn set_optional_var(var_name: &str, value: Option<String>) {
-            if let Some(value) = value {
-                set_var(var_name, value);
-            }
-        }
-
-        set_var(var_names::NETWORK_NAME, self.network_name);
-        set_var(var_names::BECH32_PREFIX, self.chain_details.bech32_account_prefix);
-
-        set_var(var_names::MIX_DENOM, self.chain_details.mix_denom.base);
-        set_var(var_names::MIX_DENOM_DISPLAY, self.chain_details.mix_denom.display);
-
-        set_var(var_names::STAKE_DENOM, self.chain_details.stake_denom.base);
-        set_var(var_names::STAKE_DENOM_DISPLAY, self.chain_details.stake_denom.display);
-
-        set_var(var_names::DENOMS_EXPONENT, self.chain_details.mix_denom.display_exponent.to_string());
-
-        if let Some(e) = self.endpoints.first() {
-            set_var(var_names::NYXD, e.nyxd_url.clone());
-            set_optional_var(var_names::NYM_API, e.api_url.clone());
-            set_optional_var(var_names::NYXD_WEBSOCKET, e.websocket_url.clone());
-        }
-
-        set_optional_var(var_names::MIXNET_CONTRACT_ADDRESS, self.contracts.mixnet_contract_address);
-        set_optional_var(var_names::VESTING_CONTRACT_ADDRESS, self.contracts.vesting_contract_address);
-        set_optional_var(var_names::ECASH_CONTRACT_ADDRESS, self.contracts.ecash_contract_address);
-        set_optional_var(var_names::GROUP_CONTRACT_ADDRESS, self.contracts.group_contract_address);
-        set_optional_var(var_names::MULTISIG_CONTRACT_ADDRESS, self.contracts.multisig_contract_address);
-        set_optional_var(var_names::COCONUT_DKG_CONTRACT_ADDRESS, self.contracts.coconut_dkg_contract_address);
-
-        set_optional_var(var_names::EXPLORER_API, self.explorer_api);
-        set_optional_var(var_names::NYM_VPN_API, self.nym_vpn_api_url);
-    }
-
     pub fn default_gas_price_amount(&self) -> f64 {
         GAS_PRICE_AMOUNT
     }

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

@@ -29,9 +29,6 @@ pub struct NodeTester<R> {
 
     packet_size: PacketSize,
 
-    /// Specify whether route selection should be determined by the packet header.
-    deterministic_route_selection: bool,
-
     /// Average delay a data packet is going to get delay at a single mixnode.
     average_packet_delay: Duration,
 
@@ -51,13 +48,11 @@ impl<R> NodeTester<R>
 where
     R: Rng + CryptoRng,
 {
-    #[allow(clippy::too_many_arguments)]
     pub fn new(
         rng: R,
         base_topology: NymTopology,
         self_address: Option<Recipient>,
         packet_size: PacketSize,
-        deterministic_route_selection: bool,
         average_packet_delay: Duration,
         average_ack_delay: Duration,
         ack_key: Arc<AckKey>,
@@ -67,7 +62,6 @@ where
             base_topology,
             self_address,
             packet_size,
-            deterministic_route_selection,
             average_packet_delay,
             average_ack_delay,
             num_mix_hops: DEFAULT_NUM_MIX_HOPS,
@@ -295,18 +289,10 @@ where
 impl<R: CryptoRng + Rng> FragmentPreparer for NodeTester<R> {
     type Rng = R;
 
-    fn deterministic_route_selection(&self) -> bool {
-        self.deterministic_route_selection
-    }
-
     fn rng(&mut self) -> &mut Self::Rng {
         &mut self.rng
     }
 
-    fn nonce(&self) -> i32 {
-        1
-    }
-
     fn num_mix_hops(&self) -> u8 {
         self.num_mix_hops
     }
@@ -318,4 +304,8 @@ impl<R: CryptoRng + Rng> FragmentPreparer for NodeTester<R> {
     fn average_ack_delay(&self) -> Duration {
         self.average_ack_delay
     }
+
+    fn nonce(&self) -> i32 {
+        1
+    }
 }

common/nym_offline_compact_ecash/src/scheme/coin_indices_signatures.rs

@@ -324,6 +324,18 @@ pub fn unchecked_aggregate_indices_signatures(
     _aggregate_indices_signatures(params, vk, signatures_shares, false)
 }
 
+/// Generates parameters for the scheme setup.
+///
+/// # Arguments
+///
+/// * `total_coins` - it is the number of coins in a freshly generated wallet. It is the public parameter of the scheme.
+///
+/// # Returns
+///
+/// A `Parameters` struct containing group parameters, public key, the number of signatures (`total_coins`),
+/// and a map of signatures for each index `l`.
+///
+
 #[cfg(test)]
 mod tests {
     use super::*;

common/nym_offline_compact_ecash/src/scheme/keygen.rs

@@ -264,7 +264,7 @@ impl<'b> Add<&'b VerificationKeyAuth> for VerificationKeyAuth {
     }
 }
 
-impl Mul<Scalar> for &VerificationKeyAuth {
+impl<'a> Mul<Scalar> for &'a VerificationKeyAuth {
     type Output = VerificationKeyAuth;
 
     #[inline]
@@ -530,15 +530,6 @@ 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/nym_offline_compact_ecash/src/scheme/mod.rs

@@ -984,7 +984,7 @@ pub struct SerialNumberRef<'a> {
     pub(crate) inner: &'a [G1Projective],
 }
 
-impl SerialNumberRef<'_> {
+impl<'a> SerialNumberRef<'a> {
     pub fn to_bytes(&self) -> Vec<u8> {
         let ss_len = self.inner.len();
         let mut bytes: Vec<u8> = Vec::with_capacity(ss_len * 48);

common/nymcoconut/src/elgamal.rs

@@ -206,10 +206,10 @@ impl Deref for PublicKey {
     }
 }
 
-impl<'a> Mul<&'a Scalar> for &PublicKey {
+impl<'a, 'b> Mul<&'b Scalar> for &'a PublicKey {
     type Output = G1Projective;
 
-    fn mul(self, rhs: &'a Scalar) -> Self::Output {
+    fn mul(self, rhs: &'b Scalar) -> Self::Output {
         self.0 * rhs
     }
 }

common/nymcoconut/src/scheme/keygen.rs

@@ -305,7 +305,7 @@ impl<'b> Add<&'b VerificationKey> for VerificationKey {
     }
 }
 
-impl Mul<Scalar> for &VerificationKey {
+impl<'a> Mul<Scalar> for &'a VerificationKey {
     type Output = VerificationKey;
 
     #[inline]

common/nymsphinx/addressing/src/clients.rs

@@ -64,7 +64,7 @@ impl<'de> Deserialize<'de> for Recipient {
     {
         struct RecipientVisitor;
 
-        impl Visitor<'_> for RecipientVisitor {
+        impl<'de> Visitor<'de> for RecipientVisitor {
             type Value = Recipient;
 
             fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {