sandbox nyx rest api

.github/dependabot.yml

@@ -31,5 +31,3 @@ updates:
         update-types:
           - "patch"
     open-pull-requests-limit: 10
-    assignees:
-      - "octol"

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

@@ -26,7 +26,6 @@ jobs:
     runs-on: ${{ matrix.platform }}
     env:
       CARGO_TERM_COLOR: always
-      RUSTUP_PERMIT_COPY_RENAME: 1
     steps:
       - uses: actions/checkout@v4
 
@@ -80,6 +79,7 @@ jobs:
             target/release/nym-socks5-client
             target/release/nym-api
             target/release/nym-network-requester
+            target/release/nym-data-observatory
             target/release/nym-cli
             target/release/nymvisor
             target/release/nym-node
@@ -97,6 +97,7 @@ jobs:
           cp target/release/nym-socks5-client $OUTPUT_DIR
           cp target/release/nym-api $OUTPUT_DIR
           cp target/release/nym-network-requester $OUTPUT_DIR
+          cp target/release/nym-data-observatory $OUTPUT_DIR
           cp target/release/nymvisor $OUTPUT_DIR
           cp target/release/nym-node $OUTPUT_DIR
           cp target/release/nym-cli $OUTPUT_DIR

.github/workflows/ci-build-vpn-api-wasm.yml

@@ -12,7 +12,6 @@ jobs:
     runs-on: arc-ubuntu-22.04
     env:
       CARGO_TERM_COLOR: always
-      RUSTUP_PERMIT_COPY_RENAME: 1
     steps:
       - name: Check out repository code
         uses: actions/checkout@v4

.github/workflows/ci-build.yml

@@ -8,18 +8,16 @@ on:
       - 'explorer-api/**'
       - 'gateway/**'
       - 'integrations/**'
-      - 'nym-api/**'
-      - 'nym-credential-proxy/**'
-      - 'nym-network-monitor/**'
-      - 'nym-node/**'
-      - 'nym-node-status-api/**'
-      - 'nym-outfox/**'
-      - 'nym-validator-rewarder/**'
-      - 'nyx-chain-watcher/**'
-      - 'sdk/ffi/**'
+      - 'mixnode/**'
       - 'sdk/rust/**'
+      - 'sdk/lib/**'
       - 'service-providers/**'
-      - 'nym-browser-extension/storage/**'
+      - 'nym-network-monitor/**'
+      - 'nym-api/**'
+      - 'nym-node/**'
+      - 'nym-outfox/**'
+      - 'nym-data-observatory/**'
+      - 'nym-validator-rewarder/**'
       - 'tools/**'
       - 'wasm/**'
       - 'Cargo.toml'
@@ -32,12 +30,11 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ arc-ubuntu-20.04, custom-windows-11, custom-runner-mac-m1 ]
+        os: [ arc-ubuntu-20.04, custom-runner-mac-m1 ]
     runs-on: ${{ matrix.os }}
     env:
       CARGO_TERM_COLOR: always
       IPINFO_API_TOKEN: ${{ secrets.IPINFO_API_TOKEN }}
-      RUSTUP_PERMIT_COPY_RENAME: 1
     steps:
       - name: Install Dependencies (Linux)
         run: sudo apt-get update && sudo apt-get -y install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libudev-dev squashfs-tools protobuf-compiler
@@ -55,20 +52,6 @@ jobs:
           override: true
           components: rustfmt, clippy
 
-      # To avoid running out of disk space, skip generating debug symbols
-      - name: Set debug to false (unix)
-        if: contains(matrix.os, 'ubuntu') || contains(matrix.os, 'mac')
-        run: |
-          sed -i.bak 's/\[profile.dev\]/\[profile.dev\]\ndebug = false/' Cargo.toml
-          git diff
-
-      - name: Set debug to false (win)
-        if: contains(matrix.os, 'windows')
-        shell: pwsh
-        run: |
-          (Get-Content Cargo.toml) -replace '\[profile.dev\]', "`$&`ndebug = false" | Set-Content Cargo.toml
-          git diff
-
       - name: Check formatting
         uses: actions-rs/cargo@v1
         with:

.github/workflows/ci-contracts.yml

@@ -9,8 +9,6 @@ on:
     paths:
       - 'contracts/**'
       - 'common/**'
-      - 'Cargo.lock'
-      - 'Cargo.toml'
       - '.github/workflows/ci-contracts.yml'
 
 jobs:

.github/workflows/ci-nym-wallet-rust.yml

@@ -30,12 +30,6 @@ jobs:
           override: true
           components: rustfmt, clippy
 
-      - name: Set debug to false
-        working-directory: nym-wallet
-        run: |
-          sed -i.bak '1s/^/\[profile.dev\]\ndebug = false\n\n/' Cargo.toml
-          git diff
-
       - name: Build all binaries
         uses: actions-rs/cargo@v1
         with:

.github/workflows/ci-sdk-wasm.yml

@@ -1,7 +1,6 @@
 name: ci-sdk-wasm
 
 on:
-  workflow_dispatch:
   pull_request:
     paths:
       - 'wasm/**'
@@ -45,11 +44,6 @@ jobs:
       - name: Install wasm-bindgen-cli
         run: cargo install wasm-bindgen-cli
 
-      - name: Set debug to false
-        run: |
-          sed -i.bak 's/\[profile.dev\]/\[profile.dev\]\ndebug = false/' Cargo.toml
-          git diff
-
       - name: "Build"
         run: make sdk-wasm-build
 

.github/workflows/nightly-build.yml

@@ -15,7 +15,6 @@ jobs:
     runs-on: ${{ matrix.os }}
     env:
       CARGO_TERM_COLOR: always
-      IPINFO_API_TOKEN: ${{ secrets.IPINFO_API_TOKEN }}
     continue-on-error: true
     steps:
       - name: Check out repository code

.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.45.1
+        uses: mikefarah/yq@v4.44.6
         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.45.1
+        uses: mikefarah/yq@v4.44.6
         id: get_version
         with:
           cmd: yq -oy '.package.version' ${{ env.WORKING_DIRECTORY }}/Cargo.toml

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

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

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

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

.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.45.1
+        uses: mikefarah/yq@v4.44.6
         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.45.1
+        uses: mikefarah/yq@v4.44.6
         id: get_version
         with:
           cmd: yq -oy '.package.version' ${{ env.WORKING_DIRECTORY }}/Cargo.toml

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

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

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

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

.gitignore

@@ -51,11 +51,4 @@ ppa-private-key.b64
 ppa-private-key.asc
 nym-network-monitor/topology.json
 nym-network-monitor/__pycache__
-nym-network-monitor/*.key
-nym-network-monitor/.envrc
-nym-network-monitor/.envrc
-nym-api/redocly/formatted-openapi.json
-
-
-*.sqlite
-.build
+nym-network-monitor/*.key

.redocly.lint-ignore.yaml

@@ -2,18 +2,22 @@
 # See https://redocly.com/docs/cli/ for more information.
 formatted-openapi.json:
   path-parameters-defined:
-    - >-
-      #/paths/~1v1~1status~1mixnode~1{mix_id}~1compute-reward-estimation/post/parameters/0/name
-    - >-
-      #/paths/~1v1~1status~1mixnode~1{mix_id}~1compute-reward-estimation/post/parameters/1/name
-    - >-
-      #/paths/~1v1~1status~1mixnode~1{mix_id}~1compute-reward-estimation/post/parameters/2/name
-    - >-
-      #/paths/~1v1~1status~1mixnode~1{mix_id}~1compute-reward-estimation/post/parameters/3/name
-    - >-
-      #/paths/~1v1~1status~1mixnode~1{mix_id}~1compute-reward-estimation/post/parameters/4/name
-    - >-
-      #/paths/~1v1~1status~1mixnode~1{mix_id}~1compute-reward-estimation/post/parameters/5/name
+    # - >-
+    #   #/paths/~1v1~1status~1mixnode~1{mix_id}~1compute-reward-estimation/post/parameters/0/name
+    # - >-
+    #   #/paths/~1v1~1status~1mixnode~1{mix_id}~1compute-reward-estimation/post/parameters/1/name
+    # - >-
+    #   #/paths/~1v1~1status~1mixnode~1{mix_id}~1compute-reward-estimation/post/parameters/2/name
+    # - >-
+    #   #/paths/~1v1~1status~1mixnode~1{mix_id}~1compute-reward-estimation/post/parameters/3/name
+    # - >-
+    #   #/paths/~1v1~1status~1mixnode~1{mix_id}~1compute-reward-estimation/post/parameters/4/name
+    # - >-
+    #   #/paths/~1v1~1status~1mixnode~1{mix_id}~1compute-reward-estimation/post/parameters/5/name
+    # - '#/paths/~1v1~1unstable~1nym-nodes~1skimmed~1active/get/parameters/0/name'
+    # - '#/paths/~1v1~1unstable~1nym-nodes~1skimmed~1active/get/parameters/1/name'
+    # - '#/paths/~1v1~1unstable~1nym-nodes~1skimmed~1active/get/parameters/2/name'
+    # - '#/paths/~1v1~1unstable~1nym-nodes~1skimmed~1active/get/parameters/3/name'
   operation-operationId-unique:
     - >-
       #/paths/~1v1~1status~1mixnodes~1active~1detailed/get/get_active_set_detailed
@@ -26,7 +30,6 @@ formatted-openapi.json:
     - '#/components/schemas/EcashTicketVerificationRejection'
     - '#/components/schemas/ExpirationDatePathParam'
     - '#/components/schemas/FullFatNode'
-    - '#/components/schemas/G2ProjectiveSchema'
     - '#/components/schemas/HistoricalPerformanceResponse'
     - '#/components/schemas/HistoricalUptimeResponse'
     - '#/components/schemas/MasterVerificationKeyResponse'
@@ -38,7 +41,6 @@ formatted-openapi.json:
     - '#/components/schemas/NymNodeDetails'
     - '#/components/schemas/PaginationRequest'
     - '#/components/schemas/PartialCoinIndicesSignatureResponse'
-    - '#/components/schemas/PayInfo'
     - '#/components/schemas/SpentCredentialsResponse'
     - '#/components/schemas/UptimeHistoryResponse'
     - '#/components/schemas/VerifyEcashCredentialBody'

.redocly.yaml

@@ -0,0 +1,83 @@
+extends:
+  - minimal
+apis:
+  nym-api:
+    root: ./formatted-openapi.json
+rules:
+  # https://redocly.com/docs/cli/rules/oas/operation-summary
+  operation-summary: off
+  # https://redocly.com/docs/cli/rules/oas/security-defined
+  security-defined: off
+  struct: off
+  # https://redocly.com/docs/cli/rules/oas/operation-2xx-response
+  operation-2xx-response: off
+# rules:
+#   skip-warnings: true
+  # ignore:
+  # - path: /v1/gateways
+  #   method: get
+  # - path: /v1/gateways/blacklisted
+  #   method: get
+  # - path: /v1/mixnodes
+  #   method: get
+  # - path: /v1/mixnodes/active
+  #   method: get
+  # - path: /v1/mixnodes/active/detailed
+  #   method: get
+  # - path: /v1/mixnodes/blacklisted
+  #   method: get
+  # - path: /v1/mixnodes/detailed
+  #   method: get
+  # - path: /v1/mixnodes/rewarded
+  #   method: get
+  # - path: /v1/mixnodes/rewarded/detailed
+  #   method: get
+  # - path: /v1/gateways/described
+  #   method: get
+  # # network-monitor-status (deprecated)
+  # - path: /v1/status/gateway/{identity}/avg_uptime
+  #   method: GET
+  # - path: /v1/status/gateway/{identity}/core-status-count
+  #   method: GET
+  # - path: /v1/status/gateway/{identity}/history
+  #   method: GET
+  # - path: /v1/status/gateway/{identity}/report
+  #   method: GET
+  # - path: /v1/status/gateways/detailed
+  #   method: GET
+  # - path: /v1/status/gateways/detailed-unfiltered
+  #   method: GET
+  # - path: /v1/status/mixnode/{mix_id}/avg_uptime
+  #   method: GET
+  # - path: /v1/status/mixnode/{mix_id}/compute-reward-estimation
+  #   method: POST
+  # - path: /v1/status/mixnode/{mix_id}/core-status-count
+  #   method: GET
+  # - path: /v1/status/mixnode/{mix_id}/history
+  #   method: GET
+  # - path: /v1/status/mixnode/{mix_id}/report
+  #   method: GET
+  # - path: /v1/status/mixnode/{mix_id}/reward-estimation
+  #   method: GET
+  # - path: /v1/status/mixnodes/detailed-unfiltered
+  #   method: GET
+  # # status
+  # - path: /v1/status/mixnode/{mix_id}/inclusion-probability
+  #   method: GET
+  # - path: /v1/status/mixnode/{mix_id}/stake-saturation
+  #   method: GET
+  # - path: /v1/status/mixnode/{mix_id}/status
+  #   method: GET
+  # - path: /v1/status/mixnodes/active/detailed
+  #   method: GET
+  # - path: /v1/status/mixnodes/detailed
+  #   method: GET
+  # - path: /v1/status/mixnodes/inclusion-probability
+  #   method: GET
+  # - path: /v1/status/mixnodes/rewarded/detailed
+  #   method: GET
+  # # unstable nym nodes
+  # - path: /v1/unstable/nym-nodes/gateways/skimmed
+  #   method: get
+  # - path: /v1/unstable/nym-nodes/mixnodes/skimmed
+  #   method: get

CHANGELOG.md

@@ -4,297 +4,6 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://
 
 ## [Unreleased]
 
-## [2025.4-dorina] (2025-03-04)
-
-- fixed sphinx version metrics registration ([#5546])
-- Feature/chain status api ([#5539])
-- Add SURBs soft threshold ([#5535])
-- Simplify IPR v8 ([#5532])
-- Shared instance for DNS AsyncResolver ([#5523])
-- merge #5512 again after reverting due to incorrect rebase ([#5520])
-- cherry-pick 17d3ff2d775f61aee381d90a304ed416c08f33fc onto dorina ([#5519])
-- cherry-pick 6e5d0dac1b75413c5f09122b0d953f8ec6ef48df onto dorina ([#5518])
-- chore: workspace global panic preventing lints ([#5512])
-- bugfix: dont query for ecash apis unless necessary when spending ticketbooks ([#5508])
-- bugfix: bound check when recovering a reply SURB ([#5502])
-- chore: removed all old coconut code ([#5500])
-- IPR request types v8 ([#5498])
-- Support static routes for HTTP requests ([#5487])
-- build(deps): bump the patch-updates group across 1 directory with 3 updates ([#5482])
-- added missing import to doctest ([#5480])
-- adjusted TestSetup::new_complex to ensure bonded node's existence ([#5478])
-- Trigger contracts CI on main workspace Cargo changes ([#5477])
-- build(deps): bump http from 1.1.0 to 1.2.0 ([#5472])
-- build(deps): bump utoipa-swagger-ui from 8.0.3 to 8.1.0 ([#5471])
-- build(deps): bump colored from 2.1.0 to 2.2.0 ([#5470])
-- build(deps): bump celes from 2.4.0 to 2.5.0 ([#5469])
-- build(deps): bump the patch-updates group with 2 updates ([#5467])
-- build(deps): bump elliptic from 6.5.4 to 6.6.1 in /docker/typescript_client/upload_contract ([#5463])
-- Run cargo autoinherit ([#5460])
-- Fix clippy::precedence ([#5457])
-- Provide Interval context with node descriptor endpoints ([#5456])
-- fix: update fx average rate calcs to ignore 0 values ([#5454])
-- Feature/add gbp currency ([#5453])
-- Add helper to extract a list of sqlite files with journal files wal/shm ([#5452])
-- Add a middleware layer to the nym api allowing for data compression ([#5451])
-- Condense core API functionalities and enable gzip decompression for reqwest payloads ([#5450])
-- build(deps): bump uniffi_build from 0.25.3 to 0.29.0 ([#5448])
-- Upgrade tower to 0.5.2 ([#5446])
-- build(deps): bump hickory-proto from 0.24.2 to 0.24.3 ([#5444])
-- Seedable clients ([#5440])
-- build(deps): bump the patch-updates group across 1 directory with 10 updates ([#5439])
-- Remove all recv_with_delay and add shutdown condition to loops in client-core ([#5435])
-- Disable the test for checking the remaining bandwidth in nym-node-status-api ([#5425])
-- Dz nym node stats ([#5418])
-- build(deps): bump hyper from 1.4.1 to 1.6.0 ([#5416])
-- build(deps): bump publicsuffix from 2.2.3 to 2.3.0 ([#5367])
-- Nymnode entrypoint docker ([#5300])
-
-[#5546]: https://github.com/nymtech/nym/pull/5546
-[#5539]: https://github.com/nymtech/nym/pull/5539
-[#5535]: https://github.com/nymtech/nym/pull/5535
-[#5532]: https://github.com/nymtech/nym/pull/5532
-[#5523]: https://github.com/nymtech/nym/pull/5523
-[#5520]: https://github.com/nymtech/nym/pull/5520
-[#5519]: https://github.com/nymtech/nym/pull/5519
-[#5518]: https://github.com/nymtech/nym/pull/5518
-[#5512]: https://github.com/nymtech/nym/pull/5512
-[#5508]: https://github.com/nymtech/nym/pull/5508
-[#5502]: https://github.com/nymtech/nym/pull/5502
-[#5500]: https://github.com/nymtech/nym/pull/5500
-[#5498]: https://github.com/nymtech/nym/pull/5498
-[#5487]: https://github.com/nymtech/nym/pull/5487
-[#5482]: https://github.com/nymtech/nym/pull/5482
-[#5480]: https://github.com/nymtech/nym/pull/5480
-[#5478]: https://github.com/nymtech/nym/pull/5478
-[#5477]: https://github.com/nymtech/nym/pull/5477
-[#5472]: https://github.com/nymtech/nym/pull/5472
-[#5471]: https://github.com/nymtech/nym/pull/5471
-[#5470]: https://github.com/nymtech/nym/pull/5470
-[#5469]: https://github.com/nymtech/nym/pull/5469
-[#5467]: https://github.com/nymtech/nym/pull/5467
-[#5463]: https://github.com/nymtech/nym/pull/5463
-[#5460]: https://github.com/nymtech/nym/pull/5460
-[#5457]: https://github.com/nymtech/nym/pull/5457
-[#5456]: https://github.com/nymtech/nym/pull/5456
-[#5454]: https://github.com/nymtech/nym/pull/5454
-[#5453]: https://github.com/nymtech/nym/pull/5453
-[#5452]: https://github.com/nymtech/nym/pull/5452
-[#5451]: https://github.com/nymtech/nym/pull/5451
-[#5450]: https://github.com/nymtech/nym/pull/5450
-[#5448]: https://github.com/nymtech/nym/pull/5448
-[#5446]: https://github.com/nymtech/nym/pull/5446
-[#5444]: https://github.com/nymtech/nym/pull/5444
-[#5440]: https://github.com/nymtech/nym/pull/5440
-[#5439]: https://github.com/nymtech/nym/pull/5439
-[#5435]: https://github.com/nymtech/nym/pull/5435
-[#5425]: https://github.com/nymtech/nym/pull/5425
-[#5418]: https://github.com/nymtech/nym/pull/5418
-[#5416]: https://github.com/nymtech/nym/pull/5416
-[#5367]: https://github.com/nymtech/nym/pull/5367
-[#5300]: https://github.com/nymtech/nym/pull/5300
-
-## [2025.3-ruta] (2025-02-10)
-
-- Push down forget me to client configs ([#5431])
-- Fix statistics shutdown ([#5426])
-- Make wait_for_graceful_shutdown to be pub ([#5424])
-- Upgrade to thiserror 2.0 ([#5414])
-- build(deps): bump the patch-updates group across 1 directory with 9 updates ([#5406])
-- Relocate a validator api function ([#5401])
-- Send shutdown instead of panic when reaching max fail ([#5398])
-- Change Explorer URL to new smooshed nodes ([#5396])
-- reduce log severity for checking topology validity ([#5395])
-- MixnetClient can send ClientRequests ([#5381])
-- Fix missing path triggers for CI ([#5380])
-- Uncouple storage reference for bandwidth client ([#5372])
-- build(deps): bump tokio from 1.40.0 to 1.43.0 ([#5370])
-- DNS resolver configuration for internal HTTP client lookups ([#5355])
-- Update README.md ([#5328])
-- Update README.md ([#5327])
-
-[#5431]: https://github.com/nymtech/nym/pull/5431
-[#5426]: https://github.com/nymtech/nym/pull/5426
-[#5424]: https://github.com/nymtech/nym/pull/5424
-[#5414]: https://github.com/nymtech/nym/pull/5414
-[#5406]: https://github.com/nymtech/nym/pull/5406
-[#5401]: https://github.com/nymtech/nym/pull/5401
-[#5398]: https://github.com/nymtech/nym/pull/5398
-[#5396]: https://github.com/nymtech/nym/pull/5396
-[#5395]: https://github.com/nymtech/nym/pull/5395
-[#5381]: https://github.com/nymtech/nym/pull/5381
-[#5380]: https://github.com/nymtech/nym/pull/5380
-[#5372]: https://github.com/nymtech/nym/pull/5372
-[#5370]: https://github.com/nymtech/nym/pull/5370
-[#5355]: https://github.com/nymtech/nym/pull/5355
-[#5328]: https://github.com/nymtech/nym/pull/5328
-[#5327]: https://github.com/nymtech/nym/pull/5327
-
-## [2025.2-hu] (2025-02-04)
-
-- Feature/remove double spending bloomfilter ([#5417])
-- HU - Downgrade harmless log message from info to debug ([#5405])
-- lower default ticket verification quorum to 0.7 ([#5404])
-- Downgrade harmless log message from info to debug ([#5403])
-- Redirect from mixnode page to nodes page ([#5397])
-- chore :update version of chain watcher and validator rewarder ([#5394])
-- bugfix: correctly handle ingore epoch roles flag ([#5390])
-- bugfix: terminate mixnet socket listener on shutdown ([#5389])
-- feat: make client ignore dual mode nodes by default ([#5388])
-- Handle ecash network errors differently ([#5378])
-- Remove empty ephemeral keys ([#5376])
-- fixed sql migration for adding default message timestamp ([#5374])
-- Bind to [::] on nym-node for both IP versions ([#5361])
-- exposed NymApiClient method for obtaining node performance history ([#5360])
-- Client gateway selection ([#5358])
-- chore: refresh wasm sdk ([#5353])
-- chore: update indexed_db_futures ([#5347])
-- build(deps): bump mikefarah/yq from 4.44.6 to 4.45.1 ([#5342])
-- updated cosmrs and tendermint-rpc to their most recent versions ([#5339])
-- build(deps): bump ts-rs from 10.0.0 to 10.1.0 ([#5338])
-- build(deps): bump tempfile from 3.14.0 to 3.15.0 ([#5337])
-- build(deps): bump the patch-updates group with 8 updates ([#5336])
-- feature: introduce /load endpoint for self-reported quantised NymNode load ([#5326])
-- feature: `CancellationToken`-based shutdowns ([#5325])
-- Use expect in geodata test to give error message on failure ([#5314])
-- feature: periodically remove stale gateway messages ([#5312])
-- build(deps): bump the patch-updates group across 1 directory with 35 updates ([#5310])
-- Add dependabot assignes for the root cargo ecosystem ([#5297])
-- Move tun constants to network defaults ([#5286])
-- Include IPINFO_API_TOKEN in nightly CI ([#5285])
-- Nyx Chain Watcher ([#5274])
-- bugfix: remove unnecessary arguments for nym-api swagger endpoints ([#5272])
-- feature: nym topology revamp ([#5271])
-- Add windows to CI builds ([#5269])
-- http-api-client: deduplicate code ([#5267])
-- build(deps): bump http from 1.1.0 to 1.2.0 ([#5228])
-- NS API: add mixnet scraper ([#5200])
-- build(deps): bump criterion from 0.4.0 to 0.5.1 ([#4911])
-
-[#5417]: https://github.com/nymtech/nym/pull/5417
-[#5405]: https://github.com/nymtech/nym/pull/5405
-[#5404]: https://github.com/nymtech/nym/pull/5404
-[#5403]: https://github.com/nymtech/nym/pull/5403
-[#5397]: https://github.com/nymtech/nym/pull/5397
-[#5394]: https://github.com/nymtech/nym/pull/5394
-[#5390]: https://github.com/nymtech/nym/pull/5390
-[#5389]: https://github.com/nymtech/nym/pull/5389
-[#5388]: https://github.com/nymtech/nym/pull/5388
-[#5378]: https://github.com/nymtech/nym/pull/5378
-[#5376]: https://github.com/nymtech/nym/pull/5376
-[#5374]: https://github.com/nymtech/nym/pull/5374
-[#5361]: https://github.com/nymtech/nym/pull/5361
-[#5360]: https://github.com/nymtech/nym/pull/5360
-[#5358]: https://github.com/nymtech/nym/pull/5358
-[#5353]: https://github.com/nymtech/nym/pull/5353
-[#5347]: https://github.com/nymtech/nym/pull/5347
-[#5342]: https://github.com/nymtech/nym/pull/5342
-[#5339]: https://github.com/nymtech/nym/pull/5339
-[#5338]: https://github.com/nymtech/nym/pull/5338
-[#5337]: https://github.com/nymtech/nym/pull/5337
-[#5336]: https://github.com/nymtech/nym/pull/5336
-[#5326]: https://github.com/nymtech/nym/pull/5326
-[#5325]: https://github.com/nymtech/nym/pull/5325
-[#5314]: https://github.com/nymtech/nym/pull/5314
-[#5312]: https://github.com/nymtech/nym/pull/5312
-[#5310]: https://github.com/nymtech/nym/pull/5310
-[#5297]: https://github.com/nymtech/nym/pull/5297
-[#5286]: https://github.com/nymtech/nym/pull/5286
-[#5285]: https://github.com/nymtech/nym/pull/5285
-[#5274]: https://github.com/nymtech/nym/pull/5274
-[#5272]: https://github.com/nymtech/nym/pull/5272
-[#5271]: https://github.com/nymtech/nym/pull/5271
-[#5269]: https://github.com/nymtech/nym/pull/5269
-[#5267]: https://github.com/nymtech/nym/pull/5267
-[#5228]: https://github.com/nymtech/nym/pull/5228
-[#5200]: https://github.com/nymtech/nym/pull/5200
-[#4911]: https://github.com/nymtech/nym/pull/4911
-
-## [2025.1-reeses] (2025-01-15)
-
-- Feture/legacy alert ([#5346])
-- chore: readjusted --mode behaviour to fix the regression ([#5331])
-- chore: apply 1.84 linter suggestions ([#5330])
-- bugfix: make sure refresh data key matches bond info ([#5329])
-- reduce log severity for number of packets being delayed ([#5321])
-- feat: warn users if node is run in exit mode only ([#5320])
-- Bugfix/contract version assignment ([#5318])
-- fixed client session histogram buckets ([#5316])
-- amend 250gb limit ([#5313])
-- feature: expand nym-node prometheus metrics ([#5298])
-- Cherry picked #5286 ([#5287])
-- Add close to credential storage ([#5283])
-- feature: wireguard metrics ([#5278])
-- Add PATCH support to nym-http-api-client ([#5260])
-- chore: removed legacy socks5 listener ([#5259])
-- bugfix: make sure to apply gateway score filtering when choosing initial node ([#5256])
-- Update TS bindings ([#5255])
-- Add conversion unit tests for auth msg ([#5251])
-- Add control messages to GatewayTransciver ([#5247])
-- Remove unneeded async function annotation ([#5246])
-- bugfix: make sure to update timestamp of last batch verification to prevent double redemption ([#5239])
-- Add FromStr impl for UserAgent ([#5236])
-- Extend swagger docs ([#5235])
-- TicketType derive Hash and Eq ([#5233])
-- Add fd callback to client core ([#5230])
-- Extend raw ws fd for gateway client ([#5218])
-- Shipping raw metrics to PG ([#5216])
-- Change sqlite journal mode to WAL ([#5213])
-- Derive serialize for UserAgent ([#5210])
-- Restore Location fields ([#5208])
-- better date serialization ([#5207])
-- Fix overflow ([#5204])
-- feature: hopefully final steps of the smoosh™️ ([#5201])
-- Fix overflow ([#5184])
-- NS API - Gateway stats scraping ([#5180])
-- introduced initial internal commands for nym-cli: ecash key and request generation ([#5174])
-- Move NS client to separate package under NS API ([#5171])
-- build(deps): bump micromatch from 4.0.4 to 4.0.8 in /testnet-faucet ([#4813])
-
-[#5346]: https://github.com/nymtech/nym/pull/5346
-[#5331]: https://github.com/nymtech/nym/pull/5331
-[#5330]: https://github.com/nymtech/nym/pull/5330
-[#5329]: https://github.com/nymtech/nym/pull/5329
-[#5321]: https://github.com/nymtech/nym/pull/5321
-[#5320]: https://github.com/nymtech/nym/pull/5320
-[#5318]: https://github.com/nymtech/nym/pull/5318
-[#5316]: https://github.com/nymtech/nym/pull/5316
-[#5313]: https://github.com/nymtech/nym/pull/5313
-[#5298]: https://github.com/nymtech/nym/pull/5298
-[#5287]: https://github.com/nymtech/nym/pull/5287
-[#5283]: https://github.com/nymtech/nym/pull/5283
-[#5278]: https://github.com/nymtech/nym/pull/5278
-[#5260]: https://github.com/nymtech/nym/pull/5260
-[#5259]: https://github.com/nymtech/nym/pull/5259
-[#5256]: https://github.com/nymtech/nym/pull/5256
-[#5255]: https://github.com/nymtech/nym/pull/5255
-[#5251]: https://github.com/nymtech/nym/pull/5251
-[#5247]: https://github.com/nymtech/nym/pull/5247
-[#5246]: https://github.com/nymtech/nym/pull/5246
-[#5239]: https://github.com/nymtech/nym/pull/5239
-[#5236]: https://github.com/nymtech/nym/pull/5236
-[#5235]: https://github.com/nymtech/nym/pull/5235
-[#5233]: https://github.com/nymtech/nym/pull/5233
-[#5230]: https://github.com/nymtech/nym/pull/5230
-[#5218]: https://github.com/nymtech/nym/pull/5218
-[#5216]: https://github.com/nymtech/nym/pull/5216
-[#5213]: https://github.com/nymtech/nym/pull/5213
-[#5210]: https://github.com/nymtech/nym/pull/5210
-[#5208]: https://github.com/nymtech/nym/pull/5208
-[#5207]: https://github.com/nymtech/nym/pull/5207
-[#5204]: https://github.com/nymtech/nym/pull/5204
-[#5201]: https://github.com/nymtech/nym/pull/5201
-[#5184]: https://github.com/nymtech/nym/pull/5184
-[#5180]: https://github.com/nymtech/nym/pull/5180
-[#5174]: https://github.com/nymtech/nym/pull/5174
-[#5171]: https://github.com/nymtech/nym/pull/5171
-[#4813]: https://github.com/nymtech/nym/pull/4813
-
-## [2024.14-crunch-patched] (2024-12-17)
-
-- Fixes an issue to allow previously registred clients to connect to latest nym-nodes
-- Fixes compatibility issues between nym-nodes and older clients
-
 ## [2024.14-crunch] (2024-12-11)
 
 - Merge/release/2024.14-crunch ([#5242])

Cargo.toml

@@ -48,12 +48,13 @@ members = [
     "common/credentials-interface",
     "common/crypto",
     "common/dkg",
+    "common/ecash-double-spending",
     "common/ecash-time",
     "common/execute",
     "common/exit-policy",
     "common/gateway-requests",
-    "common/gateway-stats-storage",
     "common/gateway-storage",
+    "common/gateway-stats-storage",
     "common/http-api-client",
     "common/http-api-common",
     "common/inclusion-probability",
@@ -66,6 +67,7 @@ members = [
     "common/nym-id",
     "common/nym-metrics",
     "common/nym_offline_compact_ecash",
+    "common/nymcoconut",
     "common/nymsphinx",
     "common/nymsphinx/acknowledgements",
     "common/nymsphinx/addressing",
@@ -91,7 +93,6 @@ members = [
     "common/topology",
     "common/tun",
     "common/types",
-    "common/verloc",
     "common/wasm/client-core",
     "common/wasm/storage",
     "common/wasm/utils",
@@ -103,22 +104,6 @@ members = [
     "explorer-api/explorer-client",
     "gateway",
     "integrations/bity",
-    "nym-api",
-    "nym-api/nym-api-requests",
-    "nym-browser-extension/storage",
-    "nym-credential-proxy/nym-credential-proxy",
-    "nym-credential-proxy/nym-credential-proxy-requests",
-    "nym-credential-proxy/vpn-api-lib-wasm",
-    "nym-network-monitor",
-    "nym-node",
-    "nym-node-status-api/nym-node-status-agent",
-    "nym-node-status-api/nym-node-status-api",
-    "nym-node-status-api/nym-node-status-client",
-    "nym-node/nym-node-metrics",
-    "nym-node/nym-node-requests",
-    "nym-outfox",
-    "nym-validator-rewarder",
-    "nyx-chain-watcher",
     "sdk/ffi/cpp",
     "sdk/ffi/go",
     "sdk/ffi/shared",
@@ -127,16 +112,26 @@ members = [
     "service-providers/common",
     "service-providers/ip-packet-router",
     "service-providers/network-requester",
+    "nym-api",
+    "nym-api/nym-api-requests",
+    "nym-browser-extension/storage",
+    "nym-credential-proxy/nym-credential-proxy",
+    "nym-credential-proxy/nym-credential-proxy-requests",
+    "nym-credential-proxy/vpn-api-lib-wasm",
+    "nym-data-observatory",
+    "nym-network-monitor",
+    "nym-node",
+    "nym-node/nym-node-requests",
+    "nym-node/nym-node-metrics",
+    "nym-node-status-api/nym-node-status-agent",
+    "nym-node-status-api/nym-node-status-api",
+    "nym-node-status-api/nym-node-status-client",
+    "nym-outfox",
+    "nym-validator-rewarder",
     "tools/echo-server",
-    "tools/echo-server",
-    "tools/internal/contract-state-importer/importer-cli",
-    "tools/internal/contract-state-importer/importer-contract",
-    "tools/internal/mixnet-connectivity-check",
-    # "tools/internal/sdk-version-bump",
     "tools/internal/ssl-inject",
+    # "tools/internal/sdk-version-bump",
     "tools/internal/testnet-manager",
-    "tools/internal/testnet-manager",
-    "tools/internal/testnet-manager/dkg-bypass-contract",
     "tools/internal/testnet-manager/dkg-bypass-contract",
     "tools/nym-cli",
     "tools/nym-id-cli",
@@ -148,6 +143,11 @@ members = [
     "wasm/mix-fetch",
     "wasm/node-tester",
     "wasm/zknym-lib",
+    "tools/echo-server",
+    "tools/internal/contract-state-importer/importer-cli",
+    "tools/internal/contract-state-importer/importer-contract",
+    "tools/internal/testnet-manager",
+    "tools/internal/testnet-manager/dkg-bypass-contract", "common/verloc", "tools/internal/mixnet-connectivity-check",
 ]
 
 default-members = [
@@ -156,11 +156,11 @@ default-members = [
     "explorer-api",
     "nym-api",
     "nym-credential-proxy/nym-credential-proxy",
+    "nym-data-observatory",
     "nym-node",
     "nym-node-status-api/nym-node-status-agent",
     "nym-node-status-api/nym-node-status-api",
     "nym-validator-rewarder",
-    "nyx-chain-watcher",
     "service-providers/authenticator",
     "service-providers/ip-packet-router",
     "service-providers/network-requester",
@@ -171,6 +171,7 @@ exclude = [
     "explorer",
     "contracts",
     "nym-wallet",
+    "nym-vpn/ui/src-tauri",
     "cpu-cycles",
 ]
 
@@ -186,49 +187,45 @@ readme = "README.md"
 
 [workspace.dependencies]
 addr = "0.15.6"
-aead = "0.5.2"
 aes = "0.8.1"
 aes-gcm = "0.10.1"
 aes-gcm-siv = "0.11.1"
-ammonia = "4"
-anyhow = "1.0.97"
-arc-swap = "1.7.1"
+aead = "0.5.2"
+anyhow = "1.0.90"
 argon2 = "0.5.0"
-async-trait = "0.1.87"
-axum = "0.7.5"
+async-trait = "0.1.83"
 axum-client-ip = "0.6.1"
+axum = "0.7.5"
 axum-extra = "0.9.4"
-axum-test = "16.2.0"
 base64 = "0.22.1"
-base85rs = "0.1.3"
 bincode = "1.3.3"
 bip39 = { version = "2.0.0", features = ["zeroize"] }
 bit-vec = "0.7.0"                                     # can we unify those?
 bitvec = "1.0.0"
-blake3 = "1.6.1"
+blake3 = "1.5.4"
 bloomfilter = "1.0.14"
 bs58 = "0.5.1"
 bytecodec = "0.4.15"
 bytes = "1.7.2"
 cargo_metadata = "0.18.1"
-celes = "2.5.0"
+celes = "2.4.0"
 cfg-if = "1.0.0"
 chacha20 = "0.9.0"
 chacha20poly1305 = "0.10.1"
-chrono = "0.4.40"
+chrono = "0.4.31"
 cipher = "0.4.3"
-clap = "4.5.31"
+clap = "4.5.20"
 clap_complete = "4.5"
 clap_complete_fig = "4.5"
-colored = "2.2"
-comfy-table = "7.1.4"
-console = "0.15.11"
+colored = "2.0"
+comfy-table = "7.1.1"
+console = "0.15.8"
 console-subscriber = "0.1.1"
 console_error_panic_hook = "0.1"
 const-str = "0.5.6"
-const_format = "0.2.34"
-criterion = "0.5"
-csv = "1.3.1"
+const_format = "0.2.33"
+criterion = "0.4"
+csv = "1.3.0"
 ctr = "0.9.1"
 cupid = "0.6.1"
 curve25519-dalek = "4.1"
@@ -241,59 +238,58 @@ doc-comment = "0.3"
 dotenvy = "0.15.6"
 ecdsa = "0.16"
 ed25519-dalek = "2.1"
-env_logger = "0.11.6"
-envy = "0.4"
 etherparse = "0.13.0"
+envy = "0.4"
 eyre = "0.6.9"
 fastrand = "2.1.1"
-flate2 = "1.1.0"
-futures = "0.3.31"
+flate2 = "1.0.34"
+futures = "0.3.28"
 futures-util = "0.3"
 generic-array = "0.14.7"
 getrandom = "0.2.10"
-getset = "0.1.5"
+getset = "0.1.3"
 handlebars = "3.5.5"
 headers = "0.4.0"
 hex = "0.4.3"
 hex-literal = "0.3.3"
-hickory-resolver = "0.24.4"
 hkdf = "0.12.3"
 hmac = "0.12.1"
 http = "1"
 http-body-util = "0.1"
 httpcodec = "0.2.3"
-human-repr = "1.1.0"
 humantime = "2.1.0"
 humantime-serde = "1.1.1"
-hyper = "1.6.0"
+human-repr = "1.1.0"
+hyper = "1.4.1"
 hyper-util = "0.1"
-indicatif = "0.17.11"
+indicatif = "0.17.8"
 inquire = "0.6.2"
 ip_network = "0.4.1"
 ipnetwork = "0.20"
 isocountry = "0.3.2"
-itertools = "0.14.0"
+itertools = "0.13.0"
 k256 = "0.13"
 lazy_static = "1.5.0"
 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"
 notify = "5.1.0"
 okapi = "0.7.0"
-once_cell = "1.20.3"
+once_cell = "1.20.2"
 opentelemetry = "0.19.0"
 opentelemetry-jaeger = "0.18.0"
 parking_lot = "0.12.3"
 pem = "0.8"
 petgraph = "0.6.5"
 pin-project = "1.1"
-pin-project-lite = "0.2.16"
+pin-project-lite = "0.2.14"
 pretty_env_logger = "0.4.0"
-publicsuffix = "2.3.0"
+publicsuffix = "2.2.3"
 quote = "1"
 rand = "0.8.5"
 rand_chacha = "0.3"
@@ -307,59 +303,55 @@ reqwest = { version = "0.12.4", default-features = false }
 rocket = "0.5.0"
 rocket_cors = "0.6.0"
 rocket_okapi = "0.8.0"
-rs_merkle = "1.4.2"
 safer-ffi = "0.1.13"
-schemars = "0.8.22"
-semver = "1.0.25"
-serde = "1.0.217"
-serde_bytes = "0.11.16"
+schemars = "0.8.21"
+semver = "1.0.23"
+serde = "1.0.211"
+serde_bytes = "0.11.15"
 serde_derive = "1.0"
-serde_json = "1.0.140"
-serde_json_path = "0.7.2"
+serde_json = "1.0.132"
+serde_json_path = "0.7.1"
 serde_repr = "0.1"
 serde_with = "3.9.0"
 serde_yaml = "0.9.25"
 sha2 = "0.10.8"
 si-scale = "0.2.3"
-sphinx-packet = "=0.4.0" # make sure to use version 0.4.0 (or higher) that has removed backwards compatibility
+sphinx-packet = "0.1.1"
 sqlx = "0.7.4"
 strum = "0.26"
 strum_macros = "0.26"
 subtle-encoding = "0.5"
 syn = "1"
-sysinfo = "0.33.0"
+sysinfo = "0.30.13"
 tap = "1.0.1"
-tar = "0.4.44"
-tempfile = "3.15"
-thiserror = "2.0"
-time = "0.3.37"
-tokio = "1.43"
-tokio-postgres = "0.7"
-tokio-stream = "0.1.17"
+tar = "0.4.42"
+tempfile = "3.14"
+thiserror = "1.0.64"
+time = "0.3.30"
+tokio = "1.39"
+tokio-stream = "0.1.16"
 tokio-test = "0.4.4"
 tokio-tun = "0.11.5"
 tokio-tungstenite = { version = "0.20.1" }
-tokio-util = "0.7.13"
-toml = "0.8.20"
-tower = "0.5.2"
+tokio-util = "0.7.12"
+toml = "0.8.14"
+tower = "0.4.13"
 tower-http = "0.5.2"
-tracing = "0.1.41"
-tracing-log = "0.2"
+tracing = "0.1.37"
 tracing-opentelemetry = "0.19.0"
-tracing-subscriber = "0.3.19"
+tracing-subscriber = "0.3.16"
 tracing-tree = "0.2.2"
-ts-rs = "10.1.0"
+tracing-log = "0.2"
+ts-rs = "10.0.0"
 tungstenite = { version = "0.20.1", default-features = false }
-uniffi = "0.29.0"
-uniffi_build = "0.29.0"
 url = "2.5"
 utoipa = "5.2"
-utoipa-swagger-ui = "8.1"
+utoipa-swagger-ui = "8.0"
 utoipauto = "0.2"
 uuid = "*"
 vergen = { version = "=8.3.1", default-features = false }
 walkdir = "2"
-wasm-bindgen-test = "0.3.49"
+wasm-bindgen-test = "0.3.43"
 x25519-dalek = "2.0.0"
 zeroize = "1.6.0"
 
@@ -390,26 +382,31 @@ cw4 = { version = "=1.1.2" }
 cw-controllers = { version = "=1.1.0" }
 
 # cosmrs-related
-bip32 = { version = "0.5.3", default-features = false }
+bip32 = { version = "0.5.2", default-features = false }
 
-
-cosmrs = { version = "0.21.1" }
-tendermint = "0.40.0"
-tendermint-rpc = "0.40.0"
-prost = { version = "0.13", default-features = false }
+# temporarily using a fork again (yay.) because we need staking and slashing support (which are already on main but not released)
+# plus response message parsing (which is, as of the time of writing this message, waiting to get merged)
+#cosmrs = { path = "../cosmos-rust-fork/cosmos-rust/cosmrs" }
+cosmrs = { git = "https://github.com/cosmos/cosmos-rust", rev = "4b1332e6d8258ac845cef71589c8d362a669675a" } # unfortuntely we need a fork by yours truly to get the staking support
+tendermint = "0.37.0"                                                                                        # same version as used by cosmrs
+tendermint-rpc = "0.37.0"                                                                                    # same version as used by cosmrs
+prost = { version = "0.12", default-features = false }
 
 # wasm-related dependencies
 gloo-utils = "0.2.0"
-gloo-net = "0.6.0"
+gloo-net = "0.5.0"
 
-indexed_db_futures = "0.6.0"
-js-sys = "0.3.76"
+# use a separate branch due to feature unification failures
+# this is blocked until the upstream removes outdates `wasm_bindgen` feature usage
+# indexed_db_futures = "0.4.1"
+indexed_db_futures = { git = "https://github.com/TiemenSch/rust-indexed-db", branch = "update-uuid" }
+js-sys = "0.3.70"
 serde-wasm-bindgen = "0.6.5"
 tsify = "0.4.5"
-wasm-bindgen = "0.2.99"
-wasm-bindgen-futures = "0.4.49"
-wasmtimer = "0.4.1"
-web-sys = "0.3.76"
+wasm-bindgen = "0.2.95"
+wasm-bindgen-futures = "0.4.45"
+wasmtimer = "0.2.0"
+web-sys = "0.3.72"
 
 # Profile settings for individual crates
 
@@ -437,13 +434,3 @@ opt-level = 'z'
 [profile.release.package.mix-fetch-wasm]
 # lto = true
 opt-level = 'z'
-
-[workspace.lints.clippy]
-unwrap_used = "deny"
-expect_used = "deny"
-todo = "deny"
-dbg_macro = "deny"
-exit = "deny"
-panic = "deny"
-unimplemented = "deny"
-unreachable = "deny"

LICENSES/BSL-1.0

@@ -1,23 +0,0 @@
-Boost Software License - Version 1.0 - August 17th, 2003
-
-Permission is hereby granted, free of charge, to any person or organization
-obtaining a copy of the software and accompanying documentation covered by
-this license (the "Software") to use, reproduce, display, distribute,
-execute, and transmit the Software, and to prepare derivative works of the
-Software, and to permit third-parties to whom the Software is furnished to
-do so, all subject to the following:
-
-The copyright notices in the Software and this entire statement, including
-the above license grant, this restriction and the following disclaimer,
-must be included in all copies of the Software, in whole or in part, and
-all derivative works of the Software, unless such copies or derivative
-works are solely in the form of machine-executable object code generated by
-a source language processor.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
-SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
-FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
-ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.

README.md

@@ -13,8 +13,8 @@ The platform is composed of multiple Rust crates. Top-level executable binary cr
 * `nym-client` - an executable which you can build into your own applications. Use it for interacting with Nym nodes.
 * `nym-socks5-client` - a Socks5 proxy you can run on your machine and use with existing applications.
 * `nym-explorer` - a (projected) block explorer and (existing) mixnet viewer.
-* `nym-wallet` - a desktop wallet implemented using the [Tauri](https://tauri.app)) framework.
-* `nym-cli` - a tool for interacting with the network from the CLI.
+* `nym-wallet` - a desktop wallet implemented using the [Tauri](https://tauri.studio/en/docs/about/intro) framework.
+* `nym-cli` - a tool for interacting with the network from the CLI. 
 <!-- coming soon
 * `nym-network-monitor` - sends packets through the full system to check that they are working as expected, and stores node uptime histories as the basis of a rewards system ("mixmining" or "proof-of-mixing").
 -->
@@ -42,10 +42,10 @@ client ───► Gateway ──┘  mix  │  mix  ┌─►mix ───►
 
 References for developers:
 
-* [Dev Docs](https://nym.com/docs/developers)
-* [SDKs](https://nym.com/docs/developers/rust)
-* [Network Docs](https://nym.com/docs/network)
-* [Release Cycle - git flow](https://nym.com/docs/operators/release-cycle)
+* [Dev Docs](https://nymtech.net/docs/developers)
+* [SDKs](https://nymtech.net/docs/developers/rust)
+* [Network Docs](https://nymtech.net/docs/network)
+* [Release Cycle - git flow](https://nymtech.net/docs/operators/release-cycle)
 
 ### Developer chat
 
@@ -66,4 +66,4 @@ As a general approach, licensing is as follows this pattern:
 - libraries and components are Apache 2.0 or MIT
 - documentation is Apache 2.0 or CC0-1.0
 
-Nym Node Operators and Validators Terms and Conditions can be found [here](https://nym.com/operators-validators-terms).
+Nym Node Operators and Validators Temrs and Conditions can be found [here](https://nymtech.net/terms-and-conditions/operators/v1.0.0).

clients/native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nym-client"
-version = "1.1.49"
+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/mod.rs

@@ -56,7 +56,7 @@ pub fn default_data_directory<P: AsRef<Path>>(id: P) -> PathBuf {
         .join(DEFAULT_DATA_DIR)
 }
 
-#[derive(Debug, Deserialize, PartialEq, Serialize, Clone)]
+#[derive(Debug, Deserialize, PartialEq, Serialize)]
 pub struct Config {
     #[serde(flatten)]
     pub base: BaseClientConfig,
@@ -94,10 +94,6 @@ impl CliClientConfig for Config {
 }
 
 impl Config {
-    pub fn base(&self) -> BaseClientConfig {
-        self.base.clone()
-    }
-
     pub fn new<S: AsRef<str>>(id: S) -> Self {
         Config {
             base: BaseClientConfig::new(id.as_ref(), env!("CARGO_PKG_VERSION")),
@@ -213,7 +209,7 @@ impl SocketType {
     }
 }
 
-#[derive(Debug, Deserialize, PartialEq, Eq, Serialize, Clone)]
+#[derive(Debug, Deserialize, PartialEq, Eq, Serialize)]
 #[serde(default, deny_unknown_fields)]
 pub struct Socket {
     pub socket_type: SocketType,

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

@@ -107,8 +107,5 @@ enabled = {{ debug.stats_reporting.enabled }}
 provider_address = '{{ debug.stats_reporting.provider_address }}'
 reporting_interval = '{{ debug.stats_reporting.reporting_interval }}'
 
-[debug.forget_me]
-client = {{ debug.forget_me.client }}
-stats = {{ debug.forget_me.stats }}
 
 "#;

clients/native/src/client/mod.rs

@@ -20,7 +20,7 @@ pub use nym_sphinx::addressing::clients::Recipient;
 
 pub mod config;
 
-type NativeClientBuilder = BaseClientBuilder<QueryHttpRpcNyxdClient, OnDiskPersistent>;
+type NativeClientBuilder<'a> = BaseClientBuilder<'a, QueryHttpRpcNyxdClient, OnDiskPersistent>;
 
 pub struct SocketClient {
     /// Client configuration options, including, among other things, packet sending rates,
@@ -32,10 +32,6 @@ pub struct SocketClient {
 }
 
 impl SocketClient {
-    pub fn config(&self) -> Config {
-        self.config.clone()
-    }
-
     pub fn new(config: Config, custom_mixnet: Option<PathBuf>) -> Self {
         SocketClient {
             config,
@@ -49,7 +45,7 @@ impl SocketClient {
         client_output: ClientOutput,
         client_state: ClientState,
         self_address: &Recipient,
-        task_client: nym_task::TaskClient,
+        shutdown: nym_task::TaskClient,
         packet_type: PacketType,
     ) {
         info!("Starting websocket listener...");
@@ -77,15 +73,10 @@ impl SocketClient {
             shared_lane_queue_lengths,
             reply_controller_sender,
             Some(packet_type),
-            task_client.fork("websocket_handler"),
         );
 
-        websocket::Listener::new(
-            config.socket.host,
-            config.socket.listening_port,
-            task_client.with_suffix("websocket_listener"),
-        )
-        .start(websocket_handler);
+        websocket::Listener::new(config.socket.host, config.socket.listening_port)
+            .start(websocket_handler, shutdown);
     }
 
     /// blocking version of `start_socket` method. Will run forever (or until SIGINT is sent)
@@ -117,9 +108,8 @@ impl SocketClient {
         let storage = self.initialise_storage().await?;
         let user_agent = nym_bin_common::bin_info!().into();
 
-        let mut base_client =
-            BaseClientBuilder::new(self.config().base(), storage, dkg_query_client)
-                .with_user_agent(user_agent);
+        let mut base_client = BaseClientBuilder::new(&self.config.base, storage, dkg_query_client)
+            .with_user_agent(user_agent);
 
         if let Some(custom_mixnet) = &self.custom_mixnet {
             base_client = base_client.with_stored_topology(custom_mixnet)?;

clients/native/src/commands/init.rs

@@ -82,7 +82,6 @@ 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,
-            forget_me: init_config.common_args.forget_me.into(),
         }
     }
 }

clients/native/src/commands/mod.rs

@@ -16,7 +16,6 @@ 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_client_core::config::ForgetMe;
 use nym_config::OptionalSet;
 use std::error::Error;
 use std::net::IpAddr;
@@ -107,7 +106,6 @@ pub(crate) struct OverrideConfig {
     nyxd_urls: Option<Vec<url::Url>>,
     enabled_credentials_mode: Option<bool>,
     stats_reporting_address: Option<Recipient>,
-    forget_me: ForgetMe,
 }
 
 pub(crate) async fn execute(args: Cli) -> Result<(), Box<dyn Error + Send + Sync>> {
@@ -135,7 +133,6 @@ pub(crate) fn override_config(config: Config, args: OverrideConfig) -> Config {
             args.fastmode,
         )
         .with_base(BaseClientConfig::with_disabled_cover_traffic, args.no_cover)
-        .with_base(BaseClientConfig::with_forget_me, args.forget_me)
         .with_optional(Config::with_port, args.port)
         .with_optional(Config::with_host, args.host)
         .with_optional_custom_env_ext(

clients/native/src/commands/run.rs

@@ -41,7 +41,6 @@ impl From<Run> for OverrideConfig {
             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,
-            forget_me: run_config.common_args.forget_me.into(),
         }
     }
 }

clients/native/src/websocket/handler.rs

@@ -19,7 +19,6 @@ use nym_sphinx::receiver::ReconstructedMessage;
 use nym_task::connections::{
     ConnectionCommand, ConnectionCommandSender, ConnectionId, LaneQueueLengths, TransmissionLane,
 };
-use nym_task::TaskClient;
 use std::time::Duration;
 use tokio::net::TcpStream;
 use tokio::time::Instant;
@@ -44,11 +43,9 @@ pub(crate) struct HandlerBuilder {
     lane_queue_lengths: LaneQueueLengths,
     reply_controller_sender: ReplyControllerSender,
     packet_type: Option<PacketType>,
-    task_client: TaskClient,
 }
 
 impl HandlerBuilder {
-    #[allow(clippy::too_many_arguments)]
     pub(crate) fn new(
         msg_input: InputMessageSender,
         client_connection_tx: ConnectionCommandSender,
@@ -57,7 +54,6 @@ impl HandlerBuilder {
         lane_queue_lengths: LaneQueueLengths,
         reply_controller_sender: ReplyControllerSender,
         packet_type: Option<PacketType>,
-        task_client: TaskClient,
     ) -> Self {
         Self {
             msg_input,
@@ -67,14 +63,11 @@ impl HandlerBuilder {
             lane_queue_lengths,
             reply_controller_sender,
             packet_type,
-            task_client,
         }
     }
 
     // TODO: make sure we only ever have one active handler
     pub fn create_active_handler(&self) -> Handler {
-        let mut task_client = self.task_client.fork("active_handler");
-        task_client.disarm();
         Handler {
             msg_input: self.msg_input.clone(),
             client_connection_tx: self.client_connection_tx.clone(),
@@ -85,7 +78,6 @@ impl HandlerBuilder {
             lane_queue_lengths: self.lane_queue_lengths.clone(),
             reply_controller_sender: self.reply_controller_sender.clone(),
             packet_type: self.packet_type,
-            task_client,
         }
     }
 }
@@ -100,18 +92,16 @@ pub(crate) struct Handler {
     lane_queue_lengths: LaneQueueLengths,
     reply_controller_sender: ReplyControllerSender,
     packet_type: Option<PacketType>,
-    task_client: TaskClient,
 }
 
 impl Drop for Handler {
     fn drop(&mut self) {
-        if let Err(err) = self
+        if self
             .buffer_requester
             .unbounded_send(ReceivedBufferMessage::ReceiverDisconnect)
+            .is_err()
         {
-            if !self.task_client.is_shutdown_poll() {
-                error!("failed to disconnect the receiver from the buffer: {err}");
-            }
+            error!("we failed to disconnect the receiver from the buffer! presumably the shutdown procedure has been initiated!")
         }
     }
 }
@@ -135,23 +125,10 @@ impl Handler {
         };
 
         // get the number of pending replies waiting for reply surbs
-        let reply_queue_length = match self
+        let reply_queue_length = self
             .reply_controller_sender
             .get_lane_queue_length(connection_id)
-            .await
-        {
-            Ok(length) => length,
-            Err(err) => {
-                if !self.task_client.is_shutdown_poll() {
-                    error!(
-                        "Failed to get reply queue length for connection {connection_id}: {err}"
-                    );
-                }
-                // We're just going to assume that the queue is empty, and I think that's okay
-                // during shutdown.
-                0
-            }
-        };
+            .await;
 
         let queue_length = base_length + reply_queue_length;
 
@@ -191,11 +168,10 @@ impl Handler {
 
         // the ack control is now responsible for chunking, etc.
         let input_msg = InputMessage::new_regular(recipient, message, lane, self.packet_type);
-        if let Err(err) = self.msg_input.send(input_msg).await {
-            if !self.task_client.is_shutdown_poll() {
-                error!("Failed to send message to the input buffer: {err}");
-            }
-        }
+        self.msg_input
+            .send(input_msg)
+            .await
+            .expect("InputMessageReceiver has stopped receiving!");
 
         // Only reply back with a `LaneQueueLength` if the sender providided a connection id
         let TransmissionLane::ConnectionId(connection_id) = lane else {
@@ -224,11 +200,10 @@ impl Handler {
 
         let input_msg =
             InputMessage::new_anonymous(recipient, message, reply_surbs, lane, self.packet_type);
-        if let Err(err) = self.msg_input.send(input_msg).await {
-            if !self.task_client.is_shutdown_poll() {
-                error!("Failed to send anonymous message to the input buffer: {err}");
-            }
-        }
+        self.msg_input
+            .send(input_msg)
+            .await
+            .expect("InputMessageReceiver has stopped receiving!");
 
         // Only reply back with a `LaneQueueLength` if the sender providided a connection id
         let TransmissionLane::ConnectionId(connection_id) = lane else {
@@ -252,11 +227,10 @@ impl Handler {
         });
 
         let input_msg = InputMessage::new_reply(recipient_tag, message, lane, self.packet_type);
-        if let Err(err) = self.msg_input.send(input_msg).await {
-            if !self.task_client.is_shutdown_poll() {
-                error!("Failed to send reply message to the input buffer: {err}");
-            }
-        }
+        self.msg_input
+            .send(input_msg)
+            .await
+            .expect("InputMessageReceiver has stopped receiving!");
 
         // Only reply back with a `LaneQueueLength` if the sender providided a connection id
         let TransmissionLane::ConnectionId(connection_id) = lane else {
@@ -271,14 +245,9 @@ impl Handler {
     }
 
     fn handle_closed_connection(&self, connection_id: u64) -> Option<ServerResponse> {
-        if let Err(err) = self
-            .client_connection_tx
+        self.client_connection_tx
             .unbounded_send(ConnectionCommand::Close(connection_id))
-        {
-            if !self.task_client.is_shutdown_poll() {
-                error!("Failed to send close connection command: {err}");
-            }
-        }
+            .unwrap();
         None
     }
 
@@ -393,10 +362,11 @@ impl Handler {
         }
     }
 
-    async fn listen_for_requests(&mut self, mut msg_receiver: ReconstructedMessagesReceiver) {
-        let mut task_client = self.task_client.fork("select");
-        task_client.disarm();
-
+    async fn listen_for_requests(
+        &mut self,
+        mut msg_receiver: ReconstructedMessagesReceiver,
+        mut task_client: nym_task::TaskClient,
+    ) {
         while !task_client.is_shutdown() {
             tokio::select! {
                 // we can either get a client request from the websocket
@@ -445,7 +415,15 @@ impl Handler {
     }
 
     // consume self to make sure `drop` is called after this is done
-    pub(crate) async fn handle_connection(mut self, socket: TcpStream) {
+    pub(crate) async fn handle_connection(
+        mut self,
+        socket: TcpStream,
+        mut task_client: nym_task::TaskClient,
+    ) {
+        // We don't want a crash in the connection handler to trigger a shutdown of the whole
+        // process.
+        task_client.disarm();
+
         let ws_stream = match accept_async(socket).await {
             Ok(ws_stream) => ws_stream,
             Err(err) => {
@@ -458,18 +436,14 @@ impl Handler {
         let (reconstructed_sender, reconstructed_receiver) = mpsc::unbounded();
 
         // tell the buffer to start sending stuff to us
-        if let Err(err) =
-            self.buffer_requester
-                .unbounded_send(ReceivedBufferMessage::ReceiverAnnounce(
-                    reconstructed_sender,
-                ))
-        {
-            if !self.task_client.is_shutdown_poll() {
-                error!("failed to announce the receiver to the buffer: {err}");
-            }
-        }
+        self.buffer_requester
+            .unbounded_send(ReceivedBufferMessage::ReceiverAnnounce(
+                reconstructed_sender,
+            ))
+            .expect("the buffer request failed!");
 
-        self.listen_for_requests(reconstructed_receiver).await;
+        self.listen_for_requests(reconstructed_receiver, task_client)
+            .await;
     }
 }
 

clients/native/src/websocket/listener.rs

@@ -3,7 +3,6 @@
 
 use super::handler::HandlerBuilder;
 use log::*;
-use nym_task::TaskClient;
 use std::net::IpAddr;
 use std::{net::SocketAddr, process, sync::Arc};
 use tokio::io::AsyncWriteExt;
@@ -23,19 +22,21 @@ impl State {
 pub(crate) struct Listener {
     address: SocketAddr,
     state: State,
-    task_client: TaskClient,
 }
 
 impl Listener {
-    pub(crate) fn new(host: IpAddr, port: u16, task_client: TaskClient) -> Self {
+    pub(crate) fn new(host: IpAddr, port: u16) -> Self {
         Listener {
             address: SocketAddr::new(host, port),
             state: State::AwaitingConnection,
-            task_client,
         }
     }
 
-    pub(crate) async fn run(&mut self, handler: HandlerBuilder) {
+    pub(crate) async fn run(
+        &mut self,
+        handler: HandlerBuilder,
+        mut task_client: nym_task::TaskClient,
+    ) {
         let tcp_listener = match tokio::net::TcpListener::bind(self.address).await {
             Ok(listener) => listener,
             Err(err) => {
@@ -46,11 +47,11 @@ impl Listener {
 
         let notify = Arc::new(Notify::new());
 
-        while !self.task_client.is_shutdown() {
+        loop {
             tokio::select! {
                 // When the handler finishes we check if shutdown is signalled
                 _ = notify.notified() => {
-                    if self.task_client.is_shutdown() {
+                    if task_client.is_shutdown() {
                         log::trace!("Websocket listener: detected shutdown after connection closed");
                         break;
                     }
@@ -59,7 +60,7 @@ impl Listener {
                 }
                 // ... but when there is no connected client at the time of shutdown being
                 // signalled, we handle it here.
-                _ = self.task_client.recv() => {
+                _ = task_client.recv() => {
                     if !self.state.is_connected() {
                         log::trace!("Not connected: shutting down");
                         break;
@@ -87,8 +88,9 @@ impl Listener {
                                 // hanging because the executor doesn't come back here
                                 let notify_clone = Arc::clone(&notify);
                                 let fresh_handler = handler.create_active_handler();
+                                let task_client_handler = task_client.clone();
                                 tokio::spawn(async move {
-                                    fresh_handler.handle_connection(socket).await;
+                                    fresh_handler.handle_connection(socket, task_client_handler).await;
                                     notify_clone.notify_one();
                                 });
                                 self.state = State::Connected;
@@ -102,9 +104,13 @@ impl Listener {
         log::debug!("Websocket listener: Exiting");
     }
 
-    pub(crate) fn start(mut self, handler: HandlerBuilder) -> JoinHandle<()> {
+    pub(crate) fn start(
+        mut self,
+        handler: HandlerBuilder,
+        shutdown: nym_task::TaskClient,
+    ) -> JoinHandle<()> {
         info!("Running websocket on {:?}", self.address.to_string());
 
-        tokio::spawn(async move { self.run(handler).await })
+        tokio::spawn(async move { self.run(handler, shutdown).await })
     }
 }

clients/socks5/Cargo.toml

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

@@ -93,7 +93,6 @@ impl From<Init> for OverrideConfig {
             enabled_credentials_mode: init_config.common_args.enabled_credentials_mode,
             outfox: false,
             stats_reporting_address: init_config.common_args.stats_reporting_address,
-            forget_me: init_config.common_args.forget_me.into(),
         }
     }
 }

clients/socks5/src/commands/mod.rs

@@ -17,7 +17,7 @@ use nym_bin_common::completions::{fig_generate, ArgShell};
 use nym_client_core::cli_helpers::CliClient;
 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::{ForgetMe, GroupBy, TopologyStructure};
+use nym_client_core::config::{GroupBy, TopologyStructure};
 use nym_config::OptionalSet;
 use nym_sphinx::addressing::Recipient;
 use nym_sphinx::params::{PacketSize, PacketType};
@@ -113,7 +113,6 @@ pub(crate) struct OverrideConfig {
     enabled_credentials_mode: Option<bool>,
     outfox: bool,
     stats_reporting_address: Option<Recipient>,
-    forget_me: ForgetMe,
 }
 
 pub(crate) async fn execute(args: Cli) -> Result<(), Box<dyn Error + Send + Sync>> {
@@ -180,7 +179,6 @@ pub(crate) fn override_config(config: Config, args: OverrideConfig) -> Config {
             BaseClientConfig::with_topology_structure,
             topology_structure,
         )
-        .with_base(BaseClientConfig::with_forget_me, args.forget_me)
         .with_optional(Config::with_anonymous_replies, args.use_anonymous_replies)
         .with_optional(Config::with_port, args.port)
         .with_optional(Config::with_ip, args.ip)

clients/socks5/src/commands/run.rs

@@ -65,7 +65,6 @@ impl From<Run> for OverrideConfig {
             enabled_credentials_mode: run_config.common_args.enabled_credentials_mode,
             outfox: run_config.outfox,
             stats_reporting_address: run_config.common_args.stats_reporting_address,
-            forget_me: run_config.common_args.forget_me.into(),
         }
     }
 }

clients/socks5/src/config/template.rs

@@ -113,8 +113,4 @@ enabled = {{ core.debug.stats_reporting.enabled }}
 provider_address = '{{ core.debug.stats_reporting.provider_address }}'
 reporting_interval = '{{ core.debug.stats_reporting.reporting_interval }}'
 
-[core.debug.forget_me]
-client = {{ core.debug.forget_me.client }}
-stats = {{ core.debug.forget_me.stats }}
-
 "#;

clippy.toml

@@ -1,3 +1,2 @@
 allow-unwrap-in-tests = true
 allow-expect-in-tests = true
-allow-panic-in-tests = true

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

@@ -28,7 +28,7 @@ pub type HmacSha256 = Hmac<Sha256>;
 pub type Nonce = u64;
 pub type Taken = Option<SystemTime>;
 
-pub const BANDWIDTH_CAP_PER_DAY: u64 = 250 * 1024 * 1024 * 1024; // 250 GB
+pub const BANDWIDTH_CAP_PER_DAY: u64 = 1024 * 1024 * 1024; // 1 GB
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 pub struct IpPair {
@@ -60,7 +60,7 @@ impl From<IpAddr> for IpPair {
             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 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],

common/bandwidth-controller/src/lib.rs

@@ -105,24 +105,26 @@ impl<C, St: Storage> BandwidthController<C, St> {
     async fn get_aggregate_verification_key(
         &self,
         epoch_id: EpochId,
-        ecash_apis: &mut ApiClientsWrapper<'_, C>,
+        apis: &mut ApiClientsWrapper,
     ) -> Result<VerificationKeyAuth, BandwidthControllerError>
     where
         C: DkgQueryClient + Sync + Send,
         <St as Storage>::StorageError: Send + Sync + 'static,
     {
+        let ecash_apis = apis.get_or_init(epoch_id, &self.client).await?;
         get_aggregate_verification_key(&self.storage, epoch_id, ecash_apis).await
     }
 
     async fn get_coin_index_signatures(
         &self,
         epoch_id: EpochId,
-        ecash_apis: &mut ApiClientsWrapper<'_, C>,
+        apis: &mut ApiClientsWrapper,
     ) -> Result<Vec<AnnotatedCoinIndexSignature>, BandwidthControllerError>
     where
         C: DkgQueryClient + Sync + Send,
         <St as Storage>::StorageError: Send + Sync + 'static,
     {
+        let ecash_apis = apis.get_or_init(epoch_id, &self.client).await?;
         get_coin_index_signatures(&self.storage, epoch_id, ecash_apis).await
     }
 
@@ -130,12 +132,13 @@ impl<C, St: Storage> BandwidthController<C, St> {
         &self,
         epoch_id: EpochId,
         expiration_date: Date,
-        ecash_apis: &mut ApiClientsWrapper<'_, C>,
+        apis: &mut ApiClientsWrapper,
     ) -> Result<Vec<AnnotatedExpirationDateSignature>, BandwidthControllerError>
     where
         C: DkgQueryClient + Sync + Send,
         <St as Storage>::StorageError: Send + Sync + 'static,
     {
+        let ecash_apis = apis.get_or_init(epoch_id, &self.client).await?;
         get_expiration_date_signatures(&self.storage, epoch_id, expiration_date, ecash_apis).await
     }
 
@@ -151,7 +154,7 @@ impl<C, St: Storage> BandwidthController<C, St> {
     {
         let epoch_id = retrieved_ticketbook.ticketbook.epoch_id();
         let expiration_date = retrieved_ticketbook.ticketbook.expiration_date();
-        let mut api_clients = ApiClientsWrapper::new(&self.client, epoch_id);
+        let mut api_clients = Default::default();
 
         let verification_key = self
             .get_aggregate_verification_key(epoch_id, &mut api_clients)

common/bandwidth-controller/src/utils.rs

@@ -21,67 +21,30 @@ use rand::thread_rng;
 use std::fmt::Display;
 use std::future::Future;
 
-pub(crate) trait EcashClientsProvider {
-    async fn try_get_ecash_clients(
-        &mut self,
-    ) -> Result<Vec<EcashApiClient>, BandwidthControllerError>;
-}
+// it really doesn't need the RwLock because it's never moved across tasks,
+// but we need all the Send/Sync action
+#[derive(Default)]
+pub(crate) struct ApiClientsWrapper(Option<Vec<EcashApiClient>>);
 
-impl EcashClientsProvider for Vec<EcashApiClient> {
-    async fn try_get_ecash_clients(
+impl ApiClientsWrapper {
+    pub(crate) async fn get_or_init<C>(
         &mut self,
-    ) -> Result<Vec<EcashApiClient>, BandwidthControllerError> {
-        Ok(self.clone())
-    }
-}
-
-impl<C> EcashClientsProvider for &mut ApiClientsWrapper<'_, C>
-where
-    C: DkgQueryClient + Sync + Send,
-{
-    async fn try_get_ecash_clients(
-        &mut self,
-    ) -> Result<Vec<EcashApiClient>, BandwidthControllerError> {
-        self.clients().await
-    }
-}
-
-pub(crate) enum ApiClientsWrapper<'a, C> {
-    Uninitialised {
-        query_client: &'a C,
         epoch_id: EpochId,
-    },
-    Cached {
-        clients: Vec<EcashApiClient>,
-    },
-}
-
-impl<'a, C> ApiClientsWrapper<'a, C> {
-    pub(crate) fn new(query_client: &'a C, epoch_id: EpochId) -> Self {
-        ApiClientsWrapper::Uninitialised {
-            query_client,
-            epoch_id,
-        }
-    }
-
-    async fn clients(&mut self) -> Result<Vec<EcashApiClient>, BandwidthControllerError>
+        dkg_client: &C,
+    ) -> Result<Vec<EcashApiClient>, BandwidthControllerError>
     where
         C: DkgQueryClient + Sync + Send,
     {
-        match self {
-            ApiClientsWrapper::Uninitialised {
-                query_client,
-                epoch_id,
-            } => {
-                let clients = all_ecash_api_clients(*query_client, *epoch_id).await?;
-                *self = ApiClientsWrapper::Cached {
-                    clients: clients.clone(),
-                };
-
-                Ok(clients)
-            }
-            ApiClientsWrapper::Cached { clients } => Ok(clients.clone()),
+        if let Some(cached) = &self.0 {
+            return Ok(cached.clone());
         }
+
+        let clients = all_ecash_api_clients(dkg_client, epoch_id).await?;
+
+        // technically we don't have to be cloning all the clients here, but it's way simpler than
+        // dealing with locking and whatnot given the performance penalty is negligible
+        self.0 = Some(clients.clone());
+        Ok(clients)
     }
 }
 
@@ -113,7 +76,7 @@ where
 pub(crate) async fn get_aggregate_verification_key<St>(
     storage: &St,
     epoch_id: EpochId,
-    mut ecash_apis: impl EcashClientsProvider,
+    ecash_apis: Vec<EcashApiClient>,
 ) -> Result<VerificationKeyAuth, BandwidthControllerError>
 where
     St: Storage,
@@ -127,8 +90,6 @@ where
         return Ok(stored);
     };
 
-    let ecash_apis = ecash_apis.try_get_ecash_clients().await?;
-
     let master_vk = query_random_apis_until_success(
         ecash_apis,
         |api| async move { api.api_client.master_verification_key(Some(epoch_id)).await },
@@ -154,7 +115,7 @@ where
 pub(crate) async fn get_coin_index_signatures<St>(
     storage: &St,
     epoch_id: EpochId,
-    mut ecash_apis: impl EcashClientsProvider,
+    ecash_apis: Vec<EcashApiClient>,
 ) -> Result<Vec<AnnotatedCoinIndexSignature>, BandwidthControllerError>
 where
     St: Storage,
@@ -168,8 +129,6 @@ where
         return Ok(stored);
     };
 
-    let ecash_apis = ecash_apis.try_get_ecash_clients().await?;
-
     let index_sigs = query_random_apis_until_success(
         ecash_apis,
         |api| async move {
@@ -200,7 +159,7 @@ pub(crate) async fn get_expiration_date_signatures<St>(
     storage: &St,
     epoch_id: EpochId,
     expiration_date: Date,
-    mut ecash_apis: impl EcashClientsProvider,
+    ecash_apis: Vec<EcashApiClient>,
 ) -> Result<Vec<AnnotatedExpirationDateSignature>, BandwidthControllerError>
 where
     St: Storage,
@@ -214,8 +173,6 @@ where
         return Ok(stored);
     };
 
-    let ecash_apis = ecash_apis.try_get_ecash_clients().await?;
-
     let expiration_sigs = query_random_apis_until_success(
         ecash_apis,
         |api| async move {

common/client-core/Cargo.toml

@@ -3,7 +3,7 @@ name = "nym-client-core"
 version = "1.1.15"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
 edition = "2021"
-rust-version = "1.76"
+rust-version = "1.70"
 license.workspace = true
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -40,13 +40,12 @@ nym-crypto = { path = "../crypto" }
 nym-explorer-client = { path = "../../explorer-api/explorer-client" }
 nym-gateway-client = { path = "../client-libs/gateway-client" }
 nym-gateway-requests = { path = "../gateway-requests" }
-nym-http-api-client = { path = "../http-api-client" }
 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 = ["persistence"] }
+nym-topology = { path = "../topology", features = ["serializable"] }
 nym-mixnet-client = { path = "../client-libs/mixnet-client", default-features = false }
 nym-validator-client = { path = "../client-libs/validator-client", default-features = false }
 nym-task = { path = "../task" }

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

@@ -45,7 +45,6 @@ const DEFAULT_COVER_TRAFFIC_PRIMARY_SIZE_RATIO: f64 = 0.70;
 // clients/client-core/src/client/replies/reply_storage/surb_storage.rs
 const DEFAULT_MINIMUM_REPLY_SURB_STORAGE_THRESHOLD: usize = 10;
 const DEFAULT_MAXIMUM_REPLY_SURB_STORAGE_THRESHOLD: usize = 200;
-const DEFAULT_MINIMUM_REPLY_SURB_THRESHOLD_BUFFER: usize = 0;
 
 // define how much to request at once
 // clients/client-core/src/client/replies/reply_controller.rs
@@ -146,11 +145,6 @@ impl Config {
         self
     }
 
-    pub fn with_forget_me(mut self, forget_me: ForgetMe) -> Self {
-        self.debug.forget_me = forget_me;
-        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:
@@ -523,7 +517,7 @@ impl Default for Acknowledgements {
 }
 
 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
-#[serde(default)]
+#[serde(default, deny_unknown_fields)]
 pub struct Topology {
     /// The uniform delay every which clients are querying the directory server
     /// to try to obtain a compatible network topology to send sphinx packets through.
@@ -556,18 +550,6 @@ pub struct Topology {
     /// Specifies a minimum performance of a gateway that is used on route construction.
     /// This setting is only applicable when `NymApi` topology is used.
     pub minimum_gateway_performance: u8,
-
-    /// Specifies whether this client should attempt to retrieve all available network nodes
-    /// as opposed to just active mixnodes/gateways.
-    pub use_extended_topology: bool,
-
-    /// Specifies whether this client should ignore the current epoch role of the target egress node
-    /// when constructing the final hop packets.
-    pub ignore_egress_epoch_role: bool,
-
-    /// Specifies whether this client should ignore the current epoch role of the ingress node
-    /// when attempting to establish new connection
-    pub ignore_ingress_epoch_role: bool,
 }
 
 #[allow(clippy::large_enum_variant)]
@@ -604,10 +586,6 @@ impl Default for Topology {
             topology_structure: TopologyStructure::default(),
             minimum_mixnode_performance: DEFAULT_MIN_MIXNODE_PERFORMANCE,
             minimum_gateway_performance: DEFAULT_MIN_GATEWAY_PERFORMANCE,
-            use_extended_topology: false,
-
-            ignore_egress_epoch_role: true,
-            ignore_ingress_epoch_role: true,
         }
     }
 }
@@ -622,10 +600,6 @@ pub struct ReplySurbs {
     /// Defines the maximum number of reply surbs the client wants to keep in its storage at any times.
     pub maximum_reply_surb_storage_threshold: usize,
 
-    /// Defines the soft threshold ontop of the minimum reply surb storage threshold for when the client
-    /// should proactively request additional reply surbs.
-    pub minimum_reply_surb_threshold_buffer: usize,
-
     /// Defines the minimum number of reply surbs the client would request.
     pub minimum_reply_surb_request_size: u32,
 
@@ -665,7 +639,6 @@ impl Default for ReplySurbs {
         ReplySurbs {
             minimum_reply_surb_storage_threshold: DEFAULT_MINIMUM_REPLY_SURB_STORAGE_THRESHOLD,
             maximum_reply_surb_storage_threshold: DEFAULT_MAXIMUM_REPLY_SURB_STORAGE_THRESHOLD,
-            minimum_reply_surb_threshold_buffer: DEFAULT_MINIMUM_REPLY_SURB_THRESHOLD_BUFFER,
             minimum_reply_surb_request_size: DEFAULT_MINIMUM_REPLY_SURB_REQUEST_SIZE,
             maximum_reply_surb_request_size: DEFAULT_MAXIMUM_REPLY_SURB_REQUEST_SIZE,
             maximum_allowed_reply_surb_request_size: DEFAULT_MAXIMUM_ALLOWED_SURB_REQUEST_SIZE,
@@ -730,9 +703,6 @@ pub struct DebugConfig {
 
     /// Defines all configuration options related to stats reporting.
     pub stats_reporting: StatsReporting,
-
-    /// Defines all configuration options related to the forget me flag.
-    pub forget_me: ForgetMe,
 }
 
 impl DebugConfig {
@@ -755,69 +725,6 @@ impl Default for DebugConfig {
             topology: Default::default(),
             reply_surbs: Default::default(),
             stats_reporting: Default::default(),
-            forget_me: Default::default(),
-        }
-    }
-}
-
-#[derive(Clone, Default, Debug, Deserialize, PartialEq, Serialize, Copy)]
-pub struct ForgetMe {
-    client: bool,
-    stats: bool,
-}
-
-impl From<bool> for ForgetMe {
-    fn from(value: bool) -> Self {
-        if value {
-            Self::new_all()
-        } else {
-            Self::new_none()
-        }
-    }
-}
-
-impl ForgetMe {
-    pub fn new_all() -> Self {
-        Self {
-            client: true,
-            stats: true,
-        }
-    }
-
-    pub fn new_client() -> Self {
-        Self {
-            client: true,
-            stats: false,
-        }
-    }
-
-    pub fn new_stats() -> Self {
-        Self {
-            client: false,
-            stats: true,
-        }
-    }
-
-    pub fn new(client: bool, stats: bool) -> Self {
-        Self { client, stats }
-    }
-
-    pub fn any(&self) -> bool {
-        self.client || self.stats
-    }
-
-    pub fn client(&self) -> bool {
-        self.client
-    }
-
-    pub fn stats(&self) -> bool {
-        self.stats
-    }
-
-    pub fn new_none() -> Self {
-        Self {
-            client: false,
-            stats: false,
         }
     }
 }

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

@@ -181,9 +181,8 @@ impl From<ConfigV5> for Config {
                     maximum_reply_surb_age: value.debug.reply_surbs.maximum_reply_surb_age,
                     maximum_reply_key_age: value.debug.reply_surbs.maximum_reply_key_age,
                     surb_mix_hops: value.debug.reply_surbs.surb_mix_hops,
-                    ..Default::default()
                 },
-                ..Default::default()
+                stats_reporting: Default::default(),
             },
         }
     }

common/client-core/gateways-storage/fs_gateways_migrations/20250227120000_remove_aes128_ctr_key.sql

@@ -1,24 +0,0 @@
-/*
- * Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
- * SPDX-License-Identifier: GPL-3.0-only
- */
-
--- make aes256gcm column non-nullable and drop any gateways that still use the legacy keys
--- (since they'd be unusable after this change)
-CREATE TABLE remote_gateway_details_tmp
-(
-    gateway_id_bs58            TEXT NOT NULL UNIQUE PRIMARY KEY REFERENCES registered_gateway (gateway_id_bs58),
-    derived_aes256_gcm_siv_key BLOB NOT NULL,
-    gateway_owner_address      TEXT,
-    gateway_listener           TEXT NOT NULL
-);
-
-INSERT INTO remote_gateway_details_tmp (gateway_id_bs58, derived_aes256_gcm_siv_key, gateway_owner_address,
-                                        gateway_listener)
-SELECT gateway_id_bs58, derived_aes256_gcm_siv_key, gateway_owner_address, gateway_listener
-FROM remote_gateway_details
-WHERE derived_aes256_gcm_siv_key IS NOT NULL;
-
-DROP TABLE remote_gateway_details;
-ALTER TABLE remote_gateway_details_tmp
-    RENAME TO remote_gateway_details;

common/client-core/gateways-storage/src/backend/fs_backend/manager.rs

@@ -8,10 +8,7 @@ use crate::{
     },
 };
 use log::{debug, error};
-use sqlx::{
-    sqlite::{SqliteAutoVacuum, SqliteSynchronous},
-    ConnectOptions,
-};
+use sqlx::ConnectOptions;
 use std::path::Path;
 
 #[derive(Debug, Clone)]
@@ -33,9 +30,6 @@ impl StorageManager {
         }
 
         let opts = sqlx::sqlite::SqliteConnectOptions::new()
-            .journal_mode(sqlx::sqlite::SqliteJournalMode::Wal)
-            .synchronous(SqliteSynchronous::Normal)
-            .auto_vacuum(SqliteAutoVacuum::Incremental)
             .filename(database_path)
             .create_if_missing(true)
             .disable_statement_logging();
@@ -116,7 +110,7 @@ impl StorageManager {
     ) -> Result<(), sqlx::Error> {
         sqlx::query!(
             r#"
-                INSERT INTO registered_gateway(gateway_id_bs58, registration_timestamp, gateway_type)
+                INSERT INTO registered_gateway(gateway_id_bs58, registration_timestamp, gateway_type) 
                 VALUES (?, ?, ?)
             "#,
             registered_gateway.gateway_id_bs58,
@@ -156,26 +150,48 @@ impl StorageManager {
 
     pub(crate) async fn set_remote_gateway_details(
         &self,
-        gateway_id_bs58: String,
-        derived_aes256_gcm_siv_key: &[u8],
-        gateway_owner_address: Option<String>,
-        gateway_listener: String,
+        remote: &RawRemoteGatewayDetails,
     ) -> Result<(), sqlx::Error> {
         sqlx::query!(
             r#"
-                INSERT INTO remote_gateway_details(gateway_id_bs58, derived_aes256_gcm_siv_key, gateway_owner_address, gateway_listener)
-                VALUES (?, ?, ?, ?)
+                INSERT INTO remote_gateway_details(gateway_id_bs58, derived_aes128_ctr_blake3_hmac_keys_bs58, derived_aes256_gcm_siv_key, gateway_owner_address, gateway_listener)
+                VALUES (?, ?, ?, ?, ?)
             "#,
-            gateway_id_bs58,
-            derived_aes256_gcm_siv_key,
-            gateway_owner_address,
-            gateway_listener,
+            remote.gateway_id_bs58,
+            remote.derived_aes128_ctr_blake3_hmac_keys_bs58,
+            remote.derived_aes256_gcm_siv_key,
+            remote.gateway_owner_address,
+            remote.gateway_listener,
         )
             .execute(&self.connection_pool)
             .await?;
         Ok(())
     }
 
+    pub(crate) async fn update_remote_gateway_key(
+        &self,
+        gateway_id_bs58: &str,
+        derived_aes128_ctr_blake3_hmac_keys_bs58: Option<&str>,
+        derived_aes256_gcm_siv_key: Option<&[u8]>,
+    ) -> Result<(), sqlx::Error> {
+        sqlx::query!(
+            r#"
+                UPDATE remote_gateway_details
+                SET
+                    derived_aes128_ctr_blake3_hmac_keys_bs58 = ?,
+                    derived_aes256_gcm_siv_key = ?
+                WHERE gateway_id_bs58 = ?
+            "#,
+            derived_aes128_ctr_blake3_hmac_keys_bs58,
+            derived_aes256_gcm_siv_key,
+            gateway_id_bs58
+        )
+        .execute(&self.connection_pool)
+        .await?;
+
+        Ok(())
+    }
+
     pub(crate) async fn remove_remote_gateway_details(
         &self,
         gateway_id: &str,
@@ -208,7 +224,7 @@ impl StorageManager {
     ) -> Result<(), sqlx::Error> {
         sqlx::query!(
             r#"
-                INSERT INTO custom_gateway_details(gateway_id_bs58, data)
+                INSERT INTO custom_gateway_details(gateway_id_bs58, data) 
                 VALUES (?, ?)
             "#,
             custom.gateway_id_bs58,

common/client-core/gateways-storage/src/backend/fs_backend/mod.rs

@@ -8,13 +8,13 @@ use crate::{
 use async_trait::async_trait;
 use manager::StorageManager;
 use nym_crypto::asymmetric::ed25519;
+use nym_gateway_requests::SharedSymmetricKey;
 use std::path::Path;
 
 pub mod error;
 mod manager;
 mod models;
 
-#[derive(Clone)]
 pub struct OnDiskGatewaysDetails {
     manager: StorageManager,
 }
@@ -118,16 +118,9 @@ impl GatewaysDetailsStore for OnDiskGatewaysDetails {
 
         match &details.details {
             GatewayDetails::Remote(remote_details) => {
+                let raw_details = remote_details.into();
                 self.manager
-                    .set_remote_gateway_details(
-                        remote_details.gateway_id.to_base58_string(),
-                        remote_details.shared_key.as_bytes(),
-                        remote_details
-                            .gateway_owner_address
-                            .as_ref()
-                            .map(|o| o.to_string()),
-                        remote_details.gateway_listener.to_string(),
-                    )
+                    .set_remote_gateway_details(&raw_details)
                     .await?;
             }
             GatewayDetails::Custom(custom_details) => {
@@ -140,6 +133,21 @@ impl GatewaysDetailsStore for OnDiskGatewaysDetails {
         Ok(())
     }
 
+    async fn upgrade_stored_remote_gateway_key(
+        &self,
+        gateway_id: ed25519::PublicKey,
+        updated_key: &SharedSymmetricKey,
+    ) -> Result<(), Self::StorageError> {
+        self.manager
+            .update_remote_gateway_key(
+                &gateway_id.to_base58_string(),
+                None,
+                Some(updated_key.as_bytes()),
+            )
+            .await?;
+        Ok(())
+    }
+
     // ideally all of those should be run under a storage tx to ensure storage consistency,
     // but at that point it's fine
     async fn remove_gateway_details(&self, gateway_id: &str) -> Result<(), Self::StorageError> {

common/client-core/gateways-storage/src/backend/mem_backend.rs

@@ -2,8 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::types::{ActiveGateway, GatewayRegistration};
-use crate::{BadGateway, GatewaysDetailsStore};
+use crate::{BadGateway, GatewayDetails, GatewaysDetailsStore};
 use async_trait::async_trait;
+use nym_crypto::asymmetric::ed25519::PublicKey;
+use nym_gateway_requests::{SharedGatewayKey, SharedSymmetricKey};
 use std::collections::HashMap;
 use std::sync::Arc;
 use thiserror::Error;
@@ -18,12 +20,12 @@ pub enum InMemStorageError {
     MalformedGateway(#[from] BadGateway),
 }
 
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct InMemGatewaysDetails {
     inner: Arc<RwLock<InMemStorageInner>>,
 }
 
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 struct InMemStorageInner {
     active_gateway: Option<String>,
     gateways: HashMap<String, GatewayRegistration>,
@@ -94,6 +96,29 @@ impl GatewaysDetailsStore for InMemGatewaysDetails {
         Ok(())
     }
 
+    async fn upgrade_stored_remote_gateway_key(
+        &self,
+        gateway_id: PublicKey,
+        updated_key: &SharedSymmetricKey,
+    ) -> Result<(), Self::StorageError> {
+        let mut guard = self.inner.write().await;
+
+        #[allow(clippy::unwrap_used)]
+        if let Some(target) = guard.gateways.get_mut(&gateway_id.to_string()) {
+            let GatewayDetails::Remote(details) = &mut target.details else {
+                return Ok(());
+            };
+            assert_eq!(Arc::strong_count(&details.shared_key), 1);
+
+            // eh. that's nasty, but it's only ever used for ephemeral clients so should be fine for now...
+            details.shared_key = Arc::new(SharedGatewayKey::Current(
+                SharedSymmetricKey::try_from_bytes(updated_key.as_bytes()).unwrap(),
+            ))
+        }
+
+        Ok(())
+    }
+
     async fn remove_gateway_details(&self, gateway_id: &str) -> Result<(), Self::StorageError> {
         let mut guard = self.inner.write().await;
         if let Some(active) = guard.active_gateway.as_ref() {

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

@@ -6,6 +6,7 @@
 
 use async_trait::async_trait;
 use nym_crypto::asymmetric::identity;
+use nym_gateway_requests::SharedSymmetricKey;
 use std::error::Error;
 
 pub mod backend;
@@ -61,6 +62,12 @@ pub trait GatewaysDetailsStore {
         details: &GatewayRegistration,
     ) -> Result<(), Self::StorageError>;
 
+    async fn upgrade_stored_remote_gateway_key(
+        &self,
+        gateway_id: identity::PublicKey,
+        updated_key: &SharedSymmetricKey,
+    ) -> Result<(), Self::StorageError>;
+
     /// Remove given gateway details from the underlying store.
     async fn remove_gateway_details(&self, gateway_id: &str) -> Result<(), Self::StorageError>;
 }

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

@@ -4,9 +4,10 @@
 use crate::BadGateway;
 use cosmrs::AccountId;
 use nym_crypto::asymmetric::identity;
-use nym_gateway_requests::shared_key::SharedSymmetricKey;
+use nym_gateway_requests::shared_key::{LegacySharedKeys, SharedGatewayKey, SharedSymmetricKey};
 use serde::{Deserialize, Serialize};
 use std::fmt::{Display, Formatter};
+use std::ops::Deref;
 use std::str::FromStr;
 use std::sync::Arc;
 use time::OffsetDateTime;
@@ -64,7 +65,7 @@ impl From<GatewayDetails> for GatewayRegistration {
 impl GatewayDetails {
     pub fn new_remote(
         gateway_id: identity::PublicKey,
-        shared_key: Arc<SharedSymmetricKey>,
+        shared_key: Arc<SharedGatewayKey>,
         gateway_owner_address: Option<AccountId>,
         gateway_listener: Url,
     ) -> Self {
@@ -87,7 +88,7 @@ impl GatewayDetails {
         }
     }
 
-    pub fn shared_key(&self) -> Option<&SharedSymmetricKey> {
+    pub fn shared_key(&self) -> Option<&SharedGatewayKey> {
         match self {
             GatewayDetails::Remote(details) => Some(&details.shared_key),
             GatewayDetails::Custom(_) => None,
@@ -167,7 +168,8 @@ pub struct RegisteredGateway {
 #[cfg_attr(feature = "sqlx", derive(sqlx::FromRow))]
 pub struct RawRemoteGatewayDetails {
     pub gateway_id_bs58: String,
-    pub derived_aes256_gcm_siv_key: Vec<u8>,
+    pub derived_aes128_ctr_blake3_hmac_keys_bs58: Option<String>,
+    pub derived_aes256_gcm_siv_key: Option<Vec<u8>>,
     pub gateway_owner_address: Option<String>,
     pub gateway_listener: String,
 }
@@ -184,11 +186,35 @@ impl TryFrom<RawRemoteGatewayDetails> for RemoteGatewayDetails {
                 }
             })?;
 
-        let shared_key = SharedSymmetricKey::try_from_bytes(&value.derived_aes256_gcm_siv_key)
-            .map_err(|source| BadGateway::MalformedSharedKeys {
-                gateway_id: value.gateway_id_bs58.clone(),
-                source,
-            })?;
+        let shared_key =
+            match (
+                &value.derived_aes256_gcm_siv_key,
+                &value.derived_aes128_ctr_blake3_hmac_keys_bs58,
+            ) {
+                (None, None) => {
+                    return Err(BadGateway::MissingSharedKey {
+                        gateway_id: value.gateway_id_bs58.clone(),
+                    })
+                }
+                (Some(aes256gcm_siv), _) => {
+                    let current_key =
+                        SharedSymmetricKey::try_from_bytes(aes256gcm_siv).map_err(|source| {
+                            BadGateway::MalformedSharedKeys {
+                                gateway_id: value.gateway_id_bs58.clone(),
+                                source,
+                            }
+                        })?;
+                    SharedGatewayKey::Current(current_key)
+                }
+                (None, Some(aes128ctr_hmac)) => {
+                    let legacy_key = LegacySharedKeys::try_from_base58_string(aes128ctr_hmac)
+                        .map_err(|source| BadGateway::MalformedSharedKeys {
+                            gateway_id: value.gateway_id_bs58.clone(),
+                            source,
+                        })?;
+                    SharedGatewayKey::Legacy(legacy_key)
+                }
+            };
 
         let gateway_owner_address = value
             .gateway_owner_address
@@ -221,11 +247,29 @@ impl TryFrom<RawRemoteGatewayDetails> for RemoteGatewayDetails {
     }
 }
 
+impl<'a> From<&'a RemoteGatewayDetails> for RawRemoteGatewayDetails {
+    fn from(value: &'a RemoteGatewayDetails) -> Self {
+        let (derived_aes128_ctr_blake3_hmac_keys_bs58, derived_aes256_gcm_siv_key) =
+            match value.shared_key.deref() {
+                SharedGatewayKey::Current(key) => (None, Some(key.to_bytes())),
+                SharedGatewayKey::Legacy(key) => (Some(key.to_base58_string()), None),
+            };
+
+        RawRemoteGatewayDetails {
+            gateway_id_bs58: value.gateway_id.to_base58_string(),
+            derived_aes128_ctr_blake3_hmac_keys_bs58,
+            derived_aes256_gcm_siv_key,
+            gateway_owner_address: value.gateway_owner_address.as_ref().map(|o| o.to_string()),
+            gateway_listener: value.gateway_listener.to_string(),
+        }
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct RemoteGatewayDetails {
     pub gateway_id: identity::PublicKey,
 
-    pub shared_key: Arc<SharedSymmetricKey>,
+    pub shared_key: Arc<SharedGatewayKey>,
 
     pub gateway_owner_address: Option<AccountId>,
 

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

@@ -112,15 +112,14 @@ where
                 source,
             }
         })?;
-        hardcoded_topology.entry_capable_nodes().cloned().collect()
+        hardcoded_topology.get_gateways()
     } else {
         let mut rng = rand::thread_rng();
-        crate::init::helpers::gateways_for_init(
+        crate::init::helpers::current_gateways(
             &mut rng,
             &core.client.nym_api_urls,
             user_agent,
             core.debug.topology.minimum_gateway_performance,
-            core.debug.topology.ignore_ingress_epoch_role,
         )
         .await?
     };
@@ -129,7 +128,7 @@ where
     // make sure the list of available gateways doesn't overlap the list of known gateways
     let available_gateways = available_gateways
         .into_iter()
-        .filter(|g| !registered_gateways.contains(&g.identity()))
+        .filter(|g| !registered_gateways.contains(g.identity()))
         .collect::<Vec<_>>();
 
     if available_gateways.is_empty() {

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

@@ -93,10 +93,6 @@ pub struct CommonClientInitArgs {
     /// Sets the address to report statistics
     #[cfg_attr(feature = "cli", clap(long, hide = true))]
     pub stats_reporting_address: Option<Recipient>,
-
-    /// Sets the forget me flag
-    #[cfg_attr(feature = "cli", clap(long, hide = true, default_value_t = false))]
-    pub forget_me: bool,
 }
 
 pub struct InitResultsWithConfig<T> {
@@ -171,15 +167,14 @@ where
                 source,
             }
         })?;
-        hardcoded_topology.entry_capable_nodes().cloned().collect()
+        hardcoded_topology.get_gateways()
     } else {
         let mut rng = rand::thread_rng();
-        crate::init::helpers::gateways_for_init(
+        crate::init::helpers::current_gateways(
             &mut rng,
             &core.client.nym_api_urls,
             user_agent,
             core.debug.topology.minimum_gateway_performance,
-            core.debug.topology.ignore_ingress_epoch_role,
         )
         .await?
     };

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

@@ -61,8 +61,4 @@ pub struct CommonClientRunArgs {
     /// Sets the address to report statistics
     #[cfg_attr(feature = "cli", clap(long, hide = true))]
     pub stats_reporting_address: Option<Recipient>,
-
-    /// Sets the forget me flag
-    #[cfg_attr(feature = "cli", clap(long, hide = true, default_value_t = false))]
-    pub forget_me: bool,
 }

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

@@ -1,9 +1,9 @@
 // Copyright 2022-2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use super::mix_traffic::ClientRequestSender;
 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;
 use crate::client::cover_traffic_stream::LoopCoverTrafficStream;
@@ -24,7 +24,7 @@ use crate::client::replies::reply_storage::{
 };
 use crate::client::topology_control::nym_api_provider::NymApiTopologyProvider;
 use crate::client::topology_control::{
-    TopologyAccessor, TopologyRefresher, TopologyRefresherConfig,
+    nym_api_provider, TopologyAccessor, TopologyRefresher, TopologyRefresherConfig,
 };
 use crate::config::{Config, DebugConfig};
 use crate::error::ClientCoreError;
@@ -36,11 +36,9 @@ use crate::{config, spawn_future};
 use futures::channel::mpsc;
 use log::*;
 use nym_bandwidth_controller::BandwidthController;
-use nym_client_core_config_types::ForgetMe;
 use nym_client_core_gateways_storage::{GatewayDetails, GatewaysDetailsStore};
 use nym_credential_storage::storage::Storage as CredentialStorage;
 use nym_crypto::asymmetric::{encryption, identity};
-use nym_crypto::hkdf::DerivationMaterial;
 use nym_gateway_client::client::config::GatewayClientConfig;
 use nym_gateway_client::{
     AcknowledgementReceiver, GatewayClient, GatewayConfig, MixnetMessageReceiver, PacketRouter,
@@ -178,8 +176,8 @@ impl From<bool> for CredentialsToggle {
     }
 }
 
-pub struct BaseClientBuilder<C, S: MixnetClientStorage> {
-    config: Config,
+pub struct BaseClientBuilder<'a, C, S: MixnetClientStorage> {
+    config: &'a Config,
     client_store: S,
     dkg_query_client: Option<C>,
 
@@ -190,23 +188,18 @@ pub struct BaseClientBuilder<C, S: MixnetClientStorage> {
     user_agent: Option<UserAgent>,
 
     setup_method: GatewaySetup,
-
-    #[cfg(unix)]
-    connection_fd_callback: Option<Arc<dyn Fn(RawFd) + Send + Sync>>,
-
-    derivation_material: Option<DerivationMaterial>,
 }
 
-impl<C, S> BaseClientBuilder<C, S>
+impl<'a, C, S> BaseClientBuilder<'a, C, S>
 where
     S: MixnetClientStorage + 'static,
     C: DkgQueryClient + Send + Sync + 'static,
 {
     pub fn new(
-        base_config: Config,
+        base_config: &'a Config,
         client_store: S,
         dkg_query_client: Option<C>,
-    ) -> BaseClientBuilder<C, S> {
+    ) -> BaseClientBuilder<'a, C, S> {
         BaseClientBuilder {
             config: base_config,
             client_store,
@@ -217,27 +210,9 @@ where
             shutdown: None,
             user_agent: None,
             setup_method: GatewaySetup::MustLoad { gateway_id: None },
-            #[cfg(unix)]
-            connection_fd_callback: None,
-            derivation_material: None,
         }
     }
 
-    #[must_use]
-    pub fn with_derivation_material(
-        mut self,
-        derivation_material: Option<DerivationMaterial>,
-    ) -> Self {
-        self.derivation_material = derivation_material;
-        self
-    }
-
-    #[must_use]
-    pub fn with_forget_me(mut self, forget_me: &ForgetMe) -> Self {
-        self.config.debug.forget_me = *forget_me;
-        self
-    }
-
     #[must_use]
     pub fn with_gateway_setup(mut self, setup: GatewaySetup) -> Self {
         self.setup_method = setup;
@@ -286,15 +261,6 @@ where
         Ok(self)
     }
 
-    #[cfg(unix)]
-    pub fn with_connection_fd_callback(
-        mut self,
-        callback: Arc<dyn Fn(RawFd) + Send + Sync>,
-    ) -> Self {
-        self.connection_fd_callback = Some(callback);
-        self
-    }
-
     // note: do **NOT** make this method public as its only valid usage is from within `start_base`
     // because it relies on the crypto keys being already loaded
     fn mix_address(details: &InitialisationResult) -> Recipient {
@@ -310,7 +276,7 @@ where
         topology_accessor: TopologyAccessor,
         mix_tx: BatchMixMessageSender,
         stats_tx: ClientStatsSender,
-        task_client: TaskClient,
+        shutdown: TaskClient,
     ) {
         info!("Starting loop cover traffic stream...");
 
@@ -323,10 +289,9 @@ where
             debug_config.traffic,
             debug_config.cover_traffic,
             stats_tx,
-            task_client,
         );
 
-        stream.start();
+        stream.start_with_shutdown(shutdown);
     }
 
     #[allow(clippy::too_many_arguments)]
@@ -341,7 +306,7 @@ where
         reply_controller_receiver: ReplyControllerReceiver,
         lane_queue_lengths: LaneQueueLengths,
         client_connection_rx: ConnectionCommandReceiver,
-        task_client: TaskClient,
+        shutdown: TaskClient,
         packet_type: PacketType,
         stats_tx: ClientStatsSender,
     ) {
@@ -359,9 +324,8 @@ where
             lane_queue_lengths,
             client_connection_rx,
             stats_tx,
-            task_client,
         )
-        .start(packet_type);
+        .start_with_shutdown(shutdown, packet_type);
     }
 
     // buffer controlling all messages fetched from provider
@@ -384,24 +348,23 @@ where
                 reply_key_storage,
                 reply_controller_sender,
                 metrics_reporter,
-                shutdown,
             );
-        controller.start()
+        controller.start_with_shutdown(shutdown)
     }
 
-    #[allow(clippy::too_many_arguments)]
     async fn start_gateway_client(
         config: &Config,
         initialisation_result: InitialisationResult,
         bandwidth_controller: Option<BandwidthController<C, S::CredentialStore>>,
+        details_store: &S::GatewaysDetailsStore,
         packet_router: PacketRouter,
         stats_reporter: ClientStatsSender,
-        #[cfg(unix)] connection_fd_callback: Option<Arc<dyn Fn(RawFd) + Send + Sync>>,
         shutdown: TaskClient,
     ) -> Result<GatewayClient<C, S::CredentialStore>, ClientCoreError>
     where
         <S::KeyStore as KeyStore>::StorageError: Send + Sync + 'static,
         <S::CredentialStore as CredentialStorage>::StorageError: Send + Sync + 'static,
+        <S::GatewaysDetailsStore as GatewaysDetailsStore>::StorageError: Sync + Send,
     {
         let managed_keys = initialisation_result.client_keys;
         let GatewayDetails::Remote(details) = initialisation_result.gateway_registration.details
@@ -438,8 +401,6 @@ where
                     packet_router,
                     bandwidth_controller,
                     stats_reporter,
-                    #[cfg(unix)]
-                    connection_fd_callback,
                     shutdown,
                 )
             };
@@ -456,18 +417,35 @@ where
         // we need to:
         // - perform handshake (reg or auth)
         // - check for key upgrade
+        // - maybe perform another upgrade handshake
         // - check for bandwidth
         // - start background tasks
-        let _auth_res = gateway_client
+        let auth_res = gateway_client
             .perform_initial_authentication()
             .await
             .map_err(gateway_failure)?;
 
+        if auth_res.requires_key_upgrade {
+            // drop the shared_key arc because we don't need it and we can't hold it for the purposes of upgrade
+            drop(auth_res);
+
+            let updated_key = gateway_client
+                .upgrade_key_authenticated()
+                .await
+                .map_err(gateway_failure)?;
+
+            details_store
+                .upgrade_stored_remote_gateway_key(gateway_client.gateway_identity(), &updated_key)
+                .await.map_err(|err| {
+                    error!("failed to store upgraded gateway key! this connection might be forever broken now: {err}");
+                    ClientCoreError::GatewaysDetailsStoreError { source: Box::new(err) }
+            })?
+        }
+
         gateway_client
             .claim_initial_bandwidth()
             .await
             .map_err(gateway_failure)?;
-
         gateway_client
             .start_listening_for_mixnet_messages()
             .map_err(gateway_failure)?;
@@ -481,14 +459,15 @@ where
         config: &Config,
         initialisation_result: InitialisationResult,
         bandwidth_controller: Option<BandwidthController<C, S::CredentialStore>>,
+        details_store: &S::GatewaysDetailsStore,
         packet_router: PacketRouter,
         stats_reporter: ClientStatsSender,
-        #[cfg(unix)] connection_fd_callback: Option<Arc<dyn Fn(RawFd) + Send + Sync>>,
         mut shutdown: TaskClient,
     ) -> Result<Box<dyn GatewayTransceiver + Send>, ClientCoreError>
     where
         <S::KeyStore as KeyStore>::StorageError: Send + Sync + 'static,
         <S::CredentialStore as CredentialStorage>::StorageError: Send + Sync + 'static,
+        <S::GatewaysDetailsStore as GatewaysDetailsStore>::StorageError: Sync + Send,
     {
         // if we have setup custom gateway sender and persisted details agree with it, return it
         if let Some(mut custom_gateway_transceiver) = custom_gateway_transceiver {
@@ -511,10 +490,9 @@ where
             config,
             initialisation_result,
             bandwidth_controller,
+            details_store,
             packet_router,
             stats_reporter,
-            #[cfg(unix)]
-            connection_fd_callback,
             shutdown,
         )
         .await?;
@@ -531,15 +509,15 @@ where
         // if no custom provider was ... provided ..., create one using nym-api
         custom_provider.unwrap_or_else(|| match config_topology.topology_structure {
             config::TopologyStructure::NymApi => Box::new(NymApiTopologyProvider::new(
-                config_topology,
+                nym_api_provider::Config {
+                    min_mixnode_performance: config_topology.minimum_mixnode_performance,
+                    min_gateway_performance: config_topology.minimum_gateway_performance,
+                },
                 nym_api_urls,
                 user_agent,
             )),
             config::TopologyStructure::GeoAware(group_by) => {
-                warn!("using deprecated 'GeoAware' topology provider - this option will be removed very soon");
-
-                #[allow(deprecated)]
-                Box::new(crate::client::topology_control::GeoAwareTopologyProvider::new(nym_api_urls, group_by))
+                Box::new(GeoAwareTopologyProvider::new(nym_api_urls, group_by))
             }
         })
     }
@@ -550,24 +528,17 @@ where
         topology_provider: Box<dyn TopologyProvider + Send + Sync>,
         topology_config: config::Topology,
         topology_accessor: TopologyAccessor,
-        local_gateway: NodeIdentity,
+        local_gateway: &NodeIdentity,
         wait_for_gateway: bool,
-        mut task_client: TaskClient,
+        mut shutdown: TaskClient,
     ) -> Result<(), ClientCoreError> {
         let topology_refresher_config =
             TopologyRefresherConfig::new(topology_config.topology_refresh_rate);
 
-        if topology_config.disable_refreshing {
-            // if we're not spawning the refresher, don't cause shutdown immediately
-            info!("The background topology refesher is not going to be started");
-            task_client.disarm();
-        }
-
         let mut topology_refresher = TopologyRefresher::new(
             topology_refresher_config,
             topology_accessor,
             topology_provider,
-            task_client,
         );
         // before returning, block entire runtime to refresh the current network view so that any
         // components depending on topology would see a non-empty view
@@ -589,7 +560,7 @@ where
         };
 
         if let Err(err) = topology_refresher
-            .ensure_contains_routable_egress(local_gateway)
+            .ensure_contains_gateway(local_gateway)
             .await
         {
             if let Some(waiting_timeout) = gateway_wait_timeout {
@@ -608,11 +579,15 @@ where
             }
         }
 
-        if !topology_config.disable_refreshing {
+        if topology_config.disable_refreshing {
+            // if we're not spawning the refresher, don't cause shutdown immediately
+            info!("The topology refesher is not going to be started");
+            shutdown.disarm();
+        } else {
             // don't spawn the refresher if we don't want to be refreshing the topology.
             // only use the initial values obtained
             info!("Starting topology refresher...");
-            topology_refresher.start();
+            topology_refresher.start_with_shutdown(shutdown);
         }
 
         Ok(())
@@ -623,29 +598,28 @@ where
         user_agent: Option<UserAgent>,
         client_stats_id: String,
         input_sender: Sender<InputMessage>,
-        task_client: TaskClient,
+        shutdown: TaskClient,
     ) -> ClientStatsSender {
         info!("Starting statistics control...");
-        StatisticsControl::create_and_start(
+        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(),
-            task_client,
+            shutdown.with_suffix("controller"),
         )
     }
 
     fn start_mix_traffic_controller(
         gateway_transceiver: Box<dyn GatewayTransceiver + Send>,
         shutdown: TaskClient,
-    ) -> (BatchMixMessageSender, ClientRequestSender) {
+    ) -> BatchMixMessageSender {
         info!("Starting mix traffic controller...");
-        let (mix_traffic_controller, mix_tx, client_tx) =
-            MixTrafficController::new(gateway_transceiver, shutdown);
-        mix_traffic_controller.start();
-        (mix_tx, client_tx)
+        let (mix_traffic_controller, mix_tx) = MixTrafficController::new(gateway_transceiver);
+        mix_traffic_controller.start_with_shutdown(shutdown);
+        mix_tx
     }
 
     // TODO: rename it as it implies the data is persistent whilst one can use InMemBackend
@@ -680,7 +654,6 @@ where
         setup_method: GatewaySetup,
         key_store: &S::KeyStore,
         details_store: &S::GatewaysDetailsStore,
-        derivation_material: Option<DerivationMaterial>,
     ) -> Result<InitialisationResult, ClientCoreError>
     where
         <S::KeyStore as KeyStore>::StorageError: Sync + Send,
@@ -690,12 +663,7 @@ where
         if key_store.load_keys().await.is_err() {
             info!("could not find valid client keys - a new set will be generated");
             let mut rng = OsRng;
-            let keys = if let Some(derivation_material) = derivation_material {
-                ClientKeys::from_master_key(&mut rng, &derivation_material)
-                    .map_err(|_| ClientCoreError::HkdfDerivationError {})?
-            } else {
-                ClientKeys::generate_new(&mut rng)
-            };
+            let keys = ClientKeys::generate_new(&mut rng);
             store_client_keys(keys, key_store).await?;
         }
 
@@ -717,11 +685,11 @@ where
             self.setup_method,
             self.client_store.key_store(),
             self.client_store.gateway_details_store(),
-            self.derivation_material,
         )
         .await?;
 
-        let (reply_storage_backend, credential_store, _) = self.client_store.into_runtime_stores();
+        let (reply_storage_backend, credential_store, details_store) =
+            self.client_store.into_runtime_stores();
 
         // channels for inter-component communication
         // TODO: make the channels be internally created by the relevant components
@@ -740,8 +708,7 @@ where
 
         // channels responsible for controlling ack messages
         let (ack_sender, ack_receiver) = mpsc::unbounded();
-        let shared_topology_accessor =
-            TopologyAccessor::new(self.config.debug.topology.ignore_egress_epoch_role);
+        let shared_topology_accessor = TopologyAccessor::new();
 
         // Shutdown notifier for signalling tasks to stop
         let shutdown = self
@@ -773,7 +740,7 @@ where
         );
 
         let stats_reporter = Self::start_statistics_control(
-            &self.config,
+            self.config,
             self.user_agent.clone(),
             generate_client_stats_id(*self_address.identity()),
             input_sender.clone(),
@@ -799,13 +766,12 @@ where
 
         let gateway_transceiver = Self::setup_gateway_transceiver(
             self.custom_gateway_transceiver,
-            &self.config,
+            self.config,
             init_res,
             bandwidth_controller,
+            &details_store,
             gateway_packet_router,
             stats_reporter.clone(),
-            #[cfg(unix)]
-            self.connection_fd_callback,
             shutdown.fork("gateway_transceiver"),
         )
         .await?;
@@ -831,8 +797,7 @@ where
         // that are to be sent to the mixnet. They are used by cover traffic stream and real
         // traffic stream.
         // The MixTrafficController then sends the actual traffic
-
-        let (message_sender, client_request_sender) = Self::start_mix_traffic_controller(
+        let message_sender = Self::start_mix_traffic_controller(
             gateway_transceiver,
             shutdown.fork("mix_traffic_controller"),
         );
@@ -909,8 +874,6 @@ where
             },
             stats_reporter,
             task_handle: shutdown,
-            client_request_sender,
-            forget_me: self.config.debug.forget_me,
         })
     }
 }
@@ -922,7 +885,6 @@ pub struct BaseClient {
     pub client_output: ClientOutputStatus,
     pub client_state: ClientState,
     pub stats_reporter: ClientStatsSender,
-    pub client_request_sender: ClientRequestSender,
+
     pub task_handle: TaskHandle,
-    pub forget_me: ForgetMe,
 }

common/client-core/src/client/base_client/storage/migration_helpers.rs

@@ -2,11 +2,24 @@
 // SPDX-License-Identifier: Apache-2.0
 
 pub mod v1_1_33 {
+    use crate::client::base_client::{
+        non_wasm_helpers::setup_fs_gateways_storage,
+        storage::helpers::{set_active_gateway, store_gateway_details},
+    };
     use crate::config::disk_persistence::old_v1_1_33::CommonClientPathsV1_1_33;
     use crate::config::disk_persistence::CommonClientPaths;
     use crate::config::old_config_v1_1_33::OldGatewayEndpointConfigV1_1_33;
     use crate::error::ClientCoreError;
+    use nym_client_core_gateways_storage::{
+        CustomGatewayDetails, GatewayDetails, GatewayRegistration, RemoteGatewayDetails,
+    };
+    use nym_gateway_requests::shared_key::LegacySharedKeys;
     use serde::{Deserialize, Serialize};
+    use sha2::{digest::Digest, Sha256};
+    use std::ops::Deref;
+    use std::path::Path;
+    use std::sync::Arc;
+    use zeroize::Zeroizing;
 
     mod base64 {
         use base64::{engine::general_purpose::STANDARD, Engine as _};
@@ -44,18 +57,155 @@ pub mod v1_1_33 {
         details: OldGatewayEndpointConfigV1_1_33,
     }
 
+    impl PersistedGatewayConfig {
+        fn verify(&self, shared_key: &LegacySharedKeys) -> bool {
+            let key_bytes = Zeroizing::new(shared_key.to_bytes());
+
+            let mut key_hasher = Sha256::new();
+            key_hasher.update(&key_bytes);
+            let key_hash = key_hasher.finalize();
+
+            self.key_hash == key_hash.deref()
+        }
+    }
+
     #[derive(Debug, Clone, Serialize, Deserialize)]
     struct PersistedCustomGatewayDetails {
         gateway_id: String,
     }
 
+    fn load_shared_key<P: AsRef<Path>>(path: P) -> Result<LegacySharedKeys, ClientCoreError> {
+        // the shared key was a simple pem file
+        Ok(nym_pemstore::load_key(path)?)
+    }
+
+    fn gateway_details_from_raw(
+        gateway_id: String,
+        gateway_owner: String,
+        gateway_listener: String,
+        gateway_shared_key: LegacySharedKeys,
+    ) -> Result<GatewayDetails, ClientCoreError> {
+        Ok(GatewayDetails::Remote(RemoteGatewayDetails {
+            gateway_id: gateway_id
+                .parse()
+                .map_err(|err| ClientCoreError::UpgradeFailure {
+                    message: format!("the stored gateway id was malformed: {err}"),
+                })?,
+            shared_key: Arc::new(gateway_shared_key.into()),
+            gateway_owner_address: Some(gateway_owner.parse().map_err(|err| {
+                ClientCoreError::UpgradeFailure {
+                    message: format!("the stored gateway owner address was malformed: {err}"),
+                }
+            })?),
+            gateway_listener: gateway_listener.parse().map_err(|err| {
+                ClientCoreError::UpgradeFailure {
+                    message: format!("the stored gateway listener address was malformed: {err}"),
+                }
+            })?,
+        }))
+    }
+
+    // helper to extract shared key and gateway details into the new GatewayRegistration
+    fn extract_gateway_registration(
+        storage_paths: &CommonClientPathsV1_1_33,
+    ) -> Result<GatewayRegistration, ClientCoreError> {
+        let details_file = std::fs::File::open(&storage_paths.gateway_details).map_err(|err| {
+            ClientCoreError::UpgradeFailure {
+                message: format!(
+                    "failed to open gateway details file at {}: {err}",
+                    storage_paths.gateway_details.display()
+                ),
+            }
+        })?;
+
+        // in v1.1.33 of the clients, the gateway details struct was saved as json
+        let details: PersistedGatewayDetails =
+            serde_json::from_reader(details_file).map_err(|err| {
+                ClientCoreError::UpgradeFailure {
+                    message: format!(
+                        "failed to deserialize gateway details from {}: {err}",
+                        storage_paths.gateway_details.display()
+                    ),
+                }
+            })?;
+
+        let details = match details {
+            PersistedGatewayDetails::Default(config) => {
+                let gateway_shared_key =
+                    load_shared_key(&storage_paths.keys.gateway_shared_key_file)?;
+                if !config.verify(&gateway_shared_key) {
+                    return Err(ClientCoreError::UpgradeFailure {
+                        message: "failed to verify consistency of the existing gateway details"
+                            .to_string(),
+                    });
+                }
+                gateway_details_from_raw(
+                    config.details.gateway_id,
+                    config.details.gateway_owner,
+                    config.details.gateway_listener,
+                    gateway_shared_key,
+                )?
+            }
+            PersistedGatewayDetails::Custom(custom) => {
+                GatewayDetails::Custom(CustomGatewayDetails {
+                    gateway_id: custom.gateway_id.parse().map_err(|err| {
+                        ClientCoreError::UpgradeFailure {
+                            message: format!("the stored gateway id was malformed: {err}"),
+                        }
+                    })?,
+                    data: None,
+                })
+            }
+        };
+
+        Ok(details.into())
+    }
+
+    // it's responsibility of the caller to ensure this is called **after** new registration has already been saved
+    fn remove_old_gateway_details(storage_paths: &CommonClientPathsV1_1_33) -> std::io::Result<()> {
+        std::fs::remove_file(&storage_paths.gateway_details)?;
+
+        if storage_paths.keys.gateway_shared_key_file.exists() {
+            std::fs::remove_file(&storage_paths.keys.gateway_shared_key_file)?;
+        }
+        Ok(())
+    }
+
     pub async fn migrate_gateway_details(
-        _old_storage_paths: &CommonClientPathsV1_1_33,
-        _new_storage_paths: &CommonClientPaths,
-        _preloaded_config: Option<OldGatewayEndpointConfigV1_1_33>,
+        old_storage_paths: &CommonClientPathsV1_1_33,
+        new_storage_paths: &CommonClientPaths,
+        preloaded_config: Option<OldGatewayEndpointConfigV1_1_33>,
     ) -> Result<(), ClientCoreError> {
-        Err(ClientCoreError::UnsupportedMigration(
-            "migration of legacy keys has been removed and is no longer supported".into(),
-        ))
+        let gateway_registration = match preloaded_config {
+            Some(config) => {
+                let gateway_shared_key =
+                    load_shared_key(&old_storage_paths.keys.gateway_shared_key_file)?;
+                gateway_details_from_raw(
+                    config.gateway_id,
+                    config.gateway_owner,
+                    config.gateway_listener,
+                    gateway_shared_key,
+                )?
+                .into()
+            }
+            None => extract_gateway_registration(old_storage_paths)?,
+        };
+
+        // since we're migrating to a brand new store, the store should be empty
+        // and thus set the 'new' gateway as the active one
+        let details_store =
+            setup_fs_gateways_storage(&new_storage_paths.gateway_registrations).await?;
+        store_gateway_details(&details_store, &gateway_registration).await?;
+        set_active_gateway(
+            &details_store,
+            &gateway_registration.details.gateway_id().to_base58_string(),
+        )
+        .await?;
+
+        remove_old_gateway_details(old_storage_paths).map_err(|err| {
+            ClientCoreError::UpgradeFailure {
+                message: format!("failed to remove old data: {err}"),
+            }
+        })
     }
 }

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

@@ -4,8 +4,6 @@
 // TODO: combine those more closely. Perhaps into a single underlying store.
 // Like for persistent, on-disk, storage, what's the point of having 3 different databases?
 
-use rand::rngs::OsRng;
-
 use crate::client::key_manager::persistence::{InMemEphemeralKeys, KeyStore};
 use crate::client::replies::reply_storage;
 use crate::client::replies::reply_storage::ReplyStorageBackend;
@@ -65,7 +63,7 @@ pub trait MixnetClientStorage {
     fn gateway_details_store(&self) -> &Self::GatewaysDetailsStore;
 }
 
-#[derive(Clone)]
+#[derive(Default)]
 pub struct Ephemeral {
     key_store: InMemEphemeralKeys,
     reply_store: reply_storage::Empty,
@@ -73,14 +71,9 @@ pub struct Ephemeral {
     gateway_details_store: InMemGatewaysDetails,
 }
 
-impl Default for Ephemeral {
-    fn default() -> Self {
-        Ephemeral {
-            key_store: InMemEphemeralKeys::new(&mut OsRng),
-            reply_store: Default::default(),
-            credential_store: Default::default(),
-            gateway_details_store: Default::default(),
-        }
+impl Ephemeral {
+    pub fn new() -> Self {
+        Default::default()
     }
 }
 
@@ -121,7 +114,6 @@ impl MixnetClientStorage for Ephemeral {
     }
 }
 
-#[derive(Clone)]
 #[cfg(all(
     not(target_arch = "wasm32"),
     feature = "fs-surb-storage",

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

@@ -13,7 +13,6 @@ 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 nym_task::TaskClient;
 use rand::{rngs::OsRng, CryptoRng, Rng};
 use std::pin::Pin;
 use std::sync::Arc;
@@ -65,8 +64,6 @@ where
     packet_type: PacketType,
 
     stats_tx: ClientStatsSender,
-
-    task_client: TaskClient,
 }
 
 impl<R> Stream for LoopCoverTrafficStream<R>
@@ -113,7 +110,6 @@ impl LoopCoverTrafficStream<OsRng> {
         traffic_config: config::Traffic,
         cover_config: config::CoverTraffic,
         stats_tx: ClientStatsSender,
-        task_client: TaskClient,
     ) -> Self {
         let rng = OsRng;
 
@@ -132,7 +128,6 @@ impl LoopCoverTrafficStream<OsRng> {
             secondary_packet_size: traffic_config.secondary_packet_size,
             packet_type: traffic_config.packet_type,
             stats_tx,
-            task_client,
         }
     }
 
@@ -168,7 +163,6 @@ impl LoopCoverTrafficStream<OsRng> {
         // poisson delay, but is it really a problem?
         let topology_permit = self.topology_access.get_read_permit().await;
         // the ack is sent back to ourselves (and then ignored)
-
         let topology_ref = match topology_permit.try_get_valid_topology_ref(
             &self.our_full_destination,
             Some(&self.our_full_destination),
@@ -180,7 +174,7 @@ impl LoopCoverTrafficStream<OsRng> {
             }
         };
 
-        let cover_message = match generate_loop_cover_packet(
+        let cover_message = generate_loop_cover_packet(
             &mut self.rng,
             topology_ref,
             &self.ack_key,
@@ -189,15 +183,8 @@ impl LoopCoverTrafficStream<OsRng> {
             self.cover_traffic.loop_cover_traffic_average_delay,
             cover_traffic_packet_size,
             self.packet_type,
-        ) {
-            Ok(cover_message) => cover_message,
-            Err(err) => {
-                warn!(
-                    "Somehow failed to generate a loop cover message with a valid topology: {err}"
-                );
-                return;
-            }
-        };
+        )
+        .expect("Somehow failed to generate a loop cover message with a valid topology");
 
         if let Err(err) = self.mix_tx.try_send(vec![cover_message]) {
             match err {
@@ -229,7 +216,7 @@ impl LoopCoverTrafficStream<OsRng> {
         tokio::task::yield_now().await;
     }
 
-    pub fn start(mut self) {
+    pub fn start_with_shutdown(mut self, mut shutdown: nym_task::TaskClient) {
         if self.cover_traffic.disable_loop_cover_traffic_stream {
             // we should have never got here in the first place - the task should have never been created to begin with
             // so panic and review the code that lead to this branch
@@ -243,8 +230,6 @@ impl LoopCoverTrafficStream<OsRng> {
         );
         self.set_next_delay(sampled);
 
-        let mut shutdown = self.task_client.fork("select");
-
         spawn_future(async move {
             debug!("Started LoopCoverTrafficStream with graceful shutdown support");
 

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

@@ -28,6 +28,7 @@ pub enum InputMessage {
         recipient: Recipient,
         data: Vec<u8>,
         lane: TransmissionLane,
+        mix_hops: Option<u8>,
     },
 
     /// Creates a message used for a duplex anonymous communication where the recipient
@@ -43,6 +44,7 @@ pub enum InputMessage {
         data: Vec<u8>,
         reply_surbs: u32,
         lane: TransmissionLane,
+        mix_hops: Option<u8>,
     },
 
     /// Attempt to use our internally received and stored `ReplySurb` to send the message back
@@ -92,6 +94,29 @@ impl InputMessage {
             recipient,
             data,
             lane,
+            mix_hops: None,
+        };
+        if let Some(packet_type) = packet_type {
+            InputMessage::new_wrapper(message, packet_type)
+        } else {
+            message
+        }
+    }
+
+    // IMHO `new_regular` should take `mix_hops: Option<u8>` as an argument instead of creating
+    // this function, but that would potentially break backwards compatibility with the current API
+    pub fn new_regular_with_custom_hops(
+        recipient: Recipient,
+        data: Vec<u8>,
+        lane: TransmissionLane,
+        packet_type: Option<PacketType>,
+        mix_hops: Option<u8>,
+    ) -> Self {
+        let message = InputMessage::Regular {
+            recipient,
+            data,
+            lane,
+            mix_hops,
         };
         if let Some(packet_type) = packet_type {
             InputMessage::new_wrapper(message, packet_type)
@@ -112,6 +137,7 @@ impl InputMessage {
             data,
             reply_surbs,
             lane,
+            mix_hops: None,
         };
         if let Some(packet_type) = packet_type {
             InputMessage::new_wrapper(message, packet_type)
@@ -128,12 +154,14 @@ impl InputMessage {
         reply_surbs: u32,
         lane: TransmissionLane,
         packet_type: Option<PacketType>,
+        mix_hops: Option<u8>,
     ) -> Self {
         let message = InputMessage::Anonymous {
             recipient,
             data,
             reply_surbs,
             lane,
+            mix_hops,
         };
         if let Some(packet_type) = packet_type {
             InputMessage::new_wrapper(message, packet_type)

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

@@ -2,18 +2,14 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::client::key_manager::persistence::KeyStore;
-use nym_crypto::{
-    asymmetric::{encryption, identity},
-    hkdf::{DerivationMaterial, InvalidLength},
-};
-use nym_gateway_requests::shared_key::SharedSymmetricKey;
+use nym_crypto::asymmetric::{encryption, identity};
+use nym_gateway_requests::shared_key::{LegacySharedKeys, SharedGatewayKey, SharedSymmetricKey};
 use nym_sphinx::acknowledgements::AckKey;
 use rand::{CryptoRng, RngCore};
 use std::sync::Arc;
 use zeroize::ZeroizeOnDrop;
 
 pub mod persistence;
-mod test;
 
 // Note: to support key rotation in the future, all keys will require adding an extra smart pointer,
 // most likely an AtomicCell, or if it doesn't work as I think it does, a Mutex. Although I think
@@ -47,24 +43,6 @@ impl ClientKeys {
         }
     }
 
-    pub fn from_master_key<R>(
-        rng: &mut R,
-        derivation_material: &DerivationMaterial,
-    ) -> Result<Self, InvalidLength>
-    where
-        R: RngCore + CryptoRng,
-    {
-        let secret = derivation_material.derive_secret()?;
-        Ok(ClientKeys {
-            identity_keypair: Arc::new(identity::KeyPair::from_secret(
-                secret,
-                derivation_material.index(),
-            )),
-            encryption_keypair: Arc::new(encryption::KeyPair::new(rng)),
-            ack_key: Arc::new(AckKey::new(rng)),
-        })
-    }
-
     pub fn from_keys(
         id_keypair: identity::KeyPair,
         enc_keypair: encryption::KeyPair,
@@ -106,5 +84,7 @@ fn _assert_keys_zeroize_on_drop() {
     _assert_zeroize_on_drop::<identity::KeyPair>();
     _assert_zeroize_on_drop::<encryption::KeyPair>();
     _assert_zeroize_on_drop::<AckKey>();
+    _assert_zeroize_on_drop::<LegacySharedKeys>();
     _assert_zeroize_on_drop::<SharedSymmetricKey>();
+    _assert_zeroize_on_drop::<SharedGatewayKey>();
 }

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

@@ -3,9 +3,7 @@
 
 use crate::client::key_manager::ClientKeys;
 use async_trait::async_trait;
-use rand::{CryptoRng, RngCore};
 use std::error::Error;
-use std::sync::Arc;
 use tokio::sync::Mutex;
 
 #[cfg(not(target_arch = "wasm32"))]
@@ -66,7 +64,6 @@ pub enum OnDiskKeysError {
     },
 }
 
-#[derive(Clone)]
 #[cfg(not(target_arch = "wasm32"))]
 pub struct OnDiskKeys {
     paths: ClientKeysPaths,
@@ -196,20 +193,9 @@ impl KeyStore for OnDiskKeys {
     }
 }
 
-#[derive(Clone)]
+#[derive(Default)]
 pub struct InMemEphemeralKeys {
-    keys: Arc<Mutex<ClientKeys>>,
-}
-
-impl InMemEphemeralKeys {
-    pub fn new<R>(rng: &mut R) -> Self
-    where
-        R: RngCore + CryptoRng,
-    {
-        InMemEphemeralKeys {
-            keys: Arc::new(Mutex::new(ClientKeys::generate_new(rng))),
-        }
-    }
+    keys: Mutex<Option<ClientKeys>>,
 }
 
 #[derive(Debug, thiserror::Error)]
@@ -222,11 +208,11 @@ impl KeyStore for InMemEphemeralKeys {
     type StorageError = EphemeralKeysError;
 
     async fn load_keys(&self) -> Result<ClientKeys, Self::StorageError> {
-        Ok(self.keys.lock().await.clone())
+        self.keys.lock().await.clone().ok_or(EphemeralKeysError)
     }
 
     async fn store_keys(&self, keys: &ClientKeys) -> Result<(), Self::StorageError> {
-        *self.keys.lock().await = keys.clone();
+        *self.keys.lock().await = Some(keys.clone());
         Ok(())
     }
 }

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

@@ -1,89 +0,0 @@
-#[cfg(test)]
-mod tests {
-    use crate::client::key_manager::ClientKeys;
-    use nym_crypto::hkdf::DerivationMaterial;
-    use rand::SeedableRng;
-    use rand_chacha::ChaCha20Rng;
-
-    #[test]
-    fn test_from_master_key_success() {
-        // Set up a deterministic RNG.
-        let seed = [33u8; 32];
-        let mut rng = ChaCha20Rng::from_seed(seed);
-
-        // Set up the derivation material.
-        let master_key = b"this is a secret master key";
-        let salt = b"unique-salt";
-        let derivation_material = DerivationMaterial::new(master_key, 0, salt);
-
-        // Generate ClientKeys from the master key.
-        let client_keys = ClientKeys::from_master_key(&mut rng, &derivation_material)
-            .expect("Failed to create client keys");
-
-        assert_eq!(
-            client_keys.identity_keypair().public_key().to_string(),
-            String::from("FX4Undr5LPPBA7zThWWpAKXKQTXSbW1C28PnxbCqUkU4")
-        );
-
-        assert_eq!(
-            client_keys.identity_keypair().private_key().to_string(),
-            String::from("6S3uMi2rU5SwyUUYCiMrF5qqdcYnEDMYLggBSvavVzEt")
-        );
-    }
-
-    #[test]
-    fn test_from_master_key_deterministic_identity() {
-        // Using identical derivation material should result in the exactly same identity keypair.
-        let seed = [1u8; 32];
-        let mut rng1 = ChaCha20Rng::from_seed(seed);
-        let mut rng2 = ChaCha20Rng::from_seed(seed);
-
-        let master_key = b"another secret master key";
-        let salt = b"deterministic-salt";
-        let index = 7u32;
-        let derivation_material = DerivationMaterial::new(master_key, index, salt);
-
-        let client_keys1 = ClientKeys::from_master_key(&mut rng1, &derivation_material)
-            .expect("Failed to create client keys (first instance)");
-        let client_keys2 = ClientKeys::from_master_key(&mut rng2, &derivation_material)
-            .expect("Failed to create client keys (second instance)");
-
-        assert_eq!(
-            client_keys1.identity_keypair().public_key().to_string(),
-            client_keys2.identity_keypair().public_key().to_string()
-        );
-
-        assert_eq!(
-            client_keys1.identity_keypair().private_key().to_string(),
-            client_keys2.identity_keypair().private_key().to_string()
-        );
-    }
-
-    #[test]
-    fn test_from_master_key_different_indices() {
-        // Changing the index should yield a different identity key.
-        let seed = [5u8; 32];
-        let mut rng = ChaCha20Rng::from_seed(seed);
-
-        let master_key = b"same secret key";
-        let salt = b"same-salt";
-
-        let derivation_material1 = DerivationMaterial::new(master_key, 1, salt);
-        let derivation_material2 = DerivationMaterial::new(master_key, 2, salt);
-
-        let client_keys1 = ClientKeys::from_master_key(&mut rng, &derivation_material1)
-            .expect("Failed to create client keys for index 1");
-        let client_keys2 = ClientKeys::from_master_key(&mut rng, &derivation_material2)
-            .expect("Failed to create client keys for index 2");
-
-        assert_ne!(
-            client_keys1.identity_keypair().public_key().to_string(),
-            client_keys2.identity_keypair().public_key().to_string()
-        );
-
-        assert_ne!(
-            client_keys1.identity_keypair().private_key().to_string(),
-            client_keys2.identity_keypair().private_key().to_string()
-        );
-    }
-}

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

@@ -2,18 +2,12 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::client::mix_traffic::transceiver::GatewayTransceiver;
-use crate::error::ClientCoreError;
 use crate::spawn_future;
 use log::*;
-use nym_gateway_requests::ClientRequest;
 use nym_sphinx::forwarding::packet::MixPacket;
-use nym_task::TaskClient;
-use transceiver::ErasedGatewayError;
 
 pub type BatchMixMessageSender = tokio::sync::mpsc::Sender<Vec<MixPacket>>;
 pub type BatchMixMessageReceiver = tokio::sync::mpsc::Receiver<Vec<MixPacket>>;
-pub type ClientRequestReceiver = tokio::sync::mpsc::Receiver<ClientRequest>;
-pub type ClientRequestSender = tokio::sync::mpsc::Sender<ClientRequest>;
 
 pub mod transceiver;
 
@@ -28,73 +22,45 @@ pub struct MixTrafficController {
     gateway_transceiver: Box<dyn GatewayTransceiver + Send>,
 
     mix_rx: BatchMixMessageReceiver,
-    client_rx: ClientRequestReceiver,
 
     // TODO: this is temporary work-around.
     // in long run `gateway_client` will be moved away from `MixTrafficController` anyway.
     consecutive_gateway_failure_count: usize,
-
-    task_client: TaskClient,
 }
 
 impl MixTrafficController {
-    pub fn new<T>(
-        gateway_transceiver: T,
-        task_client: TaskClient,
-    ) -> (
-        MixTrafficController,
-        BatchMixMessageSender,
-        ClientRequestSender,
-    )
+    pub fn new<T>(gateway_transceiver: T) -> (MixTrafficController, BatchMixMessageSender)
     where
         T: GatewayTransceiver + Send + 'static,
     {
         let (message_sender, message_receiver) =
             tokio::sync::mpsc::channel(MIX_MESSAGE_RECEIVER_BUFFER_SIZE);
-
-        let (client_sender, client_receiver) = tokio::sync::mpsc::channel(1);
-
         (
             MixTrafficController {
                 gateway_transceiver: Box::new(gateway_transceiver),
                 mix_rx: message_receiver,
-                client_rx: client_receiver,
                 consecutive_gateway_failure_count: 0,
-                task_client,
             },
             message_sender,
-            client_sender,
         )
     }
 
     pub fn new_dynamic(
         gateway_transceiver: Box<dyn GatewayTransceiver + Send>,
-        task_client: TaskClient,
-    ) -> (
-        MixTrafficController,
-        BatchMixMessageSender,
-        ClientRequestSender,
-    ) {
+    ) -> (MixTrafficController, BatchMixMessageSender) {
         let (message_sender, message_receiver) =
             tokio::sync::mpsc::channel(MIX_MESSAGE_RECEIVER_BUFFER_SIZE);
-        let (client_sender, client_receiver) = tokio::sync::mpsc::channel(1);
         (
             MixTrafficController {
                 gateway_transceiver,
                 mix_rx: message_receiver,
-                client_rx: client_receiver,
                 consecutive_gateway_failure_count: 0,
-                task_client,
             },
             message_sender,
-            client_sender,
         )
     }
 
-    async fn on_messages(
-        &mut self,
-        mut mix_packets: Vec<MixPacket>,
-    ) -> Result<(), ErasedGatewayError> {
+    async fn on_messages(&mut self, mut mix_packets: Vec<MixPacket>) {
         debug_assert!(!mix_packets.is_empty());
 
         let result = if mix_packets.len() == 1 {
@@ -106,62 +72,46 @@ impl MixTrafficController {
                 .await
         };
 
-        if result.is_err() {
-            self.consecutive_gateway_failure_count += 1;
-        } else {
-            trace!("We *might* have managed to forward sphinx packet(s) to the gateway!");
-            self.consecutive_gateway_failure_count = 0;
+        match result {
+            Err(err) => {
+                error!("Failed to send sphinx packet(s) to the gateway: {err}");
+                self.consecutive_gateway_failure_count += 1;
+                if self.consecutive_gateway_failure_count == MAX_FAILURE_COUNT {
+                    // todo: in the future this should initiate a 'graceful' shutdown or try
+                    // to reconnect?
+                    panic!("failed to send sphinx packet to the gateway {MAX_FAILURE_COUNT} times in a row - assuming the gateway is dead. Can't do anything about it yet :(")
+                }
+            }
+            Ok(_) => {
+                trace!("We *might* have managed to forward sphinx packet(s) to the gateway!");
+                self.consecutive_gateway_failure_count = 0;
+            }
         }
-
-        result
     }
 
-    pub fn start(mut self) {
+    pub fn start_with_shutdown(mut self, mut shutdown: nym_task::TaskClient) {
         spawn_future(async move {
             debug!("Started MixTrafficController with graceful shutdown support");
 
-            while !self.task_client.is_shutdown() {
+            loop {
                 tokio::select! {
                     mix_packets = self.mix_rx.recv() => match mix_packets {
                         Some(mix_packets) => {
-                            if let Err(err) = self.on_messages(mix_packets).await {
-                                error!("Failed to send sphinx packet(s) to the gateway: {err}");
-                                if self.consecutive_gateway_failure_count == MAX_FAILURE_COUNT {
-                                    // Disconnect from the gateway. If we should try to re-connect
-                                    // is handled at a higher layer.
-                                    error!("Failed to send sphinx packet to the gateway {MAX_FAILURE_COUNT} times in a row - assuming the gateway is dead");
-                                    // Do we need to handle the embedded mixnet client case
-                                    // separately?
-                                    self.task_client.send_we_stopped(Box::new(ClientCoreError::GatewayFailedToForwardMessages));
-                                    break;
-                                }
-                            }
+                            self.on_messages(mix_packets).await;
                         },
                         None => {
                             log::trace!("MixTrafficController: Stopping since channel closed");
                             break;
                         }
                     },
-                    client_request = self.client_rx.recv() => match client_request {
-                        Some(client_request) => {
-                            match self.gateway_transceiver.send_client_request(client_request).await {
-                                Ok(_) => (),
-                                Err(e) => error!("Failed to send client request: {}", e),
-                            };
-                        },
-                        None => {
-                            log::trace!("MixTrafficController, client request channel closed");
-                        }
-                    },
-                    _ = self.task_client.recv() => {
+                    _ = shutdown.recv_with_delay() => {
                         log::trace!("MixTrafficController: Received shutdown");
                         break;
                     }
                 }
             }
-            self.task_client.recv_timeout().await;
-
+            shutdown.recv_timeout().await;
             log::debug!("MixTrafficController: Exiting");
-        });
+        })
     }
 }

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

@@ -5,10 +5,8 @@ use async_trait::async_trait;
 use log::{debug, error};
 use nym_credential_storage::storage::Storage as CredentialStorage;
 use nym_crypto::asymmetric::identity;
-use nym_gateway_client::error::GatewayClientError;
 use nym_gateway_client::GatewayClient;
 pub use nym_gateway_client::{GatewayPacketRouter, PacketRouter};
-use nym_gateway_requests::ClientRequest;
 use nym_sphinx::forwarding::packet::MixPacket;
 use nym_validator_client::nyxd::contract_traits::DkgQueryClient;
 use std::fmt::Debug;
@@ -28,14 +26,9 @@ fn erase_err<E: std::error::Error + Send + Sync + 'static>(err: E) -> ErasedGate
 }
 
 /// This combines combines the functionalities of being able to send and receive mix packets.
-#[async_trait]
 pub trait GatewayTransceiver: GatewaySender + GatewayReceiver {
     fn gateway_identity(&self) -> identity::PublicKey;
     fn ws_fd(&self) -> Option<RawFd>;
-    async fn send_client_request(
-        &mut self,
-        message: ClientRequest,
-    ) -> Result<(), GatewayClientError>;
 }
 
 /// This trait defines the functionality of sending `MixPacket` into the mixnet,
@@ -72,7 +65,6 @@ pub trait GatewayReceiver {
 }
 
 // to allow for dynamic dispatch
-#[async_trait]
 impl<G: GatewayTransceiver + ?Sized + Send> GatewayTransceiver for Box<G> {
     #[inline]
     fn gateway_identity(&self) -> identity::PublicKey {
@@ -81,15 +73,6 @@ impl<G: GatewayTransceiver + ?Sized + Send> GatewayTransceiver for Box<G> {
     fn ws_fd(&self) -> Option<RawFd> {
         (**self).ws_fd()
     }
-
-    async fn send_client_request(
-        &mut self,
-        message: ClientRequest,
-    ) -> Result<(), GatewayClientError> {
-        let _ = (**self).send_client_request(message.clone()).await?;
-        log::debug!("Sent client request: {:?}", message);
-        Ok(())
-    }
 }
 
 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
@@ -108,6 +91,7 @@ impl<G: GatewaySender + ?Sized + Send> GatewaySender for Box<G> {
         (**self).batch_send_mix_packets(packets).await
     }
 }
+
 impl<G: GatewayReceiver + ?Sized> GatewayReceiver for Box<G> {
     #[inline]
     fn set_packet_router(&mut self, packet_router: PacketRouter) -> Result<(), ErasedGatewayError> {
@@ -127,7 +111,6 @@ impl<C, St> RemoteGateway<C, St> {
     }
 }
 
-#[async_trait]
 impl<C, St> GatewayTransceiver for RemoteGateway<C, St>
 where
     C: DkgQueryClient + Send + Sync,
@@ -140,13 +123,6 @@ where
     fn ws_fd(&self) -> Option<RawFd> {
         self.gateway_client.ws_fd()
     }
-
-    async fn send_client_request(
-        &mut self,
-        message: ClientRequest,
-    ) -> Result<(), GatewayClientError> {
-        self.gateway_client.send_client_request(message).await
-    }
 }
 
 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
@@ -219,7 +195,6 @@ impl LocalGateway {
 mod nonwasm_sealed {
     use super::*;
 
-    #[async_trait]
     impl GatewayTransceiver for LocalGateway {
         fn gateway_identity(&self) -> identity::PublicKey {
             self.local_identity
@@ -227,13 +202,6 @@ mod nonwasm_sealed {
         fn ws_fd(&self) -> Option<RawFd> {
             None
         }
-
-        async fn send_client_request(
-            &mut self,
-            _message: ClientRequest,
-        ) -> Result<(), GatewayClientError> {
-            Ok(())
-        }
     }
 
     #[async_trait]
@@ -301,7 +269,6 @@ impl GatewaySender for MockGateway {
     }
 }
 
-#[async_trait]
 impl GatewayTransceiver for MockGateway {
     fn gateway_identity(&self) -> identity::PublicKey {
         self.dummy_identity
@@ -309,11 +276,4 @@ impl GatewayTransceiver for MockGateway {
     fn ws_fd(&self) -> Option<RawFd> {
         None
     }
-
-    async fn send_client_request(
-        &mut self,
-        _message: ClientRequest,
-    ) -> Result<(), GatewayClientError> {
-        Ok(())
-    }
 }

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

@@ -11,7 +11,6 @@ use nym_sphinx::{
     acknowledgements::{identifier::recover_identifier, AckKey},
     chunking::fragment::{FragmentIdentifier, COVER_FRAG_ID},
 };
-use nym_task::TaskClient;
 use std::sync::Arc;
 
 /// Module responsible for listening for any data resembling acknowledgements from the network
@@ -21,7 +20,6 @@ pub(super) struct AcknowledgementListener {
     ack_receiver: AcknowledgementReceiver,
     action_sender: AckActionSender,
     stats_tx: ClientStatsSender,
-    task_client: TaskClient,
 }
 
 impl AcknowledgementListener {
@@ -30,14 +28,12 @@ impl AcknowledgementListener {
         ack_receiver: AcknowledgementReceiver,
         action_sender: AckActionSender,
         stats_tx: ClientStatsSender,
-        task_client: TaskClient,
     ) -> Self {
         AcknowledgementListener {
             ack_key,
             ack_receiver,
             action_sender,
             stats_tx,
-            task_client,
         }
     }
 
@@ -68,14 +64,9 @@ impl AcknowledgementListener {
         trace!("Received {} from the mix network", frag_id);
         self.stats_tx
             .report(PacketStatisticsEvent::RealAckReceived(ack_content.len()).into());
-        if let Err(err) = self
-            .action_sender
+        self.action_sender
             .unbounded_send(Action::new_remove(frag_id))
-        {
-            if !self.task_client.is_shutdown_poll() {
-                error!("Failed to send remove action to action controller: {err}");
-            }
-        }
+            .unwrap();
     }
 
     async fn handle_ack_receiver_item(&mut self, item: Vec<Vec<u8>>) {
@@ -85,10 +76,10 @@ impl AcknowledgementListener {
         }
     }
 
-    pub(super) async fn run(&mut self) {
+    pub(super) async fn run_with_shutdown(&mut self, mut shutdown: nym_task::TaskClient) {
         debug!("Started AcknowledgementListener with graceful shutdown support");
 
-        while !self.task_client.is_shutdown() {
+        while !shutdown.is_shutdown() {
             tokio::select! {
                 acks = self.ack_receiver.next() => match acks {
                     Some(acks) => self.handle_ack_receiver_item(acks).await,
@@ -97,12 +88,12 @@ impl AcknowledgementListener {
                         break;
                     }
                 },
-                _ = self.task_client.recv() => {
+                _ = shutdown.recv_with_delay() => {
                     log::trace!("AcknowledgementListener: Received shutdown");
                 }
             }
         }
-        self.task_client.recv_timeout().await;
+        shutdown.recv_timeout().await;
         log::debug!("AcknowledgementListener: Exiting");
     }
 }

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

@@ -9,7 +9,6 @@ use log::*;
 use nym_nonexhaustive_delayqueue::{Expired, NonExhaustiveDelayQueue, QueueKey};
 use nym_sphinx::chunking::fragment::FragmentIdentifier;
 use nym_sphinx::Delay as SphinxDelay;
-use nym_task::TaskClient;
 use std::collections::HashMap;
 use std::sync::Arc;
 use std::time::Duration;
@@ -102,8 +101,6 @@ pub(super) struct ActionController {
 
     /// Channel for notifying `RetransmissionRequestListener` about expired acknowledgements.
     retransmission_sender: RetransmissionRequestSender,
-
-    task_client: TaskClient,
 }
 
 impl ActionController {
@@ -111,7 +108,6 @@ impl ActionController {
         config: Config,
         retransmission_sender: RetransmissionRequestSender,
         incoming_actions: AckActionReceiver,
-        task_client: TaskClient,
     ) -> Self {
         ActionController {
             config,
@@ -119,7 +115,6 @@ impl ActionController {
             pending_acks_timers: NonExhaustiveDelayQueue::new(),
             incoming_actions,
             retransmission_sender,
-            task_client,
         }
     }
 
@@ -221,7 +216,11 @@ impl ActionController {
     }
 
     // note: when the entry expires it's automatically removed from pending_acks_timers
-    fn handle_expired_ack_timer(&mut self, expired_ack: Expired<FragmentIdentifier>) {
+    fn handle_expired_ack_timer(
+        &mut self,
+        expired_ack: Expired<FragmentIdentifier>,
+        task_client: &mut nym_task::TaskClient,
+    ) {
         // I'm honestly not sure how to handle it, because getting it means other things in our
         // system are already misbehaving. If we ever see this panic, then I guess we should worry
         // about it. Perhaps just reschedule it at later point?
@@ -239,13 +238,15 @@ impl ActionController {
             // downgrading an arc and then upgrading vs cloning is difference of 30ns vs 15ns
             // so it's literally a NO difference while it might prevent us from unnecessarily
             // resending data (in maybe 1 in 1 million cases, but it's something)
-            if let Err(err) = self
+            if self
                 .retransmission_sender
                 .unbounded_send(Arc::downgrade(pending_ack_data))
+                .is_err()
             {
-                if !self.task_client.is_shutdown_poll() {
-                    log::error!("Failed to send pending ack for retransmission: {err}");
-                }
+                assert!(
+                    task_client.is_shutdown_poll(),
+                    "Failed to send pending ack for retransmission"
+                );
             }
         } else {
             // this shouldn't cause any issues but shouldn't have happened to begin with!
@@ -264,10 +265,10 @@ impl ActionController {
         }
     }
 
-    pub(super) async fn run(&mut self) {
+    pub(super) async fn run_with_shutdown(&mut self, mut shutdown: nym_task::TaskClient) {
         debug!("Started ActionController with graceful shutdown support");
 
-        while !self.task_client.is_shutdown() {
+        loop {
             tokio::select! {
                 action = self.incoming_actions.next() => match action {
                     Some(action) => self.process_action(action),
@@ -279,19 +280,19 @@ impl ActionController {
                     }
                 },
                 expired_ack = self.pending_acks_timers.next() => match expired_ack {
-                    Some(expired_ack) => self.handle_expired_ack_timer(expired_ack),
+                    Some(expired_ack) => self.handle_expired_ack_timer(expired_ack, &mut shutdown),
                     None => {
                         log::trace!("ActionController: Stopping since ack channel closed");
                         break;
                     }
                 },
-                _ = self.task_client.recv() => {
+                _ = shutdown.recv_with_delay() => {
                     log::trace!("ActionController: Received shutdown");
                     break;
                 }
             }
         }
-        self.task_client.recv_timeout().await;
+        shutdown.recv_timeout().await;
         log::debug!("ActionController: Exiting");
     }
 }

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

@@ -11,7 +11,6 @@ use nym_sphinx::anonymous_replies::requests::AnonymousSenderTag;
 use nym_sphinx::forwarding::packet::MixPacket;
 use nym_sphinx::params::PacketType;
 use nym_task::connections::TransmissionLane;
-use nym_task::TaskClient;
 use rand::{CryptoRng, Rng};
 
 /// Module responsible for dealing with the received messages: splitting them, creating acknowledgements,
@@ -24,7 +23,6 @@ where
     input_receiver: InputMessageReceiver,
     message_handler: MessageHandler<R>,
     reply_controller_sender: ReplyControllerSender,
-    task_client: TaskClient,
 }
 
 impl<R> InputMessageListener<R>
@@ -38,13 +36,11 @@ where
         input_receiver: InputMessageReceiver,
         message_handler: MessageHandler<R>,
         reply_controller_sender: ReplyControllerSender,
-        task_client: TaskClient,
     ) -> Self {
         InputMessageListener {
             input_receiver,
             message_handler,
             reply_controller_sender,
-            task_client,
         }
     }
 
@@ -67,14 +63,8 @@ where
         lane: TransmissionLane,
     ) {
         // offload reply handling to the dedicated task
-        if let Err(err) = self
-            .reply_controller_sender
+        self.reply_controller_sender
             .send_reply(recipient_tag, data, lane)
-        {
-            if !self.task_client.is_shutdown_poll() {
-                error!("failed to send a reply - {err}");
-            }
-        }
     }
 
     async fn handle_plain_message(
@@ -83,10 +73,11 @@ where
         content: Vec<u8>,
         lane: TransmissionLane,
         packet_type: PacketType,
+        mix_hops: Option<u8>,
     ) {
         if let Err(err) = self
             .message_handler
-            .try_send_plain_message(recipient, content, lane, packet_type)
+            .try_send_plain_message(recipient, content, lane, packet_type, mix_hops)
             .await
         {
             warn!("failed to send a plain message - {err}")
@@ -100,10 +91,18 @@ where
         reply_surbs: u32,
         lane: TransmissionLane,
         packet_type: PacketType,
+        mix_hops: Option<u8>,
     ) {
         if let Err(err) = self
             .message_handler
-            .try_send_message_with_reply_surbs(recipient, content, reply_surbs, lane, packet_type)
+            .try_send_message_with_reply_surbs(
+                recipient,
+                content,
+                reply_surbs,
+                lane,
+                packet_type,
+                mix_hops,
+            )
             .await
         {
             warn!("failed to send a repliable message - {err}")
@@ -116,8 +115,9 @@ where
                 recipient,
                 data,
                 lane,
+                mix_hops,
             } => {
-                self.handle_plain_message(recipient, data, lane, PacketType::Mix)
+                self.handle_plain_message(recipient, data, lane, PacketType::Mix, mix_hops)
                     .await
             }
             InputMessage::Anonymous {
@@ -125,9 +125,17 @@ where
                 data,
                 reply_surbs,
                 lane,
+                mix_hops,
             } => {
-                self.handle_repliable_message(recipient, data, reply_surbs, lane, PacketType::Mix)
-                    .await
+                self.handle_repliable_message(
+                    recipient,
+                    data,
+                    reply_surbs,
+                    lane,
+                    PacketType::Mix,
+                    mix_hops,
+                )
+                .await
             }
             InputMessage::Reply {
                 recipient_tag,
@@ -145,8 +153,9 @@ where
                     recipient,
                     data,
                     lane,
+                    mix_hops,
                 } => {
-                    self.handle_plain_message(recipient, data, lane, packet_type)
+                    self.handle_plain_message(recipient, data, lane, packet_type, mix_hops)
                         .await
                 }
                 InputMessage::Anonymous {
@@ -154,9 +163,17 @@ where
                     data,
                     reply_surbs,
                     lane,
+                    mix_hops,
                 } => {
-                    self.handle_repliable_message(recipient, data, reply_surbs, lane, packet_type)
-                        .await
+                    self.handle_repliable_message(
+                        recipient,
+                        data,
+                        reply_surbs,
+                        lane,
+                        packet_type,
+                        mix_hops,
+                    )
+                    .await
                 }
                 InputMessage::Reply {
                     recipient_tag,
@@ -174,10 +191,10 @@ where
         };
     }
 
-    pub(super) async fn run(&mut self) {
+    pub(super) async fn run_with_shutdown(&mut self, mut shutdown: nym_task::TaskClient) {
         debug!("Started InputMessageListener with graceful shutdown support");
 
-        while !self.task_client.is_shutdown() {
+        while !shutdown.is_shutdown() {
             tokio::select! {
                 input_msg = self.input_receiver.recv() => match input_msg {
                     Some(input_msg) => {
@@ -188,12 +205,12 @@ where
                         break;
                     }
                 },
-                _ = self.task_client.recv() => {
+                _ = shutdown.recv_with_delay() => {
                     log::trace!("InputMessageListener: Received shutdown");
                 }
             }
         }
-        self.task_client.recv_timeout().await;
+        shutdown.recv_timeout().await;
         log::debug!("InputMessageListener: Exiting");
     }
 }

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

@@ -24,7 +24,6 @@ use nym_sphinx::{
     Delay as SphinxDelay,
 };
 use nym_statistics_common::clients::ClientStatsSender;
-use nym_task::TaskClient;
 use rand::{CryptoRng, Rng};
 use std::{
     sync::{Arc, Weak},
@@ -67,10 +66,11 @@ pub(crate) enum PacketDestination {
 
 /// Structure representing a data `Fragment` that is on-route to the specified `Recipient`
 #[derive(Debug)]
-pub struct PendingAcknowledgement {
+pub(crate) struct PendingAcknowledgement {
     message_chunk: Fragment,
     delay: SphinxDelay,
     destination: PacketDestination,
+    mix_hops: Option<u8>,
     retransmissions: u32,
 }
 
@@ -80,11 +80,13 @@ impl PendingAcknowledgement {
         message_chunk: Fragment,
         delay: SphinxDelay,
         recipient: Recipient,
+        mix_hops: Option<u8>,
     ) -> Self {
         PendingAcknowledgement {
             message_chunk,
             delay,
             destination: PacketDestination::KnownRecipient(recipient.into()),
+            mix_hops,
             retransmissions: 0,
         }
     }
@@ -102,6 +104,9 @@ impl PendingAcknowledgement {
                 recipient_tag,
                 extra_surb_request,
             },
+            // 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,
         }
     }
@@ -217,7 +222,6 @@ where
         message_handler: MessageHandler<R>,
         reply_controller_sender: ReplyControllerSender,
         stats_tx: ClientStatsSender,
-        task_client: TaskClient,
     ) -> Self {
         let (retransmission_tx, retransmission_rx) = mpsc::unbounded();
 
@@ -227,7 +231,6 @@ where
             action_config,
             retransmission_tx,
             connectors.ack_action_receiver,
-            task_client.fork("action_controller"),
         );
 
         // will listen for any acks coming from the network
@@ -236,7 +239,6 @@ where
             connectors.ack_receiver,
             connectors.ack_action_sender.clone(),
             stats_tx,
-            task_client.fork("acknowledgement_listener"),
         );
 
         // will listen for any new messages from the client
@@ -244,7 +246,6 @@ where
             connectors.input_receiver,
             message_handler.clone(),
             reply_controller_sender.clone(),
-            task_client.fork("input_message_listener"),
         );
 
         // will listen for any ack timeouts and trigger retransmission
@@ -254,16 +255,12 @@ where
             message_handler,
             retransmission_rx,
             reply_controller_sender,
-            task_client.fork("retransmission_request_listener"),
         );
 
         // will listen for events indicating the packet was sent through the network so that
         // the retransmission timer should be started.
-        let sent_notification_listener = SentNotificationListener::new(
-            connectors.sent_notifier,
-            connectors.ack_action_sender,
-            task_client.with_suffix("sent_notification_listener"),
-        );
+        let sent_notification_listener =
+            SentNotificationListener::new(connectors.sent_notifier, connectors.ack_action_sender);
 
         AcknowledgementController {
             acknowledgement_listener,
@@ -274,35 +271,53 @@ where
         }
     }
 
-    pub(super) fn start(self, packet_type: PacketType) {
+    pub(super) fn start_with_shutdown(
+        self,
+        shutdown: nym_task::TaskClient,
+        packet_type: PacketType,
+    ) {
         let mut acknowledgement_listener = self.acknowledgement_listener;
         let mut input_message_listener = self.input_message_listener;
         let mut retransmission_request_listener = self.retransmission_request_listener;
         let mut sent_notification_listener = self.sent_notification_listener;
         let mut action_controller = self.action_controller;
 
+        let shutdown_handle = shutdown.fork("acknowledgement_listener");
         spawn_future(async move {
-            acknowledgement_listener.run().await;
+            acknowledgement_listener
+                .run_with_shutdown(shutdown_handle)
+                .await;
             debug!("The acknowledgement listener has finished execution!");
         });
 
+        let shutdown_handle = shutdown.fork("input_message_listener");
         spawn_future(async move {
-            input_message_listener.run().await;
+            input_message_listener
+                .run_with_shutdown(shutdown_handle)
+                .await;
             debug!("The input listener has finished execution!");
         });
 
+        let shutdown_handle = shutdown.fork("retransmission_request_listener");
         spawn_future(async move {
-            retransmission_request_listener.run(packet_type).await;
+            retransmission_request_listener
+                .run_with_shutdown(shutdown_handle, packet_type)
+                .await;
             debug!("The retransmission request listener has finished execution!");
         });
 
+        let shutdown_handle = shutdown.fork("sent_notification_listener");
         spawn_future(async move {
-            sent_notification_listener.run().await;
+            sent_notification_listener
+                .run_with_shutdown(shutdown_handle)
+                .await;
             debug!("The sent notification listener has finished execution!");
         });
 
         spawn_future(async move {
-            action_controller.run().await;
+            action_controller
+                .run_with_shutdown(shutdown.with_suffix("action_controller"))
+                .await;
             debug!("The controller has finished execution!");
         });
     }

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

@@ -14,7 +14,7 @@ use log::*;
 use nym_sphinx::chunking::fragment::Fragment;
 use nym_sphinx::preparer::PreparedFragment;
 use nym_sphinx::{addressing::clients::Recipient, params::PacketType};
-use nym_task::{connections::TransmissionLane, TaskClient};
+use nym_task::connections::TransmissionLane;
 use rand::{CryptoRng, Rng};
 use std::sync::{Arc, Weak};
 
@@ -25,7 +25,6 @@ pub(super) struct RetransmissionRequestListener<R> {
     message_handler: MessageHandler<R>,
     request_receiver: RetransmissionRequestReceiver,
     reply_controller_sender: ReplyControllerSender,
-    task_client: TaskClient,
 }
 
 impl<R> RetransmissionRequestListener<R>
@@ -38,7 +37,6 @@ where
         message_handler: MessageHandler<R>,
         request_receiver: RetransmissionRequestReceiver,
         reply_controller_sender: ReplyControllerSender,
-        task_client: TaskClient,
     ) -> Self {
         RetransmissionRequestListener {
             maximum_retransmissions,
@@ -46,7 +44,6 @@ where
             message_handler,
             request_receiver,
             reply_controller_sender,
-            task_client,
         }
     }
 
@@ -55,12 +52,18 @@ where
         packet_recipient: Recipient,
         chunk_data: Fragment,
         packet_type: PacketType,
+        mix_hops: Option<u8>,
     ) -> Result<PreparedFragment, PreparationError> {
         debug!("retransmitting normal packet...");
 
         // TODO: Figure out retransmission packet type signaling
         self.message_handler
-            .try_prepare_single_chunk_for_sending(packet_recipient, chunk_data, packet_type)
+            .try_prepare_single_chunk_for_sending(
+                packet_recipient,
+                chunk_data,
+                packet_type,
+                mix_hops,
+            )
             .await
     }
 
@@ -82,12 +85,9 @@ where
         if let Some(limit) = self.maximum_retransmissions {
             if timed_out_ack.retransmissions >= limit {
                 warn!("reached maximum number of allowed retransmissions for the packet");
-                if let Err(err) = self
-                    .action_sender
+                self.action_sender
                     .unbounded_send(Action::new_remove(frag_id))
-                {
-                    error!("Failed to send remove action to the controller: {err}");
-                }
+                    .unwrap();
                 return;
             }
         }
@@ -99,22 +99,18 @@ where
             } => {
                 // if this is retransmission for reply, offload it to the dedicated task
                 // that deals with all the surbs
-                if let Err(err) = self.reply_controller_sender.send_retransmission_data(
+                return self.reply_controller_sender.send_retransmission_data(
                     *recipient_tag,
                     weak_timed_out_ack,
                     *extra_surb_request,
-                ) {
-                    if !self.task_client.is_shutdown_poll() {
-                        error!("Failed to send retransmission data to the reply controller: {err}");
-                    }
-                }
-                return;
+                );
             }
             PacketDestination::KnownRecipient(recipient) => {
                 self.prepare_normal_retransmission_chunk(
                     **recipient,
                     timed_out_ack.message_chunk.clone(),
                     packet_type,
+                    timed_out_ack.mix_hops,
                 )
                 .await
             }
@@ -125,12 +121,9 @@ where
             Err(err) => {
                 warn!("Could not retransmit the packet - {err}");
                 // we NEED to start timer here otherwise we will have this guy permanently stuck in memory
-                if let Err(err) = self
-                    .action_sender
+                self.action_sender
                     .unbounded_send(Action::new_start_timer(frag_id))
-                {
-                    error!("Failed to send start timer action to the controller: {err}");
-                }
+                    .unwrap();
                 return;
             }
         };
@@ -155,14 +148,9 @@ where
         // is sent to the `OutQueueControl` and has gone through its internal queue
         // with the additional poisson delay.
         // And since Actions are executed in order `UpdateTimer` will HAVE TO be executed before `StartTimer`
-        if let Err(err) = self
-            .action_sender
+        self.action_sender
             .unbounded_send(Action::new_update_pending_ack(frag_id, new_delay))
-        {
-            if !self.task_client.is_shutdown_poll() {
-                error!("Failed to send update pending ack action to the controller: {err}");
-            }
-        }
+            .unwrap();
 
         // send to `OutQueueControl` to eventually send to the mix network
         self.message_handler
@@ -176,10 +164,14 @@ where
             .await
     }
 
-    pub(super) async fn run(&mut self, packet_type: PacketType) {
+    pub(super) async fn run_with_shutdown(
+        &mut self,
+        mut shutdown: nym_task::TaskClient,
+        packet_type: PacketType,
+    ) {
         debug!("Started RetransmissionRequestListener with graceful shutdown support");
 
-        while !self.task_client.is_shutdown() {
+        while !shutdown.is_shutdown() {
             tokio::select! {
                 timed_out_ack = self.request_receiver.next() => match timed_out_ack {
                     Some(timed_out_ack) => self.on_retransmission_request(timed_out_ack, packet_type).await,
@@ -188,12 +180,12 @@ where
                         break;
                     }
                 },
-                _ = self.task_client.recv() => {
+                _ = shutdown.recv() => {
                     log::trace!("RetransmissionRequestListener: Received shutdown");
                 }
             }
         }
-        self.task_client.recv_timeout().await;
+        shutdown.recv_timeout().await;
         log::debug!("RetransmissionRequestListener: Exiting");
     }
 }

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

@@ -6,7 +6,6 @@ use super::SentPacketNotificationReceiver;
 use futures::StreamExt;
 use log::*;
 use nym_sphinx::chunking::fragment::{FragmentIdentifier, COVER_FRAG_ID};
-use nym_task::TaskClient;
 
 /// Module responsible for starting up retransmission timers.
 /// It is required because when we send our packet to the `real traffic stream` controlled
@@ -15,19 +14,16 @@ use nym_task::TaskClient;
 pub(super) struct SentNotificationListener {
     sent_notifier: SentPacketNotificationReceiver,
     action_sender: AckActionSender,
-    task_client: TaskClient,
 }
 
 impl SentNotificationListener {
     pub(super) fn new(
         sent_notifier: SentPacketNotificationReceiver,
         action_sender: AckActionSender,
-        task_client: TaskClient,
     ) -> Self {
         SentNotificationListener {
             sent_notifier,
             action_sender,
-            task_client,
         }
     }
 
@@ -36,20 +32,15 @@ impl SentNotificationListener {
             trace!("sent off a cover message - no need to start retransmission timer!");
             return;
         }
-        if let Err(err) = self
-            .action_sender
+        self.action_sender
             .unbounded_send(Action::new_start_timer(frag_id))
-        {
-            if !self.task_client.is_shutdown_poll() {
-                error!("Failed to send start timer action to action controller: {err}");
-            }
-        }
+            .unwrap();
     }
 
-    pub(super) async fn run(&mut self) {
+    pub(super) async fn run_with_shutdown(&mut self, mut shutdown: nym_task::TaskClient) {
         debug!("Started SentNotificationListener with graceful shutdown support");
 
-        while !self.task_client.is_shutdown() {
+        loop {
             tokio::select! {
                 frag_id = self.sent_notifier.next() => match frag_id {
                     Some(frag_id) => {
@@ -60,13 +51,13 @@ impl SentNotificationListener {
                         break;
                     }
                 },
-                _ = self.task_client.recv() => {
+                _ = shutdown.recv_with_delay() => {
                     log::trace!("SentNotificationListener: Received shutdown");
                     break;
                 }
             }
         }
-        assert!(self.task_client.is_shutdown_poll());
+        assert!(shutdown.is_shutdown_poll());
         log::debug!("SentNotificationListener: Exiting");
     }
 }

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

@@ -15,12 +15,11 @@ use nym_sphinx::anonymous_replies::requests::{AnonymousSenderTag, RepliableMessa
 use nym_sphinx::anonymous_replies::{ReplySurb, SurbEncryptionKey};
 use nym_sphinx::chunking::fragment::{Fragment, FragmentIdentifier};
 use nym_sphinx::message::NymMessage;
-use nym_sphinx::params::{PacketSize, PacketType};
+use nym_sphinx::params::{PacketSize, PacketType, DEFAULT_NUM_MIX_HOPS};
 use nym_sphinx::preparer::{MessagePreparer, PreparedFragment};
 use nym_sphinx::Delay;
 use nym_task::connections::TransmissionLane;
-use nym_task::TaskClient;
-use nym_topology::{NymRouteProvider, NymTopologyError};
+use nym_topology::{NymTopology, NymTopologyError};
 use rand::{CryptoRng, Rng};
 use std::collections::HashMap;
 use std::sync::Arc;
@@ -101,6 +100,10 @@ pub(crate) struct Config {
     /// Average delay an acknowledgement packet is going to get delay at a single mixnode.
     average_ack_delay: Duration,
 
+    /// Number of mix hops each packet ('real' message, ack, reply) is expected to take.
+    /// Note that it does not include gateway hops.
+    num_mix_hops: u8,
+
     /// Primary predefined packet size used for the encapsulated messages.
     primary_packet_size: PacketSize,
 
@@ -122,11 +125,19 @@ impl Config {
             deterministic_route_selection,
             average_packet_delay,
             average_ack_delay,
+            num_mix_hops: DEFAULT_NUM_MIX_HOPS,
             primary_packet_size: PacketSize::default(),
             secondary_packet_size: None,
         }
     }
 
+    /// Allows setting non-default number of expected mix hops in the network.
+    #[allow(dead_code)]
+    pub fn with_mix_hops(mut self, hops: u8) -> Self {
+        self.num_mix_hops = hops;
+        self
+    }
+
     /// Allows setting non-default size of the sphinx packets sent out.
     pub fn with_custom_primary_packet_size(mut self, packet_size: PacketSize) -> Self {
         self.primary_packet_size = packet_size;
@@ -150,14 +161,12 @@ pub(crate) struct MessageHandler<R> {
     topology_access: TopologyAccessor,
     reply_key_storage: SentReplyKeys,
     tag_storage: UsedSenderTags,
-    task_client: TaskClient,
 }
 
 impl<R> MessageHandler<R>
 where
     R: CryptoRng + Rng,
 {
-    #[allow(clippy::too_many_arguments)]
     pub(crate) fn new(
         config: Config,
         rng: R,
@@ -166,7 +175,6 @@ where
         topology_access: TopologyAccessor,
         reply_key_storage: SentReplyKeys,
         tag_storage: UsedSenderTags,
-        task_client: TaskClient,
     ) -> Self
     where
         R: Copy,
@@ -177,7 +185,9 @@ where
             config.sender_address,
             config.average_packet_delay,
             config.average_ack_delay,
-        );
+        )
+        .with_mix_hops(config.num_mix_hops);
+
         MessageHandler {
             config,
             rng,
@@ -187,7 +197,6 @@ where
             topology_access,
             reply_key_storage,
             tag_storage,
-            task_client,
         }
     }
 
@@ -207,7 +216,7 @@ where
     fn get_topology<'a>(
         &self,
         permit: &'a TopologyReadPermit<'a>,
-    ) -> Result<&'a NymRouteProvider, PreparationError> {
+    ) -> Result<&'a NymTopology, PreparationError> {
         match permit.try_get_valid_topology_ref(&self.config.sender_address, None) {
             Ok(topology_ref) => Ok(topology_ref),
             Err(err) => {
@@ -224,8 +233,9 @@ where
             return self.config.primary_packet_size;
         };
 
-        let primary_count = msg.required_packets(self.config.primary_packet_size);
-        let secondary_count = msg.required_packets(secondary_packet);
+        let primary_count =
+            msg.required_packets(self.config.primary_packet_size, self.config.num_mix_hops);
+        let secondary_count = msg.required_packets(secondary_packet, self.config.num_mix_hops);
 
         trace!("This message would require: {primary_count} primary packets or {secondary_count} secondary packets...");
         // if there would be no benefit in using the secondary packet - use the primary (duh)
@@ -414,9 +424,10 @@ where
         message: Vec<u8>,
         lane: TransmissionLane,
         packet_type: PacketType,
+        mix_hops: Option<u8>,
     ) -> Result<(), PreparationError> {
         let message = NymMessage::new_plain(message);
-        self.try_split_and_send_non_reply_message(message, recipient, lane, packet_type)
+        self.try_split_and_send_non_reply_message(message, recipient, lane, packet_type, mix_hops)
             .await
     }
 
@@ -426,6 +437,7 @@ where
         recipient: Recipient,
         lane: TransmissionLane,
         packet_type: PacketType,
+        mix_hops: Option<u8>,
     ) -> Result<(), PreparationError> {
         debug!("Sending non-reply message with packet type {packet_type}");
         // TODO: I really dislike existence of this assertion, it implies code has to be re-organised
@@ -458,6 +470,7 @@ where
                 &self.config.ack_key,
                 &recipient,
                 packet_type,
+                mix_hops,
             )?;
 
             let real_message = RealMessage::new(
@@ -465,7 +478,8 @@ where
                 Some(fragment.fragment_identifier()),
             );
             let delay = prepared_fragment.total_delay;
-            let pending_ack = PendingAcknowledgement::new_known(fragment, delay, recipient);
+            let pending_ack =
+                PendingAcknowledgement::new_known(fragment, delay, recipient, mix_hops);
 
             real_messages.push(real_message);
             pending_acks.push(pending_ack);
@@ -482,6 +496,7 @@ where
         recipient: Recipient,
         amount: u32,
         packet_type: PacketType,
+        mix_hops: Option<u8>,
     ) -> Result<(), PreparationError> {
         debug!("Sending additional reply SURBs with packet type {packet_type}");
         let sender_tag = self.get_or_create_sender_tag(&recipient);
@@ -498,6 +513,7 @@ where
             recipient,
             TransmissionLane::AdditionalReplySurbs,
             packet_type,
+            mix_hops,
         )
         .await?;
 
@@ -514,6 +530,7 @@ where
         num_reply_surbs: u32,
         lane: TransmissionLane,
         packet_type: PacketType,
+        mix_hops: Option<u8>,
     ) -> Result<(), SurbWrappedPreparationError> {
         debug!("Sending message with reply SURBs with packet type {packet_type}");
         let sender_tag = self.get_or_create_sender_tag(&recipient);
@@ -524,7 +541,7 @@ where
         let message =
             NymMessage::new_repliable(RepliableMessage::new_data(message, sender_tag, reply_surbs));
 
-        self.try_split_and_send_non_reply_message(message, recipient, lane, packet_type)
+        self.try_split_and_send_non_reply_message(message, recipient, lane, packet_type, mix_hops)
             .await?;
 
         log::trace!("storing {} reply keys", reply_keys.len());
@@ -538,18 +555,23 @@ where
         recipient: Recipient,
         chunk: Fragment,
         packet_type: PacketType,
+        mix_hops: Option<u8>,
     ) -> Result<PreparedFragment, PreparationError> {
         debug!("Sending single chunk with packet type {packet_type}");
         let topology_permit = self.topology_access.get_read_permit().await;
         let topology = self.get_topology(&topology_permit)?;
 
-        let prepared_fragment = self.message_preparer.prepare_chunk_for_sending(
-            chunk,
-            topology,
-            &self.config.ack_key,
-            &recipient,
-            packet_type,
-        )?;
+        let prepared_fragment = self
+            .message_preparer
+            .prepare_chunk_for_sending(
+                chunk,
+                topology,
+                &self.config.ack_key,
+                &recipient,
+                packet_type,
+                mix_hops,
+            )
+            .unwrap();
 
         Ok(prepared_fragment)
     }
@@ -602,37 +624,30 @@ where
             Err(err) => return Err(err.return_surbs(vec![reply_surb])),
         };
 
-        let prepared_fragment = self.message_preparer.prepare_reply_chunk_for_sending(
-            chunk,
-            topology,
-            &self.config.ack_key,
-            reply_surb,
-            PacketType::Mix,
-        )?;
+        let prepared_fragment = self
+            .message_preparer
+            .prepare_reply_chunk_for_sending(
+                chunk,
+                topology,
+                &self.config.ack_key,
+                reply_surb,
+                PacketType::Mix,
+            )
+            .unwrap();
 
         Ok(prepared_fragment)
     }
 
     pub(crate) fn update_ack_delay(&self, id: FragmentIdentifier, new_delay: Delay) {
-        if let Err(err) = self
-            .action_sender
+        self.action_sender
             .unbounded_send(Action::UpdatePendingAck(id, new_delay))
-        {
-            if !self.task_client.is_shutdown_poll() {
-                error!("Failed to send update action to the controller: {err}");
-            }
-        }
+            .expect("action control task has died")
     }
 
     pub(crate) fn insert_pending_acks(&self, pending_acks: Vec<PendingAcknowledgement>) {
-        if let Err(err) = self
-            .action_sender
+        self.action_sender
             .unbounded_send(Action::new_insert(pending_acks))
-        {
-            if !self.task_client.is_shutdown_poll() {
-                error!("Failed to send insert action to the controller: {err}");
-            }
-        }
+            .expect("action control task has died")
     }
 
     // tells real message sender (with the poisson timer) to send this to the mix network
@@ -641,14 +656,9 @@ where
         messages: Vec<RealMessage>,
         transmission_lane: TransmissionLane,
     ) {
-        if let Err(err) = self
-            .real_message_sender
+        self.real_message_sender
             .send((messages, transmission_lane))
             .await
-        {
-            if !self.task_client.is_shutdown_poll() {
-                error!("Failed to forward messages to the real message sender: {err}");
-            }
-        }
+            .expect("real message receiver task (OutQueueControl) has died");
     }
 }

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

@@ -9,12 +9,10 @@ use self::{
     acknowledgement_control::AcknowledgementController, real_traffic_stream::OutQueueControl,
 };
 use crate::client::real_messages_control::message_handler::MessageHandler;
-use crate::client::replies::reply_controller;
 use crate::client::replies::reply_controller::{
     ReplyController, ReplyControllerReceiver, ReplyControllerSender,
 };
 use crate::client::replies::reply_storage::CombinedReplyStorage;
-use crate::config;
 use crate::{
     client::{
         inbound_messages::InputMessageReceiver, mix_traffic::BatchMixMessageSender,
@@ -29,14 +27,16 @@ use nym_gateway_client::AcknowledgementReceiver;
 use nym_sphinx::acknowledgements::AckKey;
 use nym_sphinx::addressing::clients::Recipient;
 use nym_sphinx::params::PacketType;
-use nym_statistics_common::clients::ClientStatsSender;
 use nym_task::connections::{ConnectionCommandReceiver, LaneQueueLengths};
-use nym_task::TaskClient;
 use rand::{rngs::OsRng, CryptoRng, Rng};
 use std::sync::Arc;
 
+use crate::client::replies::reply_controller;
+use crate::config;
 pub(crate) use acknowledgement_control::{AckActionSender, Action};
 
+use nym_statistics_common::clients::ClientStatsSender;
+
 pub(crate) mod acknowledgement_control;
 pub(crate) mod message_handler;
 pub(crate) mod real_traffic_stream;
@@ -148,7 +148,6 @@ impl RealMessagesController<OsRng> {
         lane_queue_lengths: LaneQueueLengths,
         client_connection_rx: ConnectionCommandReceiver,
         stats_tx: ClientStatsSender,
-        task_client: TaskClient,
     ) -> Self {
         let rng = OsRng;
 
@@ -179,7 +178,6 @@ impl RealMessagesController<OsRng> {
             topology_access.clone(),
             reply_storage.key_storage(),
             reply_storage.tags_storage(),
-            task_client.fork("message_handler"),
         );
 
         let ack_control = AcknowledgementController::new(
@@ -189,7 +187,6 @@ impl RealMessagesController<OsRng> {
             message_handler.clone(),
             reply_controller_sender,
             stats_tx.clone(),
-            task_client.fork("ack_control"),
         );
 
         let reply_control = ReplyController::new(
@@ -197,7 +194,6 @@ impl RealMessagesController<OsRng> {
             message_handler,
             reply_storage,
             reply_controller_receiver,
-            task_client.fork("reply_controller"),
         );
 
         let out_queue_control = OutQueueControl::new(
@@ -210,7 +206,6 @@ impl RealMessagesController<OsRng> {
             lane_queue_lengths,
             client_connection_rx,
             stats_tx,
-            task_client.with_suffix("out_queue_control"),
         );
 
         RealMessagesController {
@@ -220,20 +215,22 @@ impl RealMessagesController<OsRng> {
         }
     }
 
-    pub fn start(self, packet_type: PacketType) {
+    pub fn start_with_shutdown(self, shutdown: nym_task::TaskClient, packet_type: PacketType) {
         let mut out_queue_control = self.out_queue_control;
         let ack_control = self.ack_control;
         let mut reply_control = self.reply_control;
 
+        let shutdown_handle = shutdown.fork("out_queue_control");
         spawn_future(async move {
-            out_queue_control.run().await;
+            out_queue_control.run_with_shutdown(shutdown_handle).await;
             debug!("The out queue controller has finished execution!");
         });
+        let shutdown_handle = shutdown.fork("reply_control");
         spawn_future(async move {
-            reply_control.run().await;
+            reply_control.run_with_shutdown(shutdown_handle).await;
             debug!("The reply controller has finished execution!");
         });
 
-        ack_control.start(packet_type);
+        ack_control.start_with_shutdown(shutdown.with_suffix("ack_control"), packet_type);
     }
 }

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

@@ -22,7 +22,6 @@ use nym_statistics_common::clients::{packet_statistics::PacketStatisticsEvent, C
 use nym_task::connections::{
     ConnectionCommand, ConnectionCommandReceiver, ConnectionId, LaneQueueLengths, TransmissionLane,
 };
-use nym_task::TaskClient;
 use rand::{CryptoRng, Rng};
 use std::pin::Pin;
 use std::sync::Arc;
@@ -118,8 +117,6 @@ where
 
     /// Channel used for sending metrics events (specifically `PacketStatistics` events) to the metrics tracker.
     stats_tx: ClientStatsSender,
-
-    task_client: TaskClient,
 }
 
 #[derive(Debug)]
@@ -179,7 +176,6 @@ where
         lane_queue_lengths: LaneQueueLengths,
         client_connection_rx: ConnectionCommandReceiver,
         stats_tx: ClientStatsSender,
-        task_client: TaskClient,
     ) -> Self {
         OutQueueControl {
             config,
@@ -194,7 +190,6 @@ where
             client_connection_rx,
             lane_queue_lengths,
             stats_tx,
-            task_client,
         }
     }
 
@@ -203,9 +198,7 @@ where
         // queues and client load rather than the required delay. So realistically we can treat
         // whatever is about to happen as negligible additional delay.
         trace!("{} is about to get sent to the mixnet", frag_id);
-        if let Err(err) = self.sent_notifier.unbounded_send(frag_id) {
-            error!("Failed to notify about sent message: {err}");
-        }
+        self.sent_notifier.unbounded_send(frag_id).unwrap();
     }
 
     fn loop_cover_message_size(&mut self) -> PacketSize {
@@ -237,7 +230,6 @@ where
                 // poisson delay, but is it really a problem?
                 let topology_permit = self.topology_access.get_read_permit().await;
                 // the ack is sent back to ourselves (and then ignored)
-
                 let topology_ref = match topology_permit.try_get_valid_topology_ref(
                     &self.config.our_full_destination,
                     Some(&self.config.our_full_destination),
@@ -278,9 +270,7 @@ where
         };
 
         if let Err(err) = self.mix_tx.send(vec![next_message]).await {
-            if !self.task_client.is_shutdown_poll() {
-                log::error!("Failed to send: {err}");
-            }
+            log::error!("Failed to send: {err}");
         } else {
             let event = if fragment_id.is_some() {
                 PacketStatisticsEvent::RealPacketSent(packet_size)
@@ -513,29 +503,21 @@ where
     }
 
     #[cfg(not(target_arch = "wasm32"))]
-    fn log_status(&self, shutdown: &mut TaskClient) {
+    fn log_status(&self, shutdown: &mut nym_task::TaskClient) {
         use crate::error::ClientCoreStatusMessage;
 
         let packets = self.transmission_buffer.total_size();
-        let lanes = self.transmission_buffer.lanes();
+        let backlog = self.transmission_buffer.total_size_in_bytes() as f64 / 1024.0;
+        let lanes = self.transmission_buffer.num_lanes();
         let mult = self.sending_delay_controller.current_multiplier();
         let delay = self.current_average_message_sending_delay().as_millis();
-
-        let lane_status = lanes
-            .iter()
-            .map(|lane_name| {
-                let lane_length = self.transmission_buffer.lane_length(lane_name).unwrap_or(0);
-                format!("{lane_name:?}: {lane_length}")
-            })
-            .collect::<Vec<String>>()
-            .join(", ");
-
         let status_str = if self.config.traffic.disable_main_poisson_packet_distribution {
-            format!("Packet backlog: {lane_status}, no delay")
+            format!("Packet backlog: {backlog:.2} kiB ({packets}), {lanes} lanes, no delay")
         } else {
-            format!("Packet backlog: {lane_status}, avg delay: {delay}ms ({mult})")
+            format!(
+                "Packet backlog: {backlog:.2} kiB ({packets}), {lanes} lanes, avg delay: {delay}ms ({mult})"
+            )
         };
-
         if packets > 1000 {
             log::warn!("{status_str}");
         } else if packets > 0 {
@@ -552,19 +534,17 @@ where
         }
     }
 
-    pub(super) async fn run(&mut self) {
+    pub(super) async fn run_with_shutdown(&mut self, mut shutdown: nym_task::TaskClient) {
         debug!("Started OutQueueControl with graceful shutdown support");
 
-        let mut shutdown = self.task_client.fork("select");
-
         #[cfg(not(target_arch = "wasm32"))]
         {
             let mut status_timer = tokio::time::interval(Duration::from_secs(5));
 
-            while !shutdown.is_shutdown() {
+            loop {
                 tokio::select! {
                     biased;
-                    _ = shutdown.recv() => {
+                    _ = shutdown.recv_with_delay() => {
                         log::trace!("OutQueueControl: Received shutdown");
                         break;
                     }

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

@@ -70,10 +70,7 @@ impl SendingDelayController {
             lower_bound,
             multiplier_elevated_counter: 0,
             time_when_logged_about_elevated_multiplier: now
-                .checked_sub(Duration::from_secs(
-                    INTERVAL_BETWEEN_WARNING_ABOUT_ELEVATED_MULTIPLIER_SECS,
-                ))
-                .unwrap_or(now),
+                - Duration::from_secs(INTERVAL_BETWEEN_WARNING_ABOUT_ELEVATED_MULTIPLIER_SECS),
             time_when_changed: now,
             time_when_backpressure_detected: now,
         }

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

@@ -20,7 +20,6 @@ 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 nym_task::TaskClient;
 use std::collections::HashSet;
 use std::sync::Arc;
 
@@ -153,7 +152,6 @@ struct ReceivedMessagesBuffer<R: MessageReceiver> {
     inner: Arc<Mutex<ReceivedMessagesBufferInner<R>>>,
     reply_key_storage: SentReplyKeys,
     reply_controller_sender: ReplyControllerSender,
-    task_client: TaskClient,
 }
 
 impl<R: MessageReceiver> ReceivedMessagesBuffer<R> {
@@ -162,7 +160,6 @@ impl<R: MessageReceiver> ReceivedMessagesBuffer<R> {
         reply_key_storage: SentReplyKeys,
         reply_controller_sender: ReplyControllerSender,
         stats_tx: ClientStatsSender,
-        task_client: TaskClient,
     ) -> Self {
         ReceivedMessagesBuffer {
             inner: Arc::new(Mutex::new(ReceivedMessagesBufferInner {
@@ -175,7 +172,6 @@ impl<R: MessageReceiver> ReceivedMessagesBuffer<R> {
             })),
             reply_key_storage,
             reply_controller_sender,
-            task_client,
         }
     }
 
@@ -261,15 +257,11 @@ impl<R: MessageReceiver> ReceivedMessagesBuffer<R> {
                 }
             };
 
-            if let Err(err) = self.reply_controller_sender.send_additional_surbs(
+            self.reply_controller_sender.send_additional_surbs(
                 msg.sender_tag,
                 reply_surbs,
                 from_surb_request,
-            ) {
-                if !self.task_client.is_shutdown_poll() {
-                    error!("{err}");
-                }
-            }
+            )
         }
         reconstructed
     }
@@ -284,14 +276,8 @@ impl<R: MessageReceiver> ReceivedMessagesBuffer<R> {
                 ReplyMessageContent::Data { message } => reconstructed.push(message.into()),
                 ReplyMessageContent::SurbRequest { recipient, amount } => {
                     debug!("received request for {amount} additional reply SURBs from {recipient}");
-                    if let Err(err) = self
-                        .reply_controller_sender
-                        .send_additional_surbs_request(*recipient, amount)
-                    {
-                        if !self.task_client.is_shutdown_poll() {
-                            error!("{err}");
-                        }
-                    }
+                    self.reply_controller_sender
+                        .send_additional_surbs_request(*recipient, amount);
                 }
             }
         }
@@ -413,19 +399,16 @@ pub enum ReceivedBufferMessage {
 struct RequestReceiver<R: MessageReceiver> {
     received_buffer: ReceivedMessagesBuffer<R>,
     query_receiver: ReceivedBufferRequestReceiver,
-    task_client: TaskClient,
 }
 
 impl<R: MessageReceiver> RequestReceiver<R> {
     fn new(
         received_buffer: ReceivedMessagesBuffer<R>,
         query_receiver: ReceivedBufferRequestReceiver,
-        task_client: TaskClient,
     ) -> Self {
         RequestReceiver {
             received_buffer,
             query_receiver,
-            task_client,
         }
     }
 
@@ -440,12 +423,12 @@ impl<R: MessageReceiver> RequestReceiver<R> {
         }
     }
 
-    async fn run(&mut self) {
+    async fn run_with_shutdown(&mut self, mut shutdown: nym_task::TaskClient) {
         debug!("Started RequestReceiver with graceful shutdown support");
-        while !self.task_client.is_shutdown() {
+        while !shutdown.is_shutdown() {
             tokio::select! {
                 biased;
-                _ = self.task_client.recv() => {
+                _ = shutdown.recv_with_delay() => {
                     log::trace!("RequestReceiver: Received shutdown");
                 }
                 request = self.query_receiver.next() => {
@@ -458,7 +441,7 @@ impl<R: MessageReceiver> RequestReceiver<R> {
                 },
             }
         }
-        self.task_client.recv().await;
+        shutdown.recv_timeout().await;
         log::debug!("RequestReceiver: Exiting");
     }
 }
@@ -466,25 +449,25 @@ impl<R: MessageReceiver> RequestReceiver<R> {
 struct FragmentedMessageReceiver<R: MessageReceiver> {
     received_buffer: ReceivedMessagesBuffer<R>,
     mixnet_packet_receiver: MixnetMessageReceiver,
-    task_client: TaskClient,
 }
 
 impl<R: MessageReceiver> FragmentedMessageReceiver<R> {
     fn new(
         received_buffer: ReceivedMessagesBuffer<R>,
         mixnet_packet_receiver: MixnetMessageReceiver,
-        task_client: TaskClient,
     ) -> Self {
         FragmentedMessageReceiver {
             received_buffer,
             mixnet_packet_receiver,
-            task_client,
         }
     }
 
-    async fn run(&mut self) -> Result<(), MessageRecoveryError> {
+    async fn run_with_shutdown(
+        &mut self,
+        mut shutdown: nym_task::TaskClient,
+    ) -> Result<(), MessageRecoveryError> {
         debug!("Started FragmentedMessageReceiver with graceful shutdown support");
-        while !self.task_client.is_shutdown() {
+        while !shutdown.is_shutdown() {
             tokio::select! {
                 new_messages = self.mixnet_packet_receiver.next() => {
                     if let Some(new_messages) = new_messages {
@@ -494,12 +477,12 @@ impl<R: MessageReceiver> FragmentedMessageReceiver<R> {
                         break;
                     }
                 },
-                _ = self.task_client.recv_with_delay() => {
+                _ = shutdown.recv_with_delay() => {
                     log::trace!("FragmentedMessageReceiver: Received shutdown");
                 }
             }
         }
-        self.task_client.recv_timeout().await;
+        shutdown.recv_timeout().await;
         log::debug!("FragmentedMessageReceiver: Exiting");
         Ok(())
     }
@@ -518,42 +501,41 @@ impl<R: MessageReceiver + Clone + Send + 'static> ReceivedMessagesBufferControll
         reply_key_storage: SentReplyKeys,
         reply_controller_sender: ReplyControllerSender,
         metrics_reporter: ClientStatsSender,
-        task_client: TaskClient,
     ) -> Self {
         let received_buffer = ReceivedMessagesBuffer::new(
             local_encryption_keypair,
             reply_key_storage,
             reply_controller_sender,
             metrics_reporter,
-            task_client.fork("received_messages_buffer"),
         );
 
         ReceivedMessagesBufferController {
             fragmented_message_receiver: FragmentedMessageReceiver::new(
                 received_buffer.clone(),
                 mixnet_packet_receiver,
-                task_client.fork("fragmented_message_receiver"),
-            ),
-            request_receiver: RequestReceiver::new(
-                received_buffer,
-                query_receiver,
-                task_client.with_suffix("request_receiver"),
             ),
+            request_receiver: RequestReceiver::new(received_buffer, query_receiver),
         }
     }
 
-    pub fn start(self) {
+    pub fn start_with_shutdown(self, shutdown: nym_task::TaskClient) {
         let mut fragmented_message_receiver = self.fragmented_message_receiver;
         let mut request_receiver = self.request_receiver;
 
+        let shutdown_handle = shutdown.fork("fragmented_message_receiver");
         spawn_future(async move {
-            match fragmented_message_receiver.run().await {
+            match fragmented_message_receiver
+                .run_with_shutdown(shutdown_handle)
+                .await
+            {
                 Ok(_) => {}
                 Err(e) => error!("{e}"),
             }
         });
         spawn_future(async move {
-            request_receiver.run().await;
+            request_receiver
+                .run_with_shutdown(shutdown.with_suffix("request_receiver"))
+                .await;
         });
     }
 }

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

@@ -12,7 +12,6 @@ use nym_sphinx::anonymous_replies::requests::AnonymousSenderTag;
 use nym_sphinx::anonymous_replies::ReplySurb;
 use nym_sphinx::chunking::fragment::{Fragment, FragmentIdentifier};
 use nym_task::connections::{ConnectionId, TransmissionLane};
-use nym_task::TaskClient;
 use rand::{CryptoRng, Rng};
 use std::cmp::{max, min};
 use std::collections::btree_map::Entry;
@@ -69,9 +68,6 @@ pub struct ReplyController<R> {
 
     message_handler: MessageHandler<R>,
     full_reply_storage: CombinedReplyStorage,
-
-    // Listen for shutdown signals
-    task_client: TaskClient,
 }
 
 impl<R> ReplyController<R>
@@ -83,7 +79,6 @@ where
         message_handler: MessageHandler<R>,
         full_reply_storage: CombinedReplyStorage,
         request_receiver: ReplyControllerReceiver,
-        task_client: TaskClient,
     ) -> Self {
         ReplyController {
             config,
@@ -92,7 +87,6 @@ where
             pending_retransmissions: HashMap::new(),
             message_handler,
             full_reply_storage,
-            task_client,
         }
     }
 
@@ -102,7 +96,6 @@ where
         fragments: I,
         lane: TransmissionLane,
     ) {
-        trace!("buffering pending replies for {recipient}");
         self.pending_replies
             .entry(*recipient)
             .or_insert_with(TransmissionBuffer::new)
@@ -114,7 +107,6 @@ where
         recipient: &AnonymousSenderTag,
         fragments: Vec<(TransmissionLane, Fragment)>,
     ) {
-        trace!("re-inserting pending replies for {recipient}");
         // the buffer should ALWAYS exist at this point, if it doesn't, it's a bug...
         self.pending_replies
             .entry(*recipient)
@@ -127,7 +119,6 @@ where
         recipient: &AnonymousSenderTag,
         data: Vec<Arc<PendingAcknowledgement>>,
     ) {
-        trace!("re-inserting pending retransmissions for {recipient}");
         // the underlying entry MUST exist as we've just got data from there
         let map_entry = self
             .pending_retransmissions
@@ -145,7 +136,7 @@ where
     }
 
     fn should_request_more_surbs(&self, target: &AnonymousSenderTag) -> bool {
-        trace!("checking if we should request more surbs from {target}");
+        trace!("checking if we should request more surbs from {:?}", target);
 
         let pending_queue_size = self
             .pending_replies
@@ -161,6 +152,11 @@ where
 
         let total_queue = pending_queue_size + retransmission_queue;
 
+        // simple as that - there's absolutely nothing to retransmit
+        if total_queue == 0 {
+            return false;
+        }
+
         let available_surbs = self
             .full_reply_storage
             .surbs_storage_ref()
@@ -177,27 +173,11 @@ where
             .full_reply_storage
             .surbs_storage_ref()
             .max_surb_threshold();
-        let min_surbs_threshold_buffer =
-            self.config.reply_surbs.minimum_reply_surb_threshold_buffer;
 
-        // After clearing the queue, we want to have at least `min_surbs_threshold` surbs available
-        // and reserved for requesting additional surbs, and in addition to that we also want to
-        // have `min_surbs_threshold_buffer` surbs available proactively.
-        let target_surbs_after_clearing_queue = min_surbs_threshold + min_surbs_threshold_buffer;
+        debug!("total queue size: {total_queue} = pending data {pending_queue_size} + pending retransmission {retransmission_queue}, available surbs: {available_surbs} pending surbs: {pending_surbs} threshold range: {min_surbs_threshold}..{max_surbs_threshold}");
 
-        // Check if we have enough surbs to handle the total queue and maintain minimum thresholds
-        let total_required_surbs = total_queue + target_surbs_after_clearing_queue;
-        let total_available_surbs = pending_surbs + available_surbs;
-
-        debug!("total queue size: {total_queue} = pending data {pending_queue_size} + pending retransmission {retransmission_queue}, available surbs: {available_surbs} pending surbs: {pending_surbs} threshold range: {min_surbs_threshold}..+{min_surbs_threshold_buffer}..{max_surbs_threshold}");
-
-        // We should request more surbs if:
-        // 1. We haven't hit the maximum surb threshold, and
-        // 2. We don't have enough surbs to handle the queue plus minimum thresholds
-        let is_below_max_threshold = total_available_surbs < max_surbs_threshold;
-        let is_below_required_surbs = total_available_surbs < total_required_surbs;
-
-        is_below_max_threshold && is_below_required_surbs
+        (pending_surbs + available_surbs) < max_surbs_threshold
+            && (pending_surbs + available_surbs) < (total_queue + min_surbs_threshold)
     }
 
     async fn handle_send_reply(
@@ -258,10 +238,6 @@ where
                         &recipient_tag,
                     );
                     warn!("failed to send reply to {recipient_tag}: {err}");
-                    info!(
-                        "buffering {no_fragments} fragments for {recipient_tag}",
-                        no_fragments = to_send.len()
-                    );
                     self.insert_pending_replies(&recipient_tag, to_send, lane);
                 }
             }
@@ -269,13 +245,6 @@ where
 
         // if there's leftover data we didn't send because we didn't have enough (or any) surbs - buffer it
         if !fragments.is_empty() {
-            // Ideally we should have enough surbs above the minimum threshold to handle sending
-            // new replies without having to first request more surbs. That's why I'd like to log
-            // these cases as they might indicate a problem with the surb management.
-            debug!(
-                "buffering {no_fragments} fragments for {recipient_tag}",
-                no_fragments = fragments.len()
-            );
             self.insert_pending_replies(&recipient_tag, fragments, lane);
         }
 
@@ -290,7 +259,6 @@ where
         target: AnonymousSenderTag,
         amount: u32,
     ) -> Result<(), PreparationError> {
-        debug!("requesting {amount} additional reply surbs for {target}");
         let reply_surb = self
             .full_reply_storage
             .surbs_storage_ref()
@@ -548,6 +516,7 @@ where
                     recipient,
                     to_send,
                     nym_sphinx::params::PacketType::Mix,
+                    self.config.reply_surbs.surb_mix_hops,
                 )
                 .await
             {
@@ -712,7 +681,7 @@ where
     // it should take into consideration the average latency, sending rate and queue size.
     // it should request as many surbs as it takes to saturate its sending rate before next batch arrives
     async fn request_reply_surbs_for_queue_clearing(&mut self, target: AnonymousSenderTag) {
-        trace!("requesting surbs for queue clearing");
+        trace!("requesting surbs for queues clearing");
 
         let pending_queue_size = self
             .pending_replies
@@ -726,18 +695,17 @@ where
             .map(|pending_queue| pending_queue.len())
             .unwrap_or_default();
 
-        let min_surbs_buffer = self.config.reply_surbs.minimum_reply_surb_threshold_buffer as u32;
-
         let total_queue = (pending_queue_size + retransmission_queue) as u32;
 
-        // To proactively request additional surbs, we aim to have a buffer of extra surbs in our
-        // storage.
-        let total_queue_with_buffer = total_queue + min_surbs_buffer;
+        if total_queue == 0 {
+            trace!("the pending queues for {:?} are already empty", target);
+            return;
+        }
 
         let request_size = min(
             self.config.reply_surbs.maximum_reply_surb_request_size,
             max(
-                total_queue_with_buffer,
+                total_queue,
                 self.config.reply_surbs.minimum_reply_surb_request_size,
             ),
         );
@@ -879,11 +847,9 @@ where
     //     todo!()
     // }
 
-    pub(crate) async fn run(&mut self) {
+    pub(crate) async fn run_with_shutdown(&mut self, mut shutdown: nym_task::TaskClient) {
         debug!("Started ReplyController with graceful shutdown support");
 
-        let mut shutdown = self.task_client.fork("select");
-
         let polling_rate = Duration::from_secs(5);
         let mut stale_inspection = new_interval_stream(polling_rate);
 
@@ -895,7 +861,7 @@ where
         while !shutdown.is_shutdown() {
             tokio::select! {
                 biased;
-                _ = shutdown.recv() => {
+                _ = shutdown.recv_with_delay() => {
                     log::trace!("ReplyController: Received shutdown");
                 },
                 req = self.request_receiver.next() => match req {

common/client-core/src/client/replies/reply_controller/requests.rs

@@ -15,27 +15,6 @@ pub(crate) fn new_control_channels() -> (ReplyControllerSender, ReplyControllerR
     (tx.into(), rx)
 }
 
-#[derive(Debug, thiserror::Error)]
-pub enum ReplyControllerSenderError {
-    #[error("failed to send retransmission data to reply controller")]
-    SendRetransmissionData(#[source] mpsc::TrySendError<ReplyControllerMessage>),
-
-    #[error("failed to send reply to reply controller")]
-    SendReply(#[source] mpsc::TrySendError<ReplyControllerMessage>),
-
-    #[error("failed to send additional surbs to reply controller")]
-    AdditionalSurbs(#[source] mpsc::TrySendError<ReplyControllerMessage>),
-
-    #[error("failed to send additional surbs request to reply controller")]
-    AdditionalSurbsRequest(#[source] mpsc::TrySendError<ReplyControllerMessage>),
-
-    #[error("failed to request lane queue length from reply controller")]
-    LaneQueueLength(#[source] mpsc::TrySendError<ReplyControllerMessage>),
-
-    #[error("response channel was dropped before we could receive the response")]
-    ResponseChannelDropped(#[source] oneshot::Canceled),
-}
-
 #[derive(Debug, Clone)]
 pub struct ReplyControllerSender(mpsc::UnboundedSender<ReplyControllerMessage>);
 
@@ -51,14 +30,14 @@ impl ReplyControllerSender {
         recipient: AnonymousSenderTag,
         timed_out_ack: Weak<PendingAcknowledgement>,
         extra_surb_request: bool,
-    ) -> Result<(), ReplyControllerSenderError> {
+    ) {
         self.0
             .unbounded_send(ReplyControllerMessage::RetransmitReply {
                 recipient,
                 timed_out_ack,
                 extra_surb_request,
             })
-            .map_err(ReplyControllerSenderError::SendRetransmissionData)
+            .expect("ReplyControllerReceiver has died!")
     }
 
     pub(crate) fn send_reply(
@@ -66,14 +45,14 @@ impl ReplyControllerSender {
         recipient: AnonymousSenderTag,
         message: Vec<u8>,
         lane: TransmissionLane,
-    ) -> Result<(), ReplyControllerSenderError> {
+    ) {
         self.0
             .unbounded_send(ReplyControllerMessage::SendReply {
                 recipient,
                 message,
                 lane,
             })
-            .map_err(ReplyControllerSenderError::SendReply)
+            .expect("ReplyControllerReceiver has died!")
     }
 
     pub(crate) fn send_additional_surbs(
@@ -81,47 +60,42 @@ impl ReplyControllerSender {
         sender_tag: AnonymousSenderTag,
         reply_surbs: Vec<ReplySurb>,
         from_surb_request: bool,
-    ) -> Result<(), ReplyControllerSenderError> {
+    ) {
         self.0
             .unbounded_send(ReplyControllerMessage::AdditionalSurbs {
                 sender_tag,
                 reply_surbs,
                 from_surb_request,
             })
-            .map_err(ReplyControllerSenderError::AdditionalSurbs)
+            .expect("ReplyControllerReceiver has died!")
     }
 
-    pub(crate) fn send_additional_surbs_request(
-        &self,
-        recipient: Recipient,
-        amount: u32,
-    ) -> Result<(), ReplyControllerSenderError> {
+    pub(crate) fn send_additional_surbs_request(&self, recipient: Recipient, amount: u32) {
         self.0
             .unbounded_send(ReplyControllerMessage::AdditionalSurbsRequest {
                 recipient: Box::new(recipient),
                 amount,
             })
-            .map_err(ReplyControllerSenderError::AdditionalSurbsRequest)
+            .expect("ReplyControllerReceiver has died!")
     }
 
-    pub async fn get_lane_queue_length(
-        &self,
-        connection_id: ConnectionId,
-    ) -> Result<usize, ReplyControllerSenderError> {
+    pub async fn get_lane_queue_length(&self, connection_id: ConnectionId) -> usize {
         let (response_tx, response_rx) = oneshot::channel();
-        if let Err(err) = self
-            .0
+        self.0
             .unbounded_send(ReplyControllerMessage::LaneQueueLength {
                 connection_id,
                 response_channel: response_tx,
             })
-        {
-            return Err(ReplyControllerSenderError::LaneQueueLength(err));
-        }
+            .expect("ReplyControllerReceiver has died!");
 
-        response_rx
-            .await
-            .map_err(ReplyControllerSenderError::ResponseChannelDropped)
+        match response_rx.await {
+            Ok(length) => length,
+            Err(_) => {
+                error!("The reply controller has dropped our response channel!");
+                // TODO: should we panic here instead? this message implies something weird and unrecoverable has happened
+                0
+            }
+        }
     }
 }
 
@@ -136,10 +110,7 @@ impl ReplyQueueLengths {
         }
     }
 
-    pub async fn get_lane_queue_length(
-        &self,
-        connection_id: ConnectionId,
-    ) -> Result<usize, ReplyControllerSenderError> {
+    pub async fn get_lane_queue_length(&self, connection_id: ConnectionId) -> usize {
         self.reply_controller_sender
             .get_lane_queue_length(connection_id)
             .await
@@ -149,7 +120,7 @@ impl ReplyQueueLengths {
 pub(crate) type ReplyControllerReceiver = mpsc::UnboundedReceiver<ReplyControllerMessage>;
 
 #[derive(Debug)]
-pub enum ReplyControllerMessage {
+pub(crate) enum ReplyControllerMessage {
     RetransmitReply {
         recipient: AnonymousSenderTag,
         timed_out_ack: Weak<PendingAcknowledgement>,

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

@@ -16,14 +16,14 @@
 #![warn(clippy::todo)]
 #![warn(clippy::dbg_macro)]
 
-use futures::StreamExt;
+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, TaskClient};
-use std::time::Duration;
+use nym_task::connections::TransmissionLane;
 
 use crate::{
     client::inbound_messages::{InputMessage, InputMessageSender},
@@ -51,9 +51,6 @@ pub(crate) struct StatisticsControl {
 
     /// Config for stats reporting (enabled, address, interval)
     reporting_config: StatsReporting,
-
-    /// Task client for listening for shutdown
-    task_client: TaskClient,
 }
 
 impl StatisticsControl {
@@ -62,24 +59,19 @@ impl StatisticsControl {
         client_type: String,
         client_stats_id: String,
         report_tx: InputMessageSender,
-        task_client: TaskClient,
     ) -> (Self, ClientStatsSender) {
         let (stats_tx, stats_rx) = tokio::sync::mpsc::unbounded_channel();
 
         let stats = ClientStatsController::new(client_stats_id, client_type);
 
-        let mut task_client_stats_sender = task_client.fork("stats_sender");
-        task_client_stats_sender.disarm();
-
         (
             StatisticsControl {
                 stats,
                 stats_rx,
                 report_tx,
                 reporting_config,
-                task_client,
             },
-            ClientStatsSender::new(Some(stats_tx), task_client_stats_sender),
+            ClientStatsSender::new(Some(stats_tx)),
         )
     }
 
@@ -99,43 +91,16 @@ impl StatisticsControl {
         }
     }
 
-    async fn run(&mut self) {
+    async fn run_with_shutdown(&mut self, mut task_client: nym_task::TaskClient) {
         log::debug!("Started StatisticsControl with graceful shutdown support");
 
-        #[cfg(not(target_arch = "wasm32"))]
-        let mut stats_report_interval = tokio_stream::wrappers::IntervalStream::new(
-            tokio::time::interval(self.reporting_config.reporting_interval),
-        );
+        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);
 
-        #[cfg(not(target_arch = "wasm32"))]
-        let mut local_report_interval = tokio_stream::wrappers::IntervalStream::new(
-            tokio::time::interval(LOCAL_REPORT_INTERVAL),
-        );
-
-        #[cfg(not(target_arch = "wasm32"))]
-        let mut snapshot_interval =
-            tokio_stream::wrappers::IntervalStream::new(tokio::time::interval(SNAPSHOT_INTERVAL));
-
-        #[cfg(target_arch = "wasm32")]
-        let mut stats_report_interval = gloo_timers::future::IntervalStream::new(
-            self.reporting_config.reporting_interval.as_millis() as u32,
-        );
-
-        #[cfg(target_arch = "wasm32")]
-        let mut local_report_interval =
-            gloo_timers::future::IntervalStream::new(LOCAL_REPORT_INTERVAL.as_millis() as u32);
-
-        #[cfg(target_arch = "wasm32")]
-        let mut snapshot_interval =
-            gloo_timers::future::IntervalStream::new(SNAPSHOT_INTERVAL.as_millis() as u32);
-
-        while !self.task_client.is_shutdown() {
+        loop {
             tokio::select! {
-                biased;
-                _ = self.task_client.recv() => {
-                    log::trace!("StatisticsControl: Received shutdown");
-                    break;
-                },
                 stats_event = self.stats_rx.recv() => match stats_event {
                         Some(stats_event) => self.stats.handle_event(stats_event),
                         None => {
@@ -143,48 +108,44 @@ impl StatisticsControl {
                             break;
                         }
                 },
-                _ = snapshot_interval.next() => {
+                _ = snapshot_interval.tick() => {
                     self.stats.snapshot();
                 }
-                _ = stats_report_interval.next() => {
-                    let Some(recipient) = self.reporting_config.provider_address else {
-                        continue
-                    };
-
-                    if self.reporting_config.enabled {
-                        self.report_stats(recipient).await;
-                    }
+                _ = 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.next() => {
-                    self.stats.local_report(&mut self.task_client);
+                _ = 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(mut self) {
+    pub(crate) fn start_with_shutdown(mut self, task_client: nym_task::TaskClient) {
         spawn_future(async move {
-            self.run().await;
+            self.run_with_shutdown(task_client).await;
         })
     }
 
-    pub(crate) fn create_and_start(
+    pub(crate) fn create_and_start_with_shutdown(
         reporting_config: StatsReporting,
         client_type: String,
         client_stats_id: String,
         report_tx: InputMessageSender,
-        task_client: TaskClient,
+        task_client: nym_task::TaskClient,
     ) -> ClientStatsSender {
-        let (controller, sender) = Self::create(
-            reporting_config,
-            client_type,
-            client_stats_id,
-            report_tx,
-            task_client,
-        );
-        controller.start();
+        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

@@ -2,7 +2,8 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use nym_sphinx::addressing::clients::Recipient;
-use nym_topology::{NymRouteProvider, NymTopology, NymTopologyError};
+use nym_sphinx::params::DEFAULT_NUM_MIX_HOPS;
+use nym_topology::{NymTopology, NymTopologyError};
 use std::ops::Deref;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
@@ -16,36 +17,29 @@ pub struct TopologyAccessorInner {
     // few seconds, while reads are needed every single packet generated.
     // However, proper benchmarks will be needed to determine if `RwLock` is indeed a better
     // approach than a `Mutex`
-    topology: RwLock<NymRouteProvider>,
+    topology: RwLock<Option<NymTopology>>,
 }
 
 impl TopologyAccessorInner {
-    fn new(initial: NymRouteProvider) -> Self {
+    fn new() -> Self {
         TopologyAccessorInner {
             controlled_manually: AtomicBool::new(false),
             released_manual_control: Notify::new(),
-            topology: RwLock::new(initial),
+            topology: RwLock::new(None),
         }
     }
 
     async fn update(&self, new: Option<NymTopology>) {
-        let mut guard = self.topology.write().await;
-
-        match new {
-            Some(updated) => {
-                guard.update(updated);
-            }
-            None => guard.clear_topology(),
-        }
+        *self.topology.write().await = new;
     }
 }
 
 pub struct TopologyReadPermit<'a> {
-    permit: RwLockReadGuard<'a, NymRouteProvider>,
+    permit: RwLockReadGuard<'a, Option<NymTopology>>,
 }
 
 impl Deref for TopologyReadPermit<'_> {
-    type Target = NymRouteProvider;
+    type Target = Option<NymTopology>;
 
     fn deref(&self) -> &Self::Target {
         &self.permit
@@ -59,31 +53,43 @@ impl<'a> TopologyReadPermit<'a> {
         &'a self,
         ack_recipient: &Recipient,
         packet_recipient: Option<&Recipient>,
-    ) -> Result<&'a NymRouteProvider, NymTopologyError> {
-        let route_provider = self.permit.deref();
-        let topology = &route_provider.topology;
-
+    ) -> Result<&'a NymTopology, NymTopologyError> {
         // 1. Have we managed to get anything from the refresher, i.e. have the nym-api queries gone through?
-        topology.ensure_not_empty()?;
+        let topology = self
+            .permit
+            .as_ref()
+            .ok_or(NymTopologyError::EmptyNetworkTopology)?;
 
-        // 2. does the topology have a node on each mixing layer?
-        topology.ensure_minimally_routable()?;
+        // 2. does it have any mixnode at all?
+        // 3. does it have any gateways at all?
+        // 4. does it have a mixnode on each layer?
+        topology.ensure_can_construct_path_through(DEFAULT_NUM_MIX_HOPS)?;
 
-        // 3. does it contain OUR gateway (so that we could create an ack packet)?
-        let _ = route_provider.egress_by_identity(ack_recipient.gateway())?;
-
-        // 4. for our target recipient, does it contain THEIR gateway (so that we send anything over?)
-        if let Some(recipient) = packet_recipient {
-            let _ = route_provider.egress_by_identity(recipient.gateway())?;
+        // 5. does it contain OUR gateway (so that we could create an ack packet)?
+        if !topology.gateway_exists(ack_recipient.gateway()) {
+            return Err(NymTopologyError::NonExistentGatewayError {
+                identity_key: ack_recipient.gateway().to_base58_string(),
+            });
         }
 
-        Ok(route_provider)
+        // 6. for our target recipient, does it contain THEIR gateway (so that we could create
+        if let Some(recipient) = packet_recipient {
+            if !topology.gateway_exists(recipient.gateway()) {
+                return Err(NymTopologyError::NonExistentGatewayError {
+                    identity_key: recipient.gateway().to_base58_string(),
+                });
+            }
+        }
+
+        Ok(topology)
     }
 }
 
-impl<'a> From<RwLockReadGuard<'a, NymRouteProvider>> for TopologyReadPermit<'a> {
-    fn from(permit: RwLockReadGuard<'a, NymRouteProvider>) -> Self {
-        TopologyReadPermit { permit }
+impl<'a> From<RwLockReadGuard<'a, Option<NymTopology>>> for TopologyReadPermit<'a> {
+    fn from(read_permit: RwLockReadGuard<'a, Option<NymTopology>>) -> Self {
+        TopologyReadPermit {
+            permit: read_permit,
+        }
     }
 }
 
@@ -93,11 +99,9 @@ pub struct TopologyAccessor {
 }
 
 impl TopologyAccessor {
-    pub fn new(ignore_egress_epoch_roles: bool) -> Self {
+    pub fn new() -> Self {
         TopologyAccessor {
-            inner: Arc::new(TopologyAccessorInner::new(NymRouteProvider::new_empty(
-                ignore_egress_epoch_roles,
-            ))),
+            inner: Arc::new(TopologyAccessorInner::new()),
         }
     }
 
@@ -117,21 +121,8 @@ impl TopologyAccessor {
         self.inner.released_manual_control.notified().await
     }
 
-    #[deprecated(note = "use .current_route_provider instead")]
     pub async fn current_topology(&self) -> Option<NymTopology> {
-        self.current_route_provider()
-            .await
-            .as_ref()
-            .map(|p| p.topology.clone())
-    }
-
-    pub async fn current_route_provider(&self) -> Option<RwLockReadGuard<NymRouteProvider>> {
-        let provider = self.inner.topology.read().await;
-        if provider.topology.is_empty() {
-            None
-        } else {
-            Some(provider)
-        }
+        self.inner.topology.read().await.clone()
     }
 
     pub async fn manually_change_topology(&self, new_topology: NymTopology) {
@@ -149,11 +140,15 @@ impl TopologyAccessor {
     // only used by the client at startup to get a slightly more reasonable error message
     // (currently displays as unused because health checker is disabled due to required changes)
     pub async fn ensure_is_routable(&self) -> Result<(), NymTopologyError> {
-        self.inner
-            .topology
-            .read()
-            .await
-            .topology
-            .ensure_minimally_routable()
+        match self.inner.topology.read().await.deref() {
+            None => Err(NymTopologyError::EmptyNetworkTopology),
+            Some(ref topology) => topology.ensure_can_construct_path_through(DEFAULT_NUM_MIX_HOPS),
+        }
+    }
+}
+
+impl Default for TopologyAccessor {
+    fn default() -> Self {
+        TopologyAccessor::new()
     }
 }

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

@@ -3,6 +3,7 @@ use log::{debug, error};
 use nym_explorer_client::{ExplorerClient, PrettyDetailedMixNodeBond};
 use nym_network_defaults::var_names::EXPLORER_API;
 use nym_topology::{
+    nym_topology_from_basic_info,
     provider_trait::{async_trait, TopologyProvider},
     NymTopology,
 };
@@ -14,6 +15,8 @@ use url::Url;
 
 pub use nym_country_group::CountryGroup;
 
+const MIN_NODES_PER_LAYER: usize = 1;
+
 fn create_explorer_client() -> Option<ExplorerClient> {
     let Ok(explorer_api_url) = std::env::var(EXPLORER_API) else {
         error!("Missing EXPLORER_API");
@@ -60,20 +63,30 @@ fn log_mixnode_distribution(mixnodes: &HashMap<CountryGroup, Vec<NodeId>>) {
 }
 
 fn check_layer_integrity(topology: NymTopology) -> Result<(), ()> {
-    if topology.ensure_minimally_routable().is_err() {
+    let mixes = topology.mixes();
+    if mixes.keys().len() < 3 {
         error!("Layer is missing in topology!");
         return Err(());
     }
+    for (layer, mixnodes) in mixes {
+        debug!("Layer {:?} has {} mixnodes", layer, mixnodes.len());
+        if mixnodes.len() < MIN_NODES_PER_LAYER {
+            error!(
+                "There are only {} mixnodes in layer {:?}",
+                mixnodes.len(),
+                layer
+            );
+            return Err(());
+        }
+    }
     Ok(())
 }
 
-#[deprecated(note = "use NymApiTopologyProvider instead as explorer API will soon be removed")]
 pub struct GeoAwareTopologyProvider {
     validator_client: nym_validator_client::client::NymApiClient,
     filter_on: GroupBy,
 }
 
-#[allow(deprecated)]
 impl GeoAwareTopologyProvider {
     pub fn new(mut nym_api_urls: Vec<Url>, filter_on: GroupBy) -> GeoAwareTopologyProvider {
         log::info!(
@@ -91,15 +104,6 @@ impl GeoAwareTopologyProvider {
     }
 
     async fn get_topology(&self) -> Option<NymTopology> {
-        let rewarded_set = self
-            .validator_client
-            .get_current_rewarded_set()
-            .await
-            .inspect_err(|err| error!("failed to get current rewarded set: {err}"))
-            .ok()?;
-
-        let mut topology = NymTopology::new_empty(rewarded_set);
-
         let mixnodes = match self
             .validator_client
             .get_all_basic_active_mixing_assigned_nodes()
@@ -183,8 +187,7 @@ impl GeoAwareTopologyProvider {
             .filter(|m| filtered_mixnode_ids.contains(&m.node_id))
             .collect::<Vec<_>>();
 
-        topology.add_skimmed_nodes(&mixnodes);
-        topology.add_skimmed_nodes(&gateways);
+        let topology = nym_topology_from_basic_info(&mixnodes, &gateways);
 
         // TODO: return real error type
         check_layer_integrity(topology.clone()).ok()?;
@@ -193,7 +196,6 @@ impl GeoAwareTopologyProvider {
     }
 }
 
-#[allow(deprecated)]
 #[cfg(not(target_arch = "wasm32"))]
 #[async_trait]
 impl TopologyProvider for GeoAwareTopologyProvider {
@@ -203,7 +205,6 @@ impl TopologyProvider for GeoAwareTopologyProvider {
     }
 }
 
-#[allow(deprecated)]
 #[cfg(target_arch = "wasm32")]
 #[async_trait(?Send)]
 impl TopologyProvider for GeoAwareTopologyProvider {

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

@@ -6,7 +6,6 @@ pub(crate) use accessor::{TopologyAccessor, TopologyReadPermit};
 use futures::StreamExt;
 use log::*;
 use nym_sphinx::addressing::nodes::NodeIdentity;
-use nym_task::TaskClient;
 use nym_topology::NymTopologyError;
 use std::time::Duration;
 
@@ -20,7 +19,6 @@ mod accessor;
 pub mod geo_aware_provider;
 pub mod nym_api_provider;
 
-#[allow(deprecated)]
 pub use geo_aware_provider::GeoAwareTopologyProvider;
 pub use nym_api_provider::{Config as NymApiTopologyProviderConfig, NymApiTopologyProvider};
 pub use nym_topology::provider_trait::TopologyProvider;
@@ -29,7 +27,7 @@ pub use nym_topology::provider_trait::TopologyProvider;
 const MAX_FAILURE_COUNT: usize = 10;
 
 pub struct TopologyRefresherConfig {
-    pub refresh_rate: Duration,
+    refresh_rate: Duration,
 }
 
 impl TopologyRefresherConfig {
@@ -44,8 +42,6 @@ pub struct TopologyRefresher {
 
     refresh_rate: Duration,
     consecutive_failure_count: usize,
-
-    task_client: TaskClient,
 }
 
 impl TopologyRefresher {
@@ -53,14 +49,12 @@ impl TopologyRefresher {
         cfg: TopologyRefresherConfig,
         topology_accessor: TopologyAccessor,
         topology_provider: Box<dyn TopologyProvider + Send + Sync>,
-        task_client: TaskClient,
     ) -> Self {
         TopologyRefresher {
             topology_provider,
             topology_accessor,
             refresh_rate: cfg.refresh_rate,
             consecutive_failure_count: 0,
-            task_client,
         }
     }
 
@@ -102,24 +96,28 @@ impl TopologyRefresher {
         self.topology_accessor.ensure_is_routable().await
     }
 
-    pub async fn ensure_contains_routable_egress(
+    pub async fn ensure_contains_gateway(
         &self,
-        egress: NodeIdentity,
+        gateway: &NodeIdentity,
     ) -> Result<(), NymTopologyError> {
         let topology = self
             .topology_accessor
-            .current_route_provider()
+            .current_topology()
             .await
             .ok_or(NymTopologyError::EmptyNetworkTopology)?;
 
-        let _ = topology.egress_by_identity(egress)?;
+        if !topology.gateway_exists(gateway) {
+            return Err(NymTopologyError::NonExistentGatewayError {
+                identity_key: gateway.to_base58_string(),
+            });
+        }
 
         Ok(())
     }
 
     pub async fn wait_for_gateway(
         &mut self,
-        gateway: NodeIdentity,
+        gateway: &NodeIdentity,
         timeout_duration: Duration,
     ) -> Result<(), NymTopologyError> {
         info!(
@@ -137,7 +135,7 @@ impl TopologyRefresher {
                     })
                 }
                 _ = self.try_refresh() => {
-                    if self.ensure_contains_routable_egress(gateway).await.is_ok() {
+                    if self.ensure_contains_gateway(gateway).await.is_ok() {
                         return Ok(())
                     }
                     info!("gateway '{gateway}' is still not online...");
@@ -147,7 +145,7 @@ impl TopologyRefresher {
         }
     }
 
-    pub fn start(mut self) {
+    pub fn start_with_shutdown(mut self, mut shutdown: nym_task::TaskClient) {
         spawn_future(async move {
             debug!("Started TopologyRefresher with graceful shutdown support");
 
@@ -160,17 +158,17 @@ impl TopologyRefresher {
             let mut interval =
                 gloo_timers::future::IntervalStream::new(self.refresh_rate.as_millis() as u32);
 
-            while !self.task_client.is_shutdown() {
+            while !shutdown.is_shutdown() {
                 tokio::select! {
                     _ = interval.next() => {
                         self.try_refresh().await;
                     },
-                    _ = self.task_client.recv() => {
+                    _ = shutdown.recv() => {
                         log::trace!("TopologyRefresher: Received shutdown");
                     },
                 }
             }
-            self.task_client.recv_timeout().await;
+            shutdown.recv_timeout().await;
             log::debug!("TopologyRefresher: Exiting");
         })
     }

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

@@ -4,39 +4,32 @@
 use async_trait::async_trait;
 use log::{debug, error, warn};
 use nym_topology::provider_trait::TopologyProvider;
-use nym_topology::NymTopology;
+use nym_topology::{NymTopology, NymTopologyError};
 use nym_validator_client::UserAgent;
 use rand::prelude::SliceRandom;
 use rand::thread_rng;
-use std::cmp::min;
 use url::Url;
 
+// the same values as our current (10.06.24) blacklist
+pub const DEFAULT_MIN_MIXNODE_PERFORMANCE: u8 = 50;
+pub const DEFAULT_MIN_GATEWAY_PERFORMANCE: u8 = 50;
+
 #[derive(Debug)]
 pub struct Config {
     pub min_mixnode_performance: u8,
     pub min_gateway_performance: u8,
-    pub use_extended_topology: bool,
-    pub ignore_egress_epoch_role: bool,
 }
 
-impl From<nym_client_core_config_types::Topology> for Config {
-    fn from(value: nym_client_core_config_types::Topology) -> Self {
+impl Default for Config {
+    fn default() -> Self {
+        // old values that decided on blacklist membership
         Config {
-            min_mixnode_performance: value.minimum_mixnode_performance,
-            min_gateway_performance: value.minimum_gateway_performance,
-            use_extended_topology: value.use_extended_topology,
-            ignore_egress_epoch_role: value.ignore_egress_epoch_role,
+            min_mixnode_performance: DEFAULT_MIN_MIXNODE_PERFORMANCE,
+            min_gateway_performance: DEFAULT_MIN_GATEWAY_PERFORMANCE,
         }
     }
 }
 
-impl Config {
-    // if we're using 'extended' topology, filter the nodes based on the lowest set performance
-    fn min_node_performance(&self) -> u8 {
-        min(self.min_mixnode_performance, self.min_gateway_performance)
-    }
-}
-
 pub struct NymApiTopologyProvider {
     config: Config,
 
@@ -46,11 +39,7 @@ pub struct NymApiTopologyProvider {
 }
 
 impl NymApiTopologyProvider {
-    pub fn new(
-        config: impl Into<Config>,
-        mut nym_api_urls: Vec<Url>,
-        user_agent: Option<UserAgent>,
-    ) -> Self {
+    pub fn new(config: Config, mut nym_api_urls: Vec<Url>, user_agent: Option<UserAgent>) -> Self {
         nym_api_urls.shuffle(&mut thread_rng());
 
         let validator_client = if let Some(user_agent) = user_agent {
@@ -63,7 +52,7 @@ impl NymApiTopologyProvider {
         };
 
         NymApiTopologyProvider {
-            config: config.into(),
+            config,
             validator_client,
             nym_api_urls,
             currently_used_api: 0,
@@ -81,69 +70,70 @@ impl NymApiTopologyProvider {
             .change_nym_api(self.nym_api_urls[self.currently_used_api].clone())
     }
 
+    /// Verifies whether nodes a reasonably distributed among all mix layers.
+    ///
+    /// In ideal world we would have 33% nodes on layer 1, 33% on layer 2 and 33% on layer 3.
+    /// However, this is a rather unrealistic expectation, instead we check whether there exists
+    /// a layer with more than 66% of nodes or with fewer than 15% and if so, we trigger a failure.
+    ///
+    /// # Arguments
+    ///
+    /// * `topology`: active topology constructed from validator api data
+    fn check_layer_distribution(
+        &self,
+        active_topology: &NymTopology,
+    ) -> Result<(), NymTopologyError> {
+        let lower_threshold = 0.15;
+        let upper_threshold = 0.66;
+        active_topology.ensure_even_layer_distribution(lower_threshold, upper_threshold)
+    }
+
     async fn get_current_compatible_topology(&mut self) -> Option<NymTopology> {
-        let rewarded_set = self
+        let mixnodes = match self
             .validator_client
-            .get_current_rewarded_set()
+            .get_all_basic_active_mixing_assigned_nodes()
             .await
-            .inspect_err(|err| error!("failed to get current rewarded set: {err}"))
-            .ok()?;
-
-        let mut topology = NymTopology::new_empty(rewarded_set);
-
-        if self.config.use_extended_topology {
-            let all_nodes = self
-                .validator_client
-                .get_all_basic_nodes()
-                .await
-                .inspect_err(|err| error!("failed to get network nodes: {err}"))
-                .ok()?;
-
-            debug!(
-                "there are {} nodes on the network (before filtering)",
-                all_nodes.len()
-            );
-            topology.add_additional_nodes(all_nodes.iter().filter(|n| {
-                n.performance.round_to_integer() >= self.config.min_node_performance()
-            }));
-        } else {
-            // if we're not using extended topology, we're only getting active set mixnodes and gateways
-
-            let mixnodes = self
-                .validator_client
-                .get_all_basic_active_mixing_assigned_nodes()
-                .await
-                .inspect_err(|err| error!("failed to get network mixnodes: {err}"))
-                .ok()?;
-
-            // TODO: we really should be getting ACTIVE gateways only
-            let gateways = self
-                .validator_client
-                .get_all_basic_entry_assigned_nodes()
-                .await
-                .inspect_err(|err| error!("failed to get network gateways: {err}"))
-                .ok()?;
-
-            debug!(
-                "there are {} mixnodes and {} gateways in total (before performance filtering)",
-                mixnodes.len(),
-                gateways.len()
-            );
-
-            topology.add_additional_nodes(mixnodes.iter().filter(|m| {
-                m.performance.round_to_integer() >= self.config.min_mixnode_performance
-            }));
-            topology.add_additional_nodes(gateways.iter().filter(|m| {
-                m.performance.round_to_integer() >= self.config.min_gateway_performance
-            }));
+        {
+            Err(err) => {
+                error!("failed to get network mixnodes - {err}");
+                return None;
+            }
+            Ok(mixes) => mixes,
         };
 
-        if !topology.is_minimally_routable() {
-            error!("the current filtered active topology can't be used to construct any packets");
-            return None;
-        }
+        let gateways = match self
+            .validator_client
+            .get_all_basic_entry_assigned_nodes()
+            .await
+        {
+            Err(err) => {
+                error!("failed to get network gateways - {err}");
+                return None;
+            }
+            Ok(gateways) => gateways,
+        };
 
-        Some(topology)
+        debug!(
+            "there are {} mixnodes and {} gateways in total (before performance filtering)",
+            mixnodes.len(),
+            gateways.len()
+        );
+
+        let topology = NymTopology::from_unordered(
+            mixnodes.iter().filter(|m| {
+                m.performance.round_to_integer() >= self.config.min_mixnode_performance
+            }),
+            gateways.iter().filter(|g| {
+                g.performance.round_to_integer() >= self.config.min_gateway_performance
+            }),
+        );
+        if let Err(err) = self.check_layer_distribution(&topology) {
+            warn!("The current filtered active topology has extremely skewed layer distribution. It cannot be used: {err}");
+            self.use_next_nym_api();
+            None
+        } else {
+            Some(topology)
+        }
     }
 }
 
@@ -152,11 +142,7 @@ impl NymApiTopologyProvider {
 #[async_trait]
 impl TopologyProvider for NymApiTopologyProvider {
     async fn get_new_topology(&mut self) -> Option<NymTopology> {
-        let Some(topology) = self.get_current_compatible_topology().await else {
-            self.use_next_nym_api();
-            return None;
-        };
-        Some(topology)
+        self.get_current_compatible_topology().await
     }
 }
 
@@ -164,10 +150,6 @@ impl TopologyProvider for NymApiTopologyProvider {
 #[async_trait(?Send)]
 impl TopologyProvider for NymApiTopologyProvider {
     async fn get_new_topology(&mut self) -> Option<NymTopology> {
-        let Some(topology) = self.get_current_compatible_topology().await else {
-            self.use_next_nym_api();
-            return None;
-        };
-        Some(topology)
+        self.get_current_compatible_topology().await
     }
 }

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

@@ -58,8 +58,8 @@ impl<T> TransmissionBuffer<T> {
     }
 
     #[cfg(not(target_arch = "wasm32"))]
-    pub(crate) fn lanes(&self) -> Vec<TransmissionLane> {
-        self.buffer.keys().cloned().collect()
+    pub(crate) fn num_lanes(&self) -> usize {
+        self.buffer.keys().count()
     }
 
     pub(crate) fn lane_length(&self, lane: &TransmissionLane) -> Option<usize> {
@@ -83,7 +83,6 @@ impl<T> TransmissionBuffer<T> {
     }
 
     #[cfg(not(target_arch = "wasm32"))]
-    #[allow(unused)]
     pub(crate) fn total_size_in_bytes(&self) -> usize
     where
         T: SizedData,

common/client-core/src/error.rs

@@ -4,17 +4,14 @@
 use crate::client::mix_traffic::transceiver::ErasedGatewayError;
 use nym_crypto::asymmetric::identity::Ed25519RecoveryError;
 use nym_gateway_client::error::GatewayClientError;
-use nym_topology::node::RoutingNodeError;
-use nym_topology::{NodeId, NymTopologyError};
+use nym_topology::gateway::GatewayConversionError;
+use nym_topology::NymTopologyError;
 use nym_validator_client::ValidatorClientError;
 use std::error::Error;
 use std::path::PathBuf;
 
 #[derive(thiserror::Error, Debug)]
 pub enum ClientCoreError {
-    #[error("could not perform the state migration: {0}")]
-    UnsupportedMigration(String),
-
     #[error("I/O error: {0}")]
     IoError(#[from] std::io::Error),
 
@@ -39,13 +36,6 @@ pub enum ClientCoreError {
     #[error("no gateway with id: {0}")]
     NoGatewayWithId(String),
 
-    #[error("Invalid URL: {0}")]
-    InvalidUrl(String),
-
-    #[cfg(not(target_arch = "wasm32"))]
-    #[error("resolution failed: {0}")]
-    ResolutionFailed(#[from] nym_http_api_client::HickoryDnsError),
-
     #[error("no gateways on network")]
     NoGatewaysOnNetwork,
 
@@ -84,10 +74,10 @@ pub enum ClientCoreError {
     #[error("the gateway id is invalid - {0}")]
     UnableToCreatePublicKeyFromGatewayId(Ed25519RecoveryError),
 
-    #[error("the node is malformed: {source}")]
+    #[error("The gateway is malformed: {source}")]
     MalformedGateway {
         #[from]
-        source: Box<RoutingNodeError>,
+        source: GatewayConversionError,
     },
 
     #[error("failed to establish connection to gateway: {source}")]
@@ -106,9 +96,6 @@ pub enum ClientCoreError {
     #[error("timed out while trying to establish gateway connection")]
     GatewayConnectionTimeout,
 
-    #[error("failed to forward mix messages to gateway")]
-    GatewayFailedToForwardMessages,
-
     #[error("no ping measurements for the gateway ({identity}) performed")]
     NoGatewayMeasurements { identity: String },
 
@@ -172,9 +159,6 @@ pub enum ClientCoreError {
     #[error("the specified gateway '{gateway}' does not support the wss protocol")]
     UnsupportedWssProtocol { gateway: String },
 
-    #[error("node {id} ({identity}) does not support mixnet entry mode")]
-    UnsupportedEntry { id: NodeId, identity: String },
-
     #[error(
     "failed to load custom topology using path '{}'. detailed message: {source}", file_path.display()
     )]
@@ -225,9 +209,6 @@ pub enum ClientCoreError {
         "fresh registration with gateway {gateway_id} somehow requires an additional key upgrade!"
     )]
     UnexpectedKeyUpgrade { gateway_id: String },
-
-    #[error("failed to derive keys from master key")]
-    HkdfDerivationError {},
 }
 
 /// Set of messages that the client can send to listeners via the task manager

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

@@ -7,7 +7,7 @@ use futures::{SinkExt, StreamExt};
 use log::{debug, info, trace, warn};
 use nym_crypto::asymmetric::identity;
 use nym_gateway_client::GatewayClient;
-use nym_topology::node::RoutingNode;
+use nym_topology::gateway;
 use nym_validator_client::client::IdentityKeyRef;
 use nym_validator_client::UserAgent;
 use rand::{seq::SliceRandom, Rng};
@@ -15,10 +15,6 @@ use std::{sync::Arc, time::Duration};
 use tungstenite::Message;
 use url::Url;
 
-#[cfg(not(target_arch = "wasm32"))]
-use crate::init::websockets::connect_async;
-
-use nym_topology::NodeId;
 #[cfg(not(target_arch = "wasm32"))]
 use tokio::net::TcpStream;
 #[cfg(not(target_arch = "wasm32"))]
@@ -26,7 +22,10 @@ use tokio::time::sleep;
 #[cfg(not(target_arch = "wasm32"))]
 use tokio::time::Instant;
 #[cfg(not(target_arch = "wasm32"))]
+use tokio_tungstenite::connect_async;
+#[cfg(not(target_arch = "wasm32"))]
 use tokio_tungstenite::{MaybeTlsStream, WebSocketStream};
+
 #[cfg(target_arch = "wasm32")]
 use wasm_utils::websocket::JSWebsocket;
 #[cfg(target_arch = "wasm32")]
@@ -49,30 +48,22 @@ const PING_TIMEOUT: Duration = Duration::from_millis(1000);
 
 // The abstraction that some of these helpers use
 pub trait ConnectableGateway {
-    fn node_id(&self) -> NodeId;
-    fn identity(&self) -> identity::PublicKey;
-    fn clients_address(&self, prefer_ipv6: bool) -> Option<String>;
+    fn identity(&self) -> &identity::PublicKey;
+    fn clients_address(&self) -> String;
     fn is_wss(&self) -> bool;
 }
 
-impl ConnectableGateway for RoutingNode {
-    fn node_id(&self) -> NodeId {
-        self.node_id
+impl ConnectableGateway for gateway::LegacyNode {
+    fn identity(&self) -> &identity::PublicKey {
+        self.identity()
     }
 
-    fn identity(&self) -> identity::PublicKey {
-        self.identity_key
-    }
-
-    fn clients_address(&self, prefer_ipv6: bool) -> Option<String> {
-        self.ws_entry_address(prefer_ipv6)
+    fn clients_address(&self) -> String {
+        self.clients_address()
     }
 
     fn is_wss(&self) -> bool {
-        self.entry
-            .as_ref()
-            .map(|e| e.clients_wss_port.is_some())
-            .unwrap_or_default()
+        self.clients_wss_port.is_some()
     }
 }
 
@@ -87,13 +78,12 @@ impl<'a, G: ConnectableGateway> GatewayWithLatency<'a, G> {
     }
 }
 
-pub async fn gateways_for_init<R: Rng>(
+pub async fn current_gateways<R: Rng>(
     rng: &mut R,
     nym_apis: &[Url],
     user_agent: Option<UserAgent>,
     minimum_performance: u8,
-    ignore_epoch_roles: bool,
-) -> Result<Vec<RoutingNode>, ClientCoreError> {
+) -> Result<Vec<gateway::LegacyNode>, ClientCoreError> {
     let nym_api = nym_apis
         .choose(rng)
         .ok_or(ClientCoreError::ListOfNymApisIsEmpty)?;
@@ -110,14 +100,11 @@ pub async fn gateways_for_init<R: Rng>(
 
     log::trace!("Gateways: {:#?}", gateways);
 
-    // filter out gateways below minimum performance and ones that could operate as a mixnode
-    // (we don't want instability)
     let valid_gateways = gateways
         .iter()
-        .filter(|g| ignore_epoch_roles || !g.supported_roles.mixnode)
         .filter(|g| g.performance.round_to_integer() >= minimum_performance)
         .filter_map(|gateway| gateway.try_into().ok())
-        .collect::<Vec<_>>();
+        .collect::<Vec<gateway::LegacyNode>>();
     log::debug!("After checking validity: {}", valid_gateways.len());
     log::trace!("Valid gateways: {:#?}", valid_gateways);
 
@@ -133,7 +120,7 @@ pub async fn gateways_for_init<R: Rng>(
 async fn connect(endpoint: &str) -> Result<WsConn, ClientCoreError> {
     match tokio::time::timeout(CONN_TIMEOUT, connect_async(endpoint)).await {
         Err(_elapsed) => Err(ClientCoreError::GatewayConnectionTimeout),
-        Ok(Err(conn_failure)) => Err(conn_failure),
+        Ok(Err(conn_failure)) => Err(conn_failure.into()),
         Ok(Ok((stream, _))) => Ok(stream),
     }
 }
@@ -147,12 +134,7 @@ async fn measure_latency<G>(gateway: &G) -> Result<GatewayWithLatency<G>, Client
 where
     G: ConnectableGateway,
 {
-    let Some(addr) = gateway.clients_address(false) else {
-        return Err(ClientCoreError::UnsupportedEntry {
-            id: gateway.node_id(),
-            identity: gateway.identity().to_string(),
-        });
-    };
+    let addr = gateway.clients_address();
     trace!(
         "establishing connection to {} ({addr})...",
         gateway.identity(),
@@ -208,7 +190,7 @@ where
     Ok(GatewayWithLatency::new(gateway, avg))
 }
 
-pub async fn choose_gateway_by_latency<R: Rng, G: ConnectableGateway + Clone>(
+pub async fn choose_gateway_by_latency<'a, R: Rng, G: ConnectableGateway + Clone>(
     rng: &mut R,
     gateways: &[G],
     must_use_tls: bool,
@@ -223,7 +205,7 @@ pub async fn choose_gateway_by_latency<R: Rng, G: ConnectableGateway + Clone>(
     let gateways_with_latency = Arc::new(tokio::sync::Mutex::new(Vec::new()));
     futures::stream::iter(gateways)
         .for_each_concurrent(CONCURRENT_GATEWAYS_MEASURED, |gateway| async {
-            let id = gateway.identity();
+            let id = *gateway.identity();
             trace!("measuring latency to {id}...");
             match measure_latency(gateway).await {
                 Ok(with_latency) => {
@@ -270,9 +252,9 @@ fn filter_by_tls<G: ConnectableGateway>(
 
 pub(super) fn uniformly_random_gateway<R: Rng>(
     rng: &mut R,
-    gateways: &[RoutingNode],
+    gateways: &[gateway::LegacyNode],
     must_use_tls: bool,
-) -> Result<RoutingNode, ClientCoreError> {
+) -> Result<gateway::LegacyNode, ClientCoreError> {
     filter_by_tls(gateways, must_use_tls)?
         .choose(rng)
         .ok_or(ClientCoreError::NoGatewaysOnNetwork)
@@ -281,9 +263,9 @@ pub(super) fn uniformly_random_gateway<R: Rng>(
 
 pub(super) fn get_specified_gateway(
     gateway_identity: IdentityKeyRef,
-    gateways: &[RoutingNode],
+    gateways: &[gateway::LegacyNode],
     must_use_tls: bool,
-) -> Result<RoutingNode, ClientCoreError> {
+) -> Result<gateway::LegacyNode, ClientCoreError> {
     log::debug!("Requesting specified gateway: {}", gateway_identity);
     let user_gateway = identity::PublicKey::from_base58_string(gateway_identity)
         .map_err(ClientCoreError::UnableToCreatePublicKeyFromGatewayId)?;
@@ -293,14 +275,7 @@ pub(super) fn get_specified_gateway(
         .find(|gateway| gateway.identity_key == user_gateway)
         .ok_or_else(|| ClientCoreError::NoGatewayWithId(gateway_identity.to_string()))?;
 
-    let Some(entry_details) = gateway.entry.as_ref() else {
-        return Err(ClientCoreError::UnsupportedEntry {
-            id: gateway.node_id,
-            identity: gateway.identity().to_string(),
-        });
-    };
-
-    if must_use_tls && entry_details.clients_wss_port.is_none() {
+    if must_use_tls && gateway.clients_wss_port.is_none() {
         return Err(ClientCoreError::UnsupportedWssProtocol {
             gateway: gateway_identity.to_string(),
         });
@@ -335,6 +310,14 @@ pub(super) async fn register_with_gateway(
             }
         })?;
 
+    // this should NEVER happen, if it did, it means the function was misused,
+    // because for any fresh **registration**, the derived key is always up to date
+    if auth_response.requires_key_upgrade {
+        return Err(ClientCoreError::UnexpectedKeyUpgrade {
+            gateway_id: gateway_id.to_base58_string(),
+        });
+    }
+
     Ok(RegistrationResult {
         shared_keys: auth_response.initial_shared_key,
         authenticated_ephemeral_client: gateway_client,

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

@@ -19,15 +19,13 @@ use crate::init::types::{
 use nym_client_core_gateways_storage::GatewaysDetailsStore;
 use nym_client_core_gateways_storage::{GatewayDetails, GatewayRegistration};
 use nym_gateway_client::client::InitGatewayClient;
-use nym_topology::node::RoutingNode;
+use nym_topology::gateway;
 use rand::rngs::OsRng;
 use rand::{CryptoRng, RngCore};
 use serde::Serialize;
 
 pub mod helpers;
 pub mod types;
-#[cfg(not(target_arch = "wasm32"))]
-pub(crate) mod websockets;
 
 // helpers for error wrapping
 
@@ -52,7 +50,7 @@ async fn setup_new_gateway<K, D>(
     key_store: &K,
     details_store: &D,
     selection_specification: GatewaySelectionSpecification,
-    available_gateways: Vec<RoutingNode>,
+    available_gateways: Vec<gateway::LegacyNode>,
 ) -> Result<InitialisationResult, ClientCoreError>
 where
     K: KeyStore,

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

@@ -11,13 +11,13 @@ use nym_client_core_gateways_storage::{
 };
 use nym_crypto::asymmetric::identity;
 use nym_gateway_client::client::InitGatewayClient;
-use nym_gateway_requests::shared_key::SharedSymmetricKey;
+use nym_gateway_requests::shared_key::SharedGatewayKey;
 use nym_sphinx::addressing::clients::Recipient;
-use nym_topology::node::RoutingNode;
+use nym_topology::gateway;
 use nym_validator_client::client::IdentityKey;
 use nym_validator_client::nyxd::AccountId;
 use serde::Serialize;
-use std::fmt::{Debug, Display};
+use std::fmt::Display;
 use std::sync::Arc;
 use time::OffsetDateTime;
 use url::Url;
@@ -38,23 +38,16 @@ pub enum SelectedGateway {
 
 impl SelectedGateway {
     pub fn from_topology_node(
-        node: RoutingNode,
+        node: gateway::LegacyNode,
         must_use_tls: bool,
     ) -> Result<Self, ClientCoreError> {
-        // for now, let's use 'old' behaviour, if you want to change it, you can pass it up the enum stack yourself : )
-        let prefer_ipv6 = false;
-
         let gateway_listener = if must_use_tls {
-            node.ws_entry_address_tls()
+            node.clients_address_tls()
                 .ok_or(ClientCoreError::UnsupportedWssProtocol {
                     gateway: node.identity_key.to_base58_string(),
                 })?
         } else {
-            node.ws_entry_address(prefer_ipv6)
-                .ok_or(ClientCoreError::UnsupportedEntry {
-                    id: node.node_id,
-                    identity: node.identity_key.to_base58_string(),
-                })?
+            node.clients_address()
         };
 
         let gateway_listener =
@@ -96,7 +89,7 @@ impl SelectedGateway {
 /// - shared keys derived between ourselves and the node
 /// - an authenticated handle of an ephemeral handle created for the purposes of registration
 pub struct RegistrationResult {
-    pub shared_keys: Arc<SharedSymmetricKey>,
+    pub shared_keys: Arc<SharedGatewayKey>,
     pub authenticated_ephemeral_client: InitGatewayClient,
 }
 
@@ -207,7 +200,7 @@ pub enum GatewaySetup {
         specification: GatewaySelectionSpecification,
 
         // TODO: seems to be a bit inefficient to pass them by value
-        available_gateways: Vec<RoutingNode>,
+        available_gateways: Vec<gateway::LegacyNode>,
     },
 
     ReuseConnection {
@@ -221,34 +214,6 @@ pub enum GatewaySetup {
     },
 }
 
-impl Debug for GatewaySetup {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            GatewaySetup::MustLoad { gateway_id } => f
-                .debug_struct("GatewaySetup::MustLoad")
-                .field("gateway_id", gateway_id)
-                .finish(),
-            GatewaySetup::New {
-                specification,
-                available_gateways,
-            } => f
-                .debug_struct("GatewaySetup::New")
-                .field("specification", specification)
-                .field("available_gateways", available_gateways)
-                .field("gateways", specification)
-                .finish(),
-            GatewaySetup::ReuseConnection {
-                gateway_details, ..
-            } => f
-                .debug_struct("GatewaySetup::ReuseConnection")
-                .field("authenticated_ephemeral_client", &"***")
-                .field("gateway_details", gateway_details)
-                .field("client_keys", &"***")
-                .finish(),
-        }
-    }
-}
-
 impl GatewaySetup {
     pub fn try_reuse_connection(init_res: InitialisationResult) -> Result<Self, ClientCoreError> {
         if let Some(authenticated_ephemeral_client) = init_res.authenticated_ephemeral_client {

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

@@ -1,44 +0,0 @@
-use crate::error::ClientCoreError;
-
-use nym_http_api_client::HickoryDnsResolver;
-use tokio::net::TcpStream;
-use tokio_tungstenite::{MaybeTlsStream, WebSocketStream};
-use tungstenite::handshake::client::Response;
-use url::{Host, Url};
-
-use std::net::SocketAddr;
-
-#[cfg(not(target_arch = "wasm32"))]
-pub(crate) async fn connect_async(
-    endpoint: &str,
-) -> Result<(WebSocketStream<MaybeTlsStream<TcpStream>>, Response), ClientCoreError> {
-    let resolver = HickoryDnsResolver::default();
-    let uri = Url::parse(endpoint).map_err(|_| ClientCoreError::InvalidUrl(endpoint.to_owned()))?;
-    let port: u16 = uri.port_or_known_default().unwrap_or(443);
-
-    let host = uri
-        .host()
-        .ok_or(ClientCoreError::InvalidUrl(endpoint.to_owned()))?;
-
-    // Get address for tcp connection, if a domain is provided use our preferred resolver rather than
-    // the default std resolve
-    let sock_addrs: Vec<SocketAddr> = match host {
-        Host::Ipv4(addr) => vec![SocketAddr::new(addr.into(), port)],
-        Host::Ipv6(addr) => vec![SocketAddr::new(addr.into(), port)],
-        Host::Domain(domain) => {
-            // Do a DNS lookup for the domain using our custom DNS resolver
-            resolver
-                .resolve_str(domain)
-                .await?
-                .into_iter()
-                .map(|a| SocketAddr::new(a, port))
-                .collect()
-        }
-    };
-
-    let stream = TcpStream::connect(&sock_addrs[..]).await?;
-
-    tokio_tungstenite::client_async_tls(endpoint, stream)
-        .await
-        .map_err(Into::into)
-}

common/client-core/src/lib.rs

@@ -14,7 +14,8 @@ pub mod error;
 pub mod init;
 
 pub use nym_topology::{
-    HardcodedTopologyProvider, NymRouteProvider, NymTopology, NymTopologyError, TopologyProvider,
+    HardcodedTopologyProvider, NymTopology, NymTopologyError, SerializableNymTopology,
+    SerializableTopologyError, TopologyProvider,
 };
 
 #[cfg(target_arch = "wasm32")]

common/client-core/surb-storage/src/backend/fs_backend/manager.rs

@@ -9,10 +9,7 @@ use crate::backend::fs_backend::{
     },
 };
 use log::{error, info};
-use sqlx::{
-    sqlite::{SqliteAutoVacuum, SqliteSynchronous},
-    ConnectOptions,
-};
+use sqlx::ConnectOptions;
 use std::path::Path;
 
 #[derive(Debug, Clone)]
@@ -34,9 +31,6 @@ impl StorageManager {
         }
 
         let opts = sqlx::sqlite::SqliteConnectOptions::new()
-            .journal_mode(sqlx::sqlite::SqliteJournalMode::Wal)
-            .synchronous(SqliteSynchronous::Normal)
-            .auto_vacuum(SqliteAutoVacuum::Incremental)
             .filename(database_path)
             .create_if_missing(fresh)
             .disable_statement_logging();

common/client-core/surb-storage/src/backend/fs_backend/mod.rs

@@ -22,7 +22,7 @@ mod error;
 mod manager;
 mod models;
 
-#[derive(Clone, Debug)]
+#[derive(Debug)]
 pub struct Backend {
     temporary_old_path: Option<PathBuf>,
     database_path: PathBuf,

common/client-core/surb-storage/src/backend/mod.rs

@@ -19,7 +19,7 @@ pub mod fs_backend;
 #[error("no information provided")]
 pub struct UndefinedError;
 
-#[derive(Clone, Debug)]
+#[derive(Debug)]
 pub struct Empty {
     // we need to keep 'basic' metadata here to "load" the CombinedReplyStorage
     pub min_surb_threshold: usize,

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

@@ -27,7 +27,6 @@ nym-credential-storage = { path = "../../credential-storage" }
 nym-credentials-interface = { path = "../../credentials-interface" }
 nym-crypto = { path = "../../crypto" }
 nym-gateway-requests = { path = "../../gateway-requests" }
-nym-http-api-client = { path = "../../http-api-client" }
 nym-network-defaults = { path = "../../network-defaults" }
 nym-sphinx = { path = "../../nymsphinx" }
 nym-statistics-common = { path = "../../statistics" }

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

@@ -20,8 +20,9 @@ use nym_credentials_interface::TicketType;
 use nym_crypto::asymmetric::identity;
 use nym_gateway_requests::registration::handshake::client_handshake;
 use nym_gateway_requests::{
-    BinaryRequest, ClientControlRequest, ClientRequest, GatewayProtocolVersionExt, ServerResponse,
-    SharedSymmetricKey, CREDENTIAL_UPDATE_V2_PROTOCOL_VERSION, CURRENT_PROTOCOL_VERSION,
+    BinaryRequest, ClientControlRequest, ClientRequest, SensitiveServerResponse, ServerResponse,
+    SharedGatewayKey, SharedSymmetricKey, AES_GCM_SIV_PROTOCOL_VERSION,
+    CREDENTIAL_UPDATE_V2_PROTOCOL_VERSION, CURRENT_PROTOCOL_VERSION,
 };
 use nym_sphinx::forwarding::packet::MixPacket;
 use nym_statistics_common::clients::connection::ConnectionStatsEvent;
@@ -39,6 +40,8 @@ use url::Url;
 use std::os::fd::RawFd;
 #[cfg(not(target_arch = "wasm32"))]
 use tokio::time::sleep;
+#[cfg(not(target_arch = "wasm32"))]
+use tokio_tungstenite::connect_async;
 
 #[cfg(not(unix))]
 use std::os::raw::c_int as RawFd;
@@ -46,14 +49,10 @@ use std::os::raw::c_int as RawFd;
 use wasm_utils::websocket::JSWebsocket;
 #[cfg(target_arch = "wasm32")]
 use wasmtimer::tokio::sleep;
+use zeroize::Zeroizing;
 
 pub mod config;
 
-#[cfg(not(target_arch = "wasm32"))]
-pub(crate) mod websockets;
-#[cfg(not(target_arch = "wasm32"))]
-use websockets::connect_async;
-
 pub struct GatewayConfig {
     pub gateway_identity: identity::PublicKey,
 
@@ -80,7 +79,8 @@ impl GatewayConfig {
 #[must_use]
 #[derive(Debug)]
 pub struct AuthenticationResponse {
-    pub initial_shared_key: Arc<SharedSymmetricKey>,
+    pub initial_shared_key: Arc<SharedGatewayKey>,
+    pub requires_key_upgrade: bool,
 }
 
 // TODO: this should be refactored into a state machine that keeps track of its authentication state
@@ -92,7 +92,7 @@ pub struct GatewayClient<C, St = EphemeralCredentialStorage> {
     gateway_address: String,
     gateway_identity: identity::PublicKey,
     local_identity: Arc<identity::KeyPair>,
-    shared_key: Option<Arc<SharedSymmetricKey>>,
+    shared_key: Option<Arc<SharedGatewayKey>>,
     connection: SocketState,
     packet_router: PacketRouter,
     bandwidth_controller: Option<BandwidthController<C, St>>,
@@ -101,10 +101,6 @@ pub struct GatewayClient<C, St = EphemeralCredentialStorage> {
     // currently unused (but populated)
     negotiated_protocol: Option<u8>,
 
-    // Callback on the fd as soon as the connection has been established
-    #[cfg(unix)]
-    connection_fd_callback: Option<Arc<dyn Fn(RawFd) + Send + Sync>>,
-
     /// Listen to shutdown messages and send notifications back to the task manager
     task_client: TaskClient,
 }
@@ -116,11 +112,10 @@ impl<C, St> GatewayClient<C, St> {
         gateway_config: GatewayConfig,
         local_identity: Arc<identity::KeyPair>,
         // TODO: make it mandatory. if you don't want to pass it, use `new_init`
-        shared_key: Option<Arc<SharedSymmetricKey>>,
+        shared_key: Option<Arc<SharedGatewayKey>>,
         packet_router: PacketRouter,
         bandwidth_controller: Option<BandwidthController<C, St>>,
         stats_reporter: ClientStatsSender,
-        #[cfg(unix)] connection_fd_callback: Option<Arc<dyn Fn(RawFd) + Send + Sync>>,
         task_client: TaskClient,
     ) -> Self {
         GatewayClient {
@@ -136,8 +131,6 @@ impl<C, St> GatewayClient<C, St> {
             bandwidth_controller,
             stats_reporter,
             negotiated_protocol: None,
-            #[cfg(unix)]
-            connection_fd_callback,
             task_client,
         }
     }
@@ -146,7 +139,7 @@ impl<C, St> GatewayClient<C, St> {
         self.gateway_identity
     }
 
-    pub fn shared_key(&self) -> Option<Arc<SharedSymmetricKey>> {
+    pub fn shared_key(&self) -> Option<Arc<SharedGatewayKey>> {
         self.shared_key.clone()
     }
 
@@ -201,15 +194,17 @@ impl<C, St> GatewayClient<C, St> {
             "Attemting to establish connection to gateway at: {}",
             self.gateway_address
         );
-        let (ws_stream, _) = connect_async(
-            &self.gateway_address,
-            #[cfg(unix)]
-            self.connection_fd_callback.clone(),
-        )
-        .await?;
+        let ws_stream = match connect_async(&self.gateway_address).await {
+            Ok((ws_stream, _)) => ws_stream,
+            Err(error) => {
+                return Err(GatewayClientError::NetworkConnectionFailed {
+                    address: self.gateway_address.clone(),
+                    source: error,
+                })
+            }
+        };
 
         self.connection = SocketState::Available(Box::new(ws_stream));
-
         Ok(())
     }
 
@@ -263,19 +258,6 @@ impl<C, St> GatewayClient<C, St> {
         }
     }
 
-    pub async fn send_client_request(
-        &mut self,
-        message: ClientRequest,
-    ) -> Result<(), GatewayClientError> {
-        if let Some(shared_key) = self.shared_key() {
-            let encrypted = message.encrypt(&shared_key)?;
-            Box::pin(self.send_websocket_message(encrypted)).await?;
-            Ok(())
-        } else {
-            Err(GatewayClientError::ConnectionInInvalidState)
-        }
-    }
-
     async fn read_control_response(&mut self) -> Result<ServerResponse, GatewayClientError> {
         // we use the fact that all request responses are Message::Text and only pushed
         // sphinx packets are Message::Binary
@@ -329,7 +311,7 @@ impl<C, St> GatewayClient<C, St> {
 
     // If we want to send a message (with response), we need to have a full control over the socket,
     // as we need to be able to write the request and read the subsequent response
-    pub async fn send_websocket_message(
+    async fn send_websocket_message(
         &mut self,
         msg: impl Into<Message>,
     ) -> Result<ServerResponse, GatewayClientError> {
@@ -407,39 +389,49 @@ impl<C, St> GatewayClient<C, St> {
         }
     }
 
-    fn check_gateway_protocol(&self, gateway_protocol: u8) -> Result<(), GatewayClientError> {
+    fn check_gateway_protocol(
+        &self,
+        gateway_protocol: Option<u8>,
+    ) -> Result<(), GatewayClientError> {
         debug!("gateway protocol: {gateway_protocol:?}, ours: {CURRENT_PROTOCOL_VERSION}");
 
-        // client should reject any gateways that do not indicate they support auth v2 or aes256gcm-siv
-        if !gateway_protocol.supports_authenticate_v2()
-            || !gateway_protocol.supports_aes256_gcm_siv()
-        {
-            return Err(GatewayClientError::IncompatibleProtocol {
-                gateway: gateway_protocol,
-                current: CURRENT_PROTOCOL_VERSION,
-            });
-        }
+        // right now there are no failure cases here, but this might change in the future
+        match gateway_protocol {
+            None => {
+                warn!("the gateway we're connected to has not specified its protocol version. It's probably running version < 1.1.X, but that's still fine for now. It will become a hard error in 1.2.0");
+                // note: in +1.2.0 we will have to return a hard error here
+                Ok(())
+            }
+            Some(v) if v > CURRENT_PROTOCOL_VERSION => {
+                let err = GatewayClientError::IncompatibleProtocol {
+                    gateway: Some(v),
+                    current: CURRENT_PROTOCOL_VERSION,
+                };
+                error!("{err}");
+                Err(err)
+            }
 
-        // we can't handle gateways with higher protocol than ours
-        if gateway_protocol <= CURRENT_PROTOCOL_VERSION {
-            debug!("the gateway is using exactly the same (or older) protocol version as we are. We're good to continue!");
-            Ok(())
-        } else {
-            let err = GatewayClientError::IncompatibleProtocol {
-                gateway: gateway_protocol,
-                current: CURRENT_PROTOCOL_VERSION,
-            };
-            error!("{err}");
-            Err(err)
+            Some(_) => {
+                debug!("the gateway is using exactly the same (or older) protocol version as we are. We're good to continue!");
+                Ok(())
+            }
         }
     }
 
-    async fn register(&mut self) -> Result<(), GatewayClientError> {
+    async fn register(
+        &mut self,
+        derive_aes256_gcm_siv_key: bool,
+    ) -> Result<(), GatewayClientError> {
         if !self.connection.is_established() {
             return Err(GatewayClientError::ConnectionNotEstablished);
         }
 
         debug_assert!(self.connection.is_available());
+        log::debug!(
+            "registering with gateway. using legacy key derivation: {}",
+            !derive_aes256_gcm_siv_key
+        );
+
         // it's fine to instantiate it here as it's only used once (during authentication or registration)
         // and putting it into the GatewayClient struct would be a hassle
         let mut rng = OsRng;
@@ -451,6 +443,7 @@ impl<C, St> GatewayClient<C, St> {
                 self.local_identity.as_ref(),
                 self.gateway_identity,
                 self.cfg.bandwidth.require_tickets,
+                derive_aes256_gcm_siv_key,
                 #[cfg(not(target_arch = "wasm32"))]
                 self.task_client.clone(),
             )
@@ -478,15 +471,99 @@ impl<C, St> GatewayClient<C, St> {
         }
 
         // populate the negotiated protocol for future uses
-        self.negotiated_protocol = Some(gateway_protocol);
+        self.negotiated_protocol = gateway_protocol;
 
         Ok(())
     }
 
-    async fn send_authenticate_request_and_handle_response(
+    pub async fn upgrade_key_authenticated(
         &mut self,
-        msg: ClientControlRequest,
-    ) -> Result<(), GatewayClientError> {
+    ) -> Result<Zeroizing<SharedSymmetricKey>, GatewayClientError> {
+        info!("*** STARTING AES128CTR-HMAC KEY UPGRADE INTO AES256GCM-SIV***");
+
+        if !self.connection.is_established() {
+            return Err(GatewayClientError::ConnectionNotEstablished);
+        }
+
+        if !self.authenticated {
+            return Err(GatewayClientError::NotAuthenticated);
+        }
+
+        let Some(shared_key) = self.shared_key.as_ref() else {
+            return Err(GatewayClientError::NoSharedKeyAvailable);
+        };
+
+        if !shared_key.is_legacy() {
+            return Err(GatewayClientError::KeyAlreadyUpgraded);
+        }
+
+        // make sure we have the only reference, so we could safely swap it
+        if Arc::strong_count(shared_key) != 1 {
+            return Err(GatewayClientError::KeyAlreadyInUse);
+        }
+
+        assert!(shared_key.is_legacy());
+        let legacy_key = shared_key.unwrap_legacy();
+        let (updated_key, hkdf_salt) = legacy_key.upgrade();
+        let derived_key_digest = updated_key.digest();
+
+        let upgrade_request = ClientRequest::UpgradeKey {
+            hkdf_salt,
+            derived_key_digest,
+        }
+        .encrypt(legacy_key)?;
+
+        info!("sending upgrade request and awaiting the acknowledgement back");
+        let (ciphertext, nonce) = match self.send_websocket_message(upgrade_request).await? {
+            ServerResponse::EncryptedResponse { ciphertext, nonce } => (ciphertext, nonce),
+            ServerResponse::Error { message } => {
+                return Err(GatewayClientError::GatewayError(message))
+            }
+            other => return Err(GatewayClientError::UnexpectedResponse { name: other.name() }),
+        };
+
+        // attempt to decrypt it using NEW key
+        let Ok(response) = SensitiveServerResponse::decrypt(&ciphertext, &nonce, &updated_key)
+        else {
+            return Err(GatewayClientError::FatalKeyUpgradeFailure);
+        };
+
+        match response {
+            SensitiveServerResponse::KeyUpgradeAck { .. } => {
+                info!("received key upgrade acknowledgement")
+            }
+            _ => return Err(GatewayClientError::FatalKeyUpgradeFailure),
+        }
+
+        // perform in memory swap and make a copy for updating storage
+        let zeroizing_updated_key = updated_key.zeroizing_clone();
+        self.shared_key = Some(Arc::new(updated_key.into()));
+
+        Ok(zeroizing_updated_key)
+    }
+
+    async fn authenticate(&mut self) -> Result<(), GatewayClientError> {
+        let Some(shared_key) = self.shared_key.as_ref() else {
+            return Err(GatewayClientError::NoSharedKeyAvailable);
+        };
+
+        if !self.connection.is_established() {
+            return Err(GatewayClientError::ConnectionNotEstablished);
+        }
+        debug!("authenticating with gateway");
+
+        let self_address = self
+            .local_identity
+            .as_ref()
+            .public_key()
+            .derive_destination_address();
+
+        let msg = ClientControlRequest::new_authenticate(
+            self_address,
+            shared_key,
+            self.cfg.bandwidth.require_tickets,
+        )?;
+
         match self.send_websocket_message(msg).await? {
             ServerResponse::Authenticate {
                 protocol_version,
@@ -497,7 +574,7 @@ impl<C, St> GatewayClient<C, St> {
                 self.authenticated = status;
                 self.bandwidth.update_and_maybe_log(bandwidth_remaining);
 
-                self.negotiated_protocol = Some(protocol_version);
+                self.negotiated_protocol = protocol_version;
                 log::debug!("authenticated: {status}, bandwidth remaining: {bandwidth_remaining}");
 
                 self.task_client.send_status_msg(Box::new(
@@ -510,26 +587,6 @@ impl<C, St> GatewayClient<C, St> {
         }
     }
 
-    async fn authenticate_v2(&mut self) -> Result<(), GatewayClientError> {
-        debug!("using v2 authentication");
-        let Some(shared_key) = self.shared_key.as_ref() else {
-            return Err(GatewayClientError::NoSharedKeyAvailable);
-        };
-
-        let msg = ClientControlRequest::new_authenticate_v2(shared_key, &self.local_identity)?;
-        self.send_authenticate_request_and_handle_response(msg)
-            .await
-    }
-
-    async fn authenticate(&mut self) -> Result<(), GatewayClientError> {
-        if !self.connection.is_established() {
-            return Err(GatewayClientError::ConnectionNotEstablished);
-        }
-        debug!("authenticating with gateway");
-
-        self.authenticate_v2().await
-    }
-
     /// Helper method to either call register or authenticate based on self.shared_key value
     #[instrument(skip_all,
         fields(
@@ -545,26 +602,18 @@ impl<C, St> GatewayClient<C, St> {
         }
 
         // 1. check gateway's protocol version
-        // if we failed to get this request resolved, it means the gateway is on an old version
-        // that definitely does not support auth v2 or aes256gcm, so we bail
-        let gw_protocol = self.get_gateway_protocol().await?;
-
-        let supports_aes_gcm_siv = gw_protocol.supports_aes256_gcm_siv();
-        let supports_auth_v2 = gw_protocol.supports_authenticate_v2();
+        let supports_aes_gcm_siv = match self.get_gateway_protocol().await {
+            Ok(protocol) => protocol >= AES_GCM_SIV_PROTOCOL_VERSION,
+            Err(_) => {
+                // if we failed to send the request, it means the gateway is running the old binary,
+                // so it has reset our connection - we have to reconnect
+                self.establish_connection().await?;
+                false
+            }
+        };
 
         if !supports_aes_gcm_siv {
-            error!("this gateway is on an old version that doesn't support AES256-GCM-SIV");
-        }
-        if !supports_aes_gcm_siv {
-            error!("this gateway is on an old version that doesn't support authentication v2");
-        }
-
-        if !supports_auth_v2 || !supports_aes_gcm_siv {
-            // we can't continue
-            return Err(GatewayClientError::IncompatibleProtocol {
-                gateway: gw_protocol,
-                current: CURRENT_PROTOCOL_VERSION,
-            });
+            warn!("this gateway is on an old version that doesn't support AES256-GCM-SIV");
         }
 
         if self.authenticated {
@@ -572,6 +621,7 @@ impl<C, St> GatewayClient<C, St> {
             return if let Some(shared_key) = &self.shared_key {
                 Ok(AuthenticationResponse {
                     initial_shared_key: Arc::clone(shared_key),
+                    requires_key_upgrade: shared_key.is_legacy() && supports_aes_gcm_siv,
                 })
             } else {
                 Err(GatewayClientError::AuthenticationFailureWithPreexistingSharedKey)
@@ -585,14 +635,17 @@ impl<C, St> GatewayClient<C, St> {
                 // if we are authenticated it means we MUST have an associated shared_key
                 let shared_key = self.shared_key.as_ref().unwrap();
 
+                let requires_key_upgrade = shared_key.is_legacy() && supports_aes_gcm_siv;
+
                 Ok(AuthenticationResponse {
                     initial_shared_key: Arc::clone(shared_key),
+                    requires_key_upgrade,
                 })
             } else {
                 Err(GatewayClientError::AuthenticationFailure)
             }
         } else {
-            self.register().await?;
+            self.register(supports_aes_gcm_siv).await?;
 
             // if registration didn't return an error, we MUST have an associated shared key
             let shared_key = self.shared_key.as_ref().unwrap();
@@ -601,6 +654,7 @@ impl<C, St> GatewayClient<C, St> {
             // so no upgrades are required
             Ok(AuthenticationResponse {
                 initial_shared_key: Arc::clone(shared_key),
+                requires_key_upgrade: false,
             })
         }
     }
@@ -978,10 +1032,8 @@ impl GatewayClient<InitOnly, EphemeralCredentialStorage> {
             connection: SocketState::NotConnected,
             packet_router,
             bandwidth_controller: None,
-            stats_reporter: ClientStatsSender::new(None, task_client.clone()),
+            stats_reporter: ClientStatsSender::new(None),
             negotiated_protocol: None,
-            #[cfg(unix)]
-            connection_fd_callback: None,
             task_client,
         }
     }
@@ -1012,8 +1064,6 @@ impl GatewayClient<InitOnly, EphemeralCredentialStorage> {
             bandwidth_controller,
             stats_reporter,
             negotiated_protocol: self.negotiated_protocol,
-            #[cfg(unix)]
-            connection_fd_callback: self.connection_fd_callback,
             task_client,
         }
     }

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

@@ -1,88 +0,0 @@
-use crate::error::GatewayClientError;
-
-use nym_http_api_client::HickoryDnsResolver;
-#[cfg(unix)]
-use std::{
-    os::fd::{AsRawFd, RawFd},
-    sync::Arc,
-};
-use tokio::net::TcpStream;
-use tokio_tungstenite::{MaybeTlsStream, WebSocketStream};
-use tungstenite::handshake::client::Response;
-use url::{Host, Url};
-
-use std::net::SocketAddr;
-
-#[cfg(not(target_arch = "wasm32"))]
-pub(crate) async fn connect_async(
-    endpoint: &str,
-    #[cfg(unix)] connection_fd_callback: Option<Arc<dyn Fn(RawFd) + Send + Sync>>,
-) -> Result<(WebSocketStream<MaybeTlsStream<TcpStream>>, Response), GatewayClientError> {
-    use tokio::net::TcpSocket;
-
-    let resolver = HickoryDnsResolver::default();
-    let uri =
-        Url::parse(endpoint).map_err(|_| GatewayClientError::InvalidUrl(endpoint.to_owned()))?;
-    let port: u16 = uri.port_or_known_default().unwrap_or(443);
-
-    let host = uri
-        .host()
-        .ok_or(GatewayClientError::InvalidUrl(endpoint.to_owned()))?;
-
-    // Get address for tcp connection, if a domain is provided use our preferred resolver rather than
-    // the default std resolve
-    let sock_addrs: Vec<SocketAddr> = match host {
-        Host::Ipv4(addr) => vec![SocketAddr::new(addr.into(), port)],
-        Host::Ipv6(addr) => vec![SocketAddr::new(addr.into(), port)],
-        Host::Domain(domain) => {
-            // Do a DNS lookup for the domain using our custom DNS resolver
-            resolver
-                .resolve_str(domain)
-                .await?
-                .into_iter()
-                .map(|a| SocketAddr::new(a, port))
-                .collect()
-        }
-    };
-
-    let mut stream = Err(GatewayClientError::NoEndpointForConnection {
-        address: endpoint.to_owned(),
-    });
-    for sock_addr in sock_addrs {
-        let socket = if sock_addr.is_ipv4() {
-            TcpSocket::new_v4()
-        } else {
-            TcpSocket::new_v6()
-        }
-        .map_err(|err| GatewayClientError::NetworkConnectionFailed {
-            address: endpoint.to_owned(),
-            source: err.into(),
-        })?;
-
-        #[cfg(unix)]
-        if let Some(callback) = connection_fd_callback.as_ref() {
-            callback.as_ref()(socket.as_raw_fd());
-        }
-
-        match socket.connect(sock_addr).await {
-            Ok(s) => {
-                stream = Ok(s);
-                break;
-            }
-            Err(err) => {
-                stream = Err(GatewayClientError::NetworkConnectionFailed {
-                    address: endpoint.to_owned(),
-                    source: err.into(),
-                });
-                continue;
-            }
-        }
-    }
-
-    tokio_tungstenite::client_async_tls(endpoint, stream?)
-        .await
-        .map_err(|error| GatewayClientError::NetworkConnectionFailed {
-            address: endpoint.to_owned(),
-            source: error,
-        })
-}

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

@@ -43,15 +43,8 @@ pub enum GatewayClientError {
     #[error("connection failed: {address}: {source}")]
     NetworkConnectionFailed { address: String, source: WsError },
 
-    #[error("no socket address for endpoint: {address}")]
-    NoEndpointForConnection { address: String },
-
     #[error("Invalid URL: {0}")]
-    InvalidUrl(String),
-
-    #[cfg(not(target_arch = "wasm32"))]
-    #[error("resolution failed: {0}")]
-    ResolutionFailed(#[from] nym_http_api_client::HickoryDnsError),
+    InvalidURL(String),
 
     #[error("No shared key was provided or obtained")]
     NoSharedKeyAvailable,
@@ -114,7 +107,7 @@ pub enum GatewayClientError {
     MixnetMsgSenderFailedToSend,
 
     #[error("Attempted to negotiate connection with gateway using incompatible protocol version. Ours is {current} and the gateway reports {gateway:?}")]
-    IncompatibleProtocol { gateway: u8, current: u8 },
+    IncompatibleProtocol { gateway: Option<u8>, current: u8 },
 
     #[error(
         "The packet router hasn't been set - are you sure you started up the client correctly?"

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

@@ -7,7 +7,9 @@ use tracing::{error, warn};
 use tungstenite::{protocol::Message, Error as WsError};
 
 pub use client::{config::GatewayClientConfig, GatewayClient, GatewayConfig};
-pub use nym_gateway_requests::shared_key::SharedSymmetricKey;
+pub use nym_gateway_requests::shared_key::{
+    LegacySharedKeys, SharedGatewayKey, SharedSymmetricKey,
+};
 pub use packet_router::{
     AcknowledgementReceiver, AcknowledgementSender, MixnetMessageReceiver, MixnetMessageSender,
     PacketRouter,
@@ -45,7 +47,7 @@ pub(crate) fn cleanup_socket_messages(
 
 pub(crate) fn try_decrypt_binary_message(
     bin_msg: Vec<u8>,
-    shared_keys: &SharedSymmetricKey,
+    shared_keys: &SharedGatewayKey,
 ) -> Option<Vec<u8>> {
     match BinaryResponse::try_from_encrypted_tagged_bytes(bin_msg, shared_keys) {
         Ok(bin_response) => match bin_response {

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

@@ -9,7 +9,7 @@ use crate::{cleanup_socket_messages, try_decrypt_binary_message};
 use futures::channel::oneshot;
 use futures::stream::{SplitSink, SplitStream};
 use futures::{SinkExt, StreamExt};
-use nym_gateway_requests::shared_key::SharedSymmetricKey;
+use nym_gateway_requests::shared_key::SharedGatewayKey;
 use nym_gateway_requests::{ServerResponse, SimpleGatewayRequestsError};
 use nym_task::TaskClient;
 use si_scale::helpers::bibytes2;
@@ -63,7 +63,7 @@ pub(crate) struct PartiallyDelegatedHandle {
 
 struct PartiallyDelegatedRouter {
     packet_router: PacketRouter,
-    shared_key: Arc<SharedSymmetricKey>,
+    shared_key: Arc<SharedGatewayKey>,
     client_bandwidth: ClientBandwidth,
 
     stream_return: SplitStreamSender,
@@ -73,7 +73,7 @@ struct PartiallyDelegatedRouter {
 impl PartiallyDelegatedRouter {
     fn new(
         packet_router: PacketRouter,
-        shared_key: Arc<SharedSymmetricKey>,
+        shared_key: Arc<SharedGatewayKey>,
         client_bandwidth: ClientBandwidth,
         stream_return: SplitStreamSender,
         stream_return_requester: oneshot::Receiver<()>,
@@ -253,7 +253,7 @@ impl PartiallyDelegatedHandle {
     pub(crate) fn split_and_listen_for_mixnet_messages(
         conn: WsConn,
         packet_router: PacketRouter,
-        shared_key: Arc<SharedSymmetricKey>,
+        shared_key: Arc<SharedGatewayKey>,
         client_bandwidth: ClientBandwidth,
         shutdown: TaskClient,
     ) -> Self {

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

@@ -8,12 +8,10 @@ license.workspace = true
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-dashmap = { workspace = true }
 futures = { workspace = true }
 tracing = { workspace = true }
-tokio = { workspace = true, features = ["time", "sync"] }
+tokio = { workspace = true, features = ["time"] }
 tokio-util = { workspace = true, features = ["codec"], optional = true }
-tokio-stream = { workspace = true }
 
 # internal
 nym-sphinx = { path = "../../nymsphinx" }

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

@@ -1,24 +1,21 @@
-// Copyright 2021-2024 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use dashmap::DashMap;
+use futures::channel::mpsc;
 use futures::StreamExt;
 use nym_sphinx::addressing::nodes::NymNodeRoutingAddress;
 use nym_sphinx::framing::codec::NymCodec;
 use nym_sphinx::framing::packet::FramedNymPacket;
 use nym_sphinx::params::PacketType;
 use nym_sphinx::NymPacket;
+use std::collections::HashMap;
 use std::io;
 use std::net::SocketAddr;
-use std::ops::Deref;
-use std::sync::atomic::{AtomicU32, AtomicUsize, Ordering};
+use std::sync::atomic::{AtomicU32, Ordering};
 use std::sync::Arc;
 use std::time::Duration;
 use tokio::net::TcpStream;
-use tokio::sync::mpsc;
-use tokio::sync::mpsc::error::TrySendError;
 use tokio::time::sleep;
-use tokio_stream::wrappers::ReceiverStream;
 use tokio_util::codec::Framed;
 use tracing::*;
 
@@ -58,37 +55,11 @@ pub trait SendWithoutResponse {
 }
 
 pub struct Client {
-    active_connections: ActiveConnections,
-    connections_count: Arc<AtomicUsize>,
+    conn_new: HashMap<NymNodeRoutingAddress, ConnectionSender>,
     config: Config,
 }
 
-#[derive(Default, Clone)]
-pub struct ActiveConnections {
-    inner: Arc<DashMap<NymNodeRoutingAddress, ConnectionSender>>,
-}
-
-impl ActiveConnections {
-    pub fn pending_packets(&self) -> usize {
-        self.inner
-            .iter()
-            .map(|sender| {
-                let max_capacity = sender.channel.max_capacity();
-                let capacity = sender.channel.capacity();
-                max_capacity - capacity
-            })
-            .sum()
-    }
-}
-
-impl Deref for ActiveConnections {
-    type Target = DashMap<NymNodeRoutingAddress, ConnectionSender>;
-    fn deref(&self) -> &Self::Target {
-        &self.inner
-    }
-}
-
-pub struct ConnectionSender {
+struct ConnectionSender {
     channel: mpsc::Sender<FramedNymPacket>,
     current_reconnection_attempt: Arc<AtomicU32>,
 }
@@ -102,53 +73,46 @@ impl ConnectionSender {
     }
 }
 
-struct ManagedConnection {
-    address: SocketAddr,
-    message_receiver: ReceiverStream<FramedNymPacket>,
-    connection_timeout: Duration,
-    current_reconnection: Arc<AtomicU32>,
-}
-
-impl ManagedConnection {
-    fn new(
-        address: SocketAddr,
-        message_receiver: mpsc::Receiver<FramedNymPacket>,
-        connection_timeout: Duration,
-        current_reconnection: Arc<AtomicU32>,
-    ) -> Self {
-        ManagedConnection {
-            address,
-            message_receiver: ReceiverStream::new(message_receiver),
-            connection_timeout,
-            current_reconnection,
+impl Client {
+    pub fn new(config: Config) -> Client {
+        Client {
+            conn_new: HashMap::new(),
+            config,
         }
     }
 
-    async fn run(self) {
-        let address = self.address;
+    async fn manage_connection(
+        address: SocketAddr,
+        receiver: mpsc::Receiver<FramedNymPacket>,
+        connection_timeout: Duration,
+        current_reconnection: &AtomicU32,
+    ) {
         let connection_fut = TcpStream::connect(address);
 
-        let conn = match tokio::time::timeout(self.connection_timeout, connection_fut).await {
+        let conn = match tokio::time::timeout(connection_timeout, connection_fut).await {
             Ok(stream_res) => match stream_res {
                 Ok(stream) => {
-                    debug!("Managed to establish connection to {}", self.address);
+                    debug!("Managed to establish connection to {}", address);
                     // if we managed to connect, reset the reconnection count (whatever it might have been)
-                    self.current_reconnection.store(0, Ordering::Release);
+                    current_reconnection.store(0, Ordering::Release);
                     Framed::new(stream, NymCodec)
                 }
                 Err(err) => {
-                    debug!("failed to establish connection to {address} (err: {err})",);
+                    debug!(
+                        "failed to establish connection to {} (err: {})",
+                        address, err
+                    );
                     return;
                 }
             },
             Err(_) => {
                 debug!(
-                    "failed to connect to {address} within {:?}",
-                    self.connection_timeout
+                    "failed to connect to {} within {:?}",
+                    address, connection_timeout
                 );
 
                 // we failed to connect - increase reconnection attempt
-                self.current_reconnection.fetch_add(1, Ordering::SeqCst);
+                current_reconnection.fetch_add(1, Ordering::SeqCst);
                 return;
             }
         };
@@ -156,28 +120,15 @@ impl ManagedConnection {
         // Take whatever the receiver channel produces and put it on the connection.
         // We could have as well used conn.send_all(receiver.map(Ok)), but considering we don't care
         // about neither receiver nor the connection, it doesn't matter which one gets consumed
-        if let Err(err) = self.message_receiver.map(Ok).forward(conn).await {
-            warn!("Failed to forward packets to {address}: {err}");
+        if let Err(err) = receiver.map(Ok).forward(conn).await {
+            warn!("Failed to forward packets to {} - {err}", address);
         }
 
         debug!(
-            "connection manager to {address} is finished. Either the connection failed or mixnet client got dropped",
+            "connection manager to {} is finished. Either the connection failed or mixnet client got dropped",
+            address
         );
     }
-}
-
-impl Client {
-    pub fn new(config: Config, connections_count: Arc<AtomicUsize>) -> Client {
-        Client {
-            active_connections: Default::default(),
-            connections_count,
-            config,
-        }
-    }
-
-    pub fn active_connections(&self) -> ActiveConnections {
-        self.active_connections.clone()
-    }
 
     /// If we're trying to reconnect, determine how long we should wait.
     fn determine_backoff(&self, current_attempt: u32) -> Option<Duration> {
@@ -197,7 +148,7 @@ impl Client {
     }
 
     fn make_connection(&mut self, address: NymNodeRoutingAddress, pending_packet: FramedNymPacket) {
-        let (sender, receiver) = mpsc::channel(self.config.maximum_connection_buffer_size);
+        let (mut sender, receiver) = mpsc::channel(self.config.maximum_connection_buffer_size);
 
         // this CAN'T fail because we just created the channel which has a non-zero capacity
         if self.config.maximum_connection_buffer_size > 0 {
@@ -205,16 +156,15 @@ impl Client {
         }
 
         // if we already tried to connect to `address` before, grab the current attempt count
-        let current_reconnection_attempt =
-            if let Some(mut existing) = self.active_connections.get_mut(&address) {
-                existing.channel = sender;
-                Arc::clone(&existing.current_reconnection_attempt)
-            } else {
-                let new_entry = ConnectionSender::new(sender);
-                let current_attempt = Arc::clone(&new_entry.current_reconnection_attempt);
-                self.active_connections.insert(address, new_entry);
-                current_attempt
-            };
+        let current_reconnection_attempt = if let Some(existing) = self.conn_new.get_mut(&address) {
+            existing.channel = sender;
+            Arc::clone(&existing.current_reconnection_attempt)
+        } else {
+            let new_entry = ConnectionSender::new(sender);
+            let current_attempt = Arc::clone(&new_entry.current_reconnection_attempt);
+            self.conn_new.insert(address, new_entry);
+            current_attempt
+        };
 
         // load the actual value.
         let reconnection_attempt = current_reconnection_attempt.load(Ordering::Acquire);
@@ -223,7 +173,6 @@ impl Client {
         // copy the value before moving into another task
         let initial_connection_timeout = self.config.initial_connection_timeout;
 
-        let connections_count = self.connections_count.clone();
         tokio::spawn(async move {
             // before executing the manager, wait for what was specified, if anything
             if let Some(backoff) = backoff {
@@ -231,16 +180,13 @@ impl Client {
                 sleep(backoff).await;
             }
 
-            connections_count.fetch_add(1, Ordering::SeqCst);
-            ManagedConnection::new(
+            Self::manage_connection(
                 address.into(),
                 receiver,
                 initial_connection_timeout,
-                current_reconnection_attempt,
+                &current_reconnection_attempt,
             )
-            .run()
-            .await;
-            connections_count.fetch_sub(1, Ordering::SeqCst);
+            .await
         });
     }
 }
@@ -255,47 +201,49 @@ impl SendWithoutResponse for Client {
         trace!("Sending packet to {address:?}");
         let framed_packet = FramedNymPacket::new(packet, packet_type);
 
-        let Some(sender) = self.active_connections.get_mut(&address) else {
+        if let Some(sender) = self.conn_new.get_mut(&address) {
+            if let Err(err) = sender.channel.try_send(framed_packet) {
+                if err.is_full() {
+                    debug!("Connection to {} seems to not be able to handle all the traffic - dropping the current packet", address);
+                    // it's not a 'big' error, but we did not manage to send the packet
+                    // if the queue is full, we can't really do anything but to drop the packet
+                    Err(io::Error::new(
+                        io::ErrorKind::WouldBlock,
+                        "connection queue is full",
+                    ))
+                } else if err.is_disconnected() {
+                    debug!(
+                        "Connection to {} seems to be dead. attempting to re-establish it...",
+                        address
+                    );
+                    // it's not a 'big' error, but we did not manage to send the packet, but queue
+                    // it up to send it as soon as the connection is re-established
+                    self.make_connection(address, err.into_inner());
+                    Err(io::Error::new(
+                        io::ErrorKind::ConnectionAborted,
+                        "reconnection attempt is in progress",
+                    ))
+                } else {
+                    // this can't really happen, but let's safe-guard against it in case something changes in futures library
+                    Err(io::Error::new(
+                        io::ErrorKind::Other,
+                        "unknown connection buffer error",
+                    ))
+                }
+            } else {
+                Ok(())
+            }
+        } else {
             // there was never a connection to begin with
             debug!("establishing initial connection to {}", address);
             // it's not a 'big' error, but we did not manage to send the packet, but queue the packet
             // for sending for as soon as the connection is created
             self.make_connection(address, framed_packet);
-            return Err(io::Error::new(
+            Err(io::Error::new(
                 io::ErrorKind::NotConnected,
                 "connection is in progress",
-            ));
-        };
-
-        let sending_res = sender.channel.try_send(framed_packet);
-        drop(sender);
-
-        sending_res.map_err(|err| {
-            match err {
-                TrySendError::Full(_) => {
-                    debug!("Connection to {address} seems to not be able to handle all the traffic - dropping the current packet");
-                    // it's not a 'big' error, but we did not manage to send the packet
-                    // if the queue is full, we can't really do anything but to drop the packet
-                    io::Error::new(
-                        io::ErrorKind::WouldBlock,
-                        "connection queue is full",
-                    )
-                }
-                TrySendError::Closed(dropped) => {
-                    debug!(
-                        "Connection to {address} seems to be dead. attempting to re-establish it...",
-                    );
-
-                    // it's not a 'big' error, but we did not manage to send the packet, but queue
-                    // it up to send it as soon as the connection is re-established
-                    self.make_connection(address, dropped);
-                    io::Error::new(
-                        io::ErrorKind::ConnectionAborted,
-                        "reconnection attempt is in progress",
-                    )
-                }
-            }
-        } )
+            ))
+        }
     }
 }
 
@@ -304,15 +252,12 @@ mod tests {
     use super::*;
 
     fn dummy_client() -> Client {
-        Client::new(
-            Config {
-                initial_reconnection_backoff: Duration::from_millis(10_000),
-                maximum_reconnection_backoff: Duration::from_millis(300_000),
-                initial_connection_timeout: Duration::from_millis(1_500),
-                maximum_connection_buffer_size: 128,
-            },
-            Default::default(),
-        )
+        Client::new(Config {
+            initial_reconnection_backoff: Duration::from_millis(10_000),
+            maximum_reconnection_backoff: Duration::from_millis(300_000),
+            initial_connection_timeout: Duration::from_millis(1_500),
+            maximum_connection_buffer_size: 128,
+        })
     }
 
     #[test]