TEMP gh runner fix

* using common middleware for all http servers

* improved span handling in credential-proxy

* ensure increase in sequence number upon making deposit

* added explicit connect options for the db

* fixed further instances of incorrect span instrumentation

* batch deposit requests together to improve concurrency

* ignore cancelled requests

* updated credential proxy version to 0.1.4

* adjusted Dockerfile with new binary location

* log binary version on startup

* reduce default log level

* guard against unavaiable commit sha

* apply review comments: dont exit(0), instead just shutdown normally

* add skip_webhook parameter to obtain-async

* removing dead code

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

@@ -15,31 +15,13 @@ on:
         type: boolean
   schedule:
     - cron: "14 0 * * *"
-  pull_request:
-    paths:
-      - "clients/**"
-      - "common/**"
-      - "explorer-api/**"
-      - "gateway/**"
-      - "integrations/**"
-      - "mixnode/**"
-      - "nym-api/**"
-      - "nym-node/**"
-      - "nym-outfox/**"
-      - 'nym-data-observatory/**'
-      - "nym-validator-rewarder/**"
-      - "sdk/rust/nym-sdk/**"
-      - "service-providers/**"
-      - "tools/**"
-      - "nymvisor/**"
-      - ".github/workflows/ci-build-upload-binaries.yml"
 
 jobs:
   publish-nym:
     strategy:
       fail-fast: false
       matrix:
-        platform: [ arc-ubuntu-20.04 ]
+        platform: [ arc-ubuntu-22.04 ]
 
     runs-on: ${{ matrix.platform }}
     env:

.github/workflows/ci-cargo-deny.yml

@@ -9,7 +9,7 @@ on:
 
 jobs:
   cargo-deny:
-    runs-on: arc-ubuntu-22.04-dind
+    runs-on: ubuntu-latest
     strategy:
       matrix:
         checks:

.github/workflows/ci-contracts-matrix-includes.json

@@ -2,9 +2,5 @@
   {
     "rust":"stable",
     "runOnEvent":"always"
-  },
-  {
-    "rust":"beta",
-    "runOnEvent":"pull_request"
   }
 ]

.github/workflows/ci-contracts-schema.yml

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

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

@@ -2,11 +2,6 @@ name: ci-contracts-upload-binaries
 
 on:
   workflow_dispatch:
-  pull_request:
-    paths:
-      - 'common/**'
-      - 'contracts/**'
-      - '.github/workflows/ci-contracts-upload-binaries.yml'
 
 env:
   NETWORK: mainnet

.github/workflows/ci-contracts.yml

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

.github/workflows/ci-nym-api-tests.yml

@@ -1,39 +0,0 @@
-name: ci-nym-api-tests
-
-on:
-  workflow_dispatch:
-  push:
-    paths:
-      - "nym-api/**"
-
-defaults:
-  run:
-    working-directory: nym-api/tests
-
-jobs:
-  test:
-    name: nym-api tests
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: install yarn in root
-        run: cd ../.. && yarn install
-
-      - name: Install npm
-        run: npm install
-
-      - name: Node v18
-        uses: actions/setup-node@v4
-        with:
-          node-version: 18.1.0
-
-      - name: Install yarn
-        run: yarn install
-
-      - name: Run yarn
-        run: yarn
-
-      - name: Run tests
-        run: yarn test:sandbox
-        working-directory: nym-api/tests

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

@@ -55,6 +55,7 @@ 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,13 +14,14 @@ jobs:
       - name: Install Rust stable
         uses: actions-rs/toolchain@v1
         with:
-          toolchain: stable
+          toolchain: 1.77
           target: wasm32-unknown-unknown
           override: true
-          components: rustfmt, clippy
 
       - name: Install wasm-opt
-        run: cargo install --version 0.114.0 wasm-opt
+        uses: ./.github/actions/install-wasm-opt
+        with:
+          version: '114'
 
       - 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.3
+        uses: mikefarah/yq@v4.44.5
         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.3
+        uses: mikefarah/yq@v4.44.5
         id: get_version
         with:
           cmd: yq -oy '.package.version' ${{ env.WORKING_DIRECTORY }}/Cargo.toml

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

@@ -25,31 +25,27 @@ jobs:
           git config --global user.email "lawrence@nymtech.net"
           git config --global user.name "Lawrence Stalder"
 
-      - name: Get version from package.json
-        uses: sergeysova/jq-action@v2
+      - name: Get version from cargo.toml
+        uses: mikefarah/yq@v4.44.5
         id: get_version
         with:
-          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
-
+          cmd: yq -oy '.package.version' ${{ env.WORKING_DIRECTORY }}/nym-network-monitor/Cargo.toml
+          
       - name: Remove existing tag if exists
         run: |
-          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 }}
+          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 }}
           fi
 
       - name: Create tag
         run: |
-          git tag -a ${{ steps.get_version.outputs.value }} -m "Version ${{ steps.get_version.outputs.value }}"
-          git push origin ${{ steps.get_version.outputs.value }}
-
+          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 }}
+          
       - 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.value }} -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.result }} -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

@@ -2,6 +2,10 @@ name: Build and upload Node Status agent container to harbor.nymte.ch
 
 on:
   workflow_dispatch:
+    inputs:
+      gateway_probe_git_ref:
+        type: string
+        description: Which gateway probe git ref to build the image with
 
 env:
   WORKING_DIRECTORY: "nym-node-status-agent"
@@ -27,30 +31,31 @@ jobs:
           git config --global user.name "Lawrence Stalder"
 
       - name: Get version from cargo.toml
-        uses: mikefarah/yq@v4.44.3
+        uses: mikefarah/yq@v4.44.5
         id: get_version
         with:
           cmd: yq -oy '.package.version' ${{ env.WORKING_DIRECTORY }}/Cargo.toml
 
-      - name: Check if tag exists
+      - name: cleanup-gateway-probe-ref
+        id: cleanup_gateway_probe_ref
         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
+          GATEWAY_PROBE_GIT_REF=${{ github.event.inputs.gateway_probe_git_ref }}
+          GIT_REF_SLUG="${GATEWAY_PROBE_GIT_REF//\//-}"
+          echo "git_ref=${GIT_REF_SLUG}" >> $GITHUB_OUTPUT
 
       - 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 }}
+          if git rev-parse ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }}-${{ steps.cleanup_gateway_probe_ref.outputs.git_ref }} >/dev/null 2>&1; then
+            git push --delete origin ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }}-${{ steps.cleanup_gateway_probe_ref.outputs.git_ref }}
+            git tag -d ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }}-${{ steps.cleanup_gateway_probe_ref.outputs.git_ref }}
           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 }}
+          git tag -a ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }}-${{ steps.cleanup_gateway_probe_ref.outputs.git_ref }} -m "Version ${{ steps.get_version.outputs.result }}-${{ steps.cleanup_gateway_probe_ref.outputs.git_ref }}"
+          git push origin ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }}-${{ steps.cleanup_gateway_probe_ref.outputs.git_ref }}
 
       - 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
+          docker build --build-arg GIT_REF=${{ github.event.inputs.gateway_probe_git_ref }} -f ${{ env.WORKING_DIRECTORY }}/Dockerfile . -t harbor.nymte.ch/nym/${{ env.CONTAINER_NAME }}:${{ steps.get_version.outputs.result }}-${{ steps.cleanup_gateway_probe_ref.outputs.git_ref }}
+          docker push harbor.nymte.ch/nym/${{ env.CONTAINER_NAME }} --all-tags

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

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

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

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

CHANGELOG.md

@@ -4,6 +4,208 @@ 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

@@ -90,6 +90,7 @@ members = [
     "common/statistics",
     "common/store-cipher",
     "common/task",
+    "common/ticketbooks-merkle",
     "common/topology",
     "common/tun",
     "common/types",
@@ -277,6 +278,7 @@ ledger-transport = "0.10.0"
 ledger-transport-hid = "0.10.0"
 log = "0.4"
 maxminddb = "0.23.0"
+rs_merkle = "1.4.2"
 mime = "0.3.17"
 moka = { version = "0.12", features = ["future"] }
 nix = "0.27.1"
@@ -312,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.6.7"
+serde_json_path = "0.7.1"
 serde_repr = "0.1"
 serde_with = "3.9.0"
 serde_yaml = "0.9.25"
@@ -327,7 +329,7 @@ syn = "1"
 sysinfo = "0.30.13"
 tap = "1.0.1"
 tar = "0.4.42"
-tempfile = "3.5.0"
+tempfile = "3.14"
 thiserror = "1.0.64"
 time = "0.3.30"
 tokio = "1.39"

clients/native/Cargo.toml

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

clients/native/src/client/config/template.rs

@@ -102,5 +102,10 @@ average_ack_delay = '{{ debug.acknowledgements.average_ack_delay }}'
 [debug.cover_traffic]
 loop_cover_traffic_average_delay = '{{ debug.cover_traffic.loop_cover_traffic_average_delay }}'
 
+[debug.stats_reporting]
+enabled = {{ debug.stats_reporting.enabled }}
+provider_address = '{{ debug.stats_reporting.provider_address }}'
+reporting_interval = '{{ debug.stats_reporting.reporting_interval }}'
+
 
 "#;

clients/native/src/commands/init.rs

@@ -81,6 +81,7 @@ impl From<Init> for OverrideConfig {
 
             nyxd_urls: init_config.common_args.nyxd_urls,
             enabled_credentials_mode: init_config.common_args.enabled_credentials_mode,
+            stats_reporting_address: init_config.common_args.stats_reporting_address,
         }
     }
 }

clients/native/src/commands/mod.rs

@@ -13,6 +13,7 @@ use clap::{Parser, Subcommand};
 use log::{error, info};
 use nym_bin_common::bin_info;
 use nym_bin_common::completions::{fig_generate, ArgShell};
+use nym_client::client::Recipient;
 use nym_client_core::cli_helpers::CliClient;
 use nym_client_core::client::base_client::storage::migration_helpers::v1_1_33;
 use nym_config::OptionalSet;
@@ -104,6 +105,7 @@ pub(crate) struct OverrideConfig {
     no_cover: bool,
     nyxd_urls: Option<Vec<url::Url>>,
     enabled_credentials_mode: Option<bool>,
+    stats_reporting_address: Option<Recipient>,
 }
 
 pub(crate) async fn execute(args: Cli) -> Result<(), Box<dyn Error + Send + Sync>> {
@@ -149,6 +151,11 @@ pub(crate) fn override_config(config: Config, args: OverrideConfig) -> Config {
             BaseClientConfig::with_disabled_credentials,
             args.enabled_credentials_mode.map(|b| !b),
         )
+        .with_optional_env_ext(
+            BaseClientConfig::with_enabled_stats_reporting_address,
+            args.stats_reporting_address,
+            nym_network_defaults::var_names::CLIENT_STATS_COLLECTION_PROVIDER,
+        )
 }
 
 async fn try_upgrade_v1_1_13_config(id: &str) -> Result<bool, ClientError> {

clients/native/src/commands/run.rs

@@ -43,6 +43,7 @@ impl From<Run> for OverrideConfig {
             no_cover: run_config.common_args.no_cover,
             nyxd_urls: run_config.common_args.nyxd_urls,
             enabled_credentials_mode: run_config.common_args.enabled_credentials_mode,
+            stats_reporting_address: run_config.common_args.stats_reporting_address,
         }
     }
 }

clients/socks5/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nym-socks5-client"
-version = "1.1.42"
+version = "1.1.45"
 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"

clients/socks5/src/commands/init.rs

@@ -92,6 +92,7 @@ impl From<Init> for OverrideConfig {
             nyxd_urls: init_config.common_args.nyxd_urls,
             enabled_credentials_mode: init_config.common_args.enabled_credentials_mode,
             outfox: false,
+            stats_reporting_address: init_config.common_args.stats_reporting_address,
         }
     }
 }

clients/socks5/src/commands/mod.rs

@@ -19,6 +19,7 @@ use nym_client_core::client::base_client::storage::migration_helpers::v1_1_33;
 use nym_client_core::client::topology_control::geo_aware_provider::CountryGroup;
 use nym_client_core::config::{GroupBy, TopologyStructure};
 use nym_config::OptionalSet;
+use nym_sphinx::addressing::Recipient;
 use nym_sphinx::params::{PacketSize, PacketType};
 use std::error::Error;
 use std::net::IpAddr;
@@ -111,6 +112,7 @@ pub(crate) struct OverrideConfig {
     nyxd_urls: Option<Vec<url::Url>>,
     enabled_credentials_mode: Option<bool>,
     outfox: bool,
+    stats_reporting_address: Option<Recipient>,
 }
 
 pub(crate) async fn execute(args: Cli) -> Result<(), Box<dyn Error + Send + Sync>> {
@@ -196,6 +198,11 @@ pub(crate) fn override_config(config: Config, args: OverrideConfig) -> Config {
             BaseClientConfig::with_disabled_credentials,
             args.enabled_credentials_mode.map(|b| !b),
         )
+        .with_optional_base_env(
+            BaseClientConfig::with_enabled_stats_reporting_address,
+            args.stats_reporting_address,
+            nym_network_defaults::var_names::CLIENT_STATS_COLLECTION_PROVIDER,
+        )
 }
 
 async fn try_upgrade_v1_1_13_config(id: &str) -> Result<bool, Socks5ClientError> {

clients/socks5/src/commands/run.rs

@@ -70,6 +70,7 @@ impl From<Run> for OverrideConfig {
             nyxd_urls: run_config.common_args.nyxd_urls,
             enabled_credentials_mode: run_config.common_args.enabled_credentials_mode,
             outfox: run_config.outfox,
+            stats_reporting_address: run_config.common_args.stats_reporting_address,
         }
     }
 }

clients/socks5/src/config/template.rs

@@ -108,4 +108,9 @@ average_ack_delay = '{{ core.debug.acknowledgements.average_ack_delay }}'
 [core.debug.cover_traffic]
 loop_cover_traffic_average_delay = '{{ core.debug.cover_traffic.loop_cover_traffic_average_delay }}'
 
+[core.debug.stats_reporting]
+enabled = {{ core.debug.stats_reporting.enabled }}
+provider_address = '{{ core.debug.stats_reporting.provider_address }}'
+reporting_interval = '{{ core.debug.stats_reporting.reporting_interval }}'
+
 "#;

common/authenticator-requests/Cargo.toml

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

common/authenticator-requests/src/error.rs

@@ -22,4 +22,7 @@ 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,16 +1,18 @@
 // 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;
+pub mod v4;
 
 mod error;
 
 pub use error::Error;
-pub use v3 as latest;
+pub use v4 as latest;
 
-pub const CURRENT_VERSION: u8 = 3;
+pub const CURRENT_VERSION: u8 = 4;
 
 fn make_bincode_serializer() -> impl bincode::Options {
     use bincode::Options;

common/authenticator-requests/src/traits.rs

@@ -0,0 +1,343 @@
+// 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/v3/conversion.rs

@@ -9,7 +9,7 @@ impl From<v2::request::AuthenticatorRequest> for v3::request::AuthenticatorReque
     fn from(authenticator_request: v2::request::AuthenticatorRequest) -> Self {
         Self {
             protocol: Protocol {
-                version: 2,
+                version: 3,
                 service_provider_type: ServiceProviderType::Authenticator,
             },
             data: authenticator_request.data.into(),
@@ -98,6 +98,16 @@ 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;
 
@@ -129,6 +139,22 @@ 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 {
@@ -139,6 +165,16 @@ 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 {
@@ -149,6 +185,16 @@ 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 {
@@ -159,6 +205,16 @@ 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 {
@@ -169,6 +225,16 @@ 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 {
@@ -179,6 +245,16 @@ 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 {
@@ -186,3 +262,11 @@ 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 = 1024 * 1024 * 1024; // 1 GB
+pub const BANDWIDTH_CAP_PER_DAY: u64 = 250 * 1024 * 1024 * 1024; // 250 GB
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct InitMessage {

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

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

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

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

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

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

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

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

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

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

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

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

common/bandwidth-controller/Cargo.toml

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

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

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

common/bandwidth-controller/src/event.rs

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

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

@@ -47,6 +47,7 @@ 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

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

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

@@ -23,4 +23,4 @@ nym-sphinx-addressing = { path = "../../nymsphinx/addressing" }
 
 
 [features]
-disk-persistence = ["nym-pemstore"]
+disk-persistence = ["nym-pemstore"]

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

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use nym_config::defaults::NymNetworkDetails;
+use nym_config::serde_helpers::{de_maybe_stringified, ser_maybe_stringified};
 use nym_sphinx_addressing::Recipient;
 use nym_sphinx_params::{PacketSize, PacketType};
 use serde::{Deserialize, Serialize};
@@ -61,6 +62,11 @@ const DEFAULT_MAXIMUM_REPLY_SURB_AGE: Duration = Duration::from_secs(12 * 60 * 6
 // 24 hours
 const DEFAULT_MAXIMUM_REPLY_KEY_AGE: Duration = Duration::from_secs(24 * 60 * 60);
 
+// stats reporting related
+
+/// Time interval between reporting statistics to the given provider if it exist
+const STATS_REPORT_INTERVAL_SECS: Duration = Duration::from_secs(300);
+
 use crate::error::InvalidTrafficModeFailure;
 pub use nym_country_group::CountryGroup;
 
@@ -133,6 +139,12 @@ impl Config {
         self
     }
 
+    pub fn with_enabled_stats_reporting_address(mut self, address: Recipient) -> Self {
+        self.debug.stats_reporting.provider_address = Some(address);
+        self.debug.stats_reporting.enabled = true; //since we are overriding the address, we assume the reporting should be enabled
+        self
+    }
+
     // TODO: this should be refactored properly
     // as of 12.09.23 the below is true (not sure how this comment will rot in the future)
     // medium_toggle:
@@ -381,13 +393,20 @@ 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 it unless you understand the consequences of that change.
+    /// Do not set it unless you understand the consequences of that change.
     pub secondary_packet_size: Option<PacketSize>,
 
     pub packet_type: PacketType,
@@ -412,6 +431,8 @@ 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,
@@ -631,6 +652,34 @@ impl Default for ReplySurbs {
     }
 }
 
+#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
+#[serde(default, deny_unknown_fields)]
+pub struct StatsReporting {
+    /// Is stats reporting enabled
+    pub enabled: bool,
+
+    /// Address of the stats collector. If this is none, no reporting will happen, regardless of `enabled`
+    #[serde(
+        serialize_with = "ser_maybe_stringified",
+        deserialize_with = "de_maybe_stringified"
+    )]
+    pub provider_address: Option<Recipient>,
+
+    /// With what frequence will statistics be sent
+    #[serde(with = "humantime_serde")]
+    pub reporting_interval: Duration,
+}
+
+impl Default for StatsReporting {
+    fn default() -> Self {
+        StatsReporting {
+            enabled: true,
+            provider_address: None,
+            reporting_interval: STATS_REPORT_INTERVAL_SECS,
+        }
+    }
+}
+
 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
 pub struct DebugConfig {
@@ -651,6 +700,9 @@ pub struct DebugConfig {
 
     /// Defines all configuration options related to reply SURBs.
     pub reply_surbs: ReplySurbs,
+
+    /// Defines all configuration options related to stats reporting.
+    pub stats_reporting: StatsReporting,
 }
 
 impl DebugConfig {
@@ -672,6 +724,7 @@ impl Default for DebugConfig {
             acknowledgements: Default::default(),
             topology: Default::default(),
             reply_surbs: Default::default(),
+            stats_reporting: Default::default(),
         }
     }
 }

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

@@ -111,6 +111,7 @@ 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
@@ -181,6 +182,7 @@ impl From<ConfigV5> for Config {
                     maximum_reply_key_age: value.debug.reply_surbs.maximum_reply_key_age,
                     surb_mix_hops: value.debug.reply_surbs.surb_mix_hops,
                 },
+                stats_reporting: Default::default(),
             },
         }
     }

common/client-core/src/cli_helpers/client_init.rs

@@ -15,6 +15,7 @@ use crate::{
 use log::info;
 use nym_client_core_gateways_storage::GatewayDetails;
 use nym_crypto::asymmetric::identity;
+use nym_sphinx::addressing::Recipient;
 use nym_topology::NymTopology;
 use nym_validator_client::UserAgent;
 use rand::rngs::OsRng;
@@ -88,6 +89,10 @@ pub struct CommonClientInitArgs {
     /// Disable loop cover traffic and the Poisson rate limiter (for debugging only)
     #[cfg_attr(feature = "cli", clap(long, hide = true))]
     pub no_cover: bool,
+
+    /// Sets the address to report statistics
+    #[cfg_attr(feature = "cli", clap(long, hide = true))]
+    pub stats_reporting_address: Option<Recipient>,
 }
 
 pub struct InitResultsWithConfig<T> {

common/client-core/src/cli_helpers/client_run.rs

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use nym_crypto::asymmetric::identity;
+use nym_sphinx::addressing::Recipient;
 use std::path::PathBuf;
 
 #[cfg_attr(feature = "cli", derive(clap::Args))]
@@ -56,4 +57,8 @@ pub struct CommonClientRunArgs {
     // has defined the conflict on that field itself
     #[cfg_attr(feature = "cli", clap(long, hide = true))]
     pub no_cover: bool,
+
+    /// Sets the address to report statistics
+    #[cfg_attr(feature = "cli", clap(long, hide = true))]
+    pub stats_reporting_address: Option<Recipient>,
 }

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

@@ -1,8 +1,8 @@
 // Copyright 2022-2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use super::packet_statistics_control::PacketStatisticsReporter;
 use super::received_buffer::ReceivedBufferMessage;
+use super::statistics_control::StatisticsControl;
 use super::topology_control::geo_aware_provider::GeoAwareTopologyProvider;
 use crate::client::base_client::storage::helpers::store_client_keys;
 use crate::client::base_client::storage::MixnetClientStorage;
@@ -12,7 +12,6 @@ use crate::client::key_manager::persistence::KeyStore;
 use crate::client::key_manager::ClientKeys;
 use crate::client::mix_traffic::transceiver::{GatewayReceiver, GatewayTransceiver, RemoteGateway};
 use crate::client::mix_traffic::{BatchMixMessageSender, MixTrafficController};
-use crate::client::packet_statistics_control::PacketStatisticsControl;
 use crate::client::real_messages_control;
 use crate::client::real_messages_control::RealMessagesController;
 use crate::client::received_buffer::{
@@ -49,6 +48,8 @@ use nym_sphinx::addressing::clients::Recipient;
 use nym_sphinx::addressing::nodes::NodeIdentity;
 use nym_sphinx::params::PacketType;
 use nym_sphinx::receiver::{ReconstructedMessage, SphinxMessageReceiver};
+use nym_statistics_common::clients::ClientStatsSender;
+use nym_statistics_common::generate_client_stats_id;
 use nym_task::connections::{ConnectionCommandReceiver, ConnectionCommandSender, LaneQueueLengths};
 use nym_task::{TaskClient, TaskHandle};
 use nym_topology::provider_trait::TopologyProvider;
@@ -59,6 +60,7 @@ use std::fmt::Debug;
 use std::os::raw::c_int as RawFd;
 use std::path::Path;
 use std::sync::Arc;
+use tokio::sync::mpsc::Sender;
 use url::Url;
 
 #[cfg(all(
@@ -273,7 +275,7 @@ where
         self_address: Recipient,
         topology_accessor: TopologyAccessor,
         mix_tx: BatchMixMessageSender,
-        stats_tx: PacketStatisticsReporter,
+        stats_tx: ClientStatsSender,
         shutdown: TaskClient,
     ) {
         info!("Starting loop cover traffic stream...");
@@ -306,7 +308,7 @@ where
         client_connection_rx: ConnectionCommandReceiver,
         shutdown: TaskClient,
         packet_type: PacketType,
-        stats_tx: PacketStatisticsReporter,
+        stats_tx: ClientStatsSender,
     ) {
         info!("Starting real traffic stream...");
 
@@ -335,7 +337,7 @@ where
         reply_key_storage: SentReplyKeys,
         reply_controller_sender: ReplyControllerSender,
         shutdown: TaskClient,
-        packet_statistics_control: PacketStatisticsReporter,
+        metrics_reporter: ClientStatsSender,
     ) {
         info!("Starting received messages buffer controller...");
         let controller: ReceivedMessagesBufferController<SphinxMessageReceiver> =
@@ -345,7 +347,7 @@ where
                 mixnet_receiver,
                 reply_key_storage,
                 reply_controller_sender,
-                packet_statistics_control,
+                metrics_reporter,
             );
         controller.start_with_shutdown(shutdown)
     }
@@ -356,6 +358,7 @@ where
         bandwidth_controller: Option<BandwidthController<C, S::CredentialStore>>,
         details_store: &S::GatewaysDetailsStore,
         packet_router: PacketRouter,
+        stats_reporter: ClientStatsSender,
         shutdown: TaskClient,
     ) -> Result<GatewayClient<C, S::CredentialStore>, ClientCoreError>
     where
@@ -371,7 +374,12 @@ where
 
         let mut gateway_client =
             if let Some(existing_client) = initialisation_result.authenticated_ephemeral_client {
-                existing_client.upgrade(packet_router, bandwidth_controller, shutdown)
+                existing_client.upgrade(
+                    packet_router,
+                    bandwidth_controller,
+                    stats_reporter,
+                    shutdown,
+                )
             } else {
                 let cfg = GatewayConfig::new(
                     details.gateway_id,
@@ -392,6 +400,7 @@ where
                     Some(details.shared_key),
                     packet_router,
                     bandwidth_controller,
+                    stats_reporter,
                     shutdown,
                 )
             };
@@ -444,6 +453,7 @@ where
         Ok(gateway_client)
     }
 
+    #[allow(clippy::too_many_arguments)]
     async fn setup_gateway_transceiver(
         custom_gateway_transceiver: Option<Box<dyn GatewayTransceiver + Send>>,
         config: &Config,
@@ -451,6 +461,7 @@ where
         bandwidth_controller: Option<BandwidthController<C, S::CredentialStore>>,
         details_store: &S::GatewaysDetailsStore,
         packet_router: PacketRouter,
+        stats_reporter: ClientStatsSender,
         mut shutdown: TaskClient,
     ) -> Result<Box<dyn GatewayTransceiver + Send>, ClientCoreError>
     where
@@ -481,6 +492,7 @@ where
             bandwidth_controller,
             details_store,
             packet_router,
+            stats_reporter,
             shutdown,
         )
         .await?;
@@ -586,11 +598,23 @@ where
         Ok(())
     }
 
-    fn start_packet_statistics_control(shutdown: TaskClient) -> PacketStatisticsReporter {
-        info!("Starting packet statistics control...");
-        let (packet_statistics_control, packet_stats_reporter) = PacketStatisticsControl::new();
-        packet_statistics_control.start_with_shutdown(shutdown);
-        packet_stats_reporter
+    fn start_statistics_control(
+        config: &Config,
+        user_agent: Option<UserAgent>,
+        client_stats_id: String,
+        input_sender: Sender<InputMessage>,
+        shutdown: TaskClient,
+    ) -> ClientStatsSender {
+        info!("Starting statistics control...");
+        StatisticsControl::create_and_start_with_shutdown(
+            config.debug.stats_reporting,
+            user_agent
+                .map(|u| u.application)
+                .unwrap_or("unknown".to_string()),
+            client_stats_id,
+            input_sender.clone(),
+            shutdown.with_suffix("controller"),
+        )
     }
 
     fn start_mix_traffic_controller(
@@ -720,6 +744,14 @@ where
             self.user_agent.clone(),
         );
 
+        let stats_reporter = Self::start_statistics_control(
+            self.config,
+            self.user_agent.clone(),
+            generate_client_stats_id(*self_address.identity()),
+            input_sender.clone(),
+            shutdown.fork("statistics_control"),
+        );
+
         // needs to be started as the first thing to block if required waiting for the gateway
         Self::start_topology_refresher(
             topology_provider,
@@ -731,9 +763,6 @@ where
         )
         .await?;
 
-        let packet_stats_reporter =
-            Self::start_packet_statistics_control(shutdown.fork("packet_statistics_control"));
-
         let gateway_packet_router = PacketRouter::new(
             ack_sender,
             mixnet_messages_sender,
@@ -747,6 +776,7 @@ where
             bandwidth_controller,
             &details_store,
             gateway_packet_router,
+            stats_reporter.clone(),
             shutdown.fork("gateway_transceiver"),
         )
         .await?;
@@ -765,7 +795,7 @@ where
             reply_storage.key_storage(),
             reply_controller_sender.clone(),
             shutdown.fork("received_messages_buffer"),
-            packet_stats_reporter.clone(),
+            stats_reporter.clone(),
         );
 
         // The message_sender is the transmitter for any component generating sphinx packets
@@ -804,7 +834,7 @@ where
             client_connection_rx,
             shutdown.fork("real_traffic_controller"),
             self.config.debug.traffic.packet_type,
-            packet_stats_reporter.clone(),
+            stats_reporter.clone(),
         );
 
         if !self
@@ -819,7 +849,7 @@ where
                 self_address,
                 shared_topology_accessor.clone(),
                 message_sender,
-                packet_stats_reporter,
+                stats_reporter.clone(),
                 shutdown.fork("cover_traffic_stream"),
             );
         }
@@ -847,6 +877,7 @@ where
                 topology_accessor: shared_topology_accessor,
                 gateway_connection: GatewayConnection { gateway_ws_fd },
             },
+            stats_reporter,
             task_handle: shutdown,
         })
     }
@@ -858,6 +889,7 @@ pub struct BaseClient {
     pub client_input: ClientInputStatus,
     pub client_output: ClientOutputStatus,
     pub client_state: ClientState,
+    pub stats_reporter: ClientStatsSender,
 
     pub task_handle: TaskHandle,
 }

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

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

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

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

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

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

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

@@ -30,7 +30,8 @@ pub(crate) enum Action {
     InsertPending(Vec<PendingAcknowledgement>),
 
     /// Removes given `PendingAcknowledgement` from the 'shared' state. Also cancels the retransmission timer.
-    /// Initiated by `AcknowledgementListener`
+    /// Initiated by `AcknowledgementListener` upon receiving the acknowledgement. Also by `RetransmissionRequestListener`
+    /// upon deciding to abandon the data.
     RemovePending(FragmentIdentifier),
 
     /// Starts the retransmission timer on given `PendingAcknowledgement` with the `Duration` based on
@@ -41,7 +42,7 @@ pub(crate) enum Action {
 
     /// Updates the expected delay of given `PendingAcknowledgement` with the new provided `SphinxDelay`.
     /// Initiated by `RetransmissionRequestListener`
-    UpdateDelay(FragmentIdentifier, SphinxDelay),
+    UpdatePendingAck(FragmentIdentifier, SphinxDelay),
 }
 
 impl Action {
@@ -57,8 +58,8 @@ impl Action {
         Action::StartTimer(frag_id)
     }
 
-    pub(crate) fn new_update_delay(frag_id: FragmentIdentifier, delay: SphinxDelay) -> Self {
-        Action::UpdateDelay(frag_id, delay)
+    pub(crate) fn new_update_pending_ack(frag_id: FragmentIdentifier, delay: SphinxDelay) -> Self {
+        Action::UpdatePendingAck(frag_id, delay)
     }
 }
 
@@ -135,7 +136,7 @@ impl ActionController {
     }
 
     fn handle_start_timer(&mut self, frag_id: FragmentIdentifier) {
-        trace!("{} is starting its timer", frag_id);
+        trace!("{frag_id} is starting its timer");
 
         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
@@ -193,7 +194,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_delay(&mut self, frag_id: FragmentIdentifier, delay: SphinxDelay) {
+    fn handle_update_pending_ack(&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) {
@@ -202,7 +203,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_delay(delay);
+            inner_data.update_retransmitted(delay);
 
             self.pending_acks_data
                 .insert(frag_id, (Arc::new(inner_data), queue_key));
@@ -225,7 +226,7 @@ impl ActionController {
         // about it. Perhaps just reschedule it at later point?
         let frag_id = expired_ack.into_inner();
 
-        trace!("{} has expired", frag_id);
+        trace!("{frag_id} has expired");
 
         if let Some((pending_ack_data, queue_key)) = self.pending_acks_data.get_mut(&frag_id) {
             if queue_key.is_none() {
@@ -258,7 +259,9 @@ 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::UpdateDelay(frag_id, delay) => self.handle_update_delay(frag_id, delay),
+            Action::UpdatePendingAck(frag_id, delay) => {
+                self.handle_update_pending_ack(frag_id, delay)
+            }
         }
     }
 

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

@@ -8,7 +8,6 @@ use self::{
     sent_notification_listener::SentNotificationListener,
 };
 use crate::client::inbound_messages::InputMessageReceiver;
-use crate::client::packet_statistics_control::PacketStatisticsReporter;
 use crate::client::real_messages_control::message_handler::MessageHandler;
 use crate::client::replies::reply_controller::ReplyControllerSender;
 use crate::spawn_future;
@@ -24,6 +23,7 @@ use nym_sphinx::{
     chunking::fragment::{Fragment, FragmentIdentifier},
     Delay as SphinxDelay,
 };
+use nym_statistics_common::clients::ClientStatsSender;
 use rand::{CryptoRng, Rng};
 use std::{
     sync::{Arc, Weak},
@@ -71,6 +71,7 @@ pub(crate) struct PendingAcknowledgement {
     delay: SphinxDelay,
     destination: PacketDestination,
     mix_hops: Option<u8>,
+    retransmissions: u32,
 }
 
 impl PendingAcknowledgement {
@@ -86,6 +87,7 @@ impl PendingAcknowledgement {
             delay,
             destination: PacketDestination::KnownRecipient(recipient.into()),
             mix_hops,
+            retransmissions: 0,
         }
     }
 
@@ -105,6 +107,7 @@ 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,
         }
     }
 
@@ -116,8 +119,9 @@ impl PendingAcknowledgement {
         self.message_chunk.clone()
     }
 
-    fn update_delay(&mut self, new_delay: SphinxDelay) {
+    fn update_retransmitted(&mut self, new_delay: SphinxDelay) {
         self.delay = new_delay;
+        self.retransmissions += 1;
     }
 }
 
@@ -163,6 +167,9 @@ 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,
 
@@ -174,8 +181,13 @@ pub(super) struct Config {
 }
 
 impl Config {
-    pub(super) fn new(ack_wait_addition: Duration, ack_wait_multiplier: f64) -> Self {
+    pub(super) fn new(
+        maximum_retransmissions: Option<u32>,
+        ack_wait_addition: Duration,
+        ack_wait_multiplier: f64,
+    ) -> Self {
         Config {
+            maximum_retransmissions,
             ack_wait_addition,
             ack_wait_multiplier,
             packet_size: Default::default(),
@@ -209,7 +221,7 @@ where
         connectors: AcknowledgementControllerConnectors,
         message_handler: MessageHandler<R>,
         reply_controller_sender: ReplyControllerSender,
-        stats_tx: PacketStatisticsReporter,
+        stats_tx: ClientStatsSender,
     ) -> Self {
         let (retransmission_tx, retransmission_rx) = mpsc::unbounded();
 
@@ -238,6 +250,7 @@ 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,6 +20,7 @@ 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,
@@ -31,12 +32,14 @@ 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,
@@ -77,6 +80,18 @@ 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,
@@ -101,8 +116,6 @@ 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) => {
@@ -136,7 +149,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_delay(frag_id, new_delay))
+            .unbounded_send(Action::new_update_pending_ack(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,6 +91,9 @@ 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,
 
@@ -114,10 +117,12 @@ 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,
@@ -176,6 +181,7 @@ where
     {
         let message_preparer = MessagePreparer::new(
             rng,
+            config.deterministic_route_selection,
             config.sender_address,
             config.average_packet_delay,
             config.average_ack_delay,
@@ -634,7 +640,7 @@ where
 
     pub(crate) fn update_ack_delay(&self, id: FragmentIdentifier, new_delay: Delay) {
         self.action_sender
-            .unbounded_send(Action::UpdateDelay(id, new_delay))
+            .unbounded_send(Action::UpdatePendingAck(id, new_delay))
             .expect("action control task has died")
     }
 

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

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

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

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

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

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

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

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

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

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

common/client-core/src/error.rs

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

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

@@ -29,6 +29,7 @@ nym-crypto = { path = "../../crypto" }
 nym-gateway-requests = { path = "../../gateway-requests" }
 nym-network-defaults = { path = "../../network-defaults" }
 nym-sphinx = { path = "../../nymsphinx" }
+nym-statistics-common = { path = "../../statistics" }
 nym-pemstore = { path = "../../pemstore" }
 nym-validator-client = { path = "../validator-client", default-features = false }
 nym-task = { path = "../../task" }

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

@@ -25,6 +25,8 @@ use nym_gateway_requests::{
     CREDENTIAL_UPDATE_V2_PROTOCOL_VERSION, CURRENT_PROTOCOL_VERSION,
 };
 use nym_sphinx::forwarding::packet::MixPacket;
+use nym_statistics_common::clients::connection::ConnectionStatsEvent;
+use nym_statistics_common::clients::ClientStatsSender;
 use nym_task::TaskClient;
 use nym_validator_client::nyxd::contract_traits::DkgQueryClient;
 use rand::rngs::OsRng;
@@ -94,6 +96,7 @@ pub struct GatewayClient<C, St = EphemeralCredentialStorage> {
     connection: SocketState,
     packet_router: PacketRouter,
     bandwidth_controller: Option<BandwidthController<C, St>>,
+    stats_reporter: ClientStatsSender,
 
     // currently unused (but populated)
     negotiated_protocol: Option<u8>,
@@ -103,6 +106,7 @@ pub struct GatewayClient<C, St = EphemeralCredentialStorage> {
 }
 
 impl<C, St> GatewayClient<C, St> {
+    #[allow(clippy::too_many_arguments)]
     pub fn new(
         cfg: GatewayClientConfig,
         gateway_config: GatewayConfig,
@@ -111,6 +115,7 @@ impl<C, St> GatewayClient<C, St> {
         shared_key: Option<Arc<SharedGatewayKey>>,
         packet_router: PacketRouter,
         bandwidth_controller: Option<BandwidthController<C, St>>,
+        stats_reporter: ClientStatsSender,
         task_client: TaskClient,
     ) -> Self {
         GatewayClient {
@@ -124,6 +129,7 @@ impl<C, St> GatewayClient<C, St> {
             connection: SocketState::NotConnected,
             packet_router,
             bandwidth_controller,
+            stats_reporter,
             negotiated_protocol: None,
             task_client,
         }
@@ -714,6 +720,7 @@ impl<C, St> GatewayClient<C, St> {
     {
         // TODO: make it configurable
         const TICKETS_TO_SPEND: u32 = 1;
+        const MIXNET_TICKET: TicketType = TicketType::V1MixnetEntry;
 
         if !self.authenticated {
             return Err(GatewayClientError::NotAuthenticated);
@@ -750,14 +757,23 @@ impl<C, St> GatewayClient<C, St> {
         let prepared_credential = self
             .unchecked_bandwidth_controller()
             .prepare_ecash_ticket(
-                TicketType::V1MixnetEntry,
+                MIXNET_TICKET,
                 self.gateway_identity.to_bytes(),
                 TICKETS_TO_SPEND,
             )
             .await?;
 
         match self.claim_ecash_bandwidth(prepared_credential.data).await {
-            Ok(_) => Ok(()),
+            Ok(_) => {
+                self.stats_reporter.report(
+                    ConnectionStatsEvent::TicketSpent {
+                        typ: MIXNET_TICKET,
+                        amount: TICKETS_TO_SPEND,
+                    }
+                    .into(),
+                );
+                Ok(())
+            }
             Err(err) => {
                 error!("failed to claim ecash bandwidth with the gateway...: {err}");
                 if err.is_ticket_replay() {
@@ -1030,6 +1046,7 @@ impl GatewayClient<InitOnly, EphemeralCredentialStorage> {
             connection: SocketState::NotConnected,
             packet_router,
             bandwidth_controller: None,
+            stats_reporter: ClientStatsSender::new(None),
             negotiated_protocol: None,
             task_client,
         }
@@ -1039,6 +1056,7 @@ impl GatewayClient<InitOnly, EphemeralCredentialStorage> {
         self,
         packet_router: PacketRouter,
         bandwidth_controller: Option<BandwidthController<C, St>>,
+        stats_reporter: ClientStatsSender,
         task_client: TaskClient,
     ) -> GatewayClient<C, St> {
         // invariants that can't be broken
@@ -1058,6 +1076,7 @@ impl GatewayClient<InitOnly, EphemeralCredentialStorage> {
             connection: self.connection,
             packet_router,
             bandwidth_controller,
+            stats_reporter,
             negotiated_protocol: self.negotiated_protocol,
             task_client,
         }

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

@@ -11,7 +11,8 @@ use crate::{
 use nym_api_requests::ecash::models::{
     AggregatedCoinIndicesSignatureResponse, AggregatedExpirationDateSignatureResponse,
     BatchRedeemTicketsBody, EcashBatchTicketRedemptionResponse, EcashTicketVerificationResponse,
-    SpentCredentialsResponse, VerifyEcashTicketBody,
+    IssuedTicketbooksChallengeResponse, IssuedTicketbooksForResponse, SpentCredentialsResponse,
+    VerifyEcashTicketBody,
 };
 use nym_api_requests::ecash::{
     BlindSignRequestBody, BlindedSignatureResponse, PartialCoinIndicesSignatureResponse,
@@ -24,16 +25,17 @@ use nym_api_requests::models::{
 use nym_api_requests::models::{LegacyDescribedGateway, MixNodeBondAnnotated};
 use nym_api_requests::nym_nodes::SkimmedNode;
 use nym_coconut_dkg_common::types::EpochId;
+use nym_ecash_contract_common::deposit::DepositId;
 use nym_http_api_client::UserAgent;
 use nym_network_defaults::NymNetworkDetails;
 use time::Date;
 use url::Url;
 
 pub use crate::nym_api::NymApiClientExt;
-use nym_mixnet_contract_common::NymNodeDetails;
 pub use nym_mixnet_contract_common::{
-    mixnode::MixNodeDetails, GatewayBond, IdentityKey, IdentityKeyRef, NodeId,
+    mixnode::MixNodeDetails, GatewayBond, IdentityKey, IdentityKeyRef, NodeId, NymNodeDetails,
 };
+
 // re-export the type to not break existing imports
 pub use crate::coconut::EcashApiClient;
 
@@ -330,10 +332,10 @@ impl NymApiClient {
         NymApiClient { nym_api }
     }
 
-    pub fn new_with_user_agent(api_url: Url, user_agent: UserAgent) -> Self {
+    pub fn new_with_user_agent(api_url: Url, user_agent: impl Into<UserAgent>) -> Self {
         let nym_api = nym_api::Client::builder::<_, ValidatorClientError>(api_url)
             .expect("invalid api url")
-            .with_user_agent(user_agent)
+            .with_user_agent(user_agent.into())
             .build::<ValidatorClientError>()
             .expect("failed to build nym api client");
 
@@ -696,4 +698,22 @@ impl NymApiClient {
     ) -> Result<VerificationKeyResponse, ValidatorClientError> {
         Ok(self.nym_api.master_verification_key(epoch_id).await?)
     }
+
+    pub async fn issued_ticketbooks_for(
+        &self,
+        expiration_date: Date,
+    ) -> Result<IssuedTicketbooksForResponse, ValidatorClientError> {
+        Ok(self.nym_api.issued_ticketbooks_for(expiration_date).await?)
+    }
+
+    pub async fn issued_ticketbooks_challenge(
+        &self,
+        expiration_date: Date,
+        deposits: Vec<DepositId>,
+    ) -> Result<IssuedTicketbooksChallengeResponse, ValidatorClientError> {
+        Ok(self
+            .nym_api
+            .issued_ticketbooks_challenge(expiration_date, deposits)
+            .await?)
+    }
 }

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

@@ -7,36 +7,34 @@ use async_trait::async_trait;
 use nym_api_requests::ecash::models::{
     AggregatedCoinIndicesSignatureResponse, AggregatedExpirationDateSignatureResponse,
     BatchRedeemTicketsBody, EcashBatchTicketRedemptionResponse, EcashTicketVerificationResponse,
-    VerifyEcashTicketBody,
+    IssuedTicketbooksChallengeRequest, IssuedTicketbooksChallengeResponse,
+    IssuedTicketbooksForResponse, VerifyEcashTicketBody,
 };
 use nym_api_requests::ecash::VerificationKeyResponse;
 use nym_api_requests::models::{
     AnnotationResponse, ApiHealthResponse, LegacyDescribedMixNode, NodePerformanceResponse,
-    NymNodeDescription,
+    NodeRefreshBody, NymNodeDescription,
 };
 use nym_api_requests::nym_nodes::PaginatedCachedNodesResponse;
 use nym_api_requests::pagination::PaginatedResponse;
 pub use nym_api_requests::{
     ecash::{
-        models::{
-            EpochCredentialsResponse, IssuedCredentialResponse, IssuedCredentialsResponse,
-            IssuedTicketbook, IssuedTicketbookBody, SpentCredentialsResponse,
-        },
-        BlindSignRequestBody, BlindedSignatureResponse, CredentialsRequestBody,
+        models::SpentCredentialsResponse, BlindSignRequestBody, BlindedSignatureResponse,
         PartialCoinIndicesSignatureResponse, PartialExpirationDateSignatureResponse,
         VerifyEcashCredentialBody,
     },
     models::{
         ComputeRewardEstParam, GatewayBondAnnotated, GatewayCoreStatusResponse,
-        GatewayStatusReportResponse, GatewayUptimeHistoryResponse, InclusionProbabilityResponse,
-        LegacyDescribedGateway, MixNodeBondAnnotated, MixnodeCoreStatusResponse,
-        MixnodeStatusReportResponse, MixnodeStatusResponse, MixnodeUptimeHistoryResponse,
-        RewardEstimationResponse, StakeSaturationResponse, UptimeResponse,
+        GatewayStatusReportResponse, GatewayUptimeHistoryResponse, LegacyDescribedGateway,
+        MixNodeBondAnnotated, MixnodeCoreStatusResponse, MixnodeStatusReportResponse,
+        MixnodeStatusResponse, MixnodeUptimeHistoryResponse, RewardEstimationResponse,
+        StakeSaturationResponse, UptimeResponse,
     },
     nym_nodes::{CachedNodesResponse, SkimmedNode},
 };
 pub use nym_coconut_dkg_common::types::EpochId;
 use nym_contracts_common::IdentityKey;
+use nym_ecash_contract_common::deposit::DepositId;
 pub use nym_http_api_client::Client;
 use nym_http_api_client::{ApiClient, NO_PARAMS};
 use nym_mixnet_contract_common::mixnode::MixNodeDetails;
@@ -673,11 +671,12 @@ pub trait NymApiClientExt: ApiClient {
     }
 
     #[deprecated]
+    #[allow(deprecated)]
     #[instrument(level = "debug", skip(self))]
     async fn get_mixnode_inclusion_probability(
         &self,
         mix_id: NodeId,
-    ) -> Result<InclusionProbabilityResponse, NymAPIError> {
+    ) -> Result<nym_api_requests::models::InclusionProbabilityResponse, NymAPIError> {
         self.get_json(
             &[
                 routes::API_VERSION,
@@ -696,16 +695,32 @@ pub trait NymApiClientExt: ApiClient {
         &self,
         node_id: NodeId,
     ) -> Result<NodePerformanceResponse, NymAPIError> {
-        self.get_json_from(format!("/v1/nym-nodes/performance/{node_id}"))
-            .await
+        self.get_json(
+            &[
+                routes::API_VERSION,
+                "nym-nodes",
+                "performance",
+                &node_id.to_string(),
+            ],
+            NO_PARAMS,
+        )
+        .await
     }
 
     async fn get_node_annotation(
         &self,
         node_id: NodeId,
     ) -> Result<AnnotationResponse, NymAPIError> {
-        self.get_json_from(format!("/v1/nym-nodes/annotation/{node_id}"))
-            .await
+        self.get_json(
+            &[
+                routes::API_VERSION,
+                "nym-nodes",
+                "annotation",
+                &node_id.to_string(),
+            ],
+            NO_PARAMS,
+        )
+        .await
     }
 
     #[deprecated]
@@ -911,62 +926,56 @@ pub trait NymApiClientExt: ApiClient {
             &[
                 routes::API_VERSION,
                 routes::ECASH_ROUTES,
-                routes::ecash::MASTER_VERIFICATION_KEY,
+                ecash::MASTER_VERIFICATION_KEY,
             ],
             &params,
         )
         .await
     }
 
-    #[instrument(level = "debug", skip(self))]
-    async fn epoch_credentials(
+    async fn force_refresh_describe_cache(
         &self,
-        dkg_epoch: EpochId,
-    ) -> Result<EpochCredentialsResponse, NymAPIError> {
+        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,
+    ) -> Result<IssuedTicketbooksForResponse, NymAPIError> {
         self.get_json(
             &[
                 routes::API_VERSION,
                 routes::ECASH_ROUTES,
-                routes::ECASH_EPOCH_CREDENTIALS,
-                &dkg_epoch.to_string(),
+                routes::ECASH_ISSUED_TICKETBOOKS_FOR,
+                &expiration_date.to_string(),
             ],
             NO_PARAMS,
         )
         .await
     }
 
-    #[instrument(level = "debug", skip(self))]
-    async fn issued_credential(
+    async fn issued_ticketbooks_challenge(
         &self,
-        credential_id: i64,
-    ) -> Result<IssuedCredentialResponse, NymAPIError> {
-        self.get_json(
-            &[
-                routes::API_VERSION,
-                routes::ECASH_ROUTES,
-                routes::ECASH_ISSUED_CREDENTIAL,
-                &credential_id.to_string(),
-            ],
-            NO_PARAMS,
-        )
-        .await
-    }
-
-    #[instrument(level = "debug", skip(self))]
-    async fn issued_credentials(
-        &self,
-        credential_ids: Vec<i64>,
-    ) -> Result<IssuedCredentialsResponse, NymAPIError> {
+        expiration_date: Date,
+        deposits: Vec<DepositId>,
+    ) -> Result<IssuedTicketbooksChallengeResponse, NymAPIError> {
         self.post_json(
             &[
                 routes::API_VERSION,
                 routes::ECASH_ROUTES,
-                routes::ECASH_ISSUED_CREDENTIALS,
+                routes::ECASH_ISSUED_TICKETBOOKS_CHALLENGE,
             ],
             NO_PARAMS,
-            &CredentialsRequestBody {
-                credential_ids,
-                pagination: None,
+            &IssuedTicketbooksChallengeRequest {
+                expiration_date,
+                deposits,
             },
         )
         .await

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

@@ -27,9 +27,8 @@ pub mod ecash {
     pub const PARTIAL_COIN_INDICES_SIGNATURES: &str = "partial-coin-indices-signatures";
     pub const GLOBAL_COIN_INDICES_SIGNATURES: &str = "aggregated-coin-indices-signatures";
     pub const MASTER_VERIFICATION_KEY: &str = "master-verification-key";
-    pub const ECASH_EPOCH_CREDENTIALS: &str = "epoch-credentials";
-    pub const ECASH_ISSUED_CREDENTIAL: &str = "issued-credential";
-    pub const ECASH_ISSUED_CREDENTIALS: &str = "issued-credentials";
+    pub const ECASH_ISSUED_TICKETBOOKS_FOR: &str = "issued-ticketbooks-for";
+    pub const ECASH_ISSUED_TICKETBOOKS_CHALLENGE: &str = "issued-ticketbooks-challenge";
 
     pub const EXPIRATION_DATE_PARAM: &str = "expiration_date";
     pub const EPOCH_ID_PARAM: &str = "epoch_id";

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

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

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

@@ -7,6 +7,7 @@ use crate::nyxd::error::NyxdError;
 use crate::nyxd::CosmWasmClient;
 use async_trait::async_trait;
 use cosmwasm_std::Coin;
+use nym_ecash_contract_common::deposit::LatestDepositResponse;
 use nym_ecash_contract_common::msg::QueryMsg as EcashQueryMsg;
 use serde::Deserialize;
 
@@ -51,6 +52,11 @@ pub trait EcashQueryClient {
             .await
     }
 
+    async fn get_latest_deposit(&self) -> Result<LatestDepositResponse, NyxdError> {
+        self.query_ecash_contract(EcashQueryMsg::GetLatestDeposit {})
+            .await
+    }
+
     async fn get_deposits_paged(
         &self,
         start_after: Option<u32>,
@@ -98,7 +104,6 @@ where
 mod tests {
     use super::*;
     use crate::nyxd::contract_traits::tests::IgnoreValue;
-    use nym_ecash_contract_common::msg::QueryMsg;
 
     // it's enough that this compiles and clippy is happy about it
     #[allow(dead_code)]
@@ -110,14 +115,17 @@ mod tests {
             EcashQueryMsg::GetBlacklistedAccount { public_key } => {
                 client.get_blacklisted_account(public_key).ignore()
             }
-            QueryMsg::GetBlacklistPaged { limit, start_after } => {
+            EcashQueryMsg::GetBlacklistPaged { limit, start_after } => {
                 client.get_blacklist_paged(start_after, limit).ignore()
             }
-            QueryMsg::GetDeposit { deposit_id } => client.get_deposit(deposit_id).ignore(),
-            QueryMsg::GetDepositsPaged { limit, start_after } => {
+            EcashQueryMsg::GetDeposit { deposit_id } => client.get_deposit(deposit_id).ignore(),
+            EcashQueryMsg::GetDepositsPaged { limit, start_after } => {
                 client.get_deposits_paged(start_after, limit).ignore()
             }
-            QueryMsg::GetRequiredDepositAmount {} => client.get_required_deposit_amount().ignore(),
+            EcashQueryMsg::GetRequiredDepositAmount {} => {
+                client.get_required_deposit_amount().ignore()
+            }
+            EcashQueryMsg::GetLatestDeposit {} => client.get_latest_deposit().ignore(),
         };
     }
 }

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, NodeOwnershipResponse,
-    NodeRewardingDetailsResponse, PagedNymNodeBondsResponse, PagedNymNodeDetailsResponse,
-    PagedUnbondedNymNodesResponse, Role, RolesMetadataResponse, StakeSaturationResponse,
-    UnbondedNodeResponse, UnbondedNymNode,
+    EpochAssignmentResponse, NodeDetailsByIdentityResponse, NodeDetailsResponse,
+    NodeOwnershipResponse, NodeRewardingDetailsResponse, PagedNymNodeBondsResponse,
+    PagedNymNodeDetailsResponse, PagedUnbondedNymNodesResponse, Role, RolesMetadataResponse,
+    StakeSaturationResponse, UnbondedNodeResponse, UnbondedNymNode,
 };
 use nym_mixnet_contract_common::reward_params::WorkFactor;
 use nym_mixnet_contract_common::{
@@ -66,11 +66,6 @@ pub trait MixnetQueryClient {
             .await
     }
 
-    async fn get_mixnet_contract_settings(&self) -> Result<ContractStateParams, NyxdError> {
-        self.query_mixnet_contract(MixnetQueryMsg::GetStateParams {})
-            .await
-    }
-
     async fn get_mixnet_contract_state_params(&self) -> Result<ContractStateParams, NyxdError> {
         self.query_mixnet_contract(MixnetQueryMsg::GetStateParams {})
             .await
@@ -316,10 +311,7 @@ pub trait MixnetQueryClient {
         .await
     }
 
-    async fn get_nymnode_details(
-        &self,
-        node_id: NodeId,
-    ) -> Result<NodeOwnershipResponse, NyxdError> {
+    async fn get_nymnode_details(&self, node_id: NodeId) -> Result<NodeDetailsResponse, NyxdError> {
         self.query_mixnet_contract(MixnetQueryMsg::GetNymNodeDetails { node_id })
             .await
     }

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

@@ -17,7 +17,7 @@ use nym_mixnet_contract_common::reward_params::{
     ActiveSetUpdate, IntervalRewardingParamsUpdate, NodeRewardingParameters,
 };
 use nym_mixnet_contract_common::{
-    ContractStateParams, ExecuteMsg as MixnetExecuteMsg, Gateway, MixNode, NodeId, NymNode,
+    ContractStateParamsUpdate, ExecuteMsg as MixnetExecuteMsg, Gateway, MixNode, NodeId, NymNode,
     RoleAssignment,
 };
 
@@ -59,12 +59,27 @@ pub trait MixnetSigningClient {
 
     async fn update_contract_state_params(
         &self,
-        updated_parameters: ContractStateParams,
+        update: ContractStateParamsUpdate,
         fee: Option<Fee>,
     ) -> Result<ExecuteResult, NyxdError> {
         self.execute_mixnet_contract(
             fee,
-            MixnetExecuteMsg::UpdateContractStateParams { updated_parameters },
+            MixnetExecuteMsg::UpdateContractStateParams { update },
+            vec![],
+        )
+        .await
+    }
+
+    async fn update_current_nym_node_semver(
+        &self,
+        current_nym_node_semver: String,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NyxdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::UpdateCurrentNymNodeSemver {
+                current_version: current_nym_node_semver,
+            },
             vec![],
         )
         .await
@@ -682,8 +697,11 @@ mod tests {
             MixnetExecuteMsg::UpdateRewardingValidatorAddress { address } => client
                 .update_rewarding_validator_address(address.parse().unwrap(), None)
                 .ignore(),
-            MixnetExecuteMsg::UpdateContractStateParams { updated_parameters } => client
-                .update_contract_state_params(updated_parameters, None)
+            MixnetExecuteMsg::UpdateContractStateParams { update } => {
+                client.update_contract_state_params(update, None).ignore()
+            }
+            MixnetExecuteMsg::UpdateCurrentNymNodeSemver { current_version } => client
+                .update_current_nym_node_semver(current_version, None)
                 .ignore(),
             MixnetExecuteMsg::UpdateActiveSetDistribution {
                 update,

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

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

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

@@ -23,7 +23,7 @@ use tendermint_rpc::endpoint::*;
 use tendermint_rpc::query::Query;
 use tendermint_rpc::{Error as TendermintRpcError, Order, Paging, SimpleRequest};
 
-pub use helpers::{ToContractResponseData, ToSingletonContractData};
+pub use helpers::{ContractResponseData, ToContractResponseData};
 
 #[cfg(feature = "http-client")]
 use crate::http_client;
@@ -303,7 +303,7 @@ where
         feature = "tendermint-rpc-http-client",
         feature = "tendermint-rpc-websocket-client"
     ))]
-    async fn wait_until_healthy<T>(&self, timeout: T) -> Result<(), Error>
+    async fn wait_until_healthy<T>(&self, timeout: T) -> Result<(), TendermintRpcError>
     where
         T: Into<core::time::Duration> + Send,
     {

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

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

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

@@ -823,7 +823,7 @@ where
         feature = "tendermint-rpc-http-client",
         feature = "tendermint-rpc-websocket-client"
     ))]
-    async fn wait_until_healthy<T>(&self, timeout: T) -> Result<(), Error>
+    async fn wait_until_healthy<T>(&self, timeout: T) -> Result<(), TendermintRpcError>
     where
         T: Into<core::time::Duration> + Send,
     {

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

@@ -523,7 +523,7 @@ mod non_wasm {
         ))]
         async fn wait_until_healthy<T>(&self, timeout: T) -> Result<(), Error>
         where
-            T: Into<Duration> + Send,
+            T: Into<core::time::Duration> + Send,
         {
             self.wait_until_healthy(timeout).await
         }

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

@@ -98,6 +98,13 @@ 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/src/ecash/issue_ticket_book.rs

@@ -6,6 +6,7 @@ use crate::utils::CommonConfigsWrapper;
 use anyhow::{anyhow, bail};
 use clap::ArgGroup;
 use clap::Parser;
+use log::info;
 use nym_credential_storage::initialise_persistent_storage;
 use nym_credential_storage::storage::Storage;
 use nym_credential_utils::utils;
@@ -150,6 +151,7 @@ async fn issue_to_file(args: Args, client: SigningClient) -> anyhow::Result<()>
         exported = exported.with_master_verification_key(&EpochVerificationKey { epoch_id, key });
     }
 
+    info!("the issued ticketbook has expiration of {expiration_date}");
     let data = exported.pack().data;
 
     if args.bs58_output {

common/commands/src/validator/cosmwasm/generators/mixnet.rs

@@ -33,6 +33,9 @@ pub struct Args {
     #[clap(long)]
     pub rewarding_denom: Option<String>,
 
+    #[clap(long)]
+    pub current_nym_node_version: String,
+
     #[clap(long, default_value_t = 720)]
     pub epochs_in_interval: u32,
 
@@ -143,6 +146,9 @@ pub async fn generate(args: Args) {
         epochs_in_interval: args.epochs_in_interval,
         epoch_duration: Duration::from_secs(args.epoch_duration),
         initial_rewarding_params,
+        current_nym_node_version: args.current_nym_node_version,
+        version_score_weights: Default::default(),
+        version_score_params: Default::default(),
         profit_margin: ProfitMarginRange {
             minimum: args.minimum_profit_margin_percent,
             maximum: args.maximum_profit_margin_percent,

common/config/src/serde_helpers.rs

@@ -1,7 +1,7 @@
 // Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use serde::{Deserialize, Deserializer};
+use serde::{Deserialize, Deserializer, Serializer};
 use std::fmt::Display;
 use std::path::PathBuf;
 use std::str::FromStr;
@@ -20,6 +20,17 @@ where
     }
 }
 
+pub fn ser_maybe_stringified<S, T>(field: &Option<T>, serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+    T: Display,
+{
+    match field {
+        Some(inner) => serializer.serialize_str(&inner.to_string()),
+        None => serializer.serialize_str(""),
+    }
+}
+
 pub fn de_maybe_string<'de, D>(deserializer: D) -> Result<Option<String>, D::Error>
 where
     D: Deserializer<'de>,

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

@@ -21,3 +21,6 @@ serde_json = { workspace = true }
 
 [build-dependencies]
 vergen = { workspace = true, features = ["build", "git", "gitcl", "rustc", "cargo"] }
+
+[features]
+naive_float = []

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

@@ -130,7 +130,7 @@ impl Deref for Percent {
 }
 
 // this is not implemented via From traits due to its naive nature and loss of precision
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(feature = "naive_float")]
 pub trait NaiveFloat {
     fn naive_to_f64(&self) -> f64;
 
@@ -139,8 +139,8 @@ pub trait NaiveFloat {
         Self: Sized;
 }
 
-#[cfg(not(target_arch = "wasm32"))]
-impl NaiveFloat for Percent {
+#[cfg(feature = "naive_float")]
+impl NaiveFloat for Decimal {
     fn naive_to_f64(&self) -> f64 {
         use cosmwasm_std::Fraction;
 
@@ -181,7 +181,21 @@ impl NaiveFloat for Percent {
         }
 
         let (n, d) = to_rational(val);
-        Percent::new(Decimal::from_ratio(n, d))
+        Ok(Decimal::from_ratio(n, d))
+    }
+}
+
+#[cfg(feature = "naive_float")]
+impl NaiveFloat for Percent {
+    fn naive_to_f64(&self) -> f64 {
+        self.0.naive_to_f64()
+    }
+
+    fn naive_try_from_f64(val: f64) -> Result<Self, ContractsCommonError>
+    where
+        Self: Sized,
+    {
+        Percent::new(Decimal::naive_try_from_f64(val)?)
     }
 }
 

common/cosmwasm-smart-contracts/ecash-contract/src/deposit.rs

@@ -47,6 +47,12 @@ impl Deposit {
     }
 }
 
+#[cw_serde]
+#[derive(Default)]
+pub struct LatestDepositResponse {
+    pub deposit: Option<DepositData>,
+}
+
 #[cw_serde]
 pub struct DepositResponse {
     pub id: DepositId,

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

@@ -1,4 +1,4 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
 use cosmwasm_schema::cw_serde;
@@ -7,7 +7,7 @@ use cosmwasm_std::Coin;
 #[cfg(feature = "schema")]
 use crate::blacklist::{BlacklistedAccountResponse, PagedBlacklistedAccountResponse};
 #[cfg(feature = "schema")]
-use crate::deposit::{DepositResponse, PagedDepositsResponse};
+use crate::deposit::{DepositResponse, LatestDepositResponse, PagedDepositsResponse};
 #[cfg(feature = "schema")]
 use cosmwasm_schema::QueryResponses;
 
@@ -73,6 +73,9 @@ pub enum QueryMsg {
     #[cfg_attr(feature = "schema", returns(DepositResponse))]
     GetDeposit { deposit_id: u32 },
 
+    #[cfg_attr(feature = "schema", returns(LatestDepositResponse))]
+    GetLatestDeposit {},
+
     #[cfg_attr(feature = "schema", returns(PagedDepositsResponse))]
     GetDepositsPaged {
         limit: Option<u32>,

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

@@ -17,6 +17,7 @@ cw-controllers = { workspace = true }
 cw2 = { workspace = true, optional = true }
 serde = { workspace = true, features = ["derive"] }
 serde_repr = { workspace = true }
+semver = { workspace = true, features = ["serde"] }
 
 # we still have to preserve that import for `JsonSchema` for `Layer` type (since we can't use cw_serde macro due to custom serde impl)
 schemars = { workspace = true }
@@ -26,8 +27,6 @@ serde-json-wasm = { workspace = true }
 humantime-serde = { workspace = true }
 utoipa = { workspace = true, optional = true }
 
-# TO CHECK WHETHER STILL NEEDED:
-log = { workspace = true }
 time = { workspace = true, features = ["parsing", "formatting"] }
 ts-rs = { workspace = true, optional = true }
 
@@ -38,6 +37,6 @@ time = { workspace = true, features = ["serde", "macros"] }
 [features]
 default = []
 contract-testing = []
-utoipa = [ "dep:utoipa" ]
+utoipa = ["dep:utoipa"]
 schema = ["cw2"]
 generate-ts = ['ts-rs']

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

@@ -166,6 +166,9 @@ pub enum MixnetContractError {
     #[error("Provided message to update rewarding params did not contain any updates")]
     EmptyParamsChangeMsg,
 
+    #[error("provided message to update state parameters did not contain any updates")]
+    EmptyStateUpdateMsg,
+
     #[error("one of the roles in the new active set is empty")]
     EmptyRoleAssignment,
 
@@ -269,6 +272,9 @@ pub enum MixnetContractError {
 
     #[error("the total work for this epoch seems to be bigger than 1.0!")]
     TotalWorkAboveOne,
+
+    #[error("the provided nym-node version is not a valid semver. got: {provided}")]
+    InvalidNymNodeSemver { provided: String },
 }
 
 impl MixnetContractError {

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

@@ -7,9 +7,9 @@ use crate::mixnode::{MixNodeConfigUpdate, NodeCostParams};
 use crate::nym_node::Role;
 use crate::reward_params::{ActiveSetUpdate, IntervalRewardParams, IntervalRewardingParamsUpdate};
 use crate::rewarding::RewardDistribution;
-use crate::{BlockHeight, ContractStateParams, EpochId, IdentityKeyRef, Interval, NodeId};
+use crate::{BlockHeight, ContractStateParamsUpdate, EpochId, IdentityKeyRef, Interval, NodeId};
 pub use contracts_common::events::*;
-use cosmwasm_std::{Addr, Coin, Decimal, Event};
+use cosmwasm_std::{attr, Addr, Coin, Decimal, Event};
 use std::fmt::Display;
 
 pub const EVENT_VERSION_PREFIX: &str = "v2_";
@@ -45,6 +45,7 @@ pub enum MixnetEventType {
     DelegationOnUnbonding,
     Undelegation,
     ContractSettingsUpdate,
+    NymNodeSemverUpdate,
     RewardingValidatorUpdate,
     BeginEpochTransition,
     AdvanceEpoch,
@@ -97,6 +98,7 @@ impl Display for MixnetEventType {
             MixnetEventType::Delegation => "delegation",
             MixnetEventType::Undelegation => "undelegation",
             MixnetEventType::ContractSettingsUpdate => "settings_update",
+            MixnetEventType::NymNodeSemverUpdate => "nym_node_semver_update",
             MixnetEventType::RewardingValidatorUpdate => "rewarding_validator_address_update",
             MixnetEventType::BeginEpochTransition => "beginning_epoch_transition",
             MixnetEventType::AdvanceEpoch => "advance_epoch",
@@ -132,11 +134,13 @@ pub const NODE_ID_KEY: &str = "node_id";
 pub const NODE_IDENTITY_KEY: &str = "identity";
 
 // settings change
-pub const OLD_MINIMUM_PLEDGE_KEY: &str = "old_minimum_pledge";
-pub const OLD_MINIMUM_DELEGATION_KEY: &str = "old_minimum_delegation";
-
 pub const NEW_MINIMUM_PLEDGE_KEY: &str = "new_minimum_pledge";
 pub const NEW_MINIMUM_DELEGATION_KEY: &str = "new_minimum_delegation";
+pub const NEW_PROFIT_MARGIN_RANGE_KEY: &str = "new_profit_margin_range";
+pub const NEW_INTERVAL_OPERATING_COST_RANGE_KEY: &str = "new_interval_operating_cost_range";
+pub const NEW_VERSION_WEIGHTS_RANGE_KEY: &str = "new_version_weights_range";
+pub const NEW_VERSION_SCORE_FORMULA_PARAMS_KEY: &str = "new_version_score_formula_params";
+pub const NYM_NODE_CURRENT_SEMVER_KEY: &str = "new_current_semver";
 
 pub const OLD_REWARDING_VALIDATOR_ADDRESS_KEY: &str = "old_rewarding_validator_address";
 pub const NEW_REWARDING_VALIDATOR_ADDRESS_KEY: &str = "new_rewarding_validator_address";
@@ -440,40 +444,73 @@ pub fn new_rewarding_validator_address_update_event(old: Addr, new: Addr) -> Eve
         .add_attribute(NEW_REWARDING_VALIDATOR_ADDRESS_KEY, new)
 }
 
-pub fn new_settings_update_event(
-    old_params: &ContractStateParams,
-    new_params: &ContractStateParams,
-) -> Event {
+pub fn new_settings_update_event(update: &ContractStateParamsUpdate) -> Event {
     let mut event = Event::new(MixnetEventType::ContractSettingsUpdate);
 
-    if old_params.minimum_pledge != new_params.minimum_pledge {
-        event = event
-            .add_attribute(
-                OLD_MINIMUM_PLEDGE_KEY,
-                old_params.minimum_pledge.to_string(),
-            )
-            .add_attribute(
-                NEW_MINIMUM_PLEDGE_KEY,
-                new_params.minimum_pledge.to_string(),
-            )
+    // check for delegations params updates
+    if let Some(delegations_update) = &update.delegations_params {
+        event.attributes.push(attr(
+            NEW_MINIMUM_DELEGATION_KEY,
+            delegations_update
+                .minimum_delegation
+                .as_ref()
+                .map(|d| d.to_string())
+                .unwrap_or("empty".to_string()),
+        ));
     }
 
-    if old_params.minimum_delegation != new_params.minimum_delegation {
-        if let Some(ref old) = old_params.minimum_delegation {
-            event = event.add_attribute(OLD_MINIMUM_DELEGATION_KEY, old.to_string())
-        } else {
-            event = event.add_attribute(OLD_MINIMUM_DELEGATION_KEY, "None")
+    // check for operators params updates
+    if let Some(operators_update) = &update.operators_params {
+        if let Some(minimum_pledge) = &operators_update.minimum_pledge {
+            event
+                .attributes
+                .push(attr(NEW_MINIMUM_PLEDGE_KEY, minimum_pledge.to_string()))
         }
-        if let Some(ref new) = new_params.minimum_delegation {
-            event = event.add_attribute(NEW_MINIMUM_DELEGATION_KEY, new.to_string())
-        } else {
-            event = event.add_attribute(NEW_MINIMUM_DELEGATION_KEY, "None")
+        if let Some(profit_margin) = &operators_update.profit_margin {
+            event
+                .attributes
+                .push(attr(NEW_PROFIT_MARGIN_RANGE_KEY, profit_margin.to_string()))
+        }
+        if let Some(interval_operating_cost) = &operators_update.interval_operating_cost {
+            event.attributes.push(attr(
+                NEW_INTERVAL_OPERATING_COST_RANGE_KEY,
+                interval_operating_cost.to_string(),
+            ))
+        }
+    }
+
+    // check for config score params updates
+    if let Some(config_score_update) = &update.config_score_params {
+        if let Some(current_nym_node_semver) = &config_score_update.current_nym_node_semver {
+            event.attributes.push(attr(
+                NYM_NODE_CURRENT_SEMVER_KEY,
+                current_nym_node_semver.to_string(),
+            ))
+        }
+        if let Some(version_weights) = &config_score_update.version_weights {
+            event.attributes.push(attr(
+                NEW_VERSION_WEIGHTS_RANGE_KEY,
+                format!("{version_weights:?}"),
+            ))
+        }
+        if let Some(version_score_formula_params) =
+            &config_score_update.version_score_formula_params
+        {
+            event.attributes.push(attr(
+                NEW_VERSION_SCORE_FORMULA_PARAMS_KEY,
+                format!("{version_score_formula_params:?}"),
+            ))
         }
     }
 
     event
 }
 
+pub fn new_update_nym_node_semver_event(new_version: &str) -> Event {
+    Event::new(MixnetEventType::NymNodeSemverUpdate)
+        .add_attribute(NYM_NODE_CURRENT_SEMVER_KEY, new_version)
+}
+
 pub fn new_not_found_node_operator_rewarding_event(interval: Interval, node_id: NodeId) -> Event {
     Event::new(MixnetEventType::NodeRewarding)
         .add_attribute(

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

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

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

@@ -12,8 +12,11 @@ use crate::reward_params::{
     ActiveSetUpdate, IntervalRewardParams, IntervalRewardingParamsUpdate, NodeRewardingParameters,
     Performance, RewardedSetParams, RewardingParams, WorkFactor,
 };
-use crate::types::{ContractStateParams, NodeId};
-use crate::{NymNode, RoleAssignment};
+use crate::types::NodeId;
+use crate::{
+    ContractStateParamsUpdate, NymNode, OutdatedVersionWeights, RoleAssignment,
+    VersionScoreFormulaParams,
+};
 use crate::{OperatingCostRange, ProfitMarginRange};
 use contracts_common::{signing::MessageSignature, IdentityKey, Percent};
 use cosmwasm_schema::cw_serde;
@@ -47,7 +50,7 @@ use crate::{
         PendingIntervalEventResponse, PendingIntervalEventsResponse,
     },
     rewarding::{EstimatedCurrentEpochRewardResponse, PendingRewardResponse},
-    types::ContractState,
+    types::{ContractState, ContractStateParams},
 };
 #[cfg(feature = "schema")]
 use contracts_common::{signing::Nonce, ContractBuildInformation};
@@ -64,6 +67,14 @@ pub struct InstantiateMsg {
     pub epoch_duration: Duration,
     pub initial_rewarding_params: InitialRewardingParams,
 
+    pub current_nym_node_version: String,
+
+    #[serde(default)]
+    pub version_score_weights: OutdatedVersionWeights,
+
+    #[serde(default)]
+    pub version_score_params: VersionScoreFormulaParams,
+
     #[serde(default)]
     pub profit_margin: ProfitMarginRange,
 
@@ -126,7 +137,10 @@ pub enum ExecuteMsg {
         address: String,
     },
     UpdateContractStateParams {
-        updated_parameters: ContractStateParams,
+        update: ContractStateParamsUpdate,
+    },
+    UpdateCurrentNymNodeSemver {
+        current_version: String,
     },
     UpdateActiveSetDistribution {
         update: ActiveSetUpdate,
@@ -295,6 +309,9 @@ impl ExecuteMsg {
             ExecuteMsg::UpdateContractStateParams { .. } => {
                 "updating mixnet state parameters".into()
             }
+            ExecuteMsg::UpdateCurrentNymNodeSemver { current_version } => {
+                format!("updating current nym-node semver to {current_version}")
+            }
             ExecuteMsg::UpdateActiveSetDistribution {
                 force_immediately, ..
             } => format!("updating active set distribution. forced: {force_immediately}"),
@@ -829,6 +846,13 @@ pub enum QueryMsg {
 
 #[cw_serde]
 pub struct MigrateMsg {
-    pub vesting_contract_address: Option<String>,
     pub unsafe_skip_state_updates: Option<bool>,
+    pub vesting_contract_address: Option<String>,
+    pub current_nym_node_semver: String,
+
+    #[serde(default)]
+    pub version_score_weights: OutdatedVersionWeights,
+
+    #[serde(default)]
+    pub version_score_params: VersionScoreFormulaParams,
 }

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

@@ -4,8 +4,8 @@
 use crate::nym_node::Role;
 use contracts_common::Percent;
 use cosmwasm_schema::cw_serde;
-use cosmwasm_std::Coin;
 use cosmwasm_std::{Addr, Uint128};
+use cosmwasm_std::{Coin, Decimal};
 use std::fmt::{Display, Formatter};
 
 // type aliases for better reasoning about available data
@@ -161,19 +161,156 @@ pub struct ContractState {
 /// Contract parameters that could be adjusted in a transaction by the contract admin.
 #[cw_serde]
 pub struct ContractStateParams {
+    /// Parameters to do with delegations.
+    pub delegations_params: DelegationsParams,
+
+    /// Parameters to do with node operators.
+    pub operators_params: OperatorsParams,
+
+    /// Parameters to do with the config score
+    pub config_score_params: ConfigScoreParams,
+}
+
+#[cw_serde]
+pub struct ContractStateParamsUpdate {
+    pub delegations_params: Option<DelegationsParams>,
+    pub operators_params: Option<OperatorsParamsUpdate>,
+    pub config_score_params: Option<ConfigScoreParamsUpdate>,
+}
+
+impl ContractStateParamsUpdate {
+    pub fn contains_updates(&self) -> bool {
+        self.delegations_params.is_some()
+            || self.operators_params.is_some()
+            || self.config_score_params.is_some()
+    }
+}
+
+#[cw_serde]
+pub struct DelegationsParams {
     /// Minimum amount a delegator must stake in orders for his delegation to get accepted.
     pub minimum_delegation: Option<Coin>,
+}
 
+#[cw_serde]
+pub struct OperatorsParams {
     /// Minimum amount a node must pledge to get into the system.
     pub minimum_pledge: Coin,
 
     /// Defines the allowed profit margin range of operators.
     /// default: 0% - 100%
-    #[serde(default)]
     pub profit_margin: ProfitMarginRange,
 
     /// Defines the allowed interval operating cost range of operators.
     /// default: 0 - 1'000'000'000'000'000 (1 Billion native tokens - the total supply)
-    #[serde(default)]
     pub interval_operating_cost: OperatingCostRange,
 }
+
+#[cw_serde]
+pub struct OperatorsParamsUpdate {
+    pub minimum_pledge: Option<Coin>,
+    pub profit_margin: Option<ProfitMarginRange>,
+    pub interval_operating_cost: Option<OperatingCostRange>,
+}
+
+impl OperatorsParamsUpdate {
+    pub fn contains_updates(&self) -> bool {
+        self.minimum_pledge.is_some()
+            || self.profit_margin.is_some()
+            || self.interval_operating_cost.is_some()
+    }
+}
+
+#[cw_serde]
+pub struct ConfigScoreParams {
+    /// Current version of the nym node that is going to be used for determining the version score of a node.
+    /// note: value stored here is pre-validated `semver::Version`
+    pub current_nym_node_semver: String,
+
+    /// Defines weights for calculating numbers of versions behind the current release.
+    pub version_weights: OutdatedVersionWeights,
+
+    /// Defines the parameters of the formula for calculating the version score
+    pub version_score_formula_params: VersionScoreFormulaParams,
+}
+
+impl ConfigScoreParams {
+    // SAFETY: the value stored in the contract is always valid
+    #[allow(clippy::unwrap_used)]
+    pub fn unchecked_nym_node_version(&self) -> semver::Version {
+        self.current_nym_node_semver.parse().unwrap()
+    }
+
+    pub fn versions_behind(&self, node_semver: &semver::Version) -> u32 {
+        let expected = self.unchecked_nym_node_version();
+
+        let major_diff = (node_semver.major as i64 - expected.major as i64).unsigned_abs() as u32;
+        let minor_diff = (node_semver.minor as i64 - expected.minor as i64).unsigned_abs() as u32;
+        let patch_diff = (node_semver.patch as i64 - expected.patch as i64).unsigned_abs() as u32;
+        let prerelease_diff = if node_semver.pre == expected.pre {
+            0
+        } else {
+            1
+        };
+
+        major_diff * self.version_weights.major
+            + minor_diff * self.version_weights.minor
+            + patch_diff * self.version_weights.patch
+            + prerelease_diff * self.version_weights.prerelease
+    }
+}
+
+/// Defines weights for calculating numbers of versions behind the current release.
+#[cw_serde]
+#[derive(Copy)]
+pub struct OutdatedVersionWeights {
+    pub major: u32,
+    pub minor: u32,
+    pub patch: u32,
+    pub prerelease: u32,
+}
+
+impl Default for OutdatedVersionWeights {
+    fn default() -> Self {
+        OutdatedVersionWeights {
+            major: 100,
+            minor: 10,
+            patch: 1,
+            prerelease: 1,
+        }
+    }
+}
+
+/// Given the formula of version_score = penalty ^ (num_versions_behind ^ penalty_scaling)
+/// define the relevant parameters
+#[cw_serde]
+#[derive(Copy)]
+pub struct VersionScoreFormulaParams {
+    pub penalty: Decimal,
+    pub penalty_scaling: Decimal,
+}
+
+impl Default for VersionScoreFormulaParams {
+    fn default() -> Self {
+        #[allow(clippy::unwrap_used)]
+        VersionScoreFormulaParams {
+            penalty: "0.8".parse().unwrap(),
+            penalty_scaling: "2.0".parse().unwrap(),
+        }
+    }
+}
+
+#[cw_serde]
+pub struct ConfigScoreParamsUpdate {
+    pub current_nym_node_semver: Option<String>,
+    pub version_weights: Option<OutdatedVersionWeights>,
+    pub version_score_formula_params: Option<VersionScoreFormulaParams>,
+}
+
+impl ConfigScoreParamsUpdate {
+    pub fn contains_updates(&self) -> bool {
+        self.current_nym_node_semver.is_some()
+            || self.version_weights.is_some()
+            || self.version_score_formula_params.is_some()
+    }
+}

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

@@ -15,7 +15,9 @@ 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 }
-ts-rs = { workspace = true, optional = 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"] }
 
 [features]
 schema = ["cw2"]

common/credential-verification/src/bandwidth_storage_manager.rs

@@ -111,7 +111,7 @@ impl<S: Storage + Clone + 'static> BandwidthStorageManager<S> {
     }
 
     #[instrument(level = "trace", skip_all)]
-    async fn sync_storage_bandwidth(&mut self) -> Result<()> {
+    pub 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_millis(5);
-const DEFAULT_CLIENT_BANDWIDTH_MAX_DELTA_FLUSHING_AMOUNT: i64 = 512 * 1024; // 512kB
+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
 
 #[derive(Debug, Clone, Copy)]
 pub struct BandwidthFlushingBehaviourConfig {

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

@@ -18,7 +18,7 @@ use nym_validator_client::nym_api::EpochId;
 use nym_validator_client::nyxd::contract_traits::{
     EcashSigningClient, MultisigQueryClient, MultisigSigningClient, PagedMultisigQueryClient,
 };
-use nym_validator_client::nyxd::cosmwasm_client::ToSingletonContractData;
+use nym_validator_client::nyxd::cosmwasm_client::ContractResponseData;
 use nym_validator_client::nyxd::cw3::Status;
 use nym_validator_client::nyxd::AccountId;
 use nym_validator_client::EcashApiClient;

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

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

common/credentials-interface/src/lib.rs

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

common/dkg/src/bte/proof_chunking.rs

@@ -26,9 +26,8 @@ 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 + PARALLEL_RUNS - 1) / PARALLEL_RUNS;
+const NUM_CHALLENGE_BITS: usize = SECURITY_PARAMETER.div_ceil(PARALLEL_RUNS);
 
 // type alias for ease of use
 type FirstChallenge = Vec<Vec<Vec<u64>>>;