push to remote for cleanbuild

add temp warning
Merge branch 'develop' of github.com:nymtech/nym into develop
2025-01-24 11:37:55 +01:00 · 2025-01-17 15:24:25 +01:00 · 2025-01-16 14:13:32 +01:00 · 2025-01-15 13:12:31 +01:00 · 2025-01-14 23:52:00 +01:00 · 2025-01-14 15:28:05 +01:00
556 changed files with 19441 additions and 56537 deletions
@@ -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,9 +97,11 @@ 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
+          cp target/release/explorer-api $OUTPUT_DIR
          if [ ${{ github.event_name == 'workflow_dispatch' && inputs.enable_deb == true }} = true ]; then
            cp target/debian/*.deb $OUTPUT_DIR
          fi
@@ -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
@@ -8,18 +8,17 @@ on:
      - 'explorer-api/**'
      - 'gateway/**'
      - 'integrations/**'
+      - 'mixnode/**'
      - 'nym-api/**'
-      - 'nym-credential-proxy/**'
+      - 'nym-data-observatory/**'
      - 'nym-network-monitor/**'
      - 'nym-node/**'
      - 'nym-node-status-api/**'
      - 'nym-outfox/**'
      - 'nym-validator-rewarder/**'
-      - 'nyx-chain-watcher/**'
-      - 'sdk/ffi/**'
+      - 'sdk/lib/**'
      - 'sdk/rust/**'
      - 'service-providers/**'
-      - 'nym-browser-extension/storage/**'
      - 'tools/**'
      - 'wasm/**'
      - 'Cargo.toml'
@@ -37,7 +36,6 @@ jobs:
    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 +53,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:
@@ -9,8 +9,6 @@ on:
    paths:
      - 'contracts/**'
      - 'common/**'
-      - 'Cargo.lock'
-      - 'Cargo.toml'
      - '.github/workflows/ci-contracts.yml'

 jobs:
@@ -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:
@@ -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

@@ -4,234 +4,6 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://

 ## [Unreleased]

-## [2025.4-dorina-patched] (2025-03-06)
-
- use legacy crypto for constructing SURB headers ([#5579])
- bugfix: make sure to correctly decode response content when putting it into error message ([#5571])
- Tweak surb management to be more conservative ([#5570])
- Deserialize v5 authenticator requests ([#5568])
- chore: additional logs when attempting to load ecash keys ([#5567])
- add full response body to error message upon decoding failure ([#5566])
- hotfix: ensure we bail on merkle leaves insertion upon missing data ([#5565])
- feature: v2 authentication request (#5537) ([#5563])
- Create authenticator v5 request/response types ([#5561])
-
-[#5579]: https://github.com/nymtech/nym/pull/5579
-[#5571]: https://github.com/nymtech/nym/pull/5571
-[#5570]: https://github.com/nymtech/nym/pull/5570
-[#5568]: https://github.com/nymtech/nym/pull/5568
-[#5567]: https://github.com/nymtech/nym/pull/5567
-[#5566]: https://github.com/nymtech/nym/pull/5566
-[#5565]: https://github.com/nymtech/nym/pull/5565
-[#5563]: https://github.com/nymtech/nym/pull/5563
-[#5561]: https://github.com/nymtech/nym/pull/5561
-
-## [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])
@@ -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,17 +112,27 @@ 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-network-monitor",
+    "nyx-chain-watcher",
+    "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/testnet-manager",
+    # "tools/internal/sdk-version-bump",
    "tools/internal/testnet-manager",
    "tools/internal/testnet-manager/dkg-bypass-contract",
-    "tools/internal/testnet-manager/dkg-bypass-contract", "tools/internal/validator-status-check",
    "tools/nym-cli",
    "tools/nym-id-cli",
    "tools/nym-nr-query",
@@ -148,6 +143,13 @@ 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 = [
@@ -171,6 +173,7 @@ exclude = [
    "explorer",
    "contracts",
    "nym-wallet",
+    "nym-vpn/ui/src-tauri",
    "cpu-cycles",
 ]

@@ -186,43 +189,39 @@ 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.95"
 argon2 = "0.5.0"
-async-trait = "0.1.87"
-axum = "0.7.5"
+async-trait = "0.1.85"
 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.5"
 bloomfilter = "1.0.14"
 bs58 = "0.5.1"
 bytecodec = "0.4.15"
-bytes = "1.10.1"
+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.39"
 cipher = "0.4.3"
-clap = "4.5.31"
+clap = "4.5.26"
 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.3"
+console = "0.15.10"
 console-subscriber = "0.1.1"
 console_error_panic_hook = "0.1"
 const-str = "0.5.6"
@@ -241,51 +240,49 @@ doc-comment = "0.3"
 dotenvy = "0.15.6"
 ecdsa = "0.16"
 ed25519-dalek = "2.1"
-encoding_rs = "0.8.35"
-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"
+flate2 = "1.0.35"
 futures = "0.3.31"
 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.9"
 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"
@@ -294,7 +291,7 @@ petgraph = "0.6.5"
 pin-project = "1.1"
 pin-project-lite = "0.2.16"
 pretty_env_logger = "0.4.0"
-publicsuffix = "2.3.0"
+publicsuffix = "2.2.3"
 quote = "1"
 rand = "0.8.5"
 rand_chacha = "0.3"
@@ -308,54 +305,50 @@ 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.5.0"
 safer-ffi = "0.1.13"
-schemars = "0.8.22"
-semver = "1.0.26"
-serde = "1.0.219"
-serde_bytes = "0.11.17"
+schemars = "0.8.21"
+semver = "1.0.24"
+serde = "1.0.217"
+serde_bytes = "0.11.15"
 serde_derive = "1.0"
-serde_json = "1.0.140"
-serde_json_path = "0.7.2"
+serde_json = "1.0.135"
+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.3.2"
+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.18"
-thiserror = "2.0"
-time = "0.3.39"
-tokio = "1.44"
-tokio-postgres = "0.7"
+tar = "0.4.43"
+tempfile = "3.15"
+thiserror = "1.0.64"
+time = "0.3.37"
+tokio = "1.39"
 tokio-stream = "0.1.17"
 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"
+toml = "0.8.19"
+tower = "0.4.13"
 tower-http = "0.5.2"
 tracing = "0.1.41"
-tracing-log = "0.2"
 tracing-opentelemetry = "0.19.0"
 tracing-subscriber = "0.3.19"
 tracing-tree = "0.2.2"
+tracing-log = "0.2"
 ts-rs = "10.1.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 }
@@ -370,9 +363,9 @@ prometheus = { version = "0.13.0" }
 # unfortunately until https://github.com/zkcrypto/bls12_381/issues/10 is resolved, we have to rely on the fork
 # as we need to be able to serialize Gt so that we could create the lookup table for baby-step-giant-step algorithm
 # plus to make our live easier we need serde support from https://github.com/zkcrypto/bls12_381/pull/125
-bls12_381 = { git = "https://github.com/jstuczyn/bls12_381", default-features = false, branch = "temp/experimental-serdect-updated" }
+bls12_381 = { git = "https://github.com/jstuczyn/bls12_381", default-features = false, branch = "temp/experimental-serdect" }
 group = { version = "0.13.0", default-features = false }
-ff = { version = "0.13.1", default-features = false }
+ff = { version = "0.13.0", default-features = false }
 subtle = "2.5.0"

 # cosmwasm-related
@@ -391,19 +384,22 @@ 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"

-indexed_db_futures = "0.6.0"
+# TODO: migrate to 0.6+
+indexed_db_futures = "0.4.2"
 js-sys = "0.3.76"
 serde-wasm-bindgen = "0.6.5"
 tsify = "0.4.5"
@@ -438,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"
@@ -13,7 +13,7 @@ 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-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").
@@ -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://nym.com/terms-and-conditions/operators/v1.0.0).
@@ -1,6 +1,6 @@
 [package]
 name = "nym-client"
-version = "1.1.51"
+version = "1.1.46"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>", "Jędrzej Stuczyński <andrew@nymtech.net>"]
 description = "Implementation of the Nym Client"
 edition = "2021"
@@ -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,
@@ -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 }}

 "#;
@@ -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)?;
@@ -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(),
        }
    }
 }
@@ -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(
@@ -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(),
        }
    }
 }
@@ -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;
    }
 }

@@ -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 })
    }
 }
@@ -1,6 +1,6 @@
 [package]
 name = "nym-socks5-client"
-version = "1.1.51"
+version = "1.1.46"
 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"
@@ -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(),
        }
    }
 }
@@ -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)
@@ -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(),
        }
    }
 }
@@ -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 }}
-
 "#;
@@ -1,3 +1,2 @@
 allow-unwrap-in-tests = true
 allow-expect-in-tests = true
-allow-panic-in-tests = true
@@ -6,15 +6,14 @@ pub mod v1;
 pub mod v2;
 pub mod v3;
 pub mod v4;
-pub mod v5;

 mod error;
 mod util;

 pub use error::Error;
-pub use v5 as latest;
+pub use v4 as latest;

-pub const CURRENT_VERSION: u8 = 5;
+pub const CURRENT_VERSION: u8 = 4;

 fn make_bincode_serializer() -> impl bincode::Options {
    use bincode::Options;
@@ -8,8 +8,8 @@ use nym_sphinx::addressing::clients::Recipient;
 use nym_wireguard_types::PeerPublicKey;

 use crate::{
-    v1, v2, v3, v4,
-    v5::{self, registration::IpPair},
+    v1, v2, v3,
+    v4::{self, registration::IpPair},
    Error,
 };

@@ -19,7 +19,6 @@ pub enum AuthenticatorVersion {
    V2,
    V3,
    V4,
-    V5,
    UNKNOWN,
 }

@@ -35,8 +34,6 @@ impl From<Protocol> for AuthenticatorVersion {
            AuthenticatorVersion::V3
        } else if value.version == v4::VERSION {
            AuthenticatorVersion::V4
-        } else if value.version == v5::VERSION {
-            AuthenticatorVersion::V5
        } else {
            AuthenticatorVersion::UNKNOWN
        }
@@ -71,12 +68,6 @@ impl InitMessage for v4::registration::InitMessage {
    }
 }

-impl InitMessage for v5::registration::InitMessage {
-    fn pub_key(&self) -> PeerPublicKey {
-        self.pub_key
-    }
-}
-
 pub trait FinalMessage {
    fn pub_key(&self) -> PeerPublicKey;
    fn verify(&self, private_key: &PrivateKey, nonce: u64) -> Result<(), Error>;
@@ -147,24 +138,6 @@ impl FinalMessage for v4::registration::FinalMessage {
        self.gateway_client.verify(private_key, nonce)
    }

-    fn private_ips(&self) -> IpPair {
-        self.gateway_client.private_ips.into()
-    }
-
-    fn credential(&self) -> Option<CredentialSpendingData> {
-        self.credential.clone()
-    }
-}
-
-impl FinalMessage for v5::registration::FinalMessage {
-    fn pub_key(&self) -> PeerPublicKey {
-        self.gateway_client.pub_key
-    }
-
-    fn verify(&self, private_key: &PrivateKey, nonce: u64) -> Result<(), Error> {
-        self.gateway_client.verify(private_key, nonce)
-    }
-
    fn private_ips(&self) -> IpPair {
        self.gateway_client.private_ips
    }
@@ -209,39 +182,29 @@ impl TopUpMessage for v4::topup::TopUpMessage {
    }
 }

-impl TopUpMessage for v5::topup::TopUpMessage {
-    fn pub_key(&self) -> PeerPublicKey {
-        self.pub_key
-    }
-
-    fn credential(&self) -> CredentialSpendingData {
-        self.credential.clone()
-    }
-}
-
 pub enum AuthenticatorRequest {
    Initial {
        msg: Box<dyn InitMessage + Send + Sync + 'static>,
        protocol: Protocol,
-        reply_to: Option<Recipient>,
+        reply_to: Recipient,
        request_id: u64,
    },
    Final {
        msg: Box<dyn FinalMessage + Send + Sync + 'static>,
        protocol: Protocol,
-        reply_to: Option<Recipient>,
+        reply_to: Recipient,
        request_id: u64,
    },
    QueryBandwidth {
        msg: Box<dyn QueryBandwidthMessage + Send + Sync + 'static>,
        protocol: Protocol,
-        reply_to: Option<Recipient>,
+        reply_to: Recipient,
        request_id: u64,
    },
    TopUpBandwidth {
        msg: Box<dyn TopUpMessage + Send + Sync + 'static>,
        protocol: Protocol,
-        reply_to: Option<Recipient>,
+        reply_to: Recipient,
        request_id: u64,
    },
 }
@@ -255,7 +218,7 @@ impl From<v1::request::AuthenticatorRequest> for AuthenticatorRequest {
                    version: value.version,
                    service_provider_type: ServiceProviderType::Authenticator,
                },
-                reply_to: Some(value.reply_to),
+                reply_to: value.reply_to,
                request_id: value.request_id,
            },
            v1::request::AuthenticatorRequestData::Final(gateway_client) => Self::Final {
@@ -264,7 +227,7 @@ impl From<v1::request::AuthenticatorRequest> for AuthenticatorRequest {
                    version: value.version,
                    service_provider_type: ServiceProviderType::Authenticator,
                },
-                reply_to: Some(value.reply_to),
+                reply_to: value.reply_to,
                request_id: value.request_id,
            },
            v1::request::AuthenticatorRequestData::QueryBandwidth(peer_public_key) => {
@@ -274,7 +237,7 @@ impl From<v1::request::AuthenticatorRequest> for AuthenticatorRequest {
                        version: value.version,
                        service_provider_type: ServiceProviderType::Authenticator,
                    },
-                    reply_to: Some(value.reply_to),
+                    reply_to: value.reply_to,
                    request_id: value.request_id,
                }
            }
@@ -288,20 +251,20 @@ impl From<v2::request::AuthenticatorRequest> for AuthenticatorRequest {
            v2::request::AuthenticatorRequestData::Initial(init_message) => Self::Initial {
                msg: Box::new(init_message),
                protocol: value.protocol,
-                reply_to: Some(value.reply_to),
+                reply_to: value.reply_to,
                request_id: value.request_id,
            },
            v2::request::AuthenticatorRequestData::Final(final_message) => Self::Final {
                msg: final_message,
                protocol: value.protocol,
-                reply_to: Some(value.reply_to),
+                reply_to: value.reply_to,
                request_id: value.request_id,
            },
            v2::request::AuthenticatorRequestData::QueryBandwidth(peer_public_key) => {
                Self::QueryBandwidth {
                    msg: Box::new(peer_public_key),
                    protocol: value.protocol,
-                    reply_to: Some(value.reply_to),
+                    reply_to: value.reply_to,
                    request_id: value.request_id,
                }
            }
@@ -315,20 +278,20 @@ impl From<v3::request::AuthenticatorRequest> for AuthenticatorRequest {
            v3::request::AuthenticatorRequestData::Initial(init_message) => Self::Initial {
                msg: Box::new(init_message),
                protocol: value.protocol,
-                reply_to: Some(value.reply_to),
+                reply_to: value.reply_to,
                request_id: value.request_id,
            },
            v3::request::AuthenticatorRequestData::Final(final_message) => Self::Final {
                msg: final_message,
                protocol: value.protocol,
-                reply_to: Some(value.reply_to),
+                reply_to: value.reply_to,
                request_id: value.request_id,
            },
            v3::request::AuthenticatorRequestData::QueryBandwidth(peer_public_key) => {
                Self::QueryBandwidth {
                    msg: Box::new(peer_public_key),
                    protocol: value.protocol,
-                    reply_to: Some(value.reply_to),
+                    reply_to: value.reply_to,
                    request_id: value.request_id,
                }
            }
@@ -336,7 +299,7 @@ impl From<v3::request::AuthenticatorRequest> for AuthenticatorRequest {
                Self::TopUpBandwidth {
                    msg: top_up_message,
                    protocol: value.protocol,
-                    reply_to: Some(value.reply_to),
+                    reply_to: value.reply_to,
                    request_id: value.request_id,
                }
            }
@@ -350,20 +313,20 @@ impl From<v4::request::AuthenticatorRequest> for AuthenticatorRequest {
            v4::request::AuthenticatorRequestData::Initial(init_message) => Self::Initial {
                msg: Box::new(init_message),
                protocol: value.protocol,
-                reply_to: Some(value.reply_to),
+                reply_to: value.reply_to,
                request_id: value.request_id,
            },
            v4::request::AuthenticatorRequestData::Final(final_message) => Self::Final {
                msg: final_message,
                protocol: value.protocol,
-                reply_to: Some(value.reply_to),
+                reply_to: value.reply_to,
                request_id: value.request_id,
            },
            v4::request::AuthenticatorRequestData::QueryBandwidth(peer_public_key) => {
                Self::QueryBandwidth {
                    msg: Box::new(peer_public_key),
                    protocol: value.protocol,
-                    reply_to: Some(value.reply_to),
+                    reply_to: value.reply_to,
                    request_id: value.request_id,
                }
            }
@@ -371,42 +334,7 @@ impl From<v4::request::AuthenticatorRequest> for AuthenticatorRequest {
                Self::TopUpBandwidth {
                    msg: top_up_message,
                    protocol: value.protocol,
-                    reply_to: Some(value.reply_to),
-                    request_id: value.request_id,
-                }
-            }
-        }
-    }
-}
-
-impl From<v5::request::AuthenticatorRequest> for AuthenticatorRequest {
-    fn from(value: v5::request::AuthenticatorRequest) -> Self {
-        match value.data {
-            v5::request::AuthenticatorRequestData::Initial(init_message) => Self::Initial {
-                msg: Box::new(init_message),
-                protocol: value.protocol,
-                reply_to: None,
-                request_id: value.request_id,
-            },
-            v5::request::AuthenticatorRequestData::Final(final_message) => Self::Final {
-                msg: final_message,
-                protocol: value.protocol,
-                reply_to: None,
-                request_id: value.request_id,
-            },
-            v5::request::AuthenticatorRequestData::QueryBandwidth(peer_public_key) => {
-                Self::QueryBandwidth {
-                    msg: Box::new(peer_public_key),
-                    protocol: value.protocol,
-                    reply_to: None,
-                    request_id: value.request_id,
-                }
-            }
-            v5::request::AuthenticatorRequestData::TopUpBandwidth(top_up_message) => {
-                Self::TopUpBandwidth {
-                    msg: top_up_message,
-                    protocol: value.protocol,
-                    reply_to: None,
+                    reply_to: value.reply_to,
                    request_id: value.request_id,
                }
            }
@@ -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],
@@ -1,478 +0,0 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use nym_service_provider_requests_common::{Protocol, ServiceProviderType};
-
-use crate::{v4, v5};
-
-impl From<v4::request::AuthenticatorRequest> for v5::request::AuthenticatorRequest {
-    fn from(authenticator_request: v4::request::AuthenticatorRequest) -> Self {
-        Self {
-            protocol: Protocol {
-                version: 5,
-                service_provider_type: ServiceProviderType::Authenticator,
-            },
-            data: authenticator_request.data.into(),
-            request_id: authenticator_request.request_id,
-        }
-    }
-}
-
-impl From<v4::request::AuthenticatorRequestData> for v5::request::AuthenticatorRequestData {
-    fn from(authenticator_request_data: v4::request::AuthenticatorRequestData) -> Self {
-        match authenticator_request_data {
-            v4::request::AuthenticatorRequestData::Initial(init_msg) => {
-                v5::request::AuthenticatorRequestData::Initial(init_msg.into())
-            }
-            v4::request::AuthenticatorRequestData::Final(final_msg) => {
-                v5::request::AuthenticatorRequestData::Final(Box::new((*final_msg).into()))
-            }
-            v4::request::AuthenticatorRequestData::QueryBandwidth(pub_key) => {
-                v5::request::AuthenticatorRequestData::QueryBandwidth(pub_key)
-            }
-            v4::request::AuthenticatorRequestData::TopUpBandwidth(top_up_message) => {
-                v5::request::AuthenticatorRequestData::TopUpBandwidth(top_up_message.into())
-            }
-        }
-    }
-}
-
-impl From<v4::registration::InitMessage> for v5::registration::InitMessage {
-    fn from(init_msg: v4::registration::InitMessage) -> Self {
-        Self {
-            pub_key: init_msg.pub_key,
-        }
-    }
-}
-
-impl From<v4::registration::FinalMessage> for v5::registration::FinalMessage {
-    fn from(final_msg: v4::registration::FinalMessage) -> Self {
-        Self {
-            gateway_client: final_msg.gateway_client.into(),
-            credential: final_msg.credential,
-        }
-    }
-}
-
-impl From<v4::registration::GatewayClient> for v5::registration::GatewayClient {
-    fn from(gateway_client: v4::registration::GatewayClient) -> Self {
-        Self {
-            pub_key: gateway_client.pub_key,
-            private_ips: gateway_client.private_ips.into(),
-            mac: gateway_client.mac.into(),
-        }
-    }
-}
-
-impl From<v5::registration::GatewayClient> for v4::registration::GatewayClient {
-    fn from(gateway_client: v5::registration::GatewayClient) -> Self {
-        Self {
-            pub_key: gateway_client.pub_key,
-            private_ips: gateway_client.private_ips.into(),
-            mac: gateway_client.mac.into(),
-        }
-    }
-}
-
-impl From<v4::registration::ClientMac> for v5::registration::ClientMac {
-    fn from(client_mac: v4::registration::ClientMac) -> Self {
-        Self::new((*client_mac).clone())
-    }
-}
-
-impl From<v5::registration::ClientMac> for v4::registration::ClientMac {
-    fn from(client_mac: v5::registration::ClientMac) -> Self {
-        Self::new((*client_mac).clone())
-    }
-}
-
-impl From<Box<v4::topup::TopUpMessage>> for Box<v5::topup::TopUpMessage> {
-    fn from(top_up_message: Box<v4::topup::TopUpMessage>) -> Self {
-        Box::new(v5::topup::TopUpMessage {
-            pub_key: top_up_message.pub_key,
-            credential: top_up_message.credential,
-        })
-    }
-}
-
-impl From<v4::response::AuthenticatorResponse> for v5::response::AuthenticatorResponse {
-    fn from(value: v4::response::AuthenticatorResponse) -> Self {
-        Self {
-            protocol: Protocol {
-                version: 5,
-                service_provider_type: value.protocol.service_provider_type,
-            },
-            data: value.data.into(),
-        }
-    }
-}
-
-impl From<v4::response::AuthenticatorResponseData> for v5::response::AuthenticatorResponseData {
-    fn from(authenticator_response_data: v4::response::AuthenticatorResponseData) -> Self {
-        match authenticator_response_data {
-            v4::response::AuthenticatorResponseData::PendingRegistration(pending_response) => {
-                v5::response::AuthenticatorResponseData::PendingRegistration(
-                    pending_response.into(),
-                )
-            }
-            v4::response::AuthenticatorResponseData::Registered(registered_response) => {
-                v5::response::AuthenticatorResponseData::Registered(registered_response.into())
-            }
-            v4::response::AuthenticatorResponseData::RemainingBandwidth(
-                remaining_bandwidth_response,
-            ) => v5::response::AuthenticatorResponseData::RemainingBandwidth(
-                remaining_bandwidth_response.into(),
-            ),
-            v4::response::AuthenticatorResponseData::TopUpBandwidth(top_up_response) => {
-                v5::response::AuthenticatorResponseData::TopUpBandwidth(top_up_response.into())
-            }
-        }
-    }
-}
-
-impl From<v4::response::RegisteredResponse> for v5::response::RegisteredResponse {
-    fn from(value: v4::response::RegisteredResponse) -> Self {
-        Self {
-            request_id: value.request_id,
-            reply: value.reply.into(),
-        }
-    }
-}
-
-impl From<v4::response::PendingRegistrationResponse> for v5::response::PendingRegistrationResponse {
-    fn from(value: v4::response::PendingRegistrationResponse) -> Self {
-        Self {
-            request_id: value.request_id,
-            reply: value.reply.into(),
-        }
-    }
-}
-
-impl From<v4::registration::RegistrationData> for v5::registration::RegistrationData {
-    fn from(value: v4::registration::RegistrationData) -> Self {
-        Self {
-            nonce: value.nonce,
-            gateway_data: value.gateway_data.into(),
-            wg_port: value.wg_port,
-        }
-    }
-}
-
-impl From<v5::registration::RegistrationData> for v4::registration::RegistrationData {
-    fn from(value: v5::registration::RegistrationData) -> Self {
-        Self {
-            nonce: value.nonce,
-            gateway_data: value.gateway_data.into(),
-            wg_port: value.wg_port,
-        }
-    }
-}
-
-impl From<v4::response::RemainingBandwidthResponse> for v5::response::RemainingBandwidthResponse {
-    fn from(value: v4::response::RemainingBandwidthResponse) -> Self {
-        Self {
-            request_id: value.request_id,
-            reply: value.reply.map(Into::into),
-        }
-    }
-}
-
-impl From<v4::response::TopUpBandwidthResponse> for v5::response::TopUpBandwidthResponse {
-    fn from(value: v4::response::TopUpBandwidthResponse) -> Self {
-        Self {
-            request_id: value.request_id,
-            reply: value.reply.into(),
-        }
-    }
-}
-
-impl From<v4::registration::RegistredData> for v5::registration::RegistredData {
-    fn from(value: v4::registration::RegistredData) -> Self {
-        Self {
-            pub_key: value.pub_key,
-            private_ips: value.private_ips.into(),
-            wg_port: value.wg_port,
-        }
-    }
-}
-
-impl From<v4::registration::RemainingBandwidthData> for v5::registration::RemainingBandwidthData {
-    fn from(value: v4::registration::RemainingBandwidthData) -> Self {
-        Self {
-            available_bandwidth: value.available_bandwidth,
-        }
-    }
-}
-
-impl From<v4::registration::IpPair> for v5::registration::IpPair {
-    fn from(value: v4::registration::IpPair) -> Self {
-        Self {
-            ipv4: value.ipv4,
-            ipv6: value.ipv6,
-        }
-    }
-}
-
-impl From<v5::registration::IpPair> for v4::registration::IpPair {
-    fn from(value: v5::registration::IpPair) -> Self {
-        Self {
-            ipv4: value.ipv4,
-            ipv6: value.ipv6,
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::{
-        net::{Ipv4Addr, Ipv6Addr},
-        str::FromStr,
-    };
-
-    use nym_credentials_interface::CredentialSpendingData;
-    use nym_crypto::asymmetric::encryption::PrivateKey;
-    use nym_sphinx::addressing::Recipient;
-    use nym_wireguard_types::PeerPublicKey;
-    use x25519_dalek::PublicKey;
-
-    use super::*;
-    use crate::{
-        util::tests::{CREDENTIAL_BYTES, RECIPIENT},
-        v4,
-    };
-
-    #[test]
-    fn upgrade_initial_req() {
-        let pub_key = PeerPublicKey::new(PublicKey::from([0; 32]));
-        let reply_to = Recipient::try_from_base58_string(RECIPIENT).unwrap();
-
-        let (msg, _) = v4::request::AuthenticatorRequest::new_initial_request(
-            v4::registration::InitMessage::new(pub_key),
-            reply_to,
-        );
-        let upgraded_msg = v5::request::AuthenticatorRequest::from(msg);
-
-        assert_eq!(
-            upgraded_msg.protocol,
-            Protocol {
-                version: 5,
-                service_provider_type: ServiceProviderType::Authenticator
-            }
-        );
-        assert_eq!(
-            upgraded_msg.data,
-            v5::request::AuthenticatorRequestData::Initial(v5::registration::InitMessage {
-                pub_key
-            })
-        );
-    }
-
-    #[test]
-    fn upgrade_final_req() {
-        let mut rng = rand::thread_rng();
-
-        let local_secret = PrivateKey::new(&mut rng);
-        let remote_secret = x25519_dalek::StaticSecret::random_from_rng(&mut rng);
-        let ipv4 = Ipv4Addr::from_str("10.10.10.10").unwrap();
-        let ipv6 = Ipv6Addr::from_str("fc01::a0a").unwrap();
-        let ips = v4::registration::IpPair::new(ipv4, ipv6);
-        let nonce = 42;
-        let gateway_client = v4::registration::GatewayClient::new(
-            &local_secret,
-            (&remote_secret).into(),
-            ips,
-            nonce,
-        );
-        let credential = Some(CredentialSpendingData::try_from_bytes(&CREDENTIAL_BYTES).unwrap());
-        let final_message = v4::registration::FinalMessage {
-            gateway_client: gateway_client.clone(),
-            credential: credential.clone(),
-        };
-        let reply_to = Recipient::try_from_base58_string(RECIPIENT).unwrap();
-
-        let (msg, _) =
-            v4::request::AuthenticatorRequest::new_final_request(final_message, reply_to);
-        let upgraded_msg = v5::request::AuthenticatorRequest::from(msg);
-
-        assert_eq!(
-            upgraded_msg.protocol,
-            Protocol {
-                version: 5,
-                service_provider_type: ServiceProviderType::Authenticator
-            }
-        );
-        assert_eq!(
-            upgraded_msg.data,
-            v5::request::AuthenticatorRequestData::Final(Box::new(
-                v5::registration::FinalMessage {
-                    gateway_client: v5::registration::GatewayClient::new(
-                        &local_secret,
-                        (&remote_secret).into(),
-                        v5::registration::IpPair::new(ipv4, ipv6),
-                        nonce
-                    ),
-                    credential
-                }
-            ))
-        );
-    }
-
-    #[test]
-    fn upgrade_query_req() {
-        let pub_key = PeerPublicKey::new(PublicKey::from([0; 32]));
-        let reply_to = Recipient::try_from_base58_string(RECIPIENT).unwrap();
-
-        let (msg, _) = v4::request::AuthenticatorRequest::new_query_request(pub_key, reply_to);
-        let upgraded_msg = v5::request::AuthenticatorRequest::from(msg);
-
-        assert_eq!(
-            upgraded_msg.protocol,
-            Protocol {
-                version: 5,
-                service_provider_type: ServiceProviderType::Authenticator
-            }
-        );
-        assert_eq!(
-            upgraded_msg.data,
-            v5::request::AuthenticatorRequestData::QueryBandwidth(pub_key)
-        );
-    }
-
-    #[test]
-    fn upgrade_pending_reg_resp() {
-        let mut rng = rand::thread_rng();
-
-        let local_secret = PrivateKey::new(&mut rng);
-        let remote_secret = x25519_dalek::StaticSecret::random_from_rng(&mut rng);
-        let ipv4 = Ipv4Addr::from_str("10.10.10.10").unwrap();
-        let ipv6 = Ipv6Addr::from_str("fc01::a0a").unwrap();
-        let ips = v4::registration::IpPair::new(ipv4, ipv6);
-        let nonce = 42;
-        let wg_port = 51822;
-        let gateway_data = v4::registration::GatewayClient::new(
-            &local_secret,
-            (&remote_secret).into(),
-            ips,
-            nonce,
-        );
-        let registration_data = v4::registration::RegistrationData {
-            nonce,
-            gateway_data,
-            wg_port,
-        };
-        let request_id = 123;
-        let reply_to = Recipient::try_from_base58_string(RECIPIENT).unwrap();
-
-        let msg = v4::response::AuthenticatorResponse::new_pending_registration_success(
-            registration_data,
-            request_id,
-            reply_to,
-        );
-        let upgraded_msg = v5::response::AuthenticatorResponse::from(msg);
-
-        assert_eq!(
-            upgraded_msg.protocol,
-            Protocol {
-                version: 5,
-                service_provider_type: ServiceProviderType::Authenticator
-            }
-        );
-
-        assert_eq!(
-            upgraded_msg.data,
-            v5::response::AuthenticatorResponseData::PendingRegistration(
-                v5::response::PendingRegistrationResponse {
-                    request_id,
-                    reply: v5::registration::RegistrationData {
-                        nonce,
-                        gateway_data: v5::registration::GatewayClient::new(
-                            &local_secret,
-                            (&remote_secret).into(),
-                            v5::registration::IpPair::new(ipv4, ipv6),
-                            nonce
-                        ),
-                        wg_port
-                    }
-                }
-            )
-        );
-    }
-
-    #[test]
-    fn upgrade_registered_resp() {
-        let pub_key = PeerPublicKey::new(PublicKey::from([0; 32]));
-        let ipv4 = Ipv4Addr::from_str("10.1.10.10").unwrap();
-        let ipv6 = Ipv6Addr::from_str("fc01::a0a").unwrap();
-        let private_ips = v4::registration::IpPair::new(ipv4, ipv6);
-        let wg_port = 51822;
-        let registred_data = v4::registration::RegistredData {
-            pub_key,
-            private_ips,
-            wg_port,
-        };
-        let request_id = 123;
-        let reply_to = Recipient::try_from_base58_string(RECIPIENT).unwrap();
-
-        let msg = v4::response::AuthenticatorResponse::new_registered(
-            registred_data,
-            reply_to,
-            request_id,
-        );
-        let upgraded_msg = v5::response::AuthenticatorResponse::from(msg);
-
-        assert_eq!(
-            upgraded_msg.protocol,
-            Protocol {
-                version: 5,
-                service_provider_type: ServiceProviderType::Authenticator
-            }
-        );
-        assert_eq!(
-            upgraded_msg.data,
-            v5::response::AuthenticatorResponseData::Registered(v5::response::RegisteredResponse {
-                request_id,
-                reply: v5::registration::RegistredData {
-                    wg_port,
-                    pub_key,
-                    private_ips: v5::registration::IpPair::new(ipv4, ipv6)
-                }
-            })
-        );
-    }
-
-    #[test]
-    fn upgrade_remaining_bandwidth_resp() {
-        let available_bandwidth = 42;
-        let remaining_bandwidth_data = Some(v4::registration::RemainingBandwidthData {
-            available_bandwidth,
-        });
-        let request_id = 123;
-        let reply_to = Recipient::try_from_base58_string(RECIPIENT).unwrap();
-
-        let msg = v4::response::AuthenticatorResponse::new_remaining_bandwidth(
-            remaining_bandwidth_data,
-            reply_to,
-            request_id,
-        );
-        let upgraded_msg = v5::response::AuthenticatorResponse::from(msg);
-
-        assert_eq!(
-            upgraded_msg.protocol,
-            Protocol {
-                version: 5,
-                service_provider_type: ServiceProviderType::Authenticator
-            }
-        );
-        assert_eq!(
-            upgraded_msg.data,
-            v5::response::AuthenticatorResponseData::RemainingBandwidth(
-                v5::response::RemainingBandwidthResponse {
-                    request_id,
-                    reply: Some(v5::registration::RemainingBandwidthData {
-                        available_bandwidth,
-                    })
-                }
-            )
-        );
-    }
-}
@@ -1,10 +0,0 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-pub mod conversion;
-pub mod registration;
-pub mod request;
-pub mod response;
-pub mod topup;
-
-pub const VERSION: u8 = 5;
@@ -1,287 +0,0 @@
-// -2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::error::Error;
-use base64::{engine::general_purpose, Engine};
-use nym_credentials_interface::CredentialSpendingData;
-use nym_network_defaults::constants::{WG_TUN_DEVICE_IP_ADDRESS_V4, WG_TUN_DEVICE_IP_ADDRESS_V6};
-use nym_wireguard_types::PeerPublicKey;
-use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
-use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
-use std::time::SystemTime;
-use std::{fmt, ops::Deref, str::FromStr};
-
-#[cfg(feature = "verify")]
-use hmac::{Hmac, Mac};
-#[cfg(feature = "verify")]
-use nym_crypto::asymmetric::encryption::PrivateKey;
-#[cfg(feature = "verify")]
-use sha2::Sha256;
-
-pub type PendingRegistrations = HashMap<PeerPublicKey, RegistrationData>;
-pub type PrivateIPs = HashMap<IpPair, Taken>;
-
-#[cfg(feature = "verify")]
-pub type HmacSha256 = Hmac<Sha256>;
-
-pub type Nonce = u64;
-pub type Taken = Option<SystemTime>;
-
-pub const BANDWIDTH_CAP_PER_DAY: u64 = 250 * 1024 * 1024 * 1024; // 250 GB
-
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
-pub struct IpPair {
-    pub ipv4: Ipv4Addr,
-    pub ipv6: Ipv6Addr,
-}
-
-impl IpPair {
-    pub fn new(ipv4: Ipv4Addr, ipv6: Ipv6Addr) -> Self {
-        IpPair { ipv4, ipv6 }
-    }
-}
-
-impl From<(Ipv4Addr, Ipv6Addr)> for IpPair {
-    fn from((ipv4, ipv6): (Ipv4Addr, Ipv6Addr)) -> Self {
-        IpPair { ipv4, ipv6 }
-    }
-}
-
-impl fmt::Display for IpPair {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "({}, {})", self.ipv4, self.ipv6)
-    }
-}
-
-impl From<IpAddr> for IpPair {
-    fn from(value: IpAddr) -> Self {
-        let (before_last_byte, last_byte) = match value {
-            std::net::IpAddr::V4(ipv4_addr) => (ipv4_addr.octets()[2], ipv4_addr.octets()[3]),
-            std::net::IpAddr::V6(ipv6_addr) => (ipv6_addr.octets()[14], ipv6_addr.octets()[15]),
-        };
-        let last_bytes = ((before_last_byte as u16) << 8) | last_byte as u16;
-        let ipv4 = Ipv4Addr::new(
-            WG_TUN_DEVICE_IP_ADDRESS_V4.octets()[0],
-            WG_TUN_DEVICE_IP_ADDRESS_V4.octets()[1],
-            before_last_byte,
-            last_byte,
-        );
-        let ipv6 = Ipv6Addr::new(
-            WG_TUN_DEVICE_IP_ADDRESS_V6.segments()[0],
-            WG_TUN_DEVICE_IP_ADDRESS_V6.segments()[1],
-            WG_TUN_DEVICE_IP_ADDRESS_V6.segments()[2],
-            WG_TUN_DEVICE_IP_ADDRESS_V6.segments()[3],
-            WG_TUN_DEVICE_IP_ADDRESS_V6.segments()[4],
-            WG_TUN_DEVICE_IP_ADDRESS_V6.segments()[5],
-            WG_TUN_DEVICE_IP_ADDRESS_V6.segments()[6],
-            last_bytes,
-        );
-        IpPair::new(ipv4, ipv6)
-    }
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
-pub struct InitMessage {
-    /// Base64 encoded x25519 public key
-    pub pub_key: PeerPublicKey,
-}
-
-impl InitMessage {
-    pub fn new(pub_key: PeerPublicKey) -> Self {
-        InitMessage { pub_key }
-    }
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
-pub struct FinalMessage {
-    /// Gateway client data
-    pub gateway_client: GatewayClient,
-
-    /// Ecash credential
-    pub credential: Option<CredentialSpendingData>,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
-pub struct RegistrationData {
-    pub nonce: u64,
-    pub gateway_data: GatewayClient,
-    pub wg_port: u16,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
-pub struct RegistredData {
-    pub pub_key: PeerPublicKey,
-    pub private_ips: IpPair,
-    pub wg_port: u16,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
-pub struct RemainingBandwidthData {
-    pub available_bandwidth: i64,
-}
-
-/// Client that wants to register sends its PublicKey bytes mac digest encrypted with a DH shared secret.
-/// Gateway/Nym node can then verify pub_key payload using the same process
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
-pub struct GatewayClient {
-    /// Base64 encoded x25519 public key
-    pub pub_key: PeerPublicKey,
-
-    /// Assigned private IPs (v4 and v6)
-    pub private_ips: IpPair,
-
-    /// Sha256 hmac on the data (alongside the prior nonce)
-    pub mac: ClientMac,
-}
-
-impl GatewayClient {
-    #[cfg(feature = "verify")]
-    pub fn new(
-        local_secret: &PrivateKey,
-        remote_public: x25519_dalek::PublicKey,
-        private_ips: IpPair,
-        nonce: u64,
-    ) -> Self {
-        // convert from 1.0 x25519-dalek private key into 2.0 x25519-dalek
-        #[allow(clippy::expect_used)]
-        let static_secret = x25519_dalek::StaticSecret::from(local_secret.to_bytes());
-        let local_public: x25519_dalek::PublicKey = (&static_secret).into();
-
-        let dh = static_secret.diffie_hellman(&remote_public);
-
-        // TODO: change that to use our nym_crypto::hmac module instead
-        #[allow(clippy::expect_used)]
-        let mut mac = HmacSha256::new_from_slice(dh.as_bytes())
-            .expect("x25519 shared secret is always 32 bytes long");
-
-        mac.update(local_public.as_bytes());
-        mac.update(private_ips.to_string().as_bytes());
-        mac.update(&nonce.to_le_bytes());
-
-        GatewayClient {
-            pub_key: PeerPublicKey::new(local_public),
-            private_ips,
-            mac: ClientMac(mac.finalize().into_bytes().to_vec()),
-        }
-    }
-
-    // Reusable secret should be gateways Wireguard PK
-    // Client should perform this step when generating its payload, using its own WG PK
-    #[cfg(feature = "verify")]
-    pub fn verify(&self, gateway_key: &PrivateKey, nonce: u64) -> Result<(), Error> {
-        // convert from 1.0 x25519-dalek private key into 2.0 x25519-dalek
-        #[allow(clippy::expect_used)]
-        let static_secret = x25519_dalek::StaticSecret::from(gateway_key.to_bytes());
-
-        let dh = static_secret.diffie_hellman(&self.pub_key);
-
-        // TODO: change that to use our nym_crypto::hmac module instead
-        #[allow(clippy::expect_used)]
-        let mut mac = HmacSha256::new_from_slice(dh.as_bytes())
-            .expect("x25519 shared secret is always 32 bytes long");
-
-        mac.update(self.pub_key.as_bytes());
-        mac.update(self.private_ips.to_string().as_bytes());
-        mac.update(&nonce.to_le_bytes());
-
-        mac.verify_slice(&self.mac)
-            .map_err(|source| Error::FailedClientMacVerification {
-                client: self.pub_key.to_string(),
-                source,
-            })
-    }
-
-    pub fn pub_key(&self) -> PeerPublicKey {
-        self.pub_key
-    }
-}
-
-// TODO: change the inner type into generic array of size HmacSha256::OutputSize
-// TODO2: rely on our internal crypto/hmac
-#[derive(Debug, Clone, PartialEq)]
-pub struct ClientMac(Vec<u8>);
-
-impl fmt::Display for ClientMac {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", general_purpose::STANDARD.encode(&self.0))
-    }
-}
-
-impl ClientMac {
-    #[allow(dead_code)]
-    pub fn new(mac: Vec<u8>) -> Self {
-        ClientMac(mac)
-    }
-}
-
-impl Deref for ClientMac {
-    type Target = Vec<u8>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl FromStr for ClientMac {
-    type Err = Error;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let mac_bytes: Vec<u8> =
-            general_purpose::STANDARD
-                .decode(s)
-                .map_err(|source| Error::MalformedClientMac {
-                    mac: s.to_string(),
-                    source,
-                })?;
-
-        Ok(ClientMac(mac_bytes))
-    }
-}
-
-impl Serialize for ClientMac {
-    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        let encoded_key = general_purpose::STANDARD.encode(self.0.clone());
-        serializer.serialize_str(&encoded_key)
-    }
-}
-
-impl<'de> Deserialize<'de> for ClientMac {
-    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
-        let encoded_key = String::deserialize(deserializer)?;
-        ClientMac::from_str(&encoded_key).map_err(serde::de::Error::custom)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use nym_crypto::asymmetric::encryption;
-
-    #[test]
-    fn create_ip_pair() {
-        let ipv4: IpAddr = Ipv4Addr::from_str("10.1.10.50").unwrap().into();
-        let ipv6: IpAddr = Ipv6Addr::from_str("fc01::0a32").unwrap().into();
-
-        assert_eq!(IpPair::from(ipv4), IpPair::from(ipv6));
-    }
-
-    #[test]
-    #[cfg(feature = "verify")]
-    fn client_request_roundtrip() {
-        let mut rng = rand::thread_rng();
-
-        let gateway_key_pair = encryption::KeyPair::new(&mut rng);
-        let client_key_pair = encryption::KeyPair::new(&mut rng);
-
-        let nonce = 1234567890;
-
-        let client = GatewayClient::new(
-            client_key_pair.private_key(),
-            x25519_dalek::PublicKey::from(gateway_key_pair.public_key().to_bytes()),
-            IpPair::new("10.0.0.42".parse().unwrap(), "fc00::42".parse().unwrap()),
-            nonce,
-        );
-        assert!(client.verify(gateway_key_pair.private_key(), nonce).is_ok())
-    }
-}
@@ -1,132 +0,0 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use super::{
-    registration::{FinalMessage, InitMessage},
-    topup::TopUpMessage,
-};
-use nym_service_provider_requests_common::{Protocol, ServiceProviderType};
-use nym_wireguard_types::PeerPublicKey;
-use serde::{Deserialize, Serialize};
-
-use crate::make_bincode_serializer;
-
-use super::VERSION;
-
-fn generate_random() -> u64 {
-    use rand::RngCore;
-    let mut rng = rand::rngs::OsRng;
-    rng.next_u64()
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
-pub struct AuthenticatorRequest {
-    pub protocol: Protocol,
-    pub data: AuthenticatorRequestData,
-    pub request_id: u64,
-}
-
-impl AuthenticatorRequest {
-    pub fn from_reconstructed_message(
-        message: &nym_sphinx::receiver::ReconstructedMessage,
-    ) -> Result<Self, bincode::Error> {
-        use bincode::Options;
-        make_bincode_serializer().deserialize(&message.message)
-    }
-
-    pub fn new_initial_request(init_message: InitMessage) -> (Self, u64) {
-        let request_id = generate_random();
-        (
-            Self {
-                protocol: Protocol {
-                    service_provider_type: ServiceProviderType::Authenticator,
-                    version: VERSION,
-                },
-                data: AuthenticatorRequestData::Initial(init_message),
-                request_id,
-            },
-            request_id,
-        )
-    }
-
-    pub fn new_final_request(final_message: FinalMessage) -> (Self, u64) {
-        let request_id = generate_random();
-        (
-            Self {
-                protocol: Protocol {
-                    service_provider_type: ServiceProviderType::Authenticator,
-                    version: VERSION,
-                },
-                data: AuthenticatorRequestData::Final(Box::new(final_message)),
-                request_id,
-            },
-            request_id,
-        )
-    }
-
-    pub fn new_query_request(peer_public_key: PeerPublicKey) -> (Self, u64) {
-        let request_id = generate_random();
-        (
-            Self {
-                protocol: Protocol {
-                    service_provider_type: ServiceProviderType::Authenticator,
-                    version: VERSION,
-                },
-                data: AuthenticatorRequestData::QueryBandwidth(peer_public_key),
-                request_id,
-            },
-            request_id,
-        )
-    }
-
-    pub fn new_topup_request(top_up_message: TopUpMessage) -> (Self, u64) {
-        let request_id = generate_random();
-        (
-            Self {
-                protocol: Protocol {
-                    service_provider_type: ServiceProviderType::Authenticator,
-                    version: VERSION,
-                },
-                data: AuthenticatorRequestData::TopUpBandwidth(Box::new(top_up_message)),
-                request_id,
-            },
-            request_id,
-        )
-    }
-
-    pub fn to_bytes(&self) -> Result<Vec<u8>, bincode::Error> {
-        use bincode::Options;
-        make_bincode_serializer().serialize(self)
-    }
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
-pub enum AuthenticatorRequestData {
-    Initial(InitMessage),
-    Final(Box<FinalMessage>),
-    QueryBandwidth(PeerPublicKey),
-    TopUpBandwidth(Box<TopUpMessage>),
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::str::FromStr;
-
-    #[test]
-    fn check_first_bytes_protocol() {
-        let version = 5;
-        let data = AuthenticatorRequest {
-            protocol: Protocol {
-                version,
-                service_provider_type: ServiceProviderType::Authenticator,
-            },
-            data: AuthenticatorRequestData::Initial(InitMessage::new(
-                PeerPublicKey::from_str("yvNUDpT5l7W/xDhiu6HkqTHDQwbs/B3J5UrLmORl1EQ=").unwrap(),
-            )),
-            request_id: 1,
-        };
-        let bytes = *data.to_bytes().unwrap().first_chunk::<2>().unwrap();
-        assert_eq!(bytes, [version, ServiceProviderType::Authenticator as u8]);
-    }
-}
@@ -1,132 +0,0 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use super::registration::{RegistrationData, RegistredData, RemainingBandwidthData};
-use nym_service_provider_requests_common::{Protocol, ServiceProviderType};
-use serde::{Deserialize, Serialize};
-
-use crate::make_bincode_serializer;
-
-use super::VERSION;
-
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
-pub struct AuthenticatorResponse {
-    pub protocol: Protocol,
-    pub data: AuthenticatorResponseData,
-}
-
-impl AuthenticatorResponse {
-    pub fn new_pending_registration_success(
-        registration_data: RegistrationData,
-        request_id: u64,
-    ) -> Self {
-        Self {
-            protocol: Protocol {
-                service_provider_type: ServiceProviderType::Authenticator,
-                version: VERSION,
-            },
-            data: AuthenticatorResponseData::PendingRegistration(PendingRegistrationResponse {
-                reply: registration_data,
-                request_id,
-            }),
-        }
-    }
-
-    pub fn new_registered(registred_data: RegistredData, request_id: u64) -> Self {
-        Self {
-            protocol: Protocol {
-                service_provider_type: ServiceProviderType::Authenticator,
-                version: VERSION,
-            },
-            data: AuthenticatorResponseData::Registered(RegisteredResponse {
-                reply: registred_data,
-                request_id,
-            }),
-        }
-    }
-
-    pub fn new_remaining_bandwidth(
-        remaining_bandwidth_data: Option<RemainingBandwidthData>,
-        request_id: u64,
-    ) -> Self {
-        Self {
-            protocol: Protocol {
-                service_provider_type: ServiceProviderType::Authenticator,
-                version: VERSION,
-            },
-            data: AuthenticatorResponseData::RemainingBandwidth(RemainingBandwidthResponse {
-                reply: remaining_bandwidth_data,
-                request_id,
-            }),
-        }
-    }
-
-    pub fn new_topup_bandwidth(
-        remaining_bandwidth_data: RemainingBandwidthData,
-        request_id: u64,
-    ) -> Self {
-        Self {
-            protocol: Protocol {
-                service_provider_type: ServiceProviderType::Authenticator,
-                version: VERSION,
-            },
-            data: AuthenticatorResponseData::TopUpBandwidth(TopUpBandwidthResponse {
-                reply: remaining_bandwidth_data,
-                request_id,
-            }),
-        }
-    }
-
-    pub fn to_bytes(&self) -> Result<Vec<u8>, bincode::Error> {
-        use bincode::Options;
-        make_bincode_serializer().serialize(self)
-    }
-
-    pub fn from_reconstructed_message(
-        message: &nym_sphinx::receiver::ReconstructedMessage,
-    ) -> Result<Self, bincode::Error> {
-        use bincode::Options;
-        make_bincode_serializer().deserialize(&message.message)
-    }
-
-    pub fn id(&self) -> Option<u64> {
-        match &self.data {
-            AuthenticatorResponseData::PendingRegistration(response) => Some(response.request_id),
-            AuthenticatorResponseData::Registered(response) => Some(response.request_id),
-            AuthenticatorResponseData::RemainingBandwidth(response) => Some(response.request_id),
-            AuthenticatorResponseData::TopUpBandwidth(response) => Some(response.request_id),
-        }
-    }
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
-pub enum AuthenticatorResponseData {
-    PendingRegistration(PendingRegistrationResponse),
-    Registered(RegisteredResponse),
-    RemainingBandwidth(RemainingBandwidthResponse),
-    TopUpBandwidth(TopUpBandwidthResponse),
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
-pub struct PendingRegistrationResponse {
-    pub request_id: u64,
-    pub reply: RegistrationData,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
-pub struct RegisteredResponse {
-    pub request_id: u64,
-    pub reply: RegistredData,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
-pub struct RemainingBandwidthResponse {
-    pub request_id: u64,
-    pub reply: Option<RemainingBandwidthData>,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
-pub struct TopUpBandwidthResponse {
-    pub request_id: u64,
-    pub reply: RemainingBandwidthData,
-}
@@ -1,15 +0,0 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use nym_credentials_interface::CredentialSpendingData;
-use nym_wireguard_types::PeerPublicKey;
-use serde::{Deserialize, Serialize};
-
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
-pub struct TopUpMessage {
-    /// Base64 encoded x25519 public key
-    pub pub_key: PeerPublicKey,
-
-    /// Ecash credential
-    pub credential: CredentialSpendingData,
-}
@@ -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)
@@ -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 {
@@ -40,7 +40,6 @@ 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" }
@@ -45,12 +45,11 @@ 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
 const DEFAULT_MINIMUM_REPLY_SURB_REQUEST_SIZE: u32 = 10;
-const DEFAULT_MAXIMUM_REPLY_SURB_REQUEST_SIZE: u32 = 50;
+const DEFAULT_MAXIMUM_REPLY_SURB_REQUEST_SIZE: u32 = 100;

 const DEFAULT_MAXIMUM_ALLOWED_SURB_REQUEST_SIZE: u32 = 500;

@@ -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.
@@ -559,15 +553,12 @@ pub struct Topology {

    /// Specifies whether this client should attempt to retrieve all available network nodes
    /// as opposed to just active mixnodes/gateways.
+    /// Useless without `ignore_epoch_roles = true`
    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)]
@@ -605,9 +596,7 @@ impl Default for Topology {
            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,
+            ignore_egress_epoch_role: false,
        }
    }
 }
@@ -622,10 +611,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,

@@ -658,9 +643,6 @@ pub struct ReplySurbs {
    /// Specifies the number of mixnet hops the packet should go through. If not specified, then
    /// the default value is used.
    pub surb_mix_hops: Option<u8>,
-
-    /// Specifies if we should reset all the sender tags on startup
-    pub fresh_sender_tags: bool,
 }

 impl Default for ReplySurbs {
@@ -668,7 +650,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,
@@ -678,7 +659,6 @@ impl Default for ReplySurbs {
            maximum_reply_surb_age: DEFAULT_MAXIMUM_REPLY_SURB_AGE,
            maximum_reply_key_age: DEFAULT_MAXIMUM_REPLY_KEY_AGE,
            surb_mix_hops: None,
-            fresh_sender_tags: false,
        }
    }
 }
@@ -734,9 +714,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 {
@@ -759,69 +736,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,
        }
    }
 }
@@ -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(),
            },
        }
    }
@@ -15,7 +15,6 @@ pub mod error;
 mod manager;
 mod models;

-#[derive(Clone)]
 pub struct OnDiskGatewaysDetails {
    manager: StorageManager,
 }
@@ -20,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>,
@@ -115,12 +115,11 @@ where
        hardcoded_topology.entry_capable_nodes().cloned().collect()
    } 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?
    };
@@ -139,8 +138,6 @@ where
    let gateway_setup = GatewaySetup::New {
        specification: selection_spec,
        available_gateways,
-        #[cfg(unix)]
-        connection_fd_callback: None,
    };

    let init_details =
@@ -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> {
@@ -174,12 +170,11 @@ where
        hardcoded_topology.entry_capable_nodes().cloned().collect()
    } 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?
    };
@@ -187,8 +182,6 @@ where
    let gateway_setup = GatewaySetup::New {
        specification: selection_spec,
        available_gateways,
-        #[cfg(unix)]
-        connection_fd_callback: None,
    };

    let init_details =
@@ -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,
 }
@@ -1,7 +1,6 @@
 // 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 crate::client::base_client::storage::helpers::store_client_keys;
@@ -32,15 +31,13 @@ use crate::init::{
    setup_gateway,
    types::{GatewaySetup, InitialisationResult},
 };
-use crate::{config, spawn_future};
+use crate::{config, spawn_future, ForgetMe};
 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 +175,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>,

@@ -194,19 +191,19 @@ pub struct BaseClientBuilder<C, S: MixnetClientStorage> {
    #[cfg(unix)]
    connection_fd_callback: Option<Arc<dyn Fn(RawFd) + Send + Sync>>,

-    derivation_material: Option<DerivationMaterial>,
+    forget_me: ForgetMe,
 }

-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,
@@ -219,22 +216,13 @@ where
            setup_method: GatewaySetup::MustLoad { gateway_id: None },
            #[cfg(unix)]
            connection_fd_callback: None,
-            derivation_material: None,
+            forget_me: Default::default(),
        }
    }

-    #[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.forget_me = forget_me.clone();
        self
    }

@@ -310,7 +298,7 @@ where
        topology_accessor: TopologyAccessor,
        mix_tx: BatchMixMessageSender,
        stats_tx: ClientStatsSender,
-        task_client: TaskClient,
+        shutdown: TaskClient,
    ) {
        info!("Starting loop cover traffic stream...");

@@ -323,10 +311,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 +328,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 +346,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,9 +370,8 @@ where
                reply_key_storage,
                reply_controller_sender,
                metrics_reporter,
-                shutdown,
            );
-        controller.start()
+        controller.start_with_shutdown(shutdown)
    }

    #[allow(clippy::too_many_arguments)]
@@ -575,22 +560,15 @@ where
        topology_accessor: TopologyAccessor,
        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
@@ -631,11 +609,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(())
@@ -646,29 +628,30 @@ 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) {
+        forget_me: ForgetMe,
+    ) -> 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, forget_me);
+        mix_traffic_controller.start_with_shutdown(shutdown);
+        mix_tx
    }

    // TODO: rename it as it implies the data is persistent whilst one can use InMemBackend
@@ -703,7 +686,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,
@@ -713,12 +695,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?;
        }

@@ -740,7 +717,6 @@ where
            self.setup_method,
            self.client_store.key_store(),
            self.client_store.gateway_details_store(),
-            self.derivation_material,
        )
        .await?;

@@ -797,7 +773,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(),
@@ -823,7 +799,7 @@ where

        let gateway_transceiver = Self::setup_gateway_transceiver(
            self.custom_gateway_transceiver,
-            &self.config,
+            self.config,
            init_res,
            bandwidth_controller,
            &details_store,
@@ -857,9 +833,10 @@ where
        // 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"),
+            self.forget_me,
        );

        // Channels that the websocket listener can use to signal downstream to the real traffic
@@ -934,8 +911,6 @@ where
            },
            stats_reporter,
            task_handle: shutdown,
-            client_request_sender,
-            forget_me: self.config.debug.forget_me,
        })
    }
 }
@@ -947,7 +922,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,
 }
@@ -88,7 +88,7 @@ pub async fn setup_fs_reply_surb_backend<P: AsRef<Path>>(
    let db_path = db_path.as_ref();
    if db_path.exists() {
        info!("loading existing surb database");
-        match fs_backend::Backend::try_load(db_path, surb_config.fresh_sender_tags).await {
+        match fs_backend::Backend::try_load(db_path).await {
            Ok(backend) => Ok(backend),
            Err(err) => {
                error!("failed to setup persistent storage backend for our reply needs: {err}. We're going to create a fresh database instead. This behaviour might change in the future");
@@ -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",
@@ -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,
        }
    }

@@ -180,7 +175,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 +184,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 +217,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 +231,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");

@@ -2,10 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::client::key_manager::persistence::KeyStore;
-use nym_crypto::{
-    asymmetric::{encryption, identity},
-    hkdf::{DerivationMaterial, InvalidLength},
-};
+use nym_crypto::asymmetric::{encryption, identity};
 use nym_gateway_requests::shared_key::{LegacySharedKeys, SharedGatewayKey, SharedSymmetricKey};
 use nym_sphinx::acknowledgements::AckKey;
 use rand::{CryptoRng, RngCore};
@@ -13,7 +10,6 @@ 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,
@@ -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(())
    }
 }
@@ -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()
-        );
-    }
-}
@@ -2,18 +2,13 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::client::mix_traffic::transceiver::GatewayTransceiver;
-use crate::error::ClientCoreError;
-use crate::spawn_future;
+use crate::{spawn_future, ForgetMe};
 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 +23,52 @@ 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,
+    forget_me: ForgetMe,
 }

 impl MixTrafficController {
    pub fn new<T>(
        gateway_transceiver: T,
-        task_client: TaskClient,
-    ) -> (
-        MixTrafficController,
-        BatchMixMessageSender,
-        ClientRequestSender,
-    )
+        forget_me: ForgetMe,
+    ) -> (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,
+                forget_me,
            },
            message_sender,
-            client_sender,
        )
    }

    pub fn new_dynamic(
        gateway_transceiver: Box<dyn GatewayTransceiver + Send>,
-        task_client: TaskClient,
-    ) -> (
-        MixTrafficController,
-        BatchMixMessageSender,
-        ClientRequestSender,
-    ) {
+        forget_me: ForgetMe,
+    ) -> (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,
+                forget_me,
            },
            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,60 +80,64 @@ 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;
+
+            if self.forget_me.any() {
+                log::info!("Sending forget me request to the gateway");
+                match self
+                    .gateway_transceiver
+                    .send_client_request(ClientRequest::ForgetMe {
+                        client: self.forget_me.client(),
+                        stats: self.forget_me.stats(),
+                    })
+                    .await
+                {
+                    Ok(_) => {
+                        log::info!("Successfully sent forget me request to the gateway");
+                    }
+                    Err(err) => {
+                        log::error!("Failed to send forget me request to the gateway: {err}");
+                    }
+                }
+            }

            log::debug!("MixTrafficController: Exiting");
        });
@@ -86,9 +86,7 @@ impl<G: GatewayTransceiver + ?Sized + Send> GatewayTransceiver for Box<G> {
        &mut self,
        message: ClientRequest,
    ) -> Result<(), GatewayClientError> {
-        let _ = (**self).send_client_request(message.clone()).await?;
-        log::debug!("Sent client request: {:?}", message);
-        Ok(())
+        (**self).send_client_request(message).await
    }
 }

@@ -145,7 +143,14 @@ where
        &mut self,
        message: ClientRequest,
    ) -> Result<(), GatewayClientError> {
-        self.gateway_client.send_client_request(message).await
+        if let Some(shared_key) = self.gateway_client.shared_key() {
+            self.gateway_client
+                .send_websocket_message(message.encrypt(&*shared_key)?)
+                .await?;
+            Ok(())
+        } else {
+            Err(GatewayClientError::ConnectionInInvalidState)
+        }
    }
 }

@@ -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");
    }
 }
@@ -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");
    }
 }
@@ -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(
@@ -174,10 +164,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 +178,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");
    }
 }
@@ -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,7 +66,7 @@ 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,
@@ -217,7 +216,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 +225,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 +233,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 +240,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 +249,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 +265,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!");
        });
    }
@@ -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,
        }
    }

@@ -82,12 +79,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,16 +93,11 @@ 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(
@@ -125,12 +114,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 +141,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 +157,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 +173,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");
    }
 }
@@ -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");
    }
 }
@@ -19,7 +19,6 @@ use nym_sphinx::params::{PacketSize, PacketType};
 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 rand::{CryptoRng, Rng};
 use std::collections::HashMap;
@@ -33,12 +32,10 @@ pub enum PreparationError {
    #[error(transparent)]
    NymTopologyError(#[from] NymTopologyError),

-    #[error("message too long for a single SURB, splitting into {fragments} fragments.")]
+    #[error("The received message cannot be sent using a single reply surb. It ended up getting split into {fragments} fragments.")]
    MessageTooLongForSingleSurb { fragments: usize },

-    #[error(
-        "not enough reply SURBs to send the message, available: {available} required: {required}."
-    )]
+    #[error("Not enough reply SURBs to send the message. We have {available} available and require at least {required}.")]
    NotEnoughSurbs { available: usize, required: usize },
 }

@@ -152,14 +149,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,
@@ -168,7 +163,6 @@ where
        topology_access: TopologyAccessor,
        reply_key_storage: SentReplyKeys,
        tag_storage: UsedSenderTags,
-        task_client: TaskClient,
    ) -> Self
    where
        R: Copy,
@@ -189,7 +183,6 @@ where
            topology_access,
            reply_key_storage,
            tag_storage,
-            task_client,
        }
    }

@@ -616,25 +609,15 @@ where
    }

    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
@@ -643,14 +626,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");
    }
 }
@@ -31,7 +31,6 @@ 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;

@@ -148,7 +147,6 @@ impl RealMessagesController<OsRng> {
        lane_queue_lengths: LaneQueueLengths,
        client_connection_rx: ConnectionCommandReceiver,
        stats_tx: ClientStatsSender,
-        task_client: TaskClient,
    ) -> Self {
        let rng = OsRng;

@@ -179,7 +177,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 +186,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 +193,6 @@ impl RealMessagesController<OsRng> {
            message_handler,
            reply_storage,
            reply_controller_receiver,
-            task_client.fork("reply_controller"),
        );

        let out_queue_control = OutQueueControl::new(
@@ -210,7 +205,6 @@ impl RealMessagesController<OsRng> {
            lane_queue_lengths,
            client_connection_rx,
            stats_tx,
-            task_client.with_suffix("out_queue_control"),
        );

        RealMessagesController {
@@ -220,20 +214,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);
    }
 }
@@ -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 {
@@ -278,9 +271,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 +504,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 +535,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;
                    }
@@ -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;
        });
    }
 }
@@ -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()
@@ -712,7 +680,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 +694,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,
            ),
        );
@@ -746,7 +713,7 @@ where
            .request_additional_reply_surbs(target, request_size)
            .await
        {
-            info!("{err}")
+            warn!("failed to request additional surbs... - {err}")
        }
    }

@@ -879,11 +846,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 +860,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 {
@@ -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>,
@@ -22,7 +22,7 @@ use nym_sphinx::addressing::Recipient;
 use nym_statistics_common::clients::{
    ClientStatsController, ClientStatsReceiver, ClientStatsSender,
 };
-use nym_task::{connections::TransmissionLane, TaskClient};
+use nym_task::connections::TransmissionLane;
 use std::time::Duration;

 use crate::{
@@ -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,7 +91,7 @@ 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"))]
@@ -129,13 +121,8 @@ impl StatisticsControl {
        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 => {
@@ -157,34 +144,34 @@ impl StatisticsControl {
                }

                _ = local_report_interval.next() => {
-                    self.stats.local_report(&mut self.task_client);
+                    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
    }
 }
@@ -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;

@@ -44,8 +43,6 @@ pub struct TopologyRefresher {

    refresh_rate: Duration,
    consecutive_failure_count: usize,
-
-    task_client: TaskClient,
 }

 impl TopologyRefresher {
@@ -53,14 +50,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,
        }
    }

@@ -147,7 +142,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 +155,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");
        })
    }
@@ -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,
@@ -36,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,

@@ -103,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 },

@@ -222,9 +212,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
@@ -11,15 +11,10 @@ use nym_topology::node::RoutingNode;
 use nym_validator_client::client::IdentityKeyRef;
 use nym_validator_client::UserAgent;
 use rand::{seq::SliceRandom, Rng};
-#[cfg(unix)]
-use std::os::fd::RawFd;
 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;
@@ -28,6 +23,8 @@ 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;
@@ -89,12 +86,11 @@ 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> {
    let nym_api = nym_apis
        .choose(rng)
@@ -112,11 +108,8 @@ 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<_>>();
@@ -135,7 +128,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),
    }
 }
@@ -315,15 +308,9 @@ pub(super) async fn register_with_gateway(
    gateway_id: identity::PublicKey,
    gateway_listener: Url,
    our_identity: Arc<identity::KeyPair>,
-    #[cfg(unix)] connection_fd_callback: Option<Arc<dyn Fn(RawFd) + Send + Sync>>,
 ) -> Result<RegistrationResult, ClientCoreError> {
-    let mut gateway_client = GatewayClient::new_init(
-        gateway_listener,
-        gateway_id,
-        our_identity.clone(),
-        #[cfg(unix)]
-        connection_fd_callback,
-    );
+    let mut gateway_client =
+        GatewayClient::new_init(gateway_listener, gateway_id, our_identity.clone());

    gateway_client.establish_connection().await.map_err(|err| {
        log::warn!("Failed to establish connection with gateway!");
@@ -23,13 +23,9 @@ use nym_topology::node::RoutingNode;
 use rand::rngs::OsRng;
 use rand::{CryptoRng, RngCore};
 use serde::Serialize;
-#[cfg(unix)]
-use std::{os::fd::RawFd, sync::Arc};

 pub mod helpers;
 pub mod types;
-#[cfg(not(target_arch = "wasm32"))]
-pub(crate) mod websockets;

 // helpers for error wrapping

@@ -55,7 +51,6 @@ async fn setup_new_gateway<K, D>(
    details_store: &D,
    selection_specification: GatewaySelectionSpecification,
    available_gateways: Vec<RoutingNode>,
-    #[cfg(unix)] connection_fd_callback: Option<Arc<dyn Fn(RawFd) + Send + Sync>>,
 ) -> Result<InitialisationResult, ClientCoreError>
 where
    K: KeyStore,
@@ -111,14 +106,9 @@ where
            // if we're using a 'normal' gateway setup, do register
            let our_identity = client_keys.identity_keypair();

-            let registration = helpers::register_with_gateway(
-                gateway_id,
-                gateway_listener.clone(),
-                our_identity,
-                #[cfg(unix)]
-                connection_fd_callback,
-            )
-            .await?;
+            let registration =
+                helpers::register_with_gateway(gateway_id, gateway_listener.clone(), our_identity)
+                    .await?;
            (
                GatewayDetails::new_remote(
                    gateway_id,
@@ -211,19 +201,9 @@ where
        GatewaySetup::New {
            specification,
            available_gateways,
-            #[cfg(unix)]
-            connection_fd_callback,
        } => {
            log::debug!("GatewaySetup::New with spec: {specification:?}");
-            setup_new_gateway(
-                key_store,
-                details_store,
-                specification,
-                available_gateways,
-                #[cfg(unix)]
-                connection_fd_callback,
-            )
-            .await
+            setup_new_gateway(key_store, details_store, specification, available_gateways).await
        }
        GatewaySetup::ReuseConnection {
            authenticated_ephemeral_client,
@@ -18,8 +18,6 @@ use nym_validator_client::client::IdentityKey;
 use nym_validator_client::nyxd::AccountId;
 use serde::Serialize;
 use std::fmt::{Debug, Display};
-#[cfg(unix)]
-use std::os::fd::RawFd;
 use std::sync::Arc;
 use time::OffsetDateTime;
 use url::Url;
@@ -210,10 +208,6 @@ pub enum GatewaySetup {

        // TODO: seems to be a bit inefficient to pass them by value
        available_gateways: Vec<RoutingNode>,
-
-        /// Callback useful for allowing initial connection to gateway
-        #[cfg(unix)]
-        connection_fd_callback: Option<Arc<dyn Fn(RawFd) + Send + Sync>>,
    },

    ReuseConnection {
@@ -237,8 +231,6 @@ impl Debug for GatewaySetup {
            GatewaySetup::New {
                specification,
                available_gateways,
-                #[cfg(unix)]
-                    connection_fd_callback: _,
            } => f
                .debug_struct("GatewaySetup::New")
                .field("specification", specification)
@@ -278,8 +270,6 @@ impl GatewaySetup {
                additional_data: None,
            },
            available_gateways: vec![],
-            #[cfg(unix)]
-            connection_fd_callback: None,
        }
    }

@@ -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)
-}
@@ -33,3 +33,48 @@ where
 {
    tokio::spawn(future);
 }
+
+#[derive(Clone, Default, Debug)]
+pub struct ForgetMe {
+    client: bool,
+    stats: bool,
+}
+
+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
+    }
+}
@@ -10,7 +10,7 @@ use crate::{
    CombinedReplyStorage, ReceivedReplySurbsMap, ReplyStorageBackend, SentReplyKeys, UsedSenderTags,
 };
 use async_trait::async_trait;
-use log::{debug, error, info, warn};
+use log::{error, info, warn};
 use nym_sphinx::anonymous_replies::requests::AnonymousSenderTag;
 use std::fs;
 use std::path::{Path, PathBuf};
@@ -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,
@@ -52,10 +52,7 @@ impl Backend {
        Ok(backend)
    }

-    pub async fn try_load<P: AsRef<Path>>(
-        database_path: P,
-        fresh_sender_tags: bool,
-    ) -> Result<Self, StorageError> {
+    pub async fn try_load<P: AsRef<Path>>(database_path: P) -> Result<Self, StorageError> {
        let owned_path: PathBuf = database_path.as_ref().into();
        if owned_path.file_name().is_none() {
            return Err(StorageError::DatabasePathWithoutFilename {
@@ -121,9 +118,6 @@ impl Backend {
        if days > 2 {
            info!("it's been over {days} days and {hours} hours since we last used our data store. our used sender tags are already outdated - we're going to purge them now.");
            manager.delete_all_tags().await?;
-        } else if fresh_sender_tags {
-            debug!("starting with fresh sender tags");
-            manager.delete_all_tags().await?;
        }

        Ok(Backend {
@@ -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,
@@ -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" }
@@ -20,8 +20,8 @@ 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,
-    SensitiveServerResponse, ServerResponse, SharedGatewayKey, SharedSymmetricKey,
+    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;
@@ -40,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;
@@ -51,11 +53,6 @@ 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,

@@ -204,15 +201,23 @@ 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));

+        #[cfg(unix)]
+        if let (Some(callback), Some(fd)) = (self.connection_fd_callback.as_ref(), self.ws_fd()) {
+            callback.as_ref()(fd);
+        }
+
        Ok(())
    }

@@ -266,19 +271,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
@@ -563,10 +555,28 @@ impl<C, St> GatewayClient<C, St> {
        Ok(zeroizing_updated_key)
    }

-    async fn send_authenticate_request_and_handle_response(
-        &mut self,
-        msg: ClientControlRequest,
-    ) -> Result<(), GatewayClientError> {
+    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,
@@ -590,51 +600,6 @@ impl<C, St> GatewayClient<C, St> {
        }
    }

-    async fn authenticate_v1(&mut self) -> Result<(), GatewayClientError> {
-        debug!("using v1 authentication");
-
-        let Some(shared_key) = self.shared_key.as_ref() else {
-            return Err(GatewayClientError::NoSharedKeyAvailable);
-        };
-
-        let self_address = self
-            .local_identity
-            .public_key()
-            .derive_destination_address();
-
-        let msg = ClientControlRequest::new_authenticate(
-            self_address,
-            shared_key,
-            self.cfg.bandwidth.require_tickets,
-        )?;
-        self.send_authenticate_request_and_handle_response(msg)
-            .await
-    }
-
-    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, use_v2: bool) -> Result<(), GatewayClientError> {
-        if !self.connection.is_established() {
-            return Err(GatewayClientError::ConnectionNotEstablished);
-        }
-        debug!("authenticating with gateway");
-
-        if use_v2 {
-            self.authenticate_v2().await
-        } else {
-            self.authenticate_v1().await
-        }
-    }
-
    /// Helper method to either call register or authenticate based on self.shared_key value
    #[instrument(skip_all,
        fields(
@@ -650,25 +615,19 @@ impl<C, St> GatewayClient<C, St> {
        }

        // 1. check gateway's protocol version
-        let gw_protocol = match self.get_gateway_protocol().await {
-            Ok(protocol) => Some(protocol),
+        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?;
-                None
+                false
            }
        };

-        let supports_aes_gcm_siv = gw_protocol.supports_aes256_gcm_siv();
-        let supports_auth_v2 = gw_protocol.supports_authenticate_v2();
-
        if !supports_aes_gcm_siv {
            warn!("this gateway is on an old version that doesn't support AES256-GCM-SIV");
        }
-        if !supports_auth_v2 {
-            warn!("this gateway is on an old version that doesn't support authentication v2")
-        }

        if self.authenticated {
            debug!("Already authenticated");
@@ -683,7 +642,7 @@ impl<C, St> GatewayClient<C, St> {
        }

        if self.shared_key.is_some() {
-            self.authenticate(supports_auth_v2).await?;
+            self.authenticate().await?;

            if self.authenticated {
                // if we are authenticated it means we MUST have an associated shared_key
@@ -1016,8 +975,7 @@ impl<C, St> GatewayClient<C, St> {
        }

        // if we're reconnecting, because we lost connection, we need to re-authenticate the connection
-        self.authenticate(self.negotiated_protocol.supports_authenticate_v2())
-            .await?;
+        self.authenticate().await?;

        // this call is NON-blocking
        self.start_listening_for_mixnet_messages()?;
@@ -1065,7 +1023,6 @@ impl GatewayClient<InitOnly, EphemeralCredentialStorage> {
        gateway_listener: Url,
        gateway_identity: identity::PublicKey,
        local_identity: Arc<identity::KeyPair>,
-        #[cfg(unix)] connection_fd_callback: Option<Arc<dyn Fn(RawFd) + Send + Sync>>,
    ) -> Self {
        log::trace!("Initialising gateway client");
        use futures::channel::mpsc;
@@ -1088,10 +1045,10 @@ 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,
+            connection_fd_callback: None,
            task_client,
        }
    }
@@ -1,96 +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
-                .inspect_err(|err| tracing::error!("Resolve error {err}"))?
-                .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 {
-        tracing::info!("Trying with {sock_addr}");
-        let socket = if sock_addr.is_ipv4() {
-            TcpSocket::new_v4()
-        } else {
-            TcpSocket::new_v6()
-        }
-        .map_err(|err| {
-            tracing::error!("Couldn't create the socket");
-            GatewayClientError::NetworkConnectionFailed {
-                address: endpoint.to_owned(),
-                source: err.into(),
-            }
-        })?;
-
-        tracing::info!("Preparing to call callback");
-        #[cfg(unix)]
-        if let Some(callback) = connection_fd_callback.as_ref() {
-            tracing::info!("Calling callback");
-            callback.as_ref()(socket.as_raw_fd());
-        }
-        tracing::info!("Preparing to connect");
-
-        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,
-        })
-}
@@ -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,
@@ -11,24 +11,23 @@ use crate::{
 use nym_api_requests::ecash::models::{
    AggregatedCoinIndicesSignatureResponse, AggregatedExpirationDateSignatureResponse,
    BatchRedeemTicketsBody, EcashBatchTicketRedemptionResponse, EcashTicketVerificationResponse,
-    IssuedTicketbooksChallengeResponse, IssuedTicketbooksForResponse, VerifyEcashTicketBody,
+    IssuedTicketbooksChallengeResponse, IssuedTicketbooksForResponse, SpentCredentialsResponse,
+    VerifyEcashTicketBody,
 };
 use nym_api_requests::ecash::{
    BlindSignRequestBody, BlindedSignatureResponse, PartialCoinIndicesSignatureResponse,
    PartialExpirationDateSignatureResponse, VerificationKeyResponse,
 };
 use nym_api_requests::models::{
-    ApiHealthResponse, GatewayBondAnnotated, GatewayCoreStatusResponse,
-    HistoricalPerformanceResponse, MixnodeCoreStatusResponse, MixnodeStatusResponse,
-    NymNodeDescription, RewardEstimationResponse, StakeSaturationResponse,
+    ApiHealthResponse, GatewayBondAnnotated, GatewayCoreStatusResponse, MixnodeCoreStatusResponse,
+    MixnodeStatusResponse, NymNodeDescription, RewardEstimationResponse, StakeSaturationResponse,
 };
 use nym_api_requests::models::{LegacyDescribedGateway, MixNodeBondAnnotated};
-use nym_api_requests::nym_nodes::{NodesByAddressesResponse, SkimmedNode};
+use nym_api_requests::nym_nodes::SkimmedNode;
 use nym_coconut_dkg_common::types::EpochId;
 use nym_ecash_contract_common::deposit::DepositId;
 use nym_http_api_client::UserAgent;
 use nym_network_defaults::NymNetworkDetails;
-use std::net::IpAddr;
 use time::Date;
 use url::Url;

@@ -265,31 +264,6 @@ impl<C, S> Client<C, S> {
        Ok(self.nym_api.get_gateways_detailed_unfiltered().await?)
    }

-    pub async fn get_full_node_performance_history(
-        &self,
-        node_id: NodeId,
-    ) -> Result<Vec<HistoricalPerformanceResponse>, ValidatorClientError> {
-        // TODO: deal with paging in macro or some helper function or something, because it's the same pattern everywhere
-        let mut page = 0;
-        let mut history = Vec::new();
-
-        loop {
-            let mut res = self
-                .nym_api
-                .get_node_performance_history(node_id, Some(page), None)
-                .await?;
-
-            history.append(&mut res.history.data);
-            if history.len() < res.history.pagination.total {
-                page += 1
-            } else {
-                break;
-            }
-        }
-
-        Ok(history)
-    }
-
    // TODO: combine with NymApiClient...
    pub async fn get_all_cached_described_nodes(
        &self,
@@ -647,6 +621,13 @@ impl NymApiClient {
            .await?)
    }

+    #[deprecated]
+    pub async fn spent_credentials_filter(
+        &self,
+    ) -> Result<SpentCredentialsResponse, ValidatorClientError> {
+        Ok(self.nym_api.double_spending_filter_v1().await?)
+    }
+
    pub async fn partial_expiration_date_signatures(
        &self,
        expiration_date: Option<Date>,
@@ -711,11 +692,4 @@ impl NymApiClient {
            .issued_ticketbooks_challenge(expiration_date, deposits)
            .await?)
    }
-
-    pub async fn nodes_by_addresses(
-        &self,
-        addresses: Vec<IpAddr>,
-    ) -> Result<NodesByAddressesResponse, ValidatorClientError> {
-        Ok(self.nym_api.nodes_by_addresses(addresses).await?)
-    }
 }
@@ -65,12 +65,6 @@ pub enum EcashApiError {
        #[from]
        source: cosmrs::ErrorReport,
    },
-
-    #[error("nym api error")]
-    NymApi {
-        #[from]
-        source: crate::ValidatorClientError,
-    },
 }

 impl TryFrom<ContractVKShare> for EcashApiClient {
@@ -83,12 +77,6 @@ impl TryFrom<ContractVKShare> for EcashApiClient {

        let url_address = Url::parse(&share.announce_address)?;

-        // The NymApiClient constructed here uses the default (hickory DoT/DoH) resolver because
-        // this EcashApiClient is used by both client and non-client applications.
-        //
-        // In non-client applications this resolver can cause warning logs about H2 connection
-        // failure. This indicates that the long lived https connection was closed by the remote
-        // peer and the resolver will have to reconnect. It should not impact actual functionality
        Ok(EcashApiClient {
            api_client: NymApiClient::new(url_address),
            verification_key: VerificationKeyAuth::try_from_bs58(&share.share)?,
@@ -12,13 +12,10 @@ use nym_api_requests::ecash::models::{
 };
 use nym_api_requests::ecash::VerificationKeyResponse;
 use nym_api_requests::models::{
-    AnnotationResponse, ApiHealthResponse, BinaryBuildInformationOwned, ChainStatusResponse,
-    LegacyDescribedMixNode, NodePerformanceResponse, NodeRefreshBody, NymNodeDescription,
-    PerformanceHistoryResponse, RewardedSetResponse,
-};
-use nym_api_requests::nym_nodes::{
-    NodesByAddressesRequestBody, NodesByAddressesResponse, PaginatedCachedNodesResponse,
+    AnnotationResponse, ApiHealthResponse, LegacyDescribedMixNode, NodePerformanceResponse,
+    NodeRefreshBody, NymNodeDescription, RewardedSetResponse,
 };
+use nym_api_requests::nym_nodes::PaginatedCachedNodesResponse;
 use nym_api_requests::pagination::PaginatedResponse;
 pub use nym_api_requests::{
    ecash::{
@@ -34,7 +31,6 @@ pub use nym_api_requests::{
        StakeSaturationResponse, UptimeResponse,
    },
    nym_nodes::{CachedNodesResponse, SkimmedNode},
-    NymNetworkDetailsResponse,
 };
 pub use nym_coconut_dkg_common::types::EpochId;
 use nym_contracts_common::IdentityKey;
@@ -43,7 +39,6 @@ pub use nym_http_api_client::Client;
 use nym_http_api_client::{ApiClient, NO_PARAMS};
 use nym_mixnet_contract_common::mixnode::MixNodeDetails;
 use nym_mixnet_contract_common::{GatewayBond, IdentityKeyRef, NodeId, NymNodeDetails};
-use std::net::IpAddr;
 use time::format_description::BorrowedFormatItem;
 use time::Date;
 use tracing::instrument;
@@ -70,19 +65,6 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

-    #[instrument(level = "debug", skip(self))]
-    async fn build_information(&self) -> Result<BinaryBuildInformationOwned, NymAPIError> {
-        self.get_json(
-            &[
-                routes::API_VERSION,
-                routes::API_STATUS_ROUTES,
-                routes::BUILD_INFORMATION,
-            ],
-            NO_PARAMS,
-        )
-        .await
-    }
-
    #[deprecated]
    #[instrument(level = "debug", skip(self))]
    async fn get_mixnodes(&self) -> Result<Vec<MixNodeDetails>, NymAPIError> {
@@ -181,35 +163,6 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

-    #[tracing::instrument(level = "debug", skip_all)]
-    async fn get_node_performance_history(
-        &self,
-        node_id: NodeId,
-        page: Option<u32>,
-        per_page: Option<u32>,
-    ) -> Result<PerformanceHistoryResponse, NymAPIError> {
-        let mut params = Vec::new();
-
-        if let Some(page) = page {
-            params.push(("page", page.to_string()))
-        }
-
-        if let Some(per_page) = per_page {
-            params.push(("per_page", per_page.to_string()))
-        }
-
-        self.get_json(
-            &[
-                routes::API_VERSION,
-                routes::NYM_NODES_ROUTES,
-                routes::NYM_NODES_PERFORMANCE_HISTORY,
-                &*node_id.to_string(),
-            ],
-            &params,
-        )
-        .await
-    }
-
    #[tracing::instrument(level = "debug", skip_all)]
    async fn get_nodes_described(
        &self,
@@ -226,15 +179,8 @@ pub trait NymApiClientExt: ApiClient {
            params.push(("per_page", per_page.to_string()))
        }

-        self.get_json(
-            &[
-                routes::API_VERSION,
-                routes::NYM_NODES_ROUTES,
-                routes::NYM_NODES_DESCRIBED,
-            ],
-            &params,
-        )
-        .await
+        self.get_json(&[routes::API_VERSION, "nym-nodes", "described"], &params)
+            .await
    }

    #[tracing::instrument(level = "debug", skip_all)]
@@ -253,15 +199,8 @@ pub trait NymApiClientExt: ApiClient {
            params.push(("per_page", per_page.to_string()))
        }

-        self.get_json(
-            &[
-                routes::API_VERSION,
-                routes::NYM_NODES_ROUTES,
-                routes::NYM_NODES_BONDED,
-            ],
-            &params,
-        )
-        .await
+        self.get_json(&[routes::API_VERSION, "nym-nodes", "bonded"], &params)
+            .await
    }

    #[deprecated]
@@ -271,7 +210,7 @@ pub trait NymApiClientExt: ApiClient {
            &[
                routes::API_VERSION,
                "unstable",
-                routes::NYM_NODES_ROUTES,
+                "nym-nodes",
                "mixnodes",
                "skimmed",
            ],
@@ -287,7 +226,7 @@ pub trait NymApiClientExt: ApiClient {
            &[
                routes::API_VERSION,
                "unstable",
-                routes::NYM_NODES_ROUTES,
+                "nym-nodes",
                "gateways",
                "skimmed",
            ],
@@ -299,11 +238,7 @@ pub trait NymApiClientExt: ApiClient {
    #[instrument(level = "debug", skip(self))]
    async fn get_rewarded_set(&self) -> Result<RewardedSetResponse, NymAPIError> {
        self.get_json(
-            &[
-                routes::API_VERSION,
-                routes::NYM_NODES_ROUTES,
-                routes::NYM_NODES_REWARDED_SET,
-            ],
+            &[routes::API_VERSION, "nym-nodes", "rewarded-set"],
            NO_PARAMS,
        )
        .await
@@ -336,7 +271,7 @@ pub trait NymApiClientExt: ApiClient {
            &[
                routes::API_VERSION,
                "unstable",
-                routes::NYM_NODES_ROUTES,
+                "nym-nodes",
                "skimmed",
                "entry-gateways",
                "all",
@@ -373,7 +308,7 @@ pub trait NymApiClientExt: ApiClient {
            &[
                routes::API_VERSION,
                "unstable",
-                routes::NYM_NODES_ROUTES,
+                "nym-nodes",
                "skimmed",
                "mixnodes",
                "active",
@@ -410,7 +345,7 @@ pub trait NymApiClientExt: ApiClient {
            &[
                routes::API_VERSION,
                "unstable",
-                routes::NYM_NODES_ROUTES,
+                "nym-nodes",
                "skimmed",
                "mixnodes",
                "all",
@@ -442,12 +377,7 @@ pub trait NymApiClientExt: ApiClient {
        }

        self.get_json(
-            &[
-                routes::API_VERSION,
-                "unstable",
-                routes::NYM_NODES_ROUTES,
-                "skimmed",
-            ],
+            &[routes::API_VERSION, "unstable", "nym-nodes", "skimmed"],
            &params,
        )
        .await
@@ -756,8 +686,8 @@ pub trait NymApiClientExt: ApiClient {
        self.get_json(
            &[
                routes::API_VERSION,
-                routes::NYM_NODES_ROUTES,
-                routes::NYM_NODES_PERFORMANCE,
+                "nym-nodes",
+                "performance",
                &node_id.to_string(),
            ],
            NO_PARAMS,
@@ -772,8 +702,8 @@ pub trait NymApiClientExt: ApiClient {
        self.get_json(
            &[
                routes::API_VERSION,
-                routes::NYM_NODES_ROUTES,
-                routes::NYM_NODES_ANNOTATION,
+                "nym-nodes",
+                "annotation",
                &node_id.to_string(),
            ],
            NO_PARAMS,
@@ -867,6 +797,20 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

+    #[deprecated]
+    #[instrument(level = "debug", skip(self))]
+    async fn double_spending_filter_v1(&self) -> Result<SpentCredentialsResponse, NymAPIError> {
+        self.get_json(
+            &[
+                routes::API_VERSION,
+                routes::ECASH_ROUTES,
+                routes::DOUBLE_SPENDING_FILTER_V1,
+            ],
+            NO_PARAMS,
+        )
+        .await
+    }
+
    #[instrument(level = "debug", skip(self))]
    async fn partial_expiration_date_signatures(
        &self,
@@ -983,11 +927,7 @@ pub trait NymApiClientExt: ApiClient {
        request: &NodeRefreshBody,
    ) -> Result<(), NymAPIError> {
        self.post_json(
-            &[
-                routes::API_VERSION,
-                routes::NYM_NODES_ROUTES,
-                routes::NYM_NODES_REFRESH_DESCRIBED,
-            ],
+            &[routes::API_VERSION, "nym-nodes", "refresh-described"],
            NO_PARAMS,
            request,
        )
@@ -1031,41 +971,6 @@ pub trait NymApiClientExt: ApiClient {
        )
        .await
    }
-
-    async fn nodes_by_addresses(
-        &self,
-        addresses: Vec<IpAddr>,
-    ) -> Result<NodesByAddressesResponse, NymAPIError> {
-        self.post_json(
-            &[
-                routes::API_VERSION,
-                "unstable",
-                routes::NYM_NODES_ROUTES,
-                routes::nym_nodes::BY_ADDRESSES,
-            ],
-            NO_PARAMS,
-            &NodesByAddressesRequestBody { addresses },
-        )
-        .await
-    }
-
-    #[instrument(level = "debug", skip(self))]
-    async fn get_network_details(&self) -> Result<NymNetworkDetailsResponse, NymAPIError> {
-        self.get_json(
-            &[routes::API_VERSION, routes::NETWORK, routes::DETAILS],
-            NO_PARAMS,
-        )
-        .await
-    }
-
-    #[instrument(level = "debug", skip(self))]
-    async fn get_chain_status(&self) -> Result<ChainStatusResponse, NymAPIError> {
-        self.get_json(
-            &[routes::API_VERSION, routes::NETWORK, routes::CHAIN_STATUS],
-            NO_PARAMS,
-        )
-        .await
-    }
 }

 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
@@ -13,6 +13,8 @@ pub const DETAILED: &str = "detailed";
 pub const DETAILED_UNFILTERED: &str = "detailed-unfiltered";
 pub const ACTIVE: &str = "active";
 pub const REWARDED: &str = "rewarded";
+pub const DOUBLE_SPENDING_FILTER_V1: &str = "double-spending-filter-v1";
+
 pub const ECASH_ROUTES: &str = "ecash";

 pub use ecash::*;
@@ -32,25 +34,9 @@ pub mod ecash {
    pub const EPOCH_ID_PARAM: &str = "epoch_id";
 }

-pub const NYM_NODES_ROUTES: &str = "nym-nodes";
-
-pub use nym_nodes::*;
-pub mod nym_nodes {
-    pub const NYM_NODES_PERFORMANCE_HISTORY: &str = "performance-history";
-    pub const NYM_NODES_PERFORMANCE: &str = "performance";
-    pub const NYM_NODES_ANNOTATION: &str = "annotation";
-    pub const NYM_NODES_DESCRIBED: &str = "described";
-    pub const NYM_NODES_BONDED: &str = "bonded";
-    pub const NYM_NODES_REWARDED_SET: &str = "rewarded-set";
-    pub const NYM_NODES_REFRESH_DESCRIBED: &str = "refresh-described";
-    pub const BY_ADDRESSES: &str = "by-addresses";
-}
-
 pub const STATUS_ROUTES: &str = "status";
 pub const API_STATUS_ROUTES: &str = "api-status";
 pub const HEALTH: &str = "health";
-pub const BUILD_INFORMATION: &str = "build-information";
-
 pub const MIXNODE: &str = "mixnode";
 pub const GATEWAY: &str = "gateway";
 pub const NYM_NODES: &str = "nym-nodes";
@@ -68,9 +54,6 @@ pub const STAKE_SATURATION: &str = "stake-saturation";
 pub const INCLUSION_CHANCE: &str = "inclusion-probability";
 pub const SUBMIT_GATEWAY: &str = "submit-gateway-monitoring-results";
 pub const SUBMIT_NODE: &str = "submit-node-monitoring-results";
+pub const PERFORMANCE: &str = "performance";

 pub const SERVICE_PROVIDERS: &str = "services";
-
-pub const DETAILS: &str = "details";
-pub const CHAIN_STATUS: &str = "chain-status";
-pub const NETWORK: &str = "network";
@@ -153,20 +153,13 @@ pub trait CosmWasmClient: TendermintRpcClient {
            let req = QueryAllBalancesRequest {
                address: address.to_string(),
                pagination,
-                resolve_denom: false,
            };

            let mut res = self
                .make_abci_query::<_, QueryAllBalancesResponse>(path.clone(), req)
                .await?;

-            let early_break = res.balances.is_empty();
            raw_balances.append(&mut res.balances);
-
-            if early_break {
-                break;
-            }
-
            if let Some(next_key) = next_page_key(res.pagination) {
                pagination = Some(create_pagination(next_key))
            } else {
@@ -194,13 +187,7 @@ pub trait CosmWasmClient: TendermintRpcClient {
                .make_abci_query::<_, QueryTotalSupplyResponse>(path.clone(), req)
                .await?;

-            let early_break = res.supply.is_empty();
            supply.append(&mut res.supply);
-
-            if early_break {
-                break;
-            }
-
            if let Some(next_key) = next_page_key(res.pagination) {
                pagination = Some(create_pagination(next_key))
            } else {
@@ -341,13 +328,7 @@ pub trait CosmWasmClient: TendermintRpcClient {
                .make_abci_query::<_, QueryCodesResponse>(path.clone(), req)
                .await?;

-            let early_break = res.code_infos.is_empty();
            raw_codes.append(&mut res.code_infos);
-
-            if early_break {
-                break;
-            }
-
            if let Some(next_key) = next_page_key(res.pagination) {
                pagination = Some(create_pagination(next_key))
            } else {
@@ -392,13 +373,7 @@ pub trait CosmWasmClient: TendermintRpcClient {
                .make_abci_query::<_, QueryContractsByCodeResponse>(path.clone(), req)
                .await?;

-            let early_break = res.contracts.is_empty();
            raw_contracts.append(&mut res.contracts);
-
-            if early_break {
-                break;
-            }
-
            if let Some(next_key) = next_page_key(res.pagination) {
                pagination = Some(create_pagination(next_key))
            } else {
@@ -454,13 +429,7 @@ pub trait CosmWasmClient: TendermintRpcClient {
                .make_abci_query::<_, QueryContractHistoryResponse>(path.clone(), req)
                .await?;

-            let early_break = res.entries.is_empty();
            raw_entries.append(&mut res.entries);
-
-            if early_break {
-                break;
-            }
-
            if let Some(next_key) = next_page_key(res.pagination) {
                pagination = Some(create_pagination(next_key))
            } else {
@@ -28,6 +28,7 @@ use nym_network_defaults::{ChainDetails, NymNetworkDetails};
 use serde::{de::DeserializeOwned, Serialize};
 use std::fmt::Debug;
 use std::time::SystemTime;
+use tendermint_rpc::endpoint::block::Response as BlockResponse;
 use tendermint_rpc::endpoint::*;
 use tendermint_rpc::{Error as TendermintRpcError, Order};
 use url::Url;
@@ -62,8 +63,6 @@ pub use cw3;
 pub use cw4;
 pub use cw_controllers;
 pub use fee::{gas_price::GasPrice, GasAdjustable, GasAdjustment};
-pub use prost::Name;
-pub use tendermint_rpc::endpoint::block::Response as BlockResponse;
 pub use tendermint_rpc::{
    endpoint::{tx::Response as TxResponse, validators::Response as ValidatorResponse},
    query::Query,
@@ -4,11 +4,9 @@
 use crate::rpc::TendermintRpcClient;
 use async_trait::async_trait;
 use base64::Engine;
-use cosmrs::tendermint;
 use cosmrs::tendermint::{block::Height, evidence::Evidence, Hash};
 use reqwest::header::HeaderMap;
 use reqwest::{header, RequestBuilder};
-use tendermint_rpc::dialect::{v0_34, v0_37, v0_38, LatestDialect};
 use tendermint_rpc::{
    client::CompatMode,
    dialect::{self, Dialect},
@@ -23,21 +21,8 @@ macro_rules! perform_with_compat {
    ($self:expr, $request:expr) => {{
        let request = $request;
        match $self.compat {
-            CompatMode::V0_38 => {
-                $self
-                    .perform_request_with_dialect(request, dialect::v0_38::Dialect)
-                    .await
-            }
-            CompatMode::V0_37 => {
-                $self
-                    .perform_request_with_dialect(request, dialect::v0_37::Dialect)
-                    .await
-            }
-            CompatMode::V0_34 => {
-                $self
-                    .perform_request_with_dialect(request, dialect::v0_34::Dialect)
-                    .await
-            }
+            CompatMode::V0_37 => $self.perform_v0_37(request).await,
+            CompatMode::V0_34 => $self.perform_v0_34(request).await,
        }
    }};
 }
@@ -85,11 +70,7 @@ impl ReqwestRpcClient {
            .headers(headers)
    }

-    async fn perform_request_with_dialect<R, S>(
-        &self,
-        request: R,
-        _dialect: S,
-    ) -> Result<R::Output, Error>
+    async fn perform_request<R, S>(&self, request: R) -> Result<R::Output, Error>
    where
        R: SimpleRequest<S>,
        S: Dialect,
@@ -100,25 +81,26 @@ impl ReqwestRpcClient {
            .send()
            .await
            .map_err(TendermintRpcErrorMap::into_rpc_err)?;
-        let response_status = response.status();
        let bytes = response
            .bytes()
            .await
            .map_err(TendermintRpcErrorMap::into_rpc_err)?;
-
-        // Successful JSON-RPC requests are expected to return a 200 OK HTTP status.
-        // Otherwise, this means that the HTTP request failed as a whole,
-        // as opposed to the JSON-RPC request returning an error,
-        // and we cannot expect the response body to be a valid JSON-RPC response.
-        if response_status != reqwest::StatusCode::OK {
-            // hehe, that's so nasty but we have to somehow convert between different versions of the same lib
-            return Err(Error::http_request_failed(
-                response_status.as_u16().try_into().unwrap(),
-            ));
-        }
-
        R::Response::from_string(bytes).map(Into::into)
    }
+
+    async fn perform_v0_34<R>(&self, request: R) -> Result<R::Output, Error>
+    where
+        R: SimpleRequest<dialect::v0_34::Dialect>,
+    {
+        self.perform_request(request).await
+    }
+
+    async fn perform_v0_37<R>(&self, request: R) -> Result<R::Output, Error>
+    where
+        R: SimpleRequest<dialect::v0_37::Dialect>,
+    {
+        self.perform_request(request).await
+    }
 }

 trait TendermintRpcErrorMap {
@@ -138,50 +120,18 @@ impl TendermintRpcClient for ReqwestRpcClient {
    where
        R: SimpleRequest,
    {
-        self.perform_request_with_dialect(request, LatestDialect)
-            .await
+        self.perform_request(request).await
    }

-    async fn block<H>(&self, height: H) -> Result<endpoint::block::Response, Error>
+    async fn block_results<H>(&self, height: H) -> Result<block_results::Response, Error>
    where
        H: Into<Height> + Send,
    {
-        perform_with_compat!(self, endpoint::block::Request::new(height.into()))
+        perform_with_compat!(self, block_results::Request::new(height.into()))
    }

-    async fn block_by_hash(
-        &self,
-        hash: tendermint::Hash,
-    ) -> Result<endpoint::block_by_hash::Response, Error> {
-        perform_with_compat!(self, endpoint::block_by_hash::Request::new(hash))
-    }
-
-    async fn latest_block(&self) -> Result<endpoint::block::Response, Error> {
-        perform_with_compat!(self, endpoint::block::Request::default())
-    }
-
-    async fn block_results<H>(&self, height: H) -> Result<endpoint::block_results::Response, Error>
-    where
-        H: Into<Height> + Send,
-    {
-        perform_with_compat!(self, endpoint::block_results::Request::new(height.into()))
-    }
-
-    async fn latest_block_results(&self) -> Result<endpoint::block_results::Response, Error> {
-        perform_with_compat!(self, endpoint::block_results::Request::default())
-    }
-
-    async fn block_search(
-        &self,
-        query: Query,
-        page: u32,
-        per_page: u8,
-        order: Order,
-    ) -> Result<endpoint::block_search::Response, Error> {
-        perform_with_compat!(
-            self,
-            endpoint::block_search::Request::new(query, page, per_page, order)
-        )
+    async fn latest_block_results(&self) -> Result<block_results::Response, Error> {
+        perform_with_compat!(self, block_results::Request::default())
    }

    async fn header<H>(&self, height: H) -> Result<endpoint::header::Response, Error>
@@ -190,26 +140,11 @@ impl TendermintRpcClient for ReqwestRpcClient {
    {
        let height = height.into();
        match self.compat {
-            CompatMode::V0_38 => {
-                self.perform_request_with_dialect(
-                    endpoint::header::Request::new(height),
-                    v0_38::Dialect,
-                )
-                .await
-            }
-            CompatMode::V0_37 => {
-                self.perform_request_with_dialect(
-                    endpoint::header::Request::new(height),
-                    v0_37::Dialect,
-                )
-                .await
-            }
+            CompatMode::V0_37 => self.perform(endpoint::header::Request::new(height)).await,
            CompatMode::V0_34 => {
                // Back-fill with a request to /block endpoint and
                // taking just the header from the response.
-                let resp = self
-                    .perform_request_with_dialect(block::Request::new(height), v0_34::Dialect)
-                    .await?;
+                let resp = self.perform_v0_34(block::Request::new(height)).await?;
                Ok(resp.into())
            }
        }
@@ -217,25 +152,12 @@ impl TendermintRpcClient for ReqwestRpcClient {

    async fn header_by_hash(&self, hash: Hash) -> Result<header_by_hash::Response, Error> {
        match self.compat {
-            CompatMode::V0_38 => {
-                self.perform_request_with_dialect(
-                    header_by_hash::Request::new(hash),
-                    v0_38::Dialect,
-                )
-                .await
-            }
-            CompatMode::V0_37 => {
-                self.perform_request_with_dialect(
-                    header_by_hash::Request::new(hash),
-                    v0_37::Dialect,
-                )
-                .await
-            }
+            CompatMode::V0_37 => self.perform(header_by_hash::Request::new(hash)).await,
            CompatMode::V0_34 => {
                // Back-fill with a request to /block_by_hash endpoint and
                // taking just the header from the response.
                let resp = self
-                    .perform_request_with_dialect(block_by_hash::Request::new(hash), v0_34::Dialect)
+                    .perform_v0_34(block_by_hash::Request::new(hash))
                    .await?;
                Ok(resp.into())
            }
@@ -245,18 +167,8 @@ impl TendermintRpcClient for ReqwestRpcClient {
    /// `/broadcast_evidence`: broadcast an evidence.
    async fn broadcast_evidence(&self, e: Evidence) -> Result<evidence::Response, Error> {
        match self.compat {
-            CompatMode::V0_38 => {
-                self.perform_request_with_dialect(evidence::Request::new(e), v0_38::Dialect)
-                    .await
-            }
-            CompatMode::V0_37 => {
-                self.perform_request_with_dialect(evidence::Request::new(e), v0_37::Dialect)
-                    .await
-            }
-            CompatMode::V0_34 => {
-                self.perform_request_with_dialect(evidence::Request::new(e), v0_34::Dialect)
-                    .await
-            }
+            CompatMode::V0_37 => self.perform(evidence::Request::new(e)).await,
+            CompatMode::V0_34 => self.perform_v0_34(evidence::Request::new(e)).await,
        }
    }

@@ -25,6 +25,15 @@ pub fn in6addr_any_init() -> IpAddr {
    IpAddr::V6(Ipv6Addr::UNSPECIFIED)
 }

+/// Helper for providing binding warnings if node tries to bind to any of those
+pub const SPECIAL_ADDRESSES: &[IpAddr] = &[
+    IpAddr::V4(Ipv4Addr::LOCALHOST),
+    IpAddr::V4(Ipv4Addr::UNSPECIFIED),
+    IpAddr::V4(Ipv4Addr::BROADCAST),
+    IpAddr::V6(Ipv6Addr::LOCALHOST),
+    IpAddr::V6(Ipv6Addr::UNSPECIFIED),
+];
+
 // TODO: is it really part of 'Config'?
 pub trait OptionalSet {
    /// If the value is available (i.e. `Some`), the provided closure is applied.
@@ -113,10 +113,6 @@ impl Role {
    pub fn is_standby(&self) -> bool {
        matches!(self, Role::Standby)
    }
-
-    pub fn is_mixnode(&self) -> bool {
-        matches!(self, Role::Layer1 | Role::Layer2 | Role::Layer3)
-    }
 }

 impl Display for Role {
@@ -8,81 +8,81 @@ use thiserror::Error;

 #[derive(Error, Debug, PartialEq)]
 pub enum VestingContractError {
-    #[error("VESTING ({l}): {0}", l = line!())]
+    #[error("VESTING ({}): {0}", line!())]
    Std(#[from] StdError),

    #[error("VESTING: {0}")]
    OverflowError(#[from] OverflowError),

-    #[error("VESTING ({l}): Account does not exist - {0}", l = line!())]
+    #[error("VESTING ({}): Account does not exist - {0}", line!())]
    NoAccountForAddress(String),

-    #[error("VESTING ({l}): Only admin can perform this action, {0} is not admin", l = line!())]
+    #[error("VESTING ({}): Only admin can perform this action, {0} is not admin", line!())]
    NotAdmin(String),

-    #[error("VESTING ({l}): Balance not found for existing account ({0}), this is a bug", l = line!())]
+    #[error("VESTING ({}): Balance not found for existing account ({0}), this is a bug", line!())]
    NoBalanceForAddress(String),

-    #[error("VESTING ({l}): Insufficient balance for address {0} -> {1}", l = line!())]
+    #[error("VESTING ({}): Insufficient balance for address {0} -> {1}", line!())]
    InsufficientBalance(String, u128),

-    #[error("VESTING ({l}): Insufficient spendable balance for address {0} -> {1}", l = line!())]
+    #[error("VESTING ({}): Insufficient spendable balance for address {0} -> {1}", line!())]
    InsufficientSpendable(String, u128),

    #[error(
-    "VESTING ({l}):Only delegation owner can perform delegation actions, {0} is not the delegation owner"
-    , l = line!())]
+    "VESTING ({}):Only delegation owner can perform delegation actions, {0} is not the delegation owner"
+    , line!())]
    NotDelegate(String),

-    #[error("VESTING ({l}): Total vesting amount is inprobably low -> {0}, this is likely an error", l = line!())]
+    #[error("VESTING ({}): Total vesting amount is inprobably low -> {0}, this is likely an error", line!())]
    ImprobableVestingAmount(u128),

-    #[error("VESTING ({l}): Address {0} has already bonded a node", l = line!())]
+    #[error("VESTING ({}): Address {0} has already bonded a node", line!())]
    AlreadyBonded(String),

-    #[error("VESTING ({l}): Received empty funds vector", l = line!())]
+    #[error("VESTING ({}): Received empty funds vector", line!())]
    EmptyFunds,

-    #[error("VESTING ({l}): Received wrong denom: {0}, expected {1}", l = line!())]
+    #[error("VESTING ({}): Received wrong denom: {0}, expected {1}", line!())]
    WrongDenom(String, String),

-    #[error("VESTING ({l}): Received multiple denoms, expected 1", l = line!())]
+    #[error("VESTING ({}): Received multiple denoms, expected 1", line!())]
    MultipleDenoms,

-    #[error("VESTING ({l}): No delegations found for account {0}, mix_identity {1}", l = line!())]
+    #[error("VESTING ({}): No delegations found for account {0}, mix_identity {1}", line!())]
    NoSuchDelegation(Addr, NodeId),

-    #[error("VESTING ({l}): Only mixnet contract can perform this operation, got {0}", l = line!())]
+    #[error("VESTING ({}): Only mixnet contract can perform this operation, got {0}", line!())]
    NotMixnetContract(Addr),

-    #[error("VESTING ({l}): Calculation underflowed", l = line!())]
+    #[error("VESTING ({}): Calculation underflowed", line!())]
    Underflow,

-    #[error("VESTING ({l}): No bond found for account {0}", l = line!())]
+    #[error("VESTING ({}): No bond found for account {0}", line!())]
    NoBondFound(String),

    #[error("VESTING: Attempted to reduce mixnode bond pledge below zero! The current pledge is {current} and we attempted to reduce it by {decrease_by}.")]
    InvalidBondPledgeReduction { current: Coin, decrease_by: Coin },

-    #[error("VESTING ({l}): Action can only be executed by account owner -> {0}", l = line!())]
+    #[error("VESTING ({}): Action can only be executed by account owner -> {0}", line!())]
    NotOwner(String),

-    #[error("VESTING ({l}): Invalid address: {0}", l = line!())]
+    #[error("VESTING ({}): Invalid address: {0}", line!())]
    InvalidAddress(String),

-    #[error("VESTING ({l}): Account already exists: {0}", l = line!())]
+    #[error("VESTING ({}): Account already exists: {0}", line!())]
    AccountAlreadyExists(String),

-    #[error("VESTING ({l}): Staking account already exists: {0}", l = line!())]
+    #[error("VESTING ({}): Staking account already exists: {0}", line!())]
    StakingAccountAlreadyExists(String),

-    #[error("VESTING ({l}): Too few coins sent for vesting account creation, sent {sent}, need at least {need}", l = line!())]
+    #[error("VESTING ({}): Too few coins sent for vesting account creation, sent {sent}, need at least {need}", line!())]
    MinVestingFunds { sent: u128, need: u128 },

-    #[error("VESTING ({l}): Maximum amount of locked coins has already been pledged: {current}, cap is {cap}", l = line!())]
+    #[error("VESTING ({}): Maximum amount of locked coins has already been pledged: {current}, cap is {cap}", line!())]
    LockedPledgeCapReached { current: Uint128, cap: Uint128 },

-    #[error("VESTING: ({l}: Account owned by {owner} has unpopulated vesting periods!", l = line!())]
+    #[error("VESTING: ({}: Account owned by {owner} has unpopulated vesting periods!", line!())]
    UnpopulatedVestingPeriods { owner: Addr },

    #[error("VESTING: Vesting account associated with {0} already exists, only addresses with not existing vesting accounts can be added as staking addresses")]
@@ -19,7 +19,7 @@ use std::error::Error;
 // `SELECT total_tickets, used_tickets FROM ecash_ticketbook WHERE expiration_date >= ?`, today_date
 // then for each calculate the diff total_tickets - used_tickets and multiply the result by the size of the ticket
 #[async_trait]
-pub trait Storage: Clone + Send + Sync {
+pub trait Storage: Send + Sync {
    type StorageError: Error;

    async fn close(&self);
@@ -26,6 +26,7 @@ nym-api-requests = { path = "../../nym-api/nym-api-requests" }
 nym-credentials = { path = "../credentials" }
 nym-credentials-interface = { path = "../credentials-interface" }
 nym-ecash-contract-common = { path = "../cosmwasm-smart-contracts/ecash-contract" }
+nym-ecash-double-spending = { path = "../ecash-double-spending" }
 nym-gateway-requests = { path = "../gateway-requests" }
 nym-gateway-storage = { path = "../gateway-storage" }
 nym-task = { path = "../task" }
@@ -13,7 +13,6 @@ use nym_api_requests::constants::MIN_BATCH_REDEMPTION_DELAY;
 use nym_api_requests::ecash::models::{BatchRedeemTicketsBody, VerifyEcashTicketBody};
 use nym_credentials_interface::Bandwidth;
 use nym_credentials_interface::{ClientTicket, TicketType};
-use nym_validator_client::coconut::EcashApiError;
 use nym_validator_client::nym_api::EpochId;
 use nym_validator_client::nyxd::contract_traits::{
    EcashSigningClient, MultisigQueryClient, MultisigSigningClient, PagedMultisigQueryClient,
@@ -353,9 +352,7 @@ impl CredentialHandler {
            }
            Err(err) => {
                error!("failed to send ticket {ticket_id} for verification to ecash signer '{client}': {err}. if we don't reach quorum, we'll retry later");
-                Err(EcashTicketError::ApiFailure(EcashApiError::NymApi {
-                    source: err,
-                }))
+                Ok(false)
            }
        }
    }
@@ -24,7 +24,6 @@ ed25519-dalek = { workspace = true, features = ["rand_core"], optional = true }
 rand = { workspace = true, optional = true }
 serde_bytes = { workspace = true, optional = true }
 serde = { workspace = true, features = ["derive"], optional = true }
-sha2 = { workspace = true, optional = true }
 subtle-encoding = { workspace = true, features = ["bech32-preview"] }
 thiserror = { workspace = true }
 zeroize = { workspace = true, optional = true, features = ["zeroize_derive"] }
@@ -37,13 +36,11 @@ nym-pemstore = { path = "../../common/pemstore", version = "0.3.0" }
 rand_chacha = { workspace = true }

 [features]
-default = []
+default = ["sphinx"]
 aead = ["dep:aead", "aead/std", "aes-gcm-siv", "generic-array"]
 serde = ["dep:serde", "serde_bytes", "ed25519-dalek/serde", "x25519-dalek/serde"]
 asymmetric = ["x25519-dalek", "ed25519-dalek", "zeroize"]
-hashing = ["blake3", "digest", "hkdf", "hmac", "generic-array", "sha2"]
+hashing = ["blake3", "digest", "hkdf", "hmac", "generic-array"]
 stream_cipher = ["aes", "ctr", "cipher", "generic-array"]
 sphinx = ["nym-sphinx-types/sphinx"]
-
-[lints]
-workspace = true
+outfox = ["nym-sphinx-types/outfox"]
@@ -202,18 +202,6 @@ impl PemStorableKey for PublicKey {
    }
 }

-impl From<x25519_dalek::PublicKey> for PublicKey {
-    fn from(public_key: x25519_dalek::PublicKey) -> Self {
-        PublicKey(public_key)
-    }
-}
-
-impl From<PublicKey> for x25519_dalek::PublicKey {
-    fn from(public_key: PublicKey) -> Self {
-        public_key.0
-    }
-}
-
 #[derive(Zeroize, ZeroizeOnDrop)]
 pub struct PrivateKey(x25519_dalek::StaticSecret);

@@ -320,15 +308,109 @@ impl PemStorableKey for PrivateKey {
    }
 }

-impl From<x25519_dalek::StaticSecret> for PrivateKey {
-    fn from(secret: x25519_dalek::StaticSecret) -> Self {
-        PrivateKey(secret)
+// compatibility with sphinx keys:
+#[cfg(feature = "sphinx")]
+impl From<PublicKey> for nym_sphinx_types::PublicKey {
+    fn from(key: PublicKey) -> Self {
+        nym_sphinx_types::PublicKey::from(key.to_bytes())
    }
 }

-impl AsRef<x25519_dalek::StaticSecret> for PrivateKey {
-    fn as_ref(&self) -> &x25519_dalek::StaticSecret {
-        &self.0
+#[cfg(feature = "sphinx")]
+impl<'a> From<&'a PublicKey> for nym_sphinx_types::PublicKey {
+    fn from(key: &'a PublicKey) -> Self {
+        nym_sphinx_types::PublicKey::from((*key).to_bytes())
+    }
+}
+
+#[cfg(feature = "sphinx")]
+impl From<nym_sphinx_types::PublicKey> for PublicKey {
+    fn from(pub_key: nym_sphinx_types::PublicKey) -> Self {
+        Self(x25519_dalek::PublicKey::from(*pub_key.as_bytes()))
+    }
+}
+
+#[cfg(feature = "sphinx")]
+impl From<PrivateKey> for nym_sphinx_types::PrivateKey {
+    fn from(key: PrivateKey) -> Self {
+        nym_sphinx_types::PrivateKey::from(key.to_bytes())
+    }
+}
+
+#[cfg(feature = "sphinx")]
+impl<'a> From<&'a PrivateKey> for nym_sphinx_types::PrivateKey {
+    fn from(key: &'a PrivateKey) -> Self {
+        nym_sphinx_types::PrivateKey::from(key.to_bytes())
+    }
+}
+
+#[cfg(feature = "sphinx")]
+impl From<nym_sphinx_types::PrivateKey> for PrivateKey {
+    fn from(private_key: nym_sphinx_types::PrivateKey) -> Self {
+        let private_key_bytes = private_key.to_bytes();
+        assert_eq!(private_key_bytes.len(), PRIVATE_KEY_SIZE);
+        Self::from_bytes(&private_key_bytes).unwrap()
+    }
+}
+
+#[cfg(test)]
+mod sphinx_key_conversion {
+    use super::*;
+    use rand_chacha::rand_core::SeedableRng;
+    use rand_chacha::ChaCha20Rng;
+
+    pub(super) fn test_rng() -> ChaCha20Rng {
+        let dummy_seed = [42u8; 32];
+        ChaCha20Rng::from_seed(dummy_seed)
+    }
+
+    const NUM_ITERATIONS: usize = 100;
+
+    #[test]
+    fn works_for_forward_conversion() {
+        let mut rng = test_rng();
+
+        for _ in 0..NUM_ITERATIONS {
+            let keys = KeyPair::new(&mut rng);
+            let private = &keys.private_key;
+            let public = &keys.public_key;
+
+            let dummy_remote = KeyPair::new(&mut rng);
+            let dh1 = private.diffie_hellman(&dummy_remote.public_key);
+
+            let public_bytes = public.to_bytes();
+
+            let sphinx_private: nym_sphinx_types::PrivateKey = private.into();
+            let recovered_private = PrivateKey::from(sphinx_private);
+
+            let dh2 = recovered_private.diffie_hellman(&dummy_remote.public_key);
+
+            let sphinx_public: nym_sphinx_types::PublicKey = public.into();
+            let recovered_public = PublicKey::from(sphinx_public);
+            assert_eq!(public_bytes, recovered_public.to_bytes());
+
+            // even though the byte representation of the private key changed, the resultant DH is the same
+            // which is what matters
+            assert_eq!(dh1, dh2);
+        }
+    }
+
+    #[test]
+    fn works_for_backward_conversion() {
+        for _ in 0..NUM_ITERATIONS {
+            let (sphinx_private, sphinx_public) = nym_sphinx_types::crypto::keygen();
+
+            let private_bytes = sphinx_private.to_bytes();
+            let public_bytes = sphinx_public.as_bytes();
+
+            let private: PrivateKey = sphinx_private.into();
+            let recovered_sphinx_private: nym_sphinx_types::PrivateKey = private.into();
+
+            let public: PublicKey = sphinx_public.into();
+            let recovered_sphinx_public: nym_sphinx_types::PublicKey = public.into();
+            assert_eq!(private_bytes, recovered_sphinx_private.to_bytes());
+            assert_eq!(public_bytes, recovered_sphinx_public.as_bytes());
+        }
    }
 }

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0

 pub use ed25519_dalek::SignatureError;
-use ed25519_dalek::{SecretKey, Signer, SigningKey};
+use ed25519_dalek::{Signer, SigningKey};
 pub use ed25519_dalek::{Verifier, PUBLIC_KEY_LENGTH, SECRET_KEY_LENGTH, SIGNATURE_LENGTH};
 use nym_pemstore::traits::{PemStorableKey, PemStorableKeyPair};
 use std::fmt::{self, Debug, Display, Formatter};
@@ -18,7 +18,7 @@ pub mod serde_helpers;
 use nym_sphinx_types::{DestinationAddressBytes, DESTINATION_ADDRESS_LENGTH};

 #[cfg(feature = "rand")]
-use rand::{CryptoRng, Rng, RngCore};
+use rand::{CryptoRng, RngCore};
 #[cfg(feature = "serde")]
 use serde::de::Error as SerdeError;
 #[cfg(feature = "serde")]
@@ -62,33 +62,16 @@ pub struct KeyPair {
    // nothing secret about public key
    #[zeroize(skip)]
    public_key: PublicKey,
-
-    #[zeroize(skip)]
-    index: u32,
 }

-/// All keys will always have an index field populated this is to prevent anyone from figuring out if
-/// the keys are derived or random, and alter their behaviour based on that.
 impl KeyPair {
    #[cfg(feature = "rand")]
    pub fn new<R: RngCore + CryptoRng>(rng: &mut R) -> Self {
-        let index = rng.gen();
        let ed25519_signing_key = ed25519_dalek::SigningKey::generate(rng);

        KeyPair {
            private_key: PrivateKey(ed25519_signing_key.to_bytes()),
            public_key: PublicKey(ed25519_signing_key.verifying_key()),
-            index,
-        }
-    }
-
-    pub fn from_secret(secret: SecretKey, index: u32) -> Self {
-        let ed25519_signing_key = SigningKey::from(secret);
-
-        KeyPair {
-            private_key: PrivateKey(ed25519_signing_key.to_bytes()),
-            public_key: PublicKey(ed25519_signing_key.verifying_key()),
-            index,
        }
    }

@@ -104,31 +87,15 @@ impl KeyPair {
        Ok(KeyPair {
            private_key: PrivateKey::from_bytes(priv_bytes)?,
            public_key: PublicKey::from_bytes(pub_bytes)?,
-            index: fake_index(pub_bytes),
        })
    }
 }

-/// Reduces a byte slice into a u32 value by XOR-ing all its bytes into a 4-byte accumulator.
-/// The process iterates over every byte in the input slice, XOR-ing each one into a slot based on its index modulo 4.
-/// If the input slice contains fewer than 4 bytes, the remaining positions in the accumulator remain zero.
-/// Finally, the accumulator is interpreted in big-endian order to produce the resulting u32.
-/// Index is used to verify deterministic identity key, master key and salt are also requried for verification.
-fn fake_index(input: &[u8]) -> u32 {
-    let mut accumulator = [0u8; 4];
-    for (i, &byte) in input.iter().enumerate() {
-        accumulator[i % 4] ^= byte;
-    }
-    u32::from_be_bytes(accumulator)
-}
-
 impl From<PrivateKey> for KeyPair {
    fn from(private_key: PrivateKey) -> Self {
-        let public_key = (&private_key).into();
        KeyPair {
-            public_key,
+            public_key: (&private_key).into(),
            private_key,
-            index: fake_index(public_key.to_bytes().as_ref()),
        }
    }
 }
@@ -148,7 +115,6 @@ impl PemStorableKeyPair for KeyPair {
        KeyPair {
            private_key,
            public_key,
-            index: fake_index(public_key.to_bytes().as_ref()),
        }
    }
 }
@@ -8,10 +8,6 @@ use hkdf::{
    },
    Hkdf,
 };
-use sha2::{Sha256, Sha512};
-
-pub use hkdf::InvalidLength;
-use zeroize::ZeroizeOnDrop;

 /// Perform HKDF `extract` then `expand` as a single step.
 pub fn extract_then_expand<D>(
@@ -32,80 +28,3 @@ where

    Ok(okm)
 }
-
-/// `DerivationMaterial` encapsulates parameters for deterministic key derivation using
-/// HKDF (SHA-512).
-///
-/// It consists of:
-///   - A master key (`master_key`): the base secret.
-///   - An index (`index`): ensures unique derivations.
-///   - A salt (`salt`): adds additional uniqueness, should be application specific.
-///
-/// Use the `derive_secret()` method to generate a 32-byte secret. To prepare for a new derivation,
-/// call the `next()` method, which increments the index. **It is the caller's responsibility to
-/// track and persist the derivation index if keys need to be rederived.**
-///
-/// # Example
-///
-/// ```rust
-/// use nym_crypto::hkdf::DerivationMaterial;
-///
-/// let master_key = [0u8; 32]; // your secret master key
-/// let salt = b"unique-salt-value";
-/// let material = DerivationMaterial::new(master_key, 0, salt);
-///
-/// // Derive a secret
-/// let secret = material.derive_secret().expect("Failed to derive secret");
-///
-/// // Prepare for the next derivation
-/// let next_material = material.next();
-/// ```
-#[derive(ZeroizeOnDrop)]
-pub struct DerivationMaterial {
-    master_key: [u8; 32],
-    index: u32,
-    salt: Vec<u8>,
-}
-
-impl DerivationMaterial {
-    pub fn index(&self) -> u32 {
-        self.index
-    }
-
-    pub fn salt(&self) -> &[u8] {
-        &self.salt
-    }
-
-    /// Derives a 32-byte seed from a master seed and an index using HKDF (with SHA-512).
-    ///
-    /// The `salt` and the use of the index (as info) bind this derivation to an application/client.
-    pub fn derive_secret(&self) -> Result<[u8; 32], hkdf::InvalidLength> {
-        let salt = &self.salt;
-        let info = self.index.to_be_bytes(); // Use the index as info
-        let hk = Hkdf::<Sha512>::new(Some(salt), &self.master_key);
-        let mut okm = [0u8; 32];
-        hk.expand(&info, &mut okm)?;
-        Ok(okm)
-    }
-
-    pub fn new<T: AsRef<[u8]>>(master_key: T, index: u32, salt: &[u8]) -> Self {
-        // Coerce master_key to [u8; 32]
-        let mut hasher = Sha256::new();
-        hasher.update(master_key.as_ref());
-        let master_key = hasher.finalize().into();
-
-        Self {
-            master_key,
-            index,
-            salt: salt.to_vec(),
-        }
-    }
-
-    pub fn next(&self) -> Self {
-        Self {
-            master_key: self.master_key,
-            index: self.index + 1,
-            salt: self.salt.clone(),
-        }
-    }
-}
@@ -16,11 +16,8 @@ pub fn compute_keyed_hmac<D>(key: &[u8], data: &[u8]) -> HmacOutput<D>
 where
    D: Digest + BlockSizeUser,
 {
-    // SAFETY: hmac is fine with keys of any size; if they're smaller than the block size of the underlying
-    // digest, they're padded with 0. if they're larger they're hashed and padded
-    // the reason for `Result` return type is due to the trait definition
-    #[allow(clippy::unwrap_used)]
-    let mut hmac = SimpleHmac::<D>::new_from_slice(key).unwrap();
+    let mut hmac = SimpleHmac::<D>::new_from_slice(key)
+        .expect("HMAC was instantiated with a key of an invalid size!");
    hmac.update(data);
    hmac.finalize()
 }
@@ -30,11 +27,8 @@ pub fn recompute_keyed_hmac_and_verify_tag<D>(key: &[u8], data: &[u8], tag: &[u8
 where
    D: Digest + BlockSizeUser,
 {
-    // SAFETY: hmac is fine with keys of any size; if they're smaller than the block size of the underlying
-    // digest, they're padded with 0. if they're larger they're hashed and padded
-    // the reason for `Result` return type is due to the trait definition
-    #[allow(clippy::unwrap_used)]
-    let mut hmac = SimpleHmac::<D>::new_from_slice(key).unwrap();
+    let mut hmac = SimpleHmac::<D>::new_from_slice(key)
+        .expect("HMAC was instantiated with a key of an invalid size!");
    hmac.update(data);

    let tag_arr = Output::<D>::from_slice(tag);
@@ -27,16 +27,12 @@ where
    // after performing diffie-hellman we don't care about the private component anymore
    let dh_result = ephemeral_keypair.private_key().diffie_hellman(remote_key);

-    // SAFETY: while this is a relatively weak assumption, it's unlikely that any stream cipher has `C::key_size()`
-    // larger than 255 * chunk_size of the digest (so for example keys larger than 8160 bytes if sh256 is used)
-    #[allow(clippy::expect_used)]
+    // there is no reason for this to fail as our okm is expected to be only C::KeySize bytes
    let okm = hkdf::extract_then_expand::<D>(None, &dh_result, None, C::key_size())
        .expect("somehow too long okm was provided");

-    // SAFETY: the generated okm has exactly `C::key_size()` elements,
-    // so this call is safe
-    #[allow(clippy::unwrap_used)]
-    let derived_shared_key = Key::<C>::from_exact_iter(okm).unwrap();
+    let derived_shared_key =
+        Key::<C>::from_exact_iter(okm).expect("okm was expanded to incorrect length!");

    (ephemeral_keypair, derived_shared_key)
 }
@@ -52,14 +48,9 @@ where
 {
    let dh_result = local_key.diffie_hellman(remote_key);

-    // SAFETY: while this is a relatively weak assumption, it's unlikely that any stream cipher has `C::key_size()`
-    // larger than 255 * chunk_size of the digest (so for example keys larger than 8160 bytes if sh256 is used)
-    #[allow(clippy::expect_used)]
+    // there is no reason for this to fail as our okm is expected to be only C::KeySize bytes
    let okm = hkdf::extract_then_expand::<D>(None, &dh_result, None, C::key_size())
        .expect("somehow too long okm was provided");

-    // SAFETY: the generated okm has exactly `C::key_size()` elements,
-    // so this call is safe
-    #[allow(clippy::unwrap_used)]
-    Key::<C>::from_exact_iter(okm).unwrap()
+    Key::<C>::from_exact_iter(okm).expect("okm was expanded to incorrect length!")
 }
@@ -60,15 +60,20 @@ where
    Iv::<C>::default()
 }

-pub fn try_iv_from_slice<C>(b: &[u8]) -> Option<&IV<C>>
+pub fn iv_from_slice<C>(b: &[u8]) -> &IV<C>
 where
    C: IvSizeUser,
 {
    if b.len() != C::iv_size() {
-        None
-    } else {
-        Some(IV::<C>::from_slice(b))
+        // `from_slice` would have caused a panic about this issue anyway.
+        // Now we at least have slightly more information
+        panic!(
+            "Tried to convert {} bytes to IV. Expected {}",
+            b.len(),
+            C::iv_size()
+        )
    }
+    IV::<C>::from_slice(b)
 }

 // TODO: there's really no way to use more parts of the keystream if it was required at some point.
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
mfahampshire	25b45a911c	push to remote for cleanbuild	2025-01-24 11:37:55 +01:00
mfahampshire	ffc72feb12	add temp warning	2025-01-17 15:24:25 +01:00
mfahampshire	0793133c95	Merge branch 'develop' of github.com:nymtech/nym into develop	2025-01-16 14:13:32 +01:00
mfahampshire	b1d10b41a4	Merge branch 'develop' of github.com:nymtech/nym into develop	2025-01-15 13:12:31 +01:00
mfahampshire	b33708bbe6	Merge branch 'develop' of github.com:nymtech/nym into develop	2025-01-14 23:52:00 +01:00
mfahampshire	eea8ee589f	removed old todos	2025-01-14 15:28:05 +01:00