Fix up webpack config so correct chunks get injected into entry points and remove inline CSS causing CSP issue

Since menu bar visible by default, change feature flag name
Remove redundant level from tauri log msg
2022-09-14 19:32:12 +01:00 · 2022-09-14 14:49:33 +02:00 · 2022-09-14 14:38:07 +02:00 · 2022-09-14 14:38:07 +02:00 · 2022-09-14 12:37:10 +01:00 · 2022-09-14 12:25:32 +01:00
1203 changed files with 41129 additions and 74370 deletions
@@ -3,21 +3,3 @@

 RUST_LOG=info
 RUST_BACKTRACE=1
-
-#########################################
-# geoipupdate (needed for explorer-api) #
-#########################################
-# MaxMind account ID (change it to a valid account ID)
-GEOIPUPDATE_ACCOUNT_ID=xxx
-# MaxMind license key (change it to a valid license key)
-GEOIPUPDATE_LICENSE_KEY=xxx
-# List of space-separated database edition IDs. Edition IDs may
-# consist of letters, digits, and dashes. For example, GeoIP2-City
-# would download the GeoIP2 City database (GeoIP2-City).
-GEOIPUPDATE_EDITION_IDS=GeoLite2-Country
-# The number of hours between geoipupdate runs. If this is not set
-# or is set to 0, geoipupdate will run once and exit.
-GEOIPUPDATE_FREQUENCY=72
-# The path to the directory where geoipupdate will download the
-# database.
-GEOIP_DB_DIRECTORY=./explorer-api/geo_ip
@@ -1,52 +1,36 @@
 name: Daily security audit

-on:
-  schedule:
-    - cron: '5 9 * * *'
+on: workflow_dispatch
 jobs:
-  cargo-deny:
-    runs-on: ubuntu-20.04
+  security_audit:
+    runs-on: ubuntu-latest
    steps:
-      - name: Checkout repository code
-        uses: actions/checkout@v2
-      - name: Install rust toolchain
-        uses: actions-rs/toolchain@v1
+      - uses: actions/checkout@v1
+      - uses: actions-rs/audit-check@v1
        with:
-          toolchain: stable
-      - name: Install cargo deny
-        run: cargo install --locked cargo-deny
-      - name: Run cargo deny
-        run: |
-          find . -name Cargo.toml -exec cargo deny --manifest-path {} check \
-            advisories -A advisory-not-detected  --hide-inclusion-graph \; &> \
-            >(uniq  &> .github/workflows/support-files/notifications/deny.message )
-      - uses: actions/upload-artifact@v3
-        with:
-          name: report
-          path: .github/workflows/support-files/notifications/deny.message
+          token: ${{ secrets.GITHUB_TOKEN }}
+
  notification:
-    needs: cargo-deny
-    runs-on: ubuntu-20.04
+    if: ${{ failure() }}
+    needs: security_audit
+    runs-on: ubuntu-latest
    steps:
      - name: Check out repository code
        uses: actions/checkout@v2
-      - name: Download report from previous job
-        uses: actions/download-artifact@v3
-        with:
-          name: report
-          path: .github/workflows/support-files/notifications
      - name: Keybase - Node Install
        run: npm install
        working-directory: .github/workflows/support-files
      - name: Keybase - Send Notification
        env:
-          NYM_NOTIFICATION_KIND: security
-          NYM_PROJECT_NAME: "Daily security report"
+          NYM_NOTIFICATION_KIND: nightly
+          NYM_PROJECT_NAME: "Nym daily audit"
          GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
+          GIT_COMMIT_MESSAGE: "${{ github.event.head_commit.message }}"
+          GIT_BRANCH: "${GITHUB_REF##*/}"
          KEYBASE_NYMBOT_USERNAME: "${{ secrets.KEYBASE_NYMBOT_USERNAME }}"
          KEYBASE_NYMBOT_PAPERKEY: "${{ secrets.KEYBASE_NYMBOT_PAPERKEY }}"
-          KEYBASE_NYMBOT_TEAM: "${{ secrets.KEYBASE_NYMBOT_TEAM }}"
-          KEYBASE_NYM_CHANNEL: "security"
+          KEYBASE_NYMBOT_TEAM: "${{ secrets.KEYBASE_NYMBTECH_TEAM }}"
+          KEYBASE_NYM_CHANNEL: "test"
        uses: docker://keybaseio/client:stable-node
        with:
          args: .github/workflows/support-files/notifications/entry_point.sh
@@ -16,7 +16,7 @@ jobs:
      RUSTC_WRAPPER: /home/ubuntu/.cargo/bin/sccache
    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
+        run: sudo apt-get update && sudo apt-get -y install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev squashfs-tools

      - name: Check out repository code
        uses: actions/checkout@v2
@@ -29,12 +29,6 @@ jobs:
          override: true
          components: rustfmt, clippy

-      - name: Check formatting
-        uses: actions-rs/cargo@v1
-        with:
-          command: fmt
-          args: --all -- --check
-
      - name: Build all binaries
        uses: actions-rs/cargo@v1
        with:
@@ -54,6 +48,12 @@ jobs:
          command: test
          args: --workspace --all-features -- --ignored

+      - name: Check formatting
+        uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: --all -- --check
+
      - uses: actions-rs/clippy-check@v1
        name: Clippy checks
        with:
@@ -66,8 +66,6 @@ jobs:
          command: clippy
          args: --workspace -- -D warnings

-      # COCONUT stuff
-
      - name: Build all binaries with coconut enabled
        uses: actions-rs/cargo@v1
        with:
@@ -84,4 +82,4 @@ jobs:
        uses: actions-rs/cargo@v1
        with:
          command: clippy
-          args: --all-targets --features=coconut -- -D warnings
+          args: --features=coconut -- -D warnings
@@ -1,6 +1,6 @@
 [
  {
-    "os":"ubuntu-20.04",
+    "os":"ubuntu-latest",
    "rust":"stable",
    "runOnEvent":"always"
  },
@@ -0,0 +1,72 @@
+name: Continuous integration on dispatch
+
+on: workflow_dispatch
+
+jobs:
+  build:
+    runs-on: [ self-hosted, custom-linux ]
+    # Enable sccache via environment variable
+    env:
+      RUSTC_WRAPPER: /home/ubuntu/.cargo/bin/sccache
+    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 squashfs-tools
+
+      - name: Check out repository code
+        uses: actions/checkout@v2
+
+      - name: Install rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: stable
+          override: true
+          components: rustfmt, clippy
+
+      - name: Build all binaries
+        uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: --workspace
+
+      - name: Run all tests
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --workspace --all-features
+
+      - name: Check formatting
+        uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: --all -- --check
+
+      - uses: actions-rs/clippy-check@v1
+        name: Clippy checks
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          args: --all-features
+
+      - name: Run clippy
+        uses: actions-rs/cargo@v1
+        with:
+          command: clippy
+          args: --workspace -- -D warnings
+
+      - name: Build all binaries with coconut enabled
+        uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: --workspace --features=coconut
+
+      - name: Run all tests with coconut enabled
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --workspace --features=coconut
+
+      - name: Run clippy with coconut enabled
+        uses: actions-rs/cargo@v1
+        with:
+          command: clippy
+          args: --features=coconut -- -D warnings
@@ -1,21 +1,16 @@
 name: Build release of Nym smart contracts
 on:
  workflow_dispatch:
-  release:
-    types: [created]
+
+defaults:
+  run:
+    working-directory: contracts

 jobs:
  build:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
-      
-      - name: Check the release tag starts with `nym-contracts-`
-        if: startsWith(github.ref, 'refs/tags/nym-contracts-') == false && github.event_name != 'workflow_dispatch'
-        uses: actions/github-script@v3
-        with:
-          script: |
-            core.setFailed('Release tag did not start with nym-contracts-...')      

      - name: Install Rust stable
        uses: actions-rs/toolchain@v1
@@ -26,7 +21,7 @@ jobs:
          components: rustfmt, clippy

      - name: Build release contracts
-        run: make wasm
+        run: RUSTFLAGS='-C link-arg=-s' cargo build --release --target wasm32-unknown-unknown

      - name: Upload Mixnet Contract Artifact
        uses: actions/upload-artifact@v3
@@ -41,11 +36,3 @@ jobs:
          name: vesting_contract.wasm
          path: contracts/target/wasm32-unknown-unknown/release/vesting_contract.wasm
          retention-days: 5
-
-      - name: Upload to release based on tag name
-        uses: softprops/action-gh-release@v1
-        if: github.event_name == 'release'
-        with:
-          files: |
-            contracts/target/wasm32-unknown-unknown/release/vesting_contract.wasm
-            contracts/target/wasm32-unknown-unknown/release/mixnet_contract.wasm
@@ -10,7 +10,7 @@ on:

 jobs:
  matrix_prep:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
    outputs:
      matrix: ${{ steps.set-matrix.outputs.matrix }}
    steps:
@@ -24,7 +24,7 @@ jobs:
  contracts:
    # since it's going to be compiled into wasm, there's absolutely
    # no point in running CI on different OS-es
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
    continue-on-error: ${{ matrix.rust == 'nightly' }}
    needs: matrix_prep
    strategy:
@@ -1,56 +0,0 @@
-name: CI for Network Explorer API
-
-on:
-  workflow_dispatch:
-  release:
-    types: [created]
-    
-env:
-  NETWORK: mainnet    
-
-jobs:
-  publish-nym:
-    strategy:
-      fail-fast: false
-      matrix:
-        platform: [ubuntu-20.04]
-
-    runs-on: ${{ matrix.platform }}
-    steps:
-      - uses: actions/checkout@v3
-
-      - 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
-
-      - name: Check the release tag starts with `nym-explorer-api-`
-        if: startsWith(github.ref, 'refs/tags/nym-explorer-api-') == false && github.event_name != 'workflow_dispatch'
-        uses: actions/github-script@v3
-        with:
-          script: |
-            core.setFailed('Release tag did not start with nym-explorer-api-...')
-
-      - name: Install Rust stable
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-
-      - name: Build all explorer-api
-        uses: actions-rs/cargo@v1
-        with:
-          command: build
-          args: --manifest-path explorer-api/Cargo.toml --workspace --release
-
-      - name: Upload Artifact
-        uses: actions/upload-artifact@v3
-        with:
-          name: my-artifact
-          path: |
-            target/release/explorer-api
-          retention-days: 30
-
-      - name: Upload to release based on tag name
-        uses: softprops/action-gh-release@v1
-        if: github.event_name == 'release'
-        with:
-          files: |
-            target/release/explorer-api
@@ -5,7 +5,7 @@ on:
    - cron: '14 1 * * *'
 jobs:
  matrix_prep:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
    outputs:
      matrix: ${{ steps.set-matrix.outputs.matrix }}
    steps:
@@ -24,8 +24,8 @@ jobs:
    continue-on-error: ${{ matrix.rust == 'nightly' || matrix.rust == 'beta' || matrix.rust == 'stable' }}
    steps:
      - name: Install Dependencies (Linux)
-        run: sudo apt-get update && sudo apt-get install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libudev-dev squashfs-tools
-        if: matrix.os == 'ubuntu-20.04'
+        run: sudo apt-get update && sudo apt-get install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev squashfs-tools
+        if: matrix.os == 'ubuntu-latest'

      - name: Check out repository code
        uses: actions/checkout@v2
@@ -96,7 +96,7 @@ jobs:

      - name: Reclaim some disk space
        uses: actions-rs/cargo@v1
-        if: ${{ matrix.os == 'windows-latest' || matrix.os == 'ubuntu-20.04' }}
+        if: ${{ matrix.os == 'windows-latest' || matrix.os == 'ubuntu-latest' }}
        with:
          command: clean

@@ -160,7 +160,7 @@ jobs:

  notification:
    needs: build
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
    steps:
      - name: Collect jobs status
        uses: technote-space/workflow-conclusion-action@v2
@@ -1,6 +1,6 @@
 [
  {
-    "os":"ubuntu-20.04",
+    "os":"ubuntu-latest",
    "rust":"stable",
    "runOnEvent":"schedule"
  },
@@ -17,7 +17,7 @@
  },

  {
-    "os":"ubuntu-20.04",
+    "os":"ubuntu-latest",
    "rust":"beta",
    "runOnEvent":"schedule"
  },
@@ -33,7 +33,7 @@
  },

  {
-    "os":"ubuntu-20.04",
+    "os":"ubuntu-latest",
    "rust":"nightly",
    "runOnEvent":"schedule"
  },
@@ -0,0 +1,50 @@
+[
+  {
+    "os":"ubuntu-latest",
+    "rust":"stable",
+    "runOnEvent":"workflow_dispatch"
+  },
+
+  {
+    "os":"windows-latest",
+    "rust":"stable",
+    "runOnEvent":"workflow_dispatch"
+  },
+  {
+    "os":"macos-latest",
+    "rust":"stable",
+    "runOnEvent":"workflow_dispatch"
+  },
+
+  {
+    "os":"ubuntu-latest",
+    "rust":"beta",
+    "runOnEvent":"workflow_dispatch"
+  },
+  {
+    "os":"windows-latest",
+    "rust":"beta",
+    "runOnEvent":"workflow_dispatch"
+  },
+  {
+    "os":"macos-latest",
+    "rust":"beta",
+    "runOnEvent":"workflow_dispatch"
+  },
+
+  {
+    "os":"ubuntu-latest",
+    "rust":"nightly",
+    "runOnEvent":"workflow_dispatch"
+  },
+  {
+    "os":"windows-latest",
+    "rust":"nightly",
+    "runOnEvent":"workflow_dispatch"
+  },
+  {
+    "os":"macos-latest",
+    "rust":"nightly",
+    "runOnEvent":"workflow_dispatch"
+  }
+]
@@ -1,49 +1,32 @@
-name: Nightly builds on latest release
+name: Nightly builds on dispatch

-on:
-  schedule:
-    - cron: '14 2 * * *'
+on: workflow_dispatch
 jobs:
  matrix_prep:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
    outputs:
      matrix: ${{ steps.set-matrix.outputs.matrix }}
    steps:
      # creates the matrix strategy from nightly_build_matrix_includes.json
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v2
      - id: set-matrix
        uses: JoshuaTheMiller/conditional-build-matrix@main
        with:
-          inputFile: '.github/workflows/nightly_build_matrix_includes.json'
+          inputFile: '.github/workflows/nightly_build_matrix_on_dispatch.json'
          filter: '[?runOnEvent==`${{ github.event_name }}` || runOnEvent==`always`]'
-  get_release:
-    runs-on: ubuntu-20.04
-    needs: matrix_prep
-    outputs:
-      output1: ${{ steps.step2.outputs.latest_release }}
-    steps:
-      - name: Check out repository code
-        uses: actions/checkout@v3
-      - name: Fetch all branches
-        run: git fetch --all
-      - name: Set output variable to latest release branch
-        id: step2
-        run: echo "latest_release=$(git branch -r | grep -E 'release/v[0-9]+\.[0-9]+\.[0-9]+' | tail -n 1 | sed 's/  origin\///')" >> $GITHUB_OUTPUT
  build:
-    needs: [get_release,matrix_prep]
+    needs: matrix_prep
    strategy:
      matrix: ${{fromJson(needs.matrix_prep.outputs.matrix)}}
    runs-on: ${{ matrix.os }}
    continue-on-error: ${{ matrix.rust == 'nightly' || matrix.rust == 'beta' || matrix.rust == 'stable' }}
    steps:
      - name: Install Dependencies (Linux)
-        run: sudo apt-get update && sudo apt-get install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libudev-dev squashfs-tools
-        if: matrix.os == 'ubuntu-20.04'
+        run: sudo apt-get update && sudo apt-get install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev squashfs-tools
+        if: matrix.os == 'ubuntu-latest'

-      - name: Check out latest release branch
-        uses: actions/checkout@v3
-        with:
-          ref: ${{needs.get_release.outputs.output1}}
+      - name: Check out repository code
+        uses: actions/checkout@v2

      - name: Install rust toolchain
        uses: actions-rs/toolchain@v1
@@ -59,12 +42,6 @@ jobs:
          command: build
          args: --workspace

-      - name: Reclaim some disk space (because Windows is being annoying)
-        uses: actions-rs/cargo@v1
-        if: ${{ matrix.os == 'windows-latest' }}
-        with:
-          command: clean
-
      - name: Run all tests
        uses: actions-rs/cargo@v1
        with:
@@ -111,7 +88,7 @@ jobs:

      - name: Reclaim some disk space
        uses: actions-rs/cargo@v1
-        if: ${{ matrix.os == 'windows-latest' || matrix.os == 'ubuntu-20.04' }}
+        if: ${{ matrix.os == 'windows-latest' || matrix.os == 'ubuntu-latest' }}
        with:
          command: clean

@@ -122,12 +99,6 @@ jobs:
          command: build
          args: --workspace --features=coconut

-      - name: Reclaim some disk space (because Windows is being annoying)
-        uses: actions-rs/cargo@v1
-        if: ${{ matrix.os == 'windows-latest' }}
-        with:
-          command: clean
-
      - name: Run all tests with coconut enabled
        uses: actions-rs/cargo@v1
        with:
@@ -174,13 +145,13 @@ jobs:
          args: --manifest-path nym-wallet/Cargo.toml --workspace --all-targets -- -D warnings

  notification:
-    needs: [build,get_release]
-    runs-on: ubuntu-20.04
+    needs: build
+    runs-on: ubuntu-latest
    steps:
      - name: Collect jobs status
        uses: technote-space/workflow-conclusion-action@v2
      - name: Check out repository code
-        uses: actions/checkout@v3
+        uses: actions/checkout@v2
      - name: Keybase - Node Install
        if: env.WORKFLOW_CONCLUSION == 'failure'
        run: npm install
@@ -189,14 +160,14 @@ jobs:
        if: env.WORKFLOW_CONCLUSION == 'failure'
        env:
          NYM_NOTIFICATION_KIND: nightly
-          NYM_PROJECT_NAME: "Nym nightly build on latest release"
+          NYM_PROJECT_NAME: "Nym nightly build"
          GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
          GIT_COMMIT_MESSAGE: "${{ github.event.head_commit.message }}"
-          GIT_BRANCH_NAME: "${{needs.get_release.outputs.output1}}"
+          GIT_BRANCH: "${GITHUB_REF##*/}"
          KEYBASE_NYMBOT_USERNAME: "${{ secrets.KEYBASE_NYMBOT_USERNAME }}"
          KEYBASE_NYMBOT_PAPERKEY: "${{ secrets.KEYBASE_NYMBOT_PAPERKEY }}"
          KEYBASE_NYMBOT_TEAM: "${{ secrets.KEYBASE_NYMBOT_TEAM }}"
-          KEYBASE_NYM_CHANNEL: "ci-nightly-release"
+          KEYBASE_NYM_CHANNEL: "ci-nightly"
          IS_SUCCESS: "${{ env.WORKFLOW_CONCLUSION == 'success' }}"
        uses: docker://keybaseio/client:stable-node
        with:
@@ -1,203 +0,0 @@
-name: Nightly builds on second latest release
-
-on:
-  schedule:
-    - cron: '24 2 * * *'
-jobs:
-  matrix_prep:
-    runs-on: ubuntu-20.04
-    outputs:
-      matrix: ${{ steps.set-matrix.outputs.matrix }}
-    steps:
-      # creates the matrix strategy from nightly_build_matrix_includes.json
-      - uses: actions/checkout@v3
-      - id: set-matrix
-        uses: JoshuaTheMiller/conditional-build-matrix@main
-        with:
-          inputFile: '.github/workflows/nightly_build_matrix_includes.json'
-          filter: '[?runOnEvent==`${{ github.event_name }}` || runOnEvent==`always`]'
-  get_release:
-    runs-on: ubuntu-20.04
-    needs: matrix_prep
-    outputs:
-      output1: ${{ steps.step2.outputs.latest_release }}
-    steps:
-      - name: Check out repository code
-        uses: actions/checkout@v3
-      - name: Fetch all branches
-        run: git fetch --all
-      - name: Set output variable to latest release branch
-        id: step2
-        run: echo "latest_release=$(git branch -r | grep -E 'release/v[0-9]+\.[0-9]+\.[0-9]+' | tail -n 2 | head -n 1 | sed 's/  origin\///')" >> $GITHUB_OUTPUT
-  build:
-    needs: [get_release,matrix_prep]
-    strategy:
-      matrix: ${{fromJson(needs.matrix_prep.outputs.matrix)}}
-    runs-on: ${{ matrix.os }}
-    continue-on-error: ${{ matrix.rust == 'nightly' || matrix.rust == 'beta' || matrix.rust == 'stable' }}
-    steps:
-      - name: Install Dependencies (Linux)
-        run: sudo apt-get update && sudo apt-get install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libudev-dev squashfs-tools
-        if: matrix.os == 'ubuntu-20.04'
-
-      - name: Check out latest release branch
-        uses: actions/checkout@v3
-        with:
-          ref: ${{needs.get_release.outputs.output1}}
-
-      - name: Install rust toolchain
-        uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: ${{ matrix.rust }}
-          override: true
-          components: rustfmt, clippy
-
-      - name: Build all binaries
-        uses: actions-rs/cargo@v1
-        with:
-          command: build
-          args: --workspace
-
-      - name: Reclaim some disk space (because Windows is being annoying)
-        uses: actions-rs/cargo@v1
-        if: ${{ matrix.os == 'windows-latest' }}
-        with:
-          command: clean
-
-      - name: Run all tests
-        uses: actions-rs/cargo@v1
-        with:
-          command: test
-          args: --workspace
-
-      - name: Reclaim some disk space (because Windows is being annoying)
-        uses: actions-rs/cargo@v1
-        if: ${{ matrix.os == 'windows-latest' }}
-        with:
-          command: clean
-
-      - name: Run expensive tests
-        if: github.ref == 'refs/heads/develop' || github.event.pull_request.base.ref == 'develop' || github.event.pull_request.base.ref == 'master'
-        uses: actions-rs/cargo@v1
-        with:
-          command: test
-          args: --workspace --all-features -- --ignored
-
-      - name: Check formatting
-        uses: actions-rs/cargo@v1
-        with:
-          command: fmt
-          args: --all -- --check
-
-      - name: Reclaim some disk space (because Windows is being annoying)
-        uses: actions-rs/cargo@v1
-        if: ${{ matrix.os == 'windows-latest' }}
-        with:
-          command: clean
-
-      - uses: actions-rs/clippy-check@v1
-        name: Clippy checks
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          args: --all-features
-
-      - name: Run clippy
-        uses: actions-rs/cargo@v1
-        if: ${{ matrix.rust != 'nightly' }}
-        with:
-          command: clippy
-          args: --workspace --all-targets -- -D warnings
-
-      - name: Reclaim some disk space
-        uses: actions-rs/cargo@v1
-        if: ${{ matrix.os == 'windows-latest' || matrix.os == 'ubuntu-20.04' }}
-        with:
-          command: clean
-
-      # COCONUT stuff
-      - name: Build all binaries with coconut enabled
-        uses: actions-rs/cargo@v1
-        with:
-          command: build
-          args: --workspace --features=coconut
-
-      - name: Reclaim some disk space (because Windows is being annoying)
-        uses: actions-rs/cargo@v1
-        if: ${{ matrix.os == 'windows-latest' }}
-        with:
-          command: clean
-
-      - name: Run all tests with coconut enabled
-        uses: actions-rs/cargo@v1
-        with:
-          command: test
-          args: --workspace --features=coconut
-
-      - name: Reclaim some disk space (because Windows is being annoying)
-        uses: actions-rs/cargo@v1
-        if: ${{ matrix.os == 'windows-latest' }}
-        with:
-          command: clean
-
-      - name: Run clippy with coconut enabled
-        uses: actions-rs/cargo@v1
-        if: ${{ matrix.rust != 'nightly' }}
-        with:
-          command: clippy
-          args: --workspace --all-targets --features=coconut -- -D warnings
-
-      # nym-wallet (the rust part)
-      - name: Build nym-wallet rust code
-        uses: actions-rs/cargo@v1
-        with:
-          command: build
-          args: --manifest-path nym-wallet/Cargo.toml --workspace
-
-      - name: Run nym-wallet tests
-        uses: actions-rs/cargo@v1
-        with:
-          command: test
-          args: --manifest-path nym-wallet/Cargo.toml --workspace
-
-      - name: Check nym-wallet formatting
-        uses: actions-rs/cargo@v1
-        with:
-          command: fmt
-          args: --manifest-path nym-wallet/Cargo.toml --all -- --check
-
-      - name: Run clippy for nym-wallet
-        uses: actions-rs/cargo@v1
-        if: ${{ matrix.rust != 'nightly' }}
-        with:
-          command: clippy
-          args: --manifest-path nym-wallet/Cargo.toml --workspace --all-targets -- -D warnings
-
-  notification:
-    needs: [build,get_release]
-    runs-on: ubuntu-20.04
-    steps:
-      - name: Collect jobs status
-        uses: technote-space/workflow-conclusion-action@v2
-      - name: Check out repository code
-        uses: actions/checkout@v3
-      - name: Keybase - Node Install
-        if: env.WORKFLOW_CONCLUSION == 'failure'
-        run: npm install
-        working-directory: .github/workflows/support-files
-      - name: Keybase - Send Notification
-        if: env.WORKFLOW_CONCLUSION == 'failure'
-        env:
-          NYM_NOTIFICATION_KIND: nightly
-          NYM_PROJECT_NAME: "Nym nightly build on latest release"
-          GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
-          GIT_COMMIT_MESSAGE: "${{ github.event.head_commit.message }}"
-          GIT_BRANCH_NAME: "${{needs.get_release.outputs.output1}}"
-          KEYBASE_NYMBOT_USERNAME: "${{ secrets.KEYBASE_NYMBOT_USERNAME }}"
-          KEYBASE_NYMBOT_PAPERKEY: "${{ secrets.KEYBASE_NYMBOT_PAPERKEY }}"
-          KEYBASE_NYMBOT_TEAM: "${{ secrets.KEYBASE_NYMBOT_TEAM }}"
-          KEYBASE_NYM_CHANNEL: "ci-nightly-release"
-          IS_SUCCESS: "${{ env.WORKFLOW_CONCLUSION == 'success' }}"
-        uses: docker://keybaseio/client:stable-node
-        with:
-          args: .github/workflows/support-files/notifications/entry_point.sh
@@ -0,0 +1,27 @@
+name: Notification on dispatch
+
+on: workflow_dispatch
+jobs:
+  notification:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out repository code
+        uses: actions/checkout@v2
+      - name: Keybase - Node Install
+        run: npm install
+        working-directory: .github/workflows/support-files
+      - name: Keybase - Send Notification
+        env:
+          NYM_NOTIFICATION_KIND: nightly
+          NYM_PROJECT_NAME: "Notification test"
+          GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
+          GIT_COMMIT_MESSAGE: "${{ github.event.head_commit.message }}"
+          GIT_BRANCH: "${GITHUB_REF##*/}"
+          KEYBASE_NYMBOT_USERNAME: "${{ secrets.KEYBASE_NYMBOT_USERNAME }}"
+          KEYBASE_NYMBOT_PAPERKEY: "${{ secrets.KEYBASE_NYMBOT_PAPERKEY }}"
+          KEYBASE_NYMBOT_TEAM: "${{ secrets.KEYBASE_NYMTECH_TEAM }}"
+          KEYBASE_NYM_CHANNEL: "test"
+          WORKFLOW_CONCLUSION: "failure"
+        uses: docker://keybaseio/client:stable-node
+        with:
+          args: .github/workflows/support-files/notifications/entry_point.sh
@@ -13,7 +13,7 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        platform: [ubuntu-20.04, windows-latest, macos-latest]
+        platform: [ubuntu-latest, windows-latest, macos-latest]

    runs-on: ${{ matrix.platform }}
    steps:
@@ -13,7 +13,7 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        platform: [ubuntu-20.04]
+        platform: [ubuntu-latest]

    runs-on: ${{ matrix.platform }}
    steps:
@@ -41,19 +41,19 @@ jobs:
    - name: Keybase - Node Install
      run: npm install
      working-directory: .github/workflows/support-files
-    - name: Keybase - Send Notification
-      env:
-        NYM_NOTIFICATION_KIND: nym-connect
-        NYM_PROJECT_NAME: "nym-connect"
-        NYM_CI_WWW_BASE: "${{ secrets.NYM_CI_WWW_BASE }}"
-        NYM_CI_WWW_LOCATION: "nym-connect-${{ env.GITHUB_REF_SLUG }}"
-        GIT_COMMIT_MESSAGE: "${{ github.event.head_commit.message }}"
-        GIT_BRANCH: "${GITHUB_REF##*/}"
-        KEYBASE_NYMBOT_USERNAME: "${{ secrets.KEYBASE_NYMBOT_USERNAME }}"
-        KEYBASE_NYMBOT_PAPERKEY: "${{ secrets.KEYBASE_NYMBOT_PAPERKEY }}"
-        KEYBASE_NYMBOT_TEAM: "${{ secrets.KEYBASE_NYMBOT_TEAM }}"
-        KEYBASE_NYM_CHANNEL: "ci-nym-connect"
-        IS_SUCCESS: "${{ job.status == 'success' }}"
-      uses: docker://keybaseio/client:stable-node
-      with:
-        args: .github/workflows/support-files/notifications/entry_point.sh
+#    - name: Keybase - Send Notification
+#      env:
+#        NYM_NOTIFICATION_KIND: nym-connect
+#        NYM_PROJECT_NAME: "nym-connect"
+#        NYM_CI_WWW_BASE: "${{ secrets.NYM_CI_WWW_BASE }}"
+#        NYM_CI_WWW_LOCATION: "nym-connect-${{ env.GITHUB_REF_SLUG }}"
+#        GIT_COMMIT_MESSAGE: "${{ github.event.head_commit.message }}"
+#        GIT_BRANCH: "${GITHUB_REF##*/}"
+#        KEYBASE_NYMBOT_USERNAME: "${{ secrets.KEYBASE_NYMBOT_USERNAME }}"
+#        KEYBASE_NYMBOT_PAPERKEY: "${{ secrets.KEYBASE_NYMBOT_PAPERKEY }}"
+#        KEYBASE_NYMBOT_TEAM: "${{ secrets.KEYBASE_NYMBOT_TEAM }}"
+#        KEYBASE_NYM_CHANNEL: "ci-nym-connect"
+#        IS_SUCCESS: "${{ job.status == 'success' }}"
+#      uses: docker://keybaseio/client:stable-node
+#      with:
+#        args: .github/workflows/support-files/notifications/entry_point.sh
@@ -2,12 +2,6 @@ name: Publish Nym binaries

 on:
  workflow_dispatch:
-    inputs:  
-      add_tokio_unstable:
-        description: 'True to add RUSTFLAGS="--cfg tokio_unstable"'
-        required: true
-        default: false
-        type: boolean 
  release:
    types: [created]
    
@@ -19,26 +13,18 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        platform: [ubuntu-20.04]
+        platform: [ubuntu-latest]

    runs-on: ${{ matrix.platform }}
    steps:
      - uses: actions/checkout@v3

-      - 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
-
      - name: Check the release tag starts with `nym-binaries-`
        if: startsWith(github.ref, 'refs/tags/nym-binaries-') == false && github.event_name != 'workflow_dispatch'
        uses: actions/github-script@v3
        with:
          script: |
            core.setFailed('Release tag did not start with nym-binaries-...')
-            
-      - name: Sets env vars for tokio if set in manual dispatch inputs
-        run: |
-          echo 'RUSTFLAGS="--cfg tokio_unstable"' >> $GITHUB_ENV
-        if: github.event_name == 'workflow_dispatch' && inputs.add_tokio_unstable == true

      - name: Install Rust stable
        uses: actions-rs/toolchain@v1
@@ -12,7 +12,7 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        platform: [ubuntu-20.04]
+        platform: [ubuntu-latest]

    runs-on: ${{ matrix.platform }}
    steps:
@@ -12,7 +12,7 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        platform: [ubuntu-20.04]
+        platform: [ubuntu-latest]
    runs-on: ${{ matrix.platform }}
    steps:
      - uses: actions/checkout@v2
@@ -12,7 +12,7 @@ defaults:
 jobs:
  test:
    name: wallet tests
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2

@@ -85,7 +85,7 @@ async function getMessageBody(context) {
            ...
          ],
          check_run_url: 'https://api.github.com/repos/nymtech/nym/check-runs/5182940024',
-          labels: [ 'ubuntu-20.04' ],
+          labels: [ 'ubuntu-latest' ],
          runner_id: 1,
          runner_name: 'Hosted Agent',
          runner_group_id: 2,
@@ -3,7 +3,7 @@ require('dotenv').config();
 const Bot = require('keybase-bot');

 let context = {
-  kinds: ['nym-wallet', 'ts-packages', 'network-explorer', 'nightly', 'nym-connect','security'],
+  kinds: ['nym-wallet', 'ts-packages', 'network-explorer', 'nightly', 'nym-connect'],
 };

 /**
@@ -1,24 +0,0 @@
-const Handlebars = require('handlebars');
-const fs = require('fs');
-const path = require('path');
-const { Octokit, App } = require('octokit');
-
-async function addToContextAndValidate(context) {
-  return
-}
-
-async function getMessageBody(context) {
-  try {
-    const source = fs
-    .readFileSync("deny.message").toString();
-    return source;
-} catch (error) {
-    console.error(error);
-}
-
-}
-
-module.exports = {
-  addToContextAndValidate,
-  getMessageBody,
-};
@@ -7,7 +7,7 @@ on:

 jobs:
  wasm:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2

@@ -37,5 +37,4 @@ validator-config
 *.patch
 validator-api-config.toml
 dist
-storybook-static
-envs/qwerty.env
+storybook-static
@@ -2,159 +2,23 @@

 Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

-## [Unreleased]
+## Unreleased

 ### Added

- socks5: send status message for service ready, and network-requester error response
-
-### Changed
-
- all-binaries: improved error logging ([#2686])
- native client: bring shutdown logic up to the same level as socks5-client
- nym-api, coconut-dkg contract: automatic, time-based dkg epoch state advancement ([#2670])
-
-[#2686]: https://github.com/nymtech/nym/pull/2686
-[#2670]: https://github.com/nymtech/nym/pull/2670
-
-## [v1.1.4] (2022-12-20)
-
-This release adds multiple Single Use Reply Blocks (SURBs) to allow arbitrarily-sized anonymized replies.
-At the moment this is turned off by default, but available for use by application developers.
-We will need to wait for network-requesters to upgrade to this new release, after which multi-SURB anonymization will become the default setting for the SOCKS proxy clients.
-
-The release also include some additional work for distributed key generation in the Coconut signing authority nodes.
-
-### Changed
-
- Feature/dkg contract threshold by @neacsu in https://github.com/nymtech/nym/pull/1885
- Multi-surbs by @jstuczyn in https://github.com/nymtech/nym/pull/2667
- Fix multi-surb backwards compatibility in pre 1.1.4 client config files by @jstuczyn in https://github.com/nymtech/nym/pull/2703
- fix: ignore corrupted surb storage and instead create fresh one by @jstuczyn in https://github.com/nymtech/nym/pull/2711
- socks5: rework waiting in inbound.rs by @octol in https://github.com/nymtech/nym/pull/1880
-
-## [v1.1.3] (2022-12-13)
-
-### Changed
-
- validator-api: can recover from shutdown during DKG process ([#1872])
- clients: deduplicate gateway inititialization, part of work towards a rust-sdk
- clients: keep all transmission lanes going at all times by making priority probabilistic
- clients: ability to use multi-reply SURBs to send arbitrarily long messages fully anonymously whilst requesting additional reply blocks whenever they're about to run out ([#1796], [#1801], [#1804], [#1835], [#1858], [#1883]))
-
-### Fixed
-
- network-requester: fix bug where websocket connection disconnect resulted in success error code
- clients: fix a few panics handling the gateway-client
- mixnode, gateway, validator-api: Use mainnet values as defaults for URLs and mixnet contract ([#1884])
- socks5: fixed bug where connections sometimes where closed too early
- clients: improve message logging when received message fails to get reconstructed ([#1803])
-
-[#1796]: https://github.com/nymtech/nym/pull/1796
-[#1801]: https://github.com/nymtech/nym/pull/1801
-[#1803]: https://github.com/nymtech/nym/pull/1803
-[#1804]: https://github.com/nymtech/nym/pull/1804
-[#1835]: https://github.com/nymtech/nym/pull/1835
-[#1858]: https://github.com/nymtech/nym/pull/1858
-[#1872]: https://github.com/nymtech/nym/pull/1872
-[#1883]: https://github.com/nymtech/nym/pull/1883
-[#1884]: https://github.com/nymtech/nym/pull/1884
-
-## [v1.1.2]
-
-### Changed
-
- gateway: Renamed flag from `enabled/disabled_credentials_mode` to `only-coconut-credentials`
- "Family" feature for node families + layers
- Initial coconut functionality including credentials and distributed key generation
-
-## [v1.1.1](https://github.com/nymtech/nym/tree/v1.1.1) (2022-11-29)
-
-### Added
-
- binaries: add `-c` shortform for `--config-env-file`
- websocket-requests: add server response signalling current packet queue length in the client
- contracts: DKG contract that handles coconut key generation ([#1678][#1708][#1747])
- validator-api: generate coconut keys interactively, using DKG and multisig contracts ([#1678][#1708][#1747])
-
-### Changed
-
- clients: add concept of transmission lanes to better handle multiple data streams ([#1720])
- clients,validator-api: take coconut signers from the chain instead of specifying them via CLI ([#1747])
- multisig contract: add DKG contract to the list of addresses that can create proposals ([#1747])
- socks5-client: wait closing inbound connection until data is sent, and throttle incoming data in general ([#1783])
- nym-cli: improve error reporting/handling and changed `vesting-schedule` queries to use query client instead of signing client
-
-### Fixed
-
- gateway-client: fix decrypting stored messages on reconnect ([#1786])
-
-### Fixed
-
- gateway-client: fix decrypting stored messages on reconnect ([#1786])
- socks5-client: fix shutting down all tasks if anyone of them panics or errors out ([#1805])
-
-[#1678]: https://github.com/nymtech/nym/pull/1678
-[#1708]: https://github.com/nymtech/nym/pull/1708
-[#1720]: https://github.com/nymtech/nym/pull/1720
-[#1747]: https://github.com/nymtech/nym/pull/1747
-[#1783]: https://github.com/nymtech/nym/pull/1783
-[#1786]: https://github.com/nymtech/nym/pull/1786
-[#1805]: https://github.com/nymtech/nym/pull/1805
-
-## [v1.1.0](https://github.com/nymtech/nym/tree/v1.1.0) (2022-11-09)
-
-### Added
-
- clients: add testing-only support for two more extended packet sizes (8kb and 16kb).
- common/ledger: new library for communicating with a Ledger device ([#1640])
- native-client/socks5-client/wasm-client: `disable_loop_cover_traffic_stream` Debug config option to disable the separate loop cover traffic stream ([#1666])
- native-client/socks5-client/wasm-client: `disable_main_poisson_packet_distribution` Debug config option to make the client ignore poisson distribution in the main packet stream and ONLY send real message (and as fast as they come) ([#1664])
- native-client/socks5-client/wasm-client: `use_extended_packet_size` Debug config option to make the client use 'ExtendedPacketSize' for its traffic (32kB as opposed to 2kB in 1.0.2) ([#1671])
- network-requester: added additional Blockstream Green wallet endpoint to `example.allowed.list` ([#1611])
- validator-api: add `interval_operating_cost` and `profit_margin_percent` to compute reward estimation endpoint
+- nym-cli: added CLI tool for interacting with the Nyx blockchain and Nym mixnet smart contracts ([#1577])
 - validator-client: added `query_contract_smart` and `query_contract_raw` on `NymdClient` ([#1558])
- wasm-client: uses updated wasm-compatible `client-core` so that it's now capable of packet retransmission, cover traffic and poisson delay (among other things!) ([#1673])
-
-### Fixed
-
- socks5-client: fix bug where in some cases packet reordering could trigger a connection being closed too early ([#1702],[#1724])
- validator-api: mixnode, gateway should now prefer values in config.toml over mainnet defaults ([#1645])
- validator-api: should now correctly update historical uptimes for all mixnodes and gateways every 24h ([#1721])

 ### Changed

- clients: bound the sphinx packet channel and reduce sending rate if gateway can't keep up ([#1703],[#1725])
- gateway-client: will attempt to read now as many as 8 websocket messages at once, assuming they're already available on the socket ([#1669])
- moved `Percent` struct to `contracts-common`, change affects explorer-api
- socks5 client: graceful shutdown should fix error on disconnect in nym-connect ([#1591])
- validator-api: changed error serialization on `inclusion_probability`, `stake-saturation` and `reward-estimation` endpoints to provide more accurate information ([#1681])
 - validator-client: made `fee` argument optional for `execute` and `execute_multiple` ([#1541])
- wasm-client: fixed build errors on MacOS and changed example JS code to use mainnet ([#1585])
- validator-api: changes to internal SQL schema due to the mixnet contract revamp ([#1472])
- validator-api: changes to internal data structures due to the mixnet contract revamp ([#1472])
- validator-api: split epoch-operations into multiple separate transactions ([#1472])
+- socks5 client: graceful shutdown should fix error on disconnect in nym-connect ([#1591])

-[#1472]: https://github.com/nymtech/nym/pull/1472
 [#1541]: https://github.com/nymtech/nym/pull/1541
 [#1558]: https://github.com/nymtech/nym/pull/1558
 [#1577]: https://github.com/nymtech/nym/pull/1577
-[#1585]: https://github.com/nymtech/nym/pull/1585
 [#1591]: https://github.com/nymtech/nym/pull/1591
-[#1640]: https://github.com/nymtech/nym/pull/1640
-[#1645]: https://github.com/nymtech/nym/pull/1645
-[#1611]: https://github.com/nymtech/nym/pull/1611
-[#1664]: https://github.com/nymtech/nym/pull/1664
-[#1666]: https://github.com/nymtech/nym/pull/1645
-[#1669]: https://github.com/nymtech/nym/pull/1669
-[#1671]: https://github.com/nymtech/nym/pull/1671
-[#1673]: https://github.com/nymtech/nym/pull/1673
-[#1681]: https://github.com/nymtech/nym/pull/1681
-[#1702]: https://github.com/nymtech/nym/pull/1702
-[#1703]: https://github.com/nymtech/nym/pull/1703
-[#1721]: https://github.com/nymtech/nym/pull/1721
-[#1724]: https://github.com/nymtech/nym/pull/1724
-[#1725]: https://github.com/nymtech/nym/pull/1725
+

 ## [nym-binaries-1.0.2](https://github.com/nymtech/nym/tree/nym-binaries-1.0.2)

@@ -209,7 +73,8 @@ The release also include some additional work for distributed key generation in
 - gateway, network-statistics: include gateway id in the sent statistical data ([#1478])
 - network explorer: tweak how active set probability is shown ([#1503])
 - validator-api: rewarder set update fails without panicking on possible nymd queries ([#1520])
- network-requester, socks5 client (nym-connect): send and receive respectively a message error to be displayed about filter check failure ([#1576])
+- network-requester, socks5 client (nym-connect): send and receive respectively a message error to be displayed about filter check failure ([#1576]) 
+

 [#1249]: https://github.com/nymtech/nym/pull/1249
 [#1256]: https://github.com/nymtech/nym/pull/1256
@@ -303,9 +168,9 @@ The release also include some additional work for distributed key generation in
 - Bump minimist from 1.2.5 to 1.2.6 in /clients/tauri-client [\#1163](https://github.com/nymtech/nym/pull/1163) ([dependabot[bot]](https://github.com/apps/dependabot))
 - Bump minimist from 1.2.5 to 1.2.6 in /clients/webassembly/js-example [\#1162](https://github.com/nymtech/nym/pull/1162) ([dependabot[bot]](https://github.com/apps/dependabot))
 - Bump minimist from 1.2.5 to 1.2.6 in /clients/native/examples/js-examples/websocket [\#1160](https://github.com/nymtech/nym/pull/1160) ([dependabot[bot]](https://github.com/apps/dependabot))
- Bump minimist from 1.2.5 to 1.2.6 in /docker/typescript_client/upload_contract [\#1159](https://github.com/nymtech/nym/pull/1159) ([dependabot[bot]](https://github.com/apps/dependabot))
+- Bump minimist from 1.2.5 to 1.2.6 in /docker/typescript\_client/upload\_contract [\#1159](https://github.com/nymtech/nym/pull/1159) ([dependabot[bot]](https://github.com/apps/dependabot))
 - Feature/vesting full [\#1158](https://github.com/nymtech/nym/pull/1158) ([fmtabbara](https://github.com/fmtabbara))
- get_current_epoch tauri [\#1156](https://github.com/nymtech/nym/pull/1156) ([durch](https://github.com/durch))
+- get\_current\_epoch tauri [\#1156](https://github.com/nymtech/nym/pull/1156) ([durch](https://github.com/durch))
 - Cleanup [\#1155](https://github.com/nymtech/nym/pull/1155) ([durch](https://github.com/durch))
 - Feature flag reward payments [\#1154](https://github.com/nymtech/nym/pull/1154) ([durch](https://github.com/durch))
 - Add Query endpoints for calculating rewards [\#1152](https://github.com/nymtech/nym/pull/1152) ([durch](https://github.com/durch))
@@ -314,7 +179,7 @@ The release also include some additional work for distributed key generation in
 - wallet: use Urls rather than Strings for validator urls [\#1148](https://github.com/nymtech/nym/pull/1148) ([octol](https://github.com/octol))
 - Change accumulated reward to Option, migrate delegations [\#1147](https://github.com/nymtech/nym/pull/1147) ([durch](https://github.com/durch))
 - wallet: fetch validators url remotely if available [\#1146](https://github.com/nymtech/nym/pull/1146) ([octol](https://github.com/octol))
- Fix delegated_free calculation [\#1145](https://github.com/nymtech/nym/pull/1145) ([durch](https://github.com/durch))
+- Fix delegated\_free calculation [\#1145](https://github.com/nymtech/nym/pull/1145) ([durch](https://github.com/durch))
 - Update Nym wallet dependencies to use `ts-packages` [\#1144](https://github.com/nymtech/nym/pull/1144) ([mmsinclair](https://github.com/mmsinclair))
 - wallet: try validators one by one if available [\#1143](https://github.com/nymtech/nym/pull/1143) ([octol](https://github.com/octol))
 - Update Network Explorer Packages and add mix node identity key copy [\#1142](https://github.com/nymtech/nym/pull/1142) ([mmsinclair](https://github.com/mmsinclair))
@@ -354,13 +219,14 @@ The release also include some additional work for distributed key generation in
 - feature/pedersen-commitments [\#1048](https://github.com/nymtech/nym/pull/1048) ([danielementary](https://github.com/danielementary))
 - Feature/reuse init owner [\#970](https://github.com/nymtech/nym/pull/970) ([neacsu](https://github.com/neacsu))

+
 ## [v0.12.1](https://github.com/nymtech/nym/tree/v0.12.1) (2021-12-23)

 [Full Changelog](https://github.com/nymtech/nym/compare/v0.12.0...v0.12.1)

 **Implemented enhancements:**

- Add version check to binaries [\#967](https://github.com/nymtech/nym/issues/967)
+- Add version check to  binaries [\#967](https://github.com/nymtech/nym/issues/967)

 **Fixed bugs:**

@@ -390,7 +256,7 @@ The release also include some additional work for distributed key generation in
 - Bugfix/remove mixnode bonding overwrite [\#917](https://github.com/nymtech/nym/pull/917) ([jstuczyn](https://github.com/jstuczyn))
 - Fixes crash condition in validator API when calculating last day uptime [\#909](https://github.com/nymtech/nym/pull/909) ([jstuczyn](https://github.com/jstuczyn))
 - Bugfix/monitor initial values wait [\#907](https://github.com/nymtech/nym/pull/907) ([jstuczyn](https://github.com/jstuczyn))
- Bug fix: Network Explorer: Add freegeoip API key and split out tasks for country distributions [\#806](https://github.com/nymtech/nym/pull/806) ([mmsinclair](https://github.com/mmsinclair))
+- Bug fix: Network Explorer: Add freegeoip API key and split out tasks for country distributions  [\#806](https://github.com/nymtech/nym/pull/806) ([mmsinclair](https://github.com/mmsinclair))
 - Explorer API: port test now split out address resolution and add units tests [\#755](https://github.com/nymtech/nym/pull/755) ([mmsinclair](https://github.com/mmsinclair))

 **Closed issues:**
@@ -405,7 +271,7 @@ The release also include some additional work for distributed key generation in
 - help!!! [\#712](https://github.com/nymtech/nym/issues/712)
 - UX feature request: show all delegated nodes in wallet [\#711](https://github.com/nymtech/nym/issues/711)
 - UX feature request: add current balance on wallet pages [\#710](https://github.com/nymtech/nym/issues/710)
- got sign issue from bot [\#709](https://github.com/nymtech/nym/issues/709)
+- got sign issue from bot  [\#709](https://github.com/nymtech/nym/issues/709)
 - As a wallet user, I would like to be able to log out of the wallet [\#706](https://github.com/nymtech/nym/issues/706)
 - As a wallet user, I would like to have a "receive" page where I can see my own wallet address [\#705](https://github.com/nymtech/nym/issues/705)
 - Update native client/socks client/mixnode/gateway `upgrade` command [\#689](https://github.com/nymtech/nym/issues/689)
@@ -415,7 +281,7 @@ The release also include some additional work for distributed key generation in
 - nym-socks5-client crash after opening Keybase team "Browse all channels" [\#494](https://github.com/nymtech/nym/issues/494)
 - Mixed Content problem [\#400](https://github.com/nymtech/nym/issues/400)
 - Gateway disk quota [\#137](https://github.com/nymtech/nym/issues/137)
- Simplify message encapsulation with regards to topology [\#127](https://github.com/nymtech/nym/issues/127)
+- Simplify message encapsulation with regards to topology  [\#127](https://github.com/nymtech/nym/issues/127)
 - Create constants for cli argument names [\#115](https://github.com/nymtech/nym/issues/115)
 - Using Blake3 as a hash function [\#103](https://github.com/nymtech/nym/issues/103)
 - Validator should decide which layer a node is in [\#86](https://github.com/nymtech/nym/issues/86)
@@ -471,10 +337,10 @@ The release also include some additional work for distributed key generation in
 - Feature/pre cosmrs updates [\#935](https://github.com/nymtech/nym/pull/935) ([jstuczyn](https://github.com/jstuczyn))
 - Feature/client on behalf [\#934](https://github.com/nymtech/nym/pull/934) ([neacsu](https://github.com/neacsu))
 - Webpack wallet prod configuration [\#933](https://github.com/nymtech/nym/pull/933) ([tommyv1987](https://github.com/tommyv1987))
- Adding tx_hash to wallet response [\#932](https://github.com/nymtech/nym/pull/932) ([futurechimp](https://github.com/futurechimp))
+- Adding tx\_hash to wallet response [\#932](https://github.com/nymtech/nym/pull/932) ([futurechimp](https://github.com/futurechimp))
 - Release/1.0.0 pre1 [\#931](https://github.com/nymtech/nym/pull/931) ([durch](https://github.com/durch))
 - Feature/identity verification [\#930](https://github.com/nymtech/nym/pull/930) ([jstuczyn](https://github.com/jstuczyn))
- Move cleaned up smart contracts to main code repo [\#929](https://github.com/nymtech/nym/pull/929) ([mfahampshire](https://github.com/mfahampshire))
+- Move cleaned up smart contracts to main code repo  [\#929](https://github.com/nymtech/nym/pull/929) ([mfahampshire](https://github.com/mfahampshire))
 - Feature/mixnet contract further adjustments [\#928](https://github.com/nymtech/nym/pull/928) ([jstuczyn](https://github.com/jstuczyn))
 - typo copy change for nodemap [\#926](https://github.com/nymtech/nym/pull/926) ([Aid19801](https://github.com/Aid19801))
 - Feature/UI enhancements for Desktop Wallet [\#925](https://github.com/nymtech/nym/pull/925) ([fmtabbara](https://github.com/fmtabbara))
@@ -487,7 +353,7 @@ The release also include some additional work for distributed key generation in
 - Feature/faucet page react [\#911](https://github.com/nymtech/nym/pull/911) ([fmtabbara](https://github.com/fmtabbara))
 - Feature/mixnet contract refactor [\#910](https://github.com/nymtech/nym/pull/910) ([futurechimp](https://github.com/futurechimp))
 - Update README.md [\#905](https://github.com/nymtech/nym/pull/905) ([tommyv1987](https://github.com/tommyv1987))
- BUG: Bond cell denom [\#904](https://github.com/nymtech/nym/pull/904) ([Aid19801](https://github.com/Aid19801))
+- BUG: Bond cell denom  [\#904](https://github.com/nymtech/nym/pull/904) ([Aid19801](https://github.com/Aid19801))
 - Explorer UI tests missing data-testid [\#903](https://github.com/nymtech/nym/pull/903) ([tommyv1987](https://github.com/tommyv1987))
 - Fix up Nym-Wallet README.md [\#899](https://github.com/nymtech/nym/pull/899) ([tommyv1987](https://github.com/tommyv1987))
 - Feature/batch delegator rewarding [\#898](https://github.com/nymtech/nym/pull/898) ([jstuczyn](https://github.com/jstuczyn))
@@ -505,7 +371,7 @@ The release also include some additional work for distributed key generation in
 - Reverted gateway registration handshake to its 0.11.0 version [\#882](https://github.com/nymtech/nym/pull/882) ([jstuczyn](https://github.com/jstuczyn))
 - Network Explorer [\#881](https://github.com/nymtech/nym/pull/881) ([mmsinclair](https://github.com/mmsinclair))
 - Feature/rewarding interval updates [\#880](https://github.com/nymtech/nym/pull/880) ([jstuczyn](https://github.com/jstuczyn))
- Put client_address and id in the correct order [\#875](https://github.com/nymtech/nym/pull/875) ([neacsu](https://github.com/neacsu))
+- Put client\_address and id in the correct order [\#875](https://github.com/nymtech/nym/pull/875) ([neacsu](https://github.com/neacsu))
 - remove gateway selection on delegation and undelegation pages [\#873](https://github.com/nymtech/nym/pull/873) ([fmtabbara](https://github.com/fmtabbara))
 - Set MSRV on all binaries to 1.56 [\#872](https://github.com/nymtech/nym/pull/872) ([jstuczyn](https://github.com/jstuczyn))
 - add native window items \(copy/paste\) via tauri [\#871](https://github.com/nymtech/nym/pull/871) ([fmtabbara](https://github.com/fmtabbara))
@@ -521,7 +387,7 @@ The release also include some additional work for distributed key generation in
 - Overflow checks in release [\#846](https://github.com/nymtech/nym/pull/846) ([jstuczyn](https://github.com/jstuczyn))
 - fix delegate success overflow [\#842](https://github.com/nymtech/nym/pull/842) ([fmtabbara](https://github.com/fmtabbara))
 - Feature NYM wallet webdriverio test [\#841](https://github.com/nymtech/nym/pull/841) ([tommyv1987](https://github.com/tommyv1987))
- Update nym_wallet.yml [\#840](https://github.com/nymtech/nym/pull/840) ([tommyv1987](https://github.com/tommyv1987))
+- Update nym\_wallet.yml [\#840](https://github.com/nymtech/nym/pull/840) ([tommyv1987](https://github.com/tommyv1987))
 - Feature/vouchers [\#837](https://github.com/nymtech/nym/pull/837) ([aniampio](https://github.com/aniampio))
 - Apply readable ids to elements on Nym Wallet [\#836](https://github.com/nymtech/nym/pull/836) ([tommyv1987](https://github.com/tommyv1987))
 - Feature/removal of monitor good nodes [\#833](https://github.com/nymtech/nym/pull/833) ([jstuczyn](https://github.com/jstuczyn))
@@ -545,8 +411,8 @@ The release also include some additional work for distributed key generation in
 - Created getters for AccountData [\#787](https://github.com/nymtech/nym/pull/787) ([jstuczyn](https://github.com/jstuczyn))
 - Feature/migrate hidden delegations [\#786](https://github.com/nymtech/nym/pull/786) ([neacsu](https://github.com/neacsu))
 - Feature/persistent gateway storage [\#784](https://github.com/nymtech/nym/pull/784) ([jstuczyn](https://github.com/jstuczyn))
- Replaced unwrap_or_else with unwrap_or_default [\#780](https://github.com/nymtech/nym/pull/780) ([jstuczyn](https://github.com/jstuczyn))
- Add block_height method to Delegation [\#778](https://github.com/nymtech/nym/pull/778) ([durch](https://github.com/durch))
+- Replaced unwrap\_or\_else with unwrap\_or\_default [\#780](https://github.com/nymtech/nym/pull/780) ([jstuczyn](https://github.com/jstuczyn))
+- Add block\_height method to Delegation [\#778](https://github.com/nymtech/nym/pull/778) ([durch](https://github.com/durch))
 - Make fee helpers public [\#777](https://github.com/nymtech/nym/pull/777) ([durch](https://github.com/durch))
 - re-enable bonding [\#776](https://github.com/nymtech/nym/pull/776) ([fmtabbara](https://github.com/fmtabbara))
 - Explorer-api: add API resource to show the delegations for each mix node [\#774](https://github.com/nymtech/nym/pull/774) ([mmsinclair](https://github.com/mmsinclair))
@@ -555,14 +421,14 @@ The release also include some additional work for distributed key generation in
 - Adding deps for building the Tauri wallet under Ubuntu [\#770](https://github.com/nymtech/nym/pull/770) ([futurechimp](https://github.com/futurechimp))
 - remove alert [\#767](https://github.com/nymtech/nym/pull/767) ([fmtabbara](https://github.com/fmtabbara))
 - Feature/consumable bandwidth [\#766](https://github.com/nymtech/nym/pull/766) ([neacsu](https://github.com/neacsu))
- Update coconut-rs and use hash_to_scalar from there [\#765](https://github.com/nymtech/nym/pull/765) ([neacsu](https://github.com/neacsu))
+- Update coconut-rs and use hash\_to\_scalar from there [\#765](https://github.com/nymtech/nym/pull/765) ([neacsu](https://github.com/neacsu))
 - Feature/active sets [\#764](https://github.com/nymtech/nym/pull/764) ([jstuczyn](https://github.com/jstuczyn))
 - add app alert banner [\#762](https://github.com/nymtech/nym/pull/762) ([fmtabbara](https://github.com/fmtabbara))
 - Updated cosmos-sdk [\#761](https://github.com/nymtech/nym/pull/761) ([jstuczyn](https://github.com/jstuczyn))
 - Feature/bond blockstamp [\#760](https://github.com/nymtech/nym/pull/760) ([neacsu](https://github.com/neacsu))
 - Feature/revert migration code [\#759](https://github.com/nymtech/nym/pull/759) ([neacsu](https://github.com/neacsu))
 - Bump next from 11.1.0 to 11.1.1 in /wallet-web [\#758](https://github.com/nymtech/nym/pull/758) ([dependabot[bot]](https://github.com/apps/dependabot))
- Add block_height in the Delegation structure as well [\#757](https://github.com/nymtech/nym/pull/757) ([neacsu](https://github.com/neacsu))
+- Add block\_height in the Delegation structure as well [\#757](https://github.com/nymtech/nym/pull/757) ([neacsu](https://github.com/neacsu))
 - Feature/add blockstamp [\#756](https://github.com/nymtech/nym/pull/756) ([neacsu](https://github.com/neacsu))
 - NetworkMonitorBuilder - starting the monitor after rocket has launched [\#754](https://github.com/nymtech/nym/pull/754) ([jstuczyn](https://github.com/jstuczyn))
 - Enabled validators api argument [\#753](https://github.com/nymtech/nym/pull/753) ([jstuczyn](https://github.com/jstuczyn))
@@ -574,7 +440,7 @@ The release also include some additional work for distributed key generation in
 - Feature/more reliable uptime calculation [\#747](https://github.com/nymtech/nym/pull/747) ([jstuczyn](https://github.com/jstuczyn))
 - Update template toml key [\#746](https://github.com/nymtech/nym/pull/746) ([neacsu](https://github.com/neacsu))
 - Feature/cred after handshake [\#745](https://github.com/nymtech/nym/pull/745) ([neacsu](https://github.com/neacsu))
- Reinstate the POST method blind_sign [\#744](https://github.com/nymtech/nym/pull/744) ([neacsu](https://github.com/neacsu))
+- Reinstate the POST method blind\_sign [\#744](https://github.com/nymtech/nym/pull/744) ([neacsu](https://github.com/neacsu))
 - explorer-api: add pending field to port check response [\#742](https://github.com/nymtech/nym/pull/742) ([mmsinclair](https://github.com/mmsinclair))
 - Feature/use delegation rates [\#741](https://github.com/nymtech/nym/pull/741) ([neacsu](https://github.com/neacsu))
 - Feature/copy to clipboard [\#740](https://github.com/nymtech/nym/pull/740) ([fmtabbara](https://github.com/fmtabbara))
@@ -611,4 +477,6 @@ The release also include some additional work for distributed key generation in
 - Hang coconut issuance off the validator-api [\#679](https://github.com/nymtech/nym/pull/679) ([durch](https://github.com/durch))
 - Update hmac and blake3 [\#673](https://github.com/nymtech/nym/pull/673) ([durch](https://github.com/durch))

-\* _This Changelog was automatically generated by [github_changelog_generator](https://github.com/github-changelog-generator/github-changelog-generator)_
+
+
+\* *This Changelog was automatically generated by [github_changelog_generator](https://github.com/github-changelog-generator/github-changelog-generator)*
@@ -26,12 +26,10 @@ members = [
    "common/client-libs/gateway-client",
    "common/client-libs/mixnet-client",
    "common/client-libs/validator-client",
-    "common/client-connections",
    "common/coconut-interface",
    "common/commands",
    "common/config",
    "common/cosmwasm-smart-contracts/coconut-bandwidth-contract",
-    "common/cosmwasm-smart-contracts/coconut-dkg",
    "common/cosmwasm-smart-contracts/contracts-common",
    "common/cosmwasm-smart-contracts/mixnet-contract",
    "common/cosmwasm-smart-contracts/multisig-contract",
@@ -42,8 +40,6 @@ members = [
    "common/crypto/dkg",
    "common/execute",
    "common/inclusion-probability",
-    "common/ledger",
-    "common/logging",
    "common/mixnode-common",
    "common/network-defaults",
    "common/nonexhaustive-delayqueue",
@@ -66,17 +62,14 @@ members = [
    "common/topology",
    "common/types",
    "common/wasm-utils",
-    "common/completions",
    "explorer-api",
    "gateway",
    "gateway/gateway-requests",
-    "integrations/bity",
    "mixnode",
    "service-providers/network-requester",
    "service-providers/network-statistics",
-    "nym-api",
-    "nym-api/nym-api-requests",
-    "nym-outfox",
+    "validator-api",
+    "validator-api/validator-api-requests",
    "tools/nym-cli",
    "tools/ts-rs-cli"
 ]
@@ -88,8 +81,8 @@ default-members = [
    "service-providers/network-requester",
    "service-providers/network-statistics",
    "mixnode",
-    "nym-api",
+    "validator-api",
    "explorer-api",
 ]

-exclude = ["explorer", "contracts", "clients/webassembly", "nym-wallet", "nym-connect"]
+exclude = ["explorer", "contracts", "tokenomics-py", "clients/webassembly", "nym-wallet", "nym-connect"]
@@ -2,12 +2,12 @@ test: clippy-all cargo-test wasm fmt
 test-all: test cargo-test-expensive
 no-clippy: build cargo-test wasm fmt
 happy: fmt clippy-happy test
-clippy-all: clippy-main clippy-coconut clippy-all-contracts clippy-all-wallet clippy-all-connect clippy-all-wasm-client
+clippy-all: clippy-all-main clippy-all-contracts clippy-all-wallet clippy-all-connect
 clippy-happy: clippy-happy-main clippy-happy-contracts clippy-happy-wallet clippy-happy-connect
-cargo-test: test-main test-contracts test-wallet test-connect test-coconut test-wasm-client
-cargo-test-expensive: test-main-expensive test-contracts-expensive test-wallet-expensive test-connect-expensive test-coconut-expensive
-build: build-contracts build-wallet build-main build-connect build-wasm-client
-fmt: fmt-main fmt-contracts fmt-wallet fmt-connect fmt-wasm-client
+cargo-test: test-main test-contracts test-wallet test-connect
+cargo-test-expensive: test-main-expensive test-contracts-expensive test-wallet-expensive test-connect-expensive
+build: build-contracts build-wallet build-main build-connect
+fmt: fmt-main fmt-contracts fmt-wallet fmt-connect

 clippy-happy-main:
 	cargo clippy
@@ -21,15 +21,8 @@ clippy-happy-wallet:
 clippy-happy-connect:
 	cargo clippy --manifest-path nym-connect/Cargo.toml

-clippy-main:
-	cargo clippy --workspace -- -D warnings
-
-clippy-coconut:
-	cargo clippy --workspace --features coconut -- -D warnings
-
-clippy-wasm:
-	cargo clippy --manifest-path clients/webassembly/Cargo.toml --target wasm32-unknown-unknown --workspace -- -D warnings
-
+clippy-all-main:
+	cargo clippy --workspace --all-features -- -D warnings

 clippy-all-contracts:
 	cargo clippy --workspace --manifest-path contracts/Cargo.toml --all-features --target wasm32-unknown-unknown -- -D warnings
@@ -40,21 +33,11 @@ clippy-all-wallet:
 clippy-all-connect:
 	cargo clippy --workspace --manifest-path nym-connect/Cargo.toml --all-features -- -D warnings

-clippy-all-wasm-client:
-	cargo clippy --workspace --manifest-path clients/webassembly/Cargo.toml --all-features --target wasm32-unknown-unknown -- -D warnings
-
 test-main:
-	cargo test --workspace
-
-test-coconut:
-	cargo test --workspace --features coconut
-
+	cargo test --all-features --workspace

 test-main-expensive:
-	cargo test --workspace -- --ignored
-
-test-coconut-expensive:
-	cargo test --workspace --features coconut -- --ignored
+	cargo test --all-features --workspace -- --ignored

 test-contracts:
 	cargo test --manifest-path contracts/Cargo.toml --all-features
@@ -68,9 +51,6 @@ test-wallet:
 test-wallet-expensive:
 	cargo test --manifest-path nym-wallet/Cargo.toml --all-features -- --ignored

-test-wasm-client:
-	cargo test --workspace --manifest-path clients/webassembly/Cargo.toml --all-features
-
 test-connect:
 	cargo test --manifest-path nym-connect/Cargo.toml --all-features

@@ -89,12 +69,6 @@ build-wallet:
 build-connect:
 	cargo build --manifest-path nym-connect/Cargo.toml --workspace

-build-explorer-api:
-	cargo build --manifest-path explorer-api/Cargo.toml --workspace
-
-build-wasm-client:
-	cargo build --manifest-path clients/webassembly/Cargo.toml --workspace --target wasm32-unknown-unknown
-
 build-nym-cli:
 	cargo build --release --manifest-path tools/nym-cli/Cargo.toml

@@ -110,15 +84,9 @@ fmt-wallet:
 fmt-connect:
 	cargo fmt --manifest-path nym-connect/Cargo.toml --all

-fmt-wasm-client:
-	cargo fmt --manifest-path clients/webassembly/Cargo.toml --all
-
 wasm:
 	RUSTFLAGS='-C link-arg=-s' cargo build --manifest-path contracts/Cargo.toml --release --target wasm32-unknown-unknown

-mixnet-opt: wasm
-	cd contracts/mixnet && make opt
-
 generate-typescript:
 	cd tools/ts-rs-cli && cargo run && cd ../..
 	yarn types:lint:fix
@@ -1,86 +1,38 @@
 [package]
 name = "client-core"
-version = "1.1.4"
+version = "1.0.1"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
 edition = "2021"
-rust-version = "1.66"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [dependencies]
-async-trait = { version = "0.1.58" }
 dirs = "4.0"
-dashmap = "5.4.0"
 futures = "0.3"
 humantime-serde = "1.0"
 log = "0.4"
 rand = { version = "0.7.3", features = ["wasm-bindgen"] }
 serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0.89"
-tap = "1.0.1"
+sled = "0.34"
 thiserror = "1.0.34"
+tokio = { version = "1.19.1", features = ["macros"] }
 url = { version ="2.2", features = ["serde"] }
-tokio = { version = "1.21.2", features = ["macros"]}
-time = "0.3.17"

 # internal
 config = { path = "../../common/config" }
-client-connections = { path = "../../common/client-connections" }
 crypto = { path = "../../common/crypto" }
 gateway-client = { path = "../../common/client-libs/gateway-client" }
-#gateway-client = { path = "../../common/client-libs/gateway-client", default-features = false, features = ["wasm", "coconut"] }
 gateway-requests = { path = "../../gateway/gateway-requests" }
 nonexhaustive-delayqueue = { path = "../../common/nonexhaustive-delayqueue" }
 nymsphinx = { path = "../../common/nymsphinx" }
 pemstore = { path = "../../common/pemstore" }
-topology = { path = "../../common/topology" }
-validator-client = { path = "../../common/client-libs/validator-client", default-features = false }
 task = { path = "../../common/task" }
-
-[target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio-stream]
-version = "0.1.9"
-features = ["time"]
-
-[target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio]
-version = "1.21.2"
-features = ["time"]
-
-[target."cfg(not(target_arch = \"wasm32\"))".dependencies.sqlx]
-version = "0.6.2"
-features = ["runtime-tokio-rustls", "sqlite", "macros", "migrate"]
-optional = true
-
-[target."cfg(target_arch = \"wasm32\")".dependencies.wasm-bindgen-futures]
-version = "0.4"
-
-[target."cfg(target_arch = \"wasm32\")".dependencies.wasm-bindgen]
-version = "0.2.83"
-
-[target."cfg(target_arch = \"wasm32\")".dependencies.wasm-timer]
-git = "https://github.com/mmsinclair/wasm-timer"
-rev = "b9d1a54ad514c2f230a026afe0dde341e98cd7b6"
-
-[target."cfg(target_arch = \"wasm32\")".dependencies.gloo-timers]
-version = "0.2.4"
-features = ["futures"]
-
-[target."cfg(target_arch = \"wasm32\")".dependencies.wasm-utils]
-path = "../../common/wasm-utils"
-
-[target."cfg(target_arch = \"wasm32\")".dependencies.time]
-version = "0.3.17"
-features = ["wasm-bindgen"]
+topology = { path = "../../common/topology" }
+validator-client = { path = "../../common/client-libs/validator-client" }
+tap = "1.0.1"

 [dev-dependencies]
 tempfile = "3.1.0"

-[build-dependencies]
-tokio = { version = "1.21.2", features = ["rt-multi-thread", "macros"] }
-sqlx = { version = "0.6.2", features = ["runtime-tokio-rustls", "sqlite", "macros", "migrate"] }
-
 [features]
-default = []
-fs-surb-storage = ["sqlx"]
-wasm = ["gateway-client/wasm"]
 coconut = ["gateway-client/coconut", "gateway-requests/coconut"]
-
@@ -1,31 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-#[tokio::main]
-async fn main() {
-    #[cfg(feature = "fs-surb-storage")]
-    {
-        use sqlx::{Connection, SqliteConnection};
-        use std::env;
-
-        let out_dir = env::var("OUT_DIR").unwrap();
-        let database_path = format!("{}/fs-surbs-example.sqlite", out_dir);
-
-        let mut conn = SqliteConnection::connect(&format!("sqlite://{}?mode=rwc", database_path))
-            .await
-            .expect("Failed to create SQLx database connection");
-
-        sqlx::migrate!("./fs_surbs_migrations")
-            .run(&mut conn)
-            .await
-            .expect("Failed to perform SQLx migrations");
-
-        #[cfg(target_family = "unix")]
-        println!("cargo:rustc-env=DATABASE_URL=sqlite://{}", &database_path);
-
-        #[cfg(target_family = "windows")]
-        // for some strange reason we need to add a leading `/` to the windows path even though it's
-        // not a valid windows path... but hey, it works...
-        println!("cargo:rustc-env=DATABASE_URL=sqlite:///{}", &database_path);
-    }
-}
@@ -1,40 +0,0 @@
-CREATE TABLE status
-(
-    flush_in_progress        INTEGER NOT NULL,
-    previous_flush_timestamp INTEGER NOT NULL,
-    client_in_use            INTEGER NOT NULL
-);
-
-CREATE TABLE reply_surb_storage_metadata
-(
-    min_reply_surb_threshold INTEGER NOT NULL,
-    max_reply_surb_threshold INTEGER NOT NULL
-);
-
-CREATE TABLE sender_tag
-(
-    recipient BLOB NOT NULL UNIQUE,
-    tag       BLOB NOT NULL UNIQUE
-);
-
-CREATE TABLE reply_key
-(
-    key_digest        BLOB    NOT NULL UNIQUE,
-    reply_key         BLOB    NOT NULL UNIQUE,
-    sent_at_timestamp INTEGER NOT NULL
-);
-
-CREATE TABLE reply_surb_sender
-(
-    id                  INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
-    last_sent_timestamp INTEGER NOT NULL,
-    tag                 BLOB    NOT NULL UNIQUE
-);
-
-CREATE TABLE reply_surb
-(
-    reply_surb_sender_id INTEGER NOT NULL,
-    reply_surb           BLOB    NOT NULL,
-
-    FOREIGN KEY (reply_surb_sender_id) REFERENCES reply_surb_sender (id)
-);
@@ -1,488 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::client::cover_traffic_stream::LoopCoverTrafficStream;
-use crate::client::inbound_messages::{InputMessage, InputMessageReceiver, InputMessageSender};
-use crate::client::key_manager::KeyManager;
-use crate::client::mix_traffic::{BatchMixMessageSender, MixTrafficController};
-use crate::client::real_messages_control;
-use crate::client::real_messages_control::RealMessagesController;
-use crate::client::received_buffer::{
-    ReceivedBufferRequestReceiver, ReceivedBufferRequestSender, ReceivedMessagesBufferController,
-};
-use crate::client::replies::reply_controller;
-use crate::client::replies::reply_controller::{ReplyControllerReceiver, ReplyControllerSender};
-use crate::client::replies::reply_storage::{
-    CombinedReplyStorage, PersistentReplyStorage, ReplyStorageBackend, SentReplyKeys,
-};
-use crate::client::topology_control::{
-    TopologyAccessor, TopologyRefresher, TopologyRefresherConfig,
-};
-use crate::config::{Config, DebugConfig, GatewayEndpointConfig};
-use crate::error::ClientCoreError;
-use crate::spawn_future;
-use client_connections::{ConnectionCommandReceiver, ConnectionCommandSender, LaneQueueLengths};
-use crypto::asymmetric::{encryption, identity};
-use futures::channel::mpsc;
-use gateway_client::bandwidth::BandwidthController;
-use gateway_client::{
-    AcknowledgementReceiver, AcknowledgementSender, GatewayClient, MixnetMessageReceiver,
-    MixnetMessageSender,
-};
-use log::{debug, info};
-use nymsphinx::acknowledgements::AckKey;
-use nymsphinx::addressing::clients::Recipient;
-use nymsphinx::addressing::nodes::NodeIdentity;
-use std::sync::Arc;
-use std::time::Duration;
-use tap::TapFallible;
-use task::{TaskClient, TaskManager};
-use url::Url;
-
-#[cfg(all(not(target_arch = "wasm32"), feature = "fs-surb-storage"))]
-pub mod non_wasm_helpers;
-
-pub struct ClientInput {
-    pub connection_command_sender: ConnectionCommandSender,
-    pub input_sender: InputMessageSender,
-}
-
-pub struct ClientOutput {
-    pub shared_lane_queue_lengths: LaneQueueLengths,
-    pub received_buffer_request_sender: ReceivedBufferRequestSender,
-}
-
-pub enum ClientInputStatus {
-    AwaitingProducer { client_input: ClientInput },
-    Connected,
-}
-
-impl ClientInputStatus {
-    pub fn register_producer(&mut self) -> ClientInput {
-        match std::mem::replace(self, ClientInputStatus::Connected) {
-            ClientInputStatus::AwaitingProducer { client_input } => client_input,
-            ClientInputStatus::Connected => panic!("producer was already registered before"),
-        }
-    }
-}
-
-pub enum ClientOutputStatus {
-    AwaitingConsumer { client_output: ClientOutput },
-    Connected,
-}
-
-impl ClientOutputStatus {
-    pub fn register_consumer(&mut self) -> ClientOutput {
-        match std::mem::replace(self, ClientOutputStatus::Connected) {
-            ClientOutputStatus::AwaitingConsumer { client_output } => client_output,
-            ClientOutputStatus::Connected => panic!("consumer was already registered before"),
-        }
-    }
-}
-
-pub struct BaseClientBuilder<'a, B> {
-    // due to wasm limitations I had to split it like this : (
-    gateway_config: &'a GatewayEndpointConfig,
-    debug_config: &'a DebugConfig,
-    disabled_credentials: bool,
-    nym_api_endpoints: Vec<Url>,
-    reply_storage_backend: B,
-
-    bandwidth_controller: Option<BandwidthController>,
-    key_manager: KeyManager,
-}
-
-impl<'a, B> BaseClientBuilder<'a, B>
-where
-    B: ReplyStorageBackend + Send + Sync + 'static,
-{
-    pub fn new_from_base_config<T>(
-        base_config: &'a Config<T>,
-        key_manager: KeyManager,
-        bandwidth_controller: Option<BandwidthController>,
-        reply_storage_backend: B,
-    ) -> BaseClientBuilder<'a, B> {
-        BaseClientBuilder {
-            gateway_config: base_config.get_gateway_endpoint_config(),
-            debug_config: base_config.get_debug_config(),
-            disabled_credentials: base_config.get_disabled_credentials_mode(),
-            nym_api_endpoints: base_config.get_nym_api_endpoints(),
-            bandwidth_controller,
-            reply_storage_backend,
-            key_manager,
-        }
-    }
-
-    pub fn new(
-        gateway_config: &'a GatewayEndpointConfig,
-        debug_config: &'a DebugConfig,
-        key_manager: KeyManager,
-        bandwidth_controller: Option<BandwidthController>,
-        reply_storage_backend: B,
-        disabled_credentials: bool,
-        nym_api_endpoints: Vec<Url>,
-    ) -> BaseClientBuilder<'a, B> {
-        BaseClientBuilder {
-            gateway_config,
-            debug_config,
-            disabled_credentials,
-            nym_api_endpoints,
-            reply_storage_backend,
-            bandwidth_controller,
-            key_manager,
-        }
-    }
-
-    pub fn as_mix_recipient(&self) -> Recipient {
-        Recipient::new(
-            *self.key_manager.identity_keypair().public_key(),
-            *self.key_manager.encryption_keypair().public_key(),
-            // TODO: below only works under assumption that gateway address == gateway id
-            // (which currently is true)
-            NodeIdentity::from_base58_string(&self.gateway_config.gateway_id).unwrap(),
-        )
-    }
-
-    // future constantly pumping loop cover traffic at some specified average rate
-    // the pumped traffic goes to the MixTrafficController
-    fn start_cover_traffic_stream(
-        debug_config: &DebugConfig,
-        ack_key: Arc<AckKey>,
-        self_address: Recipient,
-        topology_accessor: TopologyAccessor,
-        mix_tx: BatchMixMessageSender,
-        shutdown: TaskClient,
-    ) {
-        info!("Starting loop cover traffic stream...");
-
-        let mut stream = LoopCoverTrafficStream::new(
-            ack_key,
-            debug_config.average_ack_delay,
-            debug_config.average_packet_delay,
-            debug_config.loop_cover_traffic_average_delay,
-            mix_tx,
-            self_address,
-            topology_accessor,
-        );
-
-        if let Some(size) = debug_config.use_extended_packet_size {
-            log::debug!("Setting extended packet size: {:?}", size);
-            stream.set_custom_packet_size(size.into());
-        }
-
-        stream.start_with_shutdown(shutdown);
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    fn start_real_traffic_controller(
-        controller_config: real_messages_control::Config,
-        topology_accessor: TopologyAccessor,
-        ack_receiver: AcknowledgementReceiver,
-        input_receiver: InputMessageReceiver,
-        mix_sender: BatchMixMessageSender,
-        reply_storage: CombinedReplyStorage,
-        reply_controller_sender: ReplyControllerSender,
-        reply_controller_receiver: ReplyControllerReceiver,
-        lane_queue_lengths: LaneQueueLengths,
-        client_connection_rx: ConnectionCommandReceiver,
-        shutdown: TaskClient,
-    ) {
-        info!("Starting real traffic stream...");
-
-        RealMessagesController::new(
-            controller_config,
-            ack_receiver,
-            input_receiver,
-            mix_sender,
-            topology_accessor,
-            reply_storage,
-            reply_controller_sender,
-            reply_controller_receiver,
-            lane_queue_lengths,
-            client_connection_rx,
-        )
-        .start_with_shutdown(shutdown);
-    }
-
-    // buffer controlling all messages fetched from provider
-    // required so that other components would be able to use them (say the websocket)
-    fn start_received_messages_buffer_controller(
-        local_encryption_keypair: Arc<encryption::KeyPair>,
-        query_receiver: ReceivedBufferRequestReceiver,
-        mixnet_receiver: MixnetMessageReceiver,
-        reply_key_storage: SentReplyKeys,
-        reply_controller_sender: ReplyControllerSender,
-        shutdown: TaskClient,
-    ) {
-        info!("Starting received messages buffer controller...");
-        ReceivedMessagesBufferController::new(
-            local_encryption_keypair,
-            query_receiver,
-            mixnet_receiver,
-            reply_key_storage,
-            reply_controller_sender,
-        )
-        .start_with_shutdown(shutdown)
-    }
-
-    async fn start_gateway_client(
-        &mut self,
-        mixnet_message_sender: MixnetMessageSender,
-        ack_sender: AcknowledgementSender,
-        shutdown: TaskClient,
-    ) -> Result<GatewayClient, ClientCoreError<B>> {
-        let gateway_id = self.gateway_config.gateway_id.clone();
-        if gateway_id.is_empty() {
-            return Err(ClientCoreError::GatewayIdUnknown);
-        }
-        let gateway_owner = self.gateway_config.gateway_owner.clone();
-        if gateway_owner.is_empty() {
-            return Err(ClientCoreError::GatewayOwnerUnknown);
-        }
-        let gateway_address = self.gateway_config.gateway_listener.clone();
-        if gateway_address.is_empty() {
-            return Err(ClientCoreError::GatwayAddressUnknown);
-        }
-
-        let gateway_identity = identity::PublicKey::from_base58_string(gateway_id)
-            .map_err(ClientCoreError::UnableToCreatePublicKeyFromGatewayId)?;
-
-        // disgusting wasm workaround since there's no key persistence there (nor `client init`)
-        let shared_key = if self.key_manager.gateway_key_set() {
-            Some(self.key_manager.gateway_shared_key())
-        } else {
-            None
-        };
-
-        let mut gateway_client = GatewayClient::new(
-            gateway_address,
-            self.key_manager.identity_keypair(),
-            gateway_identity,
-            gateway_owner,
-            shared_key,
-            mixnet_message_sender,
-            ack_sender,
-            self.debug_config.gateway_response_timeout,
-            self.bandwidth_controller.take(),
-            shutdown,
-        );
-
-        gateway_client.set_disabled_credentials_mode(self.disabled_credentials);
-
-        gateway_client
-            .authenticate_and_start()
-            .await
-            .tap_err(|err| {
-                log::error!("Could not authenticate and start up the gateway connection - {err}")
-            })?;
-        Ok(gateway_client)
-    }
-
-    // future responsible for periodically polling directory server and updating
-    // the current global view of topology
-    async fn start_topology_refresher(
-        nym_api_urls: Vec<Url>,
-        refresh_rate: Duration,
-        topology_accessor: TopologyAccessor,
-        shutdown: TaskClient,
-    ) -> Result<(), ClientCoreError<B>> {
-        let topology_refresher_config = TopologyRefresherConfig::new(
-            nym_api_urls,
-            refresh_rate,
-            env!("CARGO_PKG_VERSION").to_string(),
-        );
-        let mut topology_refresher =
-            TopologyRefresher::new(topology_refresher_config, topology_accessor);
-        // before returning, block entire runtime to refresh the current network view so that any
-        // components depending on topology would see a non-empty view
-        info!("Obtaining initial network topology");
-        topology_refresher.refresh().await;
-
-        if let Err(err) = topology_refresher.ensure_topology_is_routable().await {
-            log::error!(
-                "The current network topology seem to be insufficient to route any packets through \
-                - check if enough nodes and a gateway are online - source: {err}"
-            );
-            return Err(ClientCoreError::InsufficientNetworkTopology(err));
-        }
-
-        info!("Starting topology refresher...");
-        topology_refresher.start_with_shutdown(shutdown);
-        Ok(())
-    }
-
-    // controller for sending sphinx packets to mixnet (either real traffic or cover traffic)
-    // TODO: if we want to send control messages to gateway_client, this CAN'T take the ownership
-    // over it. Perhaps GatewayClient needs to be thread-shareable or have some channel for
-    // requests?
-    fn start_mix_traffic_controller(
-        gateway_client: GatewayClient,
-        shutdown: TaskClient,
-    ) -> BatchMixMessageSender {
-        info!("Starting mix traffic controller...");
-        let (mix_traffic_controller, mix_tx) = MixTrafficController::new(gateway_client);
-        mix_traffic_controller.start_with_shutdown(shutdown);
-        mix_tx
-    }
-
-    async fn setup_persistent_reply_storage(
-        backend: B,
-        shutdown: TaskClient,
-    ) -> Result<CombinedReplyStorage, ClientCoreError<B>> {
-        let persistent_storage = PersistentReplyStorage::new(backend);
-        let mem_store = persistent_storage
-            .load_state_from_backend()
-            .await
-            .map_err(|err| ClientCoreError::SurbStorageError { source: err })?;
-
-        let store_clone = mem_store.clone();
-        spawn_future(async move {
-            persistent_storage
-                .flush_on_shutdown(store_clone, shutdown)
-                .await
-        });
-
-        Ok(mem_store)
-    }
-
-    pub async fn start_base(mut self) -> Result<BaseClient, ClientCoreError<B>> {
-        info!("Starting nym client");
-        // channels for inter-component communication
-        // TODO: make the channels be internally created by the relevant components
-        // rather than creating them here, so say for example the buffer controller would create the request channels
-        // and would allow anyone to clone the sender channel
-
-        // unwrapped_sphinx_sender is the transmitter of mixnet messages received from the gateway
-        // unwrapped_sphinx_receiver is the receiver for said messages - used by ReceivedMessagesBuffer
-        let (mixnet_messages_sender, mixnet_messages_receiver) = mpsc::unbounded();
-
-        // used for announcing connection or disconnection of a channel for pushing re-assembled messages to
-        let (received_buffer_request_sender, received_buffer_request_receiver) = mpsc::unbounded();
-
-        // channels responsible for controlling real messages
-        let (input_sender, input_receiver) = tokio::sync::mpsc::channel::<InputMessage>(1);
-
-        // channels responsible for controlling ack messages
-        let (ack_sender, ack_receiver) = mpsc::unbounded();
-        let shared_topology_accessor = TopologyAccessor::new();
-
-        // Shutdown notifier for signalling tasks to stop
-        let task_manager = TaskManager::default();
-
-        // channels responsible for dealing with reply-related fun
-        let (reply_controller_sender, reply_controller_receiver) =
-            reply_controller::requests::new_control_channels();
-
-        let self_address = self.as_mix_recipient();
-
-        // the components are started in very specific order. Unless you know what you are doing,
-        // do not change that.
-        let gateway_client = self
-            .start_gateway_client(mixnet_messages_sender, ack_sender, task_manager.subscribe())
-            .await?;
-
-        let reply_storage = Self::setup_persistent_reply_storage(
-            self.reply_storage_backend,
-            task_manager.subscribe(),
-        )
-        .await?;
-
-        Self::start_topology_refresher(
-            self.nym_api_endpoints.clone(),
-            self.debug_config.topology_refresh_rate,
-            shared_topology_accessor.clone(),
-            task_manager.subscribe(),
-        )
-        .await?;
-
-        Self::start_received_messages_buffer_controller(
-            self.key_manager.encryption_keypair(),
-            received_buffer_request_receiver,
-            mixnet_messages_receiver,
-            reply_storage.key_storage(),
-            reply_controller_sender.clone(),
-            task_manager.subscribe(),
-        );
-
-        // The sphinx_message_sender is the transmitter for any component generating sphinx packets
-        // that are to be sent to the mixnet. They are used by cover traffic stream and real
-        // traffic stream.
-        // The MixTrafficController then sends the actual traffic
-        let sphinx_message_sender =
-            Self::start_mix_traffic_controller(gateway_client, task_manager.subscribe());
-
-        // Channels that the websocket listener can use to signal downstream to the real traffic
-        // controller that connections are closed.
-        let (client_connection_tx, client_connection_rx) = mpsc::unbounded();
-
-        // Shared queue length data. Published by the `OutQueueController` in the client, and used
-        // primarily to throttle incoming connections (e.g socks5 for attached network-requesters)
-        let shared_lane_queue_lengths = LaneQueueLengths::new();
-
-        let mut controller_config = real_messages_control::Config::new(
-            self.debug_config,
-            self.key_manager.ack_key(),
-            self_address,
-        );
-
-        if let Some(size) = self.debug_config.use_extended_packet_size {
-            log::debug!("Setting extended packet size: {:?}", size);
-            controller_config.set_custom_packet_size(size.into());
-        }
-
-        Self::start_real_traffic_controller(
-            controller_config,
-            shared_topology_accessor.clone(),
-            ack_receiver,
-            input_receiver,
-            sphinx_message_sender.clone(),
-            reply_storage,
-            reply_controller_sender.clone(),
-            reply_controller_receiver,
-            shared_lane_queue_lengths.clone(),
-            client_connection_rx,
-            task_manager.subscribe(),
-        );
-
-        if !self.debug_config.disable_loop_cover_traffic_stream {
-            Self::start_cover_traffic_stream(
-                self.debug_config,
-                self.key_manager.ack_key(),
-                self_address,
-                shared_topology_accessor,
-                sphinx_message_sender,
-                task_manager.subscribe(),
-            );
-        }
-
-        debug!("Core client startup finished!");
-        debug!("The address of this client is: {self_address}");
-
-        Ok(BaseClient {
-            client_input: ClientInputStatus::AwaitingProducer {
-                client_input: ClientInput {
-                    connection_command_sender: client_connection_tx,
-                    input_sender,
-                },
-            },
-            client_output: ClientOutputStatus::AwaitingConsumer {
-                client_output: ClientOutput {
-                    shared_lane_queue_lengths,
-                    received_buffer_request_sender,
-                },
-            },
-            reply_controller_sender,
-            task_manager,
-        })
-    }
-}
-
-pub struct BaseClient {
-    pub client_input: ClientInputStatus,
-    pub client_output: ClientOutputStatus,
-
-    // it feels very wrong to put this channel here, but I can't think of any other way of passing it to the native client
-    pub reply_controller_sender: ReplyControllerSender,
-
-    pub task_manager: TaskManager,
-}
@@ -1,83 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::client::replies::reply_storage::{
-    fs_backend, CombinedReplyStorage, ReplyStorageBackend,
-};
-use crate::config::DebugConfig;
-use crate::error::ClientCoreError;
-use log::{error, info};
-use std::path::Path;
-use std::{fs, io};
-use time::OffsetDateTime;
-
-async fn setup_fresh_backend<P: AsRef<Path>>(
-    db_path: P,
-    debug_config: &DebugConfig,
-) -> Result<fs_backend::Backend, ClientCoreError<fs_backend::Backend>> {
-    info!("creating fresh surb database");
-    let mut storage_backend = match fs_backend::Backend::init(db_path).await {
-        Ok(backend) => backend,
-        Err(err) => {
-            error!("failed to setup persistent storage backend for our reply needs: {err}");
-            return Err(ClientCoreError::SurbStorageError { source: err });
-        }
-    };
-
-    // while I kinda hate that we're going to be creating `CombinedReplyStorage` twice,
-    // it will only be happening on the very first run and in practice won't incur huge
-    // costs since the storage is going to be empty
-    let mem_store = CombinedReplyStorage::new(
-        debug_config.minimum_reply_surb_storage_threshold,
-        debug_config.maximum_reply_surb_storage_threshold,
-    );
-    storage_backend
-        .init_fresh(&mem_store)
-        .await
-        .map_err(|err| ClientCoreError::SurbStorageError { source: err })?;
-
-    Ok(storage_backend)
-}
-
-fn archive_corrupted_database<P: AsRef<Path>>(db_path: P) -> io::Result<()> {
-    let db_path = db_path.as_ref();
-    debug_assert!(db_path.exists());
-
-    let now = OffsetDateTime::now_utc().unix_timestamp();
-
-    let suffix = format!("_{now}.corrupted");
-
-    let new_extension =
-        if let Some(existing_extension) = db_path.extension().and_then(|ext| ext.to_str()) {
-            format!("{existing_extension}.{}", suffix)
-        } else {
-            suffix
-        };
-
-    let mut renamed = db_path.to_owned();
-    renamed.set_extension(new_extension);
-
-    fs::rename(db_path, renamed)
-}
-
-pub async fn setup_fs_reply_surb_backend<P: AsRef<Path>>(
-    db_path: P,
-    debug_config: &DebugConfig,
-) -> Result<fs_backend::Backend, ClientCoreError<fs_backend::Backend>> {
-    // if the database file doesnt exist, initialise fresh storage, otherwise attempt to load the existing one
-    let db_path = db_path.as_ref();
-    if db_path.exists() {
-        info!("loading existing surb database");
-        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");
-
-                archive_corrupted_database(db_path)?;
-                setup_fresh_backend(db_path, debug_config).await
-            }
-        }
-    } else {
-        setup_fresh_backend(db_path, debug_config).await
-    }
-}
@@ -3,27 +3,20 @@

 use crate::client::mix_traffic::BatchMixMessageSender;
 use crate::client::topology_control::TopologyAccessor;
-use crate::spawn_future;
 use futures::task::{Context, Poll};
 use futures::{Future, Stream, StreamExt};
 use log::*;
 use nymsphinx::acknowledgements::AckKey;
 use nymsphinx::addressing::clients::Recipient;
 use nymsphinx::cover::generate_loop_cover_packet;
-use nymsphinx::params::PacketSize;
 use nymsphinx::utils::sample_poisson_duration;
 use rand::{rngs::OsRng, CryptoRng, Rng};
 use std::pin::Pin;
 use std::sync::Arc;
-use std::time::Duration;
-use tokio::sync::mpsc::error::TrySendError;
-
-#[cfg(not(target_arch = "wasm32"))]
+use task::ShutdownListener;
+use tokio::task::JoinHandle;
 use tokio::time;

-#[cfg(target_arch = "wasm32")]
-use wasm_timer;
-
 pub struct LoopCoverTrafficStream<R>
 where
    R: CryptoRng + Rng,
@@ -32,22 +25,18 @@ where
    ack_key: Arc<AckKey>,

    /// Average delay an acknowledgement packet is going to get delay at a single mixnode.
-    average_ack_delay: Duration,
+    average_ack_delay: time::Duration,

    /// Average delay a data packet is going to get delay at a single mixnode.
-    average_packet_delay: Duration,
+    average_packet_delay: time::Duration,

    /// Average delay between sending subsequent cover packets.
-    average_cover_message_sending_delay: Duration,
+    average_cover_message_sending_delay: time::Duration,

    /// Internal state, determined by `average_message_sending_delay`,
    /// used to keep track of when a next packet should be sent out.
-    #[cfg(not(target_arch = "wasm32"))]
    next_delay: Pin<Box<time::Sleep>>,

-    #[cfg(target_arch = "wasm32")]
-    next_delay: Pin<Box<wasm_timer::Delay>>,
-
    /// Channel used for sending prepared sphinx packets to `MixTrafficController` that sends them
    /// out to the network without any further delays.
    mix_tx: BatchMixMessageSender,
@@ -61,8 +50,8 @@ where
    /// Accessor to the common instance of network topology.
    topology_access: TopologyAccessor,

-    /// Predefined packet size used for the loop cover messages.
-    packet_size: PacketSize,
+    /// Listen to shutdown signals.
+    shutdown: ShutdownListener,
 }

 impl<R> Stream for LoopCoverTrafficStream<R>
@@ -84,21 +73,13 @@ where
        // we know it's time to send a message, so let's prepare delay for the next one
        // Get the `now` by looking at the current `delay` deadline
        let avg_delay = self.average_cover_message_sending_delay;
+        let now = self.next_delay.deadline();
        let next_poisson_delay = sample_poisson_duration(&mut self.rng, avg_delay);

        // The next interval value is `next_poisson_delay` after the one that just
        // yielded.
-        #[cfg(not(target_arch = "wasm32"))]
-        {
-            let now = self.next_delay.deadline();
-            let next = now + next_poisson_delay;
-            self.next_delay.as_mut().reset(next);
-        }
-
-        #[cfg(target_arch = "wasm32")]
-        {
-            self.next_delay.as_mut().reset(next_poisson_delay);
-        }
+        let next = now + next_poisson_delay;
+        self.next_delay.as_mut().reset(next);

        Poll::Ready(Some(()))
    }
@@ -110,49 +91,30 @@ impl LoopCoverTrafficStream<OsRng> {
    #[allow(clippy::too_many_arguments)]
    pub fn new(
        ack_key: Arc<AckKey>,
-        average_ack_delay: Duration,
-        average_packet_delay: Duration,
-        average_cover_message_sending_delay: Duration,
+        average_ack_delay: time::Duration,
+        average_packet_delay: time::Duration,
+        average_cover_message_sending_delay: time::Duration,
        mix_tx: BatchMixMessageSender,
        our_full_destination: Recipient,
        topology_access: TopologyAccessor,
+        shutdown: ShutdownListener,
    ) -> Self {
        let rng = OsRng;

-        #[cfg(not(target_arch = "wasm32"))]
-        let next_delay = Box::pin(time::sleep(Default::default()));
-
-        #[cfg(target_arch = "wasm32")]
-        let next_delay = Box::pin(wasm_timer::Delay::new(Default::default()));
-
        LoopCoverTrafficStream {
            ack_key,
            average_ack_delay,
            average_packet_delay,
            average_cover_message_sending_delay,
-            next_delay,
+            next_delay: Box::pin(time::sleep(Default::default())),
            mix_tx,
            our_full_destination,
            rng,
            topology_access,
-            packet_size: Default::default(),
+            shutdown,
        }
    }

-    pub fn set_custom_packet_size(&mut self, packet_size: PacketSize) {
-        self.packet_size = packet_size;
-    }
-
-    fn set_next_delay(&mut self, amount: Duration) {
-        #[cfg(not(target_arch = "wasm32"))]
-        let next_delay = Box::pin(time::sleep(amount));
-
-        #[cfg(target_arch = "wasm32")]
-        let next_delay = Box::pin(wasm_timer::Delay::new(amount));
-
-        self.next_delay = next_delay;
-    }
-
    async fn on_new_message(&mut self) {
        trace!("next cover message!");

@@ -161,44 +123,31 @@ impl LoopCoverTrafficStream<OsRng> {
        // poisson delay, but is it really a problem?
        let topology_permit = self.topology_access.get_read_permit().await;
        // the ack is sent back to ourselves (and then ignored)
-        let topology_ref = match topology_permit.try_get_valid_topology_ref(
+        let topology_ref_option = topology_permit.try_get_valid_topology_ref(
            &self.our_full_destination,
            Some(&self.our_full_destination),
-        ) {
-            Ok(topology) => topology,
-            Err(err) => {
-                warn!("We're not going to send any loop cover message this time, as the current topology seem to be invalid - {err}");
-                return;
-            }
-        };
+        );
+        if topology_ref_option.is_none() {
+            warn!("No valid topology detected - won't send any loop cover message this time");
+            return;
+        }
+        let topology_ref = topology_ref_option.unwrap();

        let cover_message = generate_loop_cover_packet(
            &mut self.rng,
            topology_ref,
-            &self.ack_key,
+            &*self.ack_key,
            &self.our_full_destination,
            self.average_ack_delay,
            self.average_packet_delay,
-            self.packet_size,
        )
        .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 {
-                TrySendError::Full(_) => {
-                    // This isn't a problem, if the channel is full means we're already sending the
-                    // max amount of messages downstream can handle.
-                    log::debug!("Failed to send cover message - channel full");
-                    // However it's still useful to alert the user that the gateway or the link to
-                    // the gateway can't keep up. Either due to insufficient bandwidth on the
-                    // client side, or that the gateway is overloaded.
-                    log::warn!("Failed to send sphinx packet - gateway or connection to gatway can't keep up");
-                }
-                TrySendError::Closed(_) => {
-                    log::warn!("Failed to send cover message - channel closed");
-                }
-            }
-        }
+        // if this one fails, there's no retrying because it means that either:
+        // - we run out of memory
+        // - the receiver channel is closed
+        // in either case there's no recovery and we can only panic
+        self.mix_tx.unbounded_send(vec![cover_message]).unwrap();

        // TODO: I'm not entirely sure whether this is really required, because I'm not 100%
        // sure how `yield_now()` works - whether it just notifies the scheduler or whether it
@@ -207,39 +156,40 @@ impl LoopCoverTrafficStream<OsRng> {

        // JS: due to identical logical structure to OutQueueControl::on_message(), this is also
        // presumably required to prevent bugs in the future. Exact reason is still unknown to me.
-
-        // TODO: temporary and BAD workaround for wasm (we should find a way to yield here in wasm)
-        #[cfg(not(target_arch = "wasm32"))]
        tokio::task::yield_now().await;
    }

-    pub fn start_with_shutdown(mut self, mut shutdown: task::TaskClient) {
+    async fn run(&mut self) {
        // we should set initial delay only when we actually start the stream
-        let sampled =
-            sample_poisson_duration(&mut self.rng, self.average_cover_message_sending_delay);
-        self.set_next_delay(sampled);
+        self.next_delay = Box::pin(time::sleep(sample_poisson_duration(
+            &mut self.rng,
+            self.average_cover_message_sending_delay,
+        )));

-        spawn_future(async move {
-            debug!("Started LoopCoverTrafficStream with graceful shutdown support");
-
-            while !shutdown.is_shutdown() {
-                tokio::select! {
-                    biased;
-                    _ = shutdown.recv() => {
-                        log::trace!("LoopCoverTrafficStream: Received shutdown");
-                    }
-                    next = self.next() => {
-                        if next.is_some() {
-                            self.on_new_message().await;
-                        } else {
-                            log::trace!("LoopCoverTrafficStream: Stopping since channel closed");
-                            break;
-                        }
+        let mut shutdown = self.shutdown.clone();
+        while !shutdown.is_shutdown() {
+            tokio::select! {
+                biased;
+                _ = shutdown.recv() => {
+                    log::trace!("LoopCoverTrafficStream: Received shutdown");
+                }
+                next = self.next() => {
+                    if next.is_some() {
+                        self.on_new_message().await;
+                    } else {
+                        log::trace!("LoopCoverTrafficStream: Stopping since channel closed");
+                        break;
                    }
                }
            }
-            shutdown.recv_timeout().await;
-            log::debug!("LoopCoverTrafficStream: Exiting");
+        }
+        assert!(self.shutdown.is_shutdown_poll());
+        log::debug!("LoopCoverTrafficStream: Exiting");
+    }
+
+    pub fn start(mut self) -> JoinHandle<()> {
+        tokio::spawn(async move {
+            self.run().await;
        })
    }
 }
@@ -1,14 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-#[cfg(not(target_arch = "wasm32"))]
-mod non_wasm;
-
-#[cfg(target_arch = "wasm32")]
-mod wasm;
-
-#[cfg(not(target_arch = "wasm32"))]
-pub use non_wasm::*;
-
-#[cfg(target_arch = "wasm32")]
-pub use wasm::*;
@@ -1,13 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-pub use tokio::time::*;
-pub type IntervalStream = tokio_stream::wrappers::IntervalStream;
-
-pub(crate) fn get_time_now() -> Instant {
-    Instant::now()
-}
-
-pub(crate) fn new_interval_stream(polling_rate: Duration) -> IntervalStream {
-    tokio_stream::wrappers::IntervalStream::new(tokio::time::interval(polling_rate))
-}
@@ -1,16 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use std::time::Duration;
-use wasm_timer;
-
-pub use wasm_timer::*;
-pub type IntervalStream = gloo_timers::future::IntervalStream;
-
-pub(crate) fn get_time_now() -> Instant {
-    wasm_timer::Instant::now()
-}
-
-pub(crate) fn new_interval_stream(polling_rate: Duration) -> IntervalStream {
-    gloo_timers::future::IntervalStream::new(polling_rate.as_millis() as u32)
-}
@@ -1,80 +1,33 @@
-use client_connections::TransmissionLane;
+use futures::channel::mpsc;
 use nymsphinx::addressing::clients::Recipient;
-use nymsphinx::anonymous_replies::requests::AnonymousSenderTag;
+use nymsphinx::anonymous_replies::ReplySurb;

-pub type InputMessageSender = tokio::sync::mpsc::Sender<InputMessage>;
-pub type InputMessageReceiver = tokio::sync::mpsc::Receiver<InputMessage>;
+pub type InputMessageSender = mpsc::UnboundedSender<InputMessage>;
+pub type InputMessageReceiver = mpsc::UnboundedReceiver<InputMessage>;

 #[derive(Debug)]
 pub enum InputMessage {
-    /// The simplest message variant where no additional information is attached.
-    /// You're simply sending your `data` to specified `recipient` without any tagging.
-    ///
-    /// Ends up with `NymMessage::Plain` variant
-    Regular {
+    Fresh {
        recipient: Recipient,
        data: Vec<u8>,
-        lane: TransmissionLane,
+        with_reply_surb: bool,
    },
-
-    /// Creates a message used for a duplex anonymous communication where the recipient
-    /// will never learn of our true identity. This is achieved by carefully sending `reply_surbs`.
-    ///
-    /// Note that if reply_surbs is set to zero then
-    /// this variant requires the client having sent some reply_surbs in the past
-    /// (and thus the recipient also knowing our sender tag).
-    ///
-    /// Ends up with `NymMessage::Repliable` variant
-    Anonymous {
-        recipient: Recipient,
-        data: Vec<u8>,
-        reply_surbs: u32,
-        lane: TransmissionLane,
-    },
-
-    /// Attempt to use our internally received and stored `ReplySurb` to send the message back
-    /// to specified recipient whilst not knowing its full identity (or even gateway).
-    ///
-    /// Ends up with `NymMessage::Reply` variant
    Reply {
-        recipient_tag: AnonymousSenderTag,
+        reply_surb: ReplySurb,
        data: Vec<u8>,
-        lane: TransmissionLane,
    },
 }

 impl InputMessage {
-    pub fn new_regular(recipient: Recipient, data: Vec<u8>, lane: TransmissionLane) -> Self {
-        InputMessage::Regular {
+    pub fn new_fresh(recipient: Recipient, data: Vec<u8>, with_reply_surb: bool) -> Self {
+        InputMessage::Fresh {
            recipient,
            data,
-            lane,
+            with_reply_surb,
        }
    }

-    pub fn new_anonymous(
-        recipient: Recipient,
-        data: Vec<u8>,
-        reply_surbs: u32,
-        lane: TransmissionLane,
-    ) -> Self {
-        InputMessage::Anonymous {
-            recipient,
-            data,
-            reply_surbs,
-            lane,
-        }
-    }
-
-    pub fn new_reply(
-        recipient_tag: AnonymousSenderTag,
-        data: Vec<u8>,
-        lane: TransmissionLane,
-    ) -> Self {
-        InputMessage::Reply {
-            recipient_tag,
-            data,
-            lane,
-        }
+    pub fn new_reply(reply_surb: ReplySurb, data: Vec<u8>) -> Self {
+        InputMessage::Reply { reply_surb, data }
    }
 }
@@ -149,10 +149,6 @@ impl KeyManager {
        )
    }

-    pub fn gateway_key_set(&self) -> bool {
-        self.gateway_shared_key.is_some()
-    }
-
    /// Gets an atomically reference counted pointer to [`AckKey`].
    pub fn ack_key(&self) -> Arc<AckKey> {
        Arc::clone(&self.ack_key)
@@ -1,16 +1,17 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::spawn_future;
+use futures::channel::mpsc;
+use futures::StreamExt;
 use gateway_client::GatewayClient;
 use log::*;
 use nymsphinx::forwarding::packet::MixPacket;
+use task::ShutdownListener;
+use tokio::task::JoinHandle;

-pub type BatchMixMessageSender = tokio::sync::mpsc::Sender<Vec<MixPacket>>;
-pub type BatchMixMessageReceiver = tokio::sync::mpsc::Receiver<Vec<MixPacket>>;
+pub type BatchMixMessageSender = mpsc::UnboundedSender<Vec<MixPacket>>;
+pub type BatchMixMessageReceiver = mpsc::UnboundedReceiver<Vec<MixPacket>>;

-// We remind ourselves that 32 x 32kb = 1024kb, a reasonable size for a network buffer.
-pub const MIX_MESSAGE_RECEIVER_BUFFER_SIZE: usize = 32;
 const MAX_FAILURE_COUNT: usize = 100;

 pub struct MixTrafficController {
@@ -18,6 +19,7 @@ pub struct MixTrafficController {
    // later on gateway_client will need to be accessible by other entities
    gateway_client: GatewayClient,
    mix_rx: BatchMixMessageReceiver,
+    shutdown: ShutdownListener,

    // TODO: this is temporary work-around.
    // in long run `gateway_client` will be moved away from `MixTrafficController` anyway.
@@ -25,17 +27,17 @@ pub struct MixTrafficController {
 }

 impl MixTrafficController {
-    pub fn new(gateway_client: GatewayClient) -> (MixTrafficController, BatchMixMessageSender) {
-        let (sphinx_message_sender, sphinx_message_receiver) =
-            tokio::sync::mpsc::channel(MIX_MESSAGE_RECEIVER_BUFFER_SIZE);
-        (
-            MixTrafficController {
-                gateway_client,
-                mix_rx: sphinx_message_receiver,
-                consecutive_gateway_failure_count: 0,
-            },
-            sphinx_message_sender,
-        )
+    pub fn new(
+        mix_rx: BatchMixMessageReceiver,
+        gateway_client: GatewayClient,
+        shutdown: ShutdownListener,
+    ) -> MixTrafficController {
+        MixTrafficController {
+            gateway_client,
+            mix_rx,
+            shutdown,
+            consecutive_gateway_failure_count: 0,
+        }
    }

    async fn on_messages(&mut self, mut mix_packets: Vec<MixPacket>) {
@@ -51,8 +53,8 @@ impl MixTrafficController {
        };

        match result {
-            Err(err) => {
-                error!("Failed to send sphinx packet(s) to the gateway! - {err}");
+            Err(e) => {
+                error!("Failed to send sphinx packet(s) to the gateway! - {:?}", e);
                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
@@ -67,29 +69,30 @@ impl MixTrafficController {
        }
    }

-    pub fn start_with_shutdown(mut self, mut shutdown: task::TaskClient) {
-        spawn_future(async move {
-            debug!("Started MixTrafficController with graceful shutdown support");
-
-            loop {
-                tokio::select! {
-                    mix_packets = self.mix_rx.recv() => match mix_packets {
-                        Some(mix_packets) => {
-                            self.on_messages(mix_packets).await;
-                        },
-                        None => {
-                            log::trace!("MixTrafficController: Stopping since channel closed");
-                            break;
-                        }
+    pub async fn run(&mut self) {
+        while !self.shutdown.is_shutdown() {
+            tokio::select! {
+                mix_packets = self.mix_rx.next() => match mix_packets {
+                    Some(mix_packets) => {
+                        self.on_messages(mix_packets).await;
                    },
-                    _ = shutdown.recv_with_delay() => {
-                        log::trace!("MixTrafficController: Received shutdown");
+                    None => {
+                        log::trace!("MixTrafficController: Stopping since channel closed");
                        break;
                    }
+                },
+                _ = self.shutdown.recv() => {
+                    log::trace!("MixTrafficController: Received shutdown");
                }
            }
-            shutdown.recv_timeout().await;
-            log::debug!("MixTrafficController: Exiting");
+        }
+        assert!(self.shutdown.is_shutdown_poll());
+        log::debug!("MixTrafficController: Exiting");
+    }
+
+    pub fn start(mut self) -> JoinHandle<()> {
+        tokio::spawn(async move {
+            self.run().await;
        })
    }
 }
@@ -1,14 +1,17 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
+use std::sync::atomic::AtomicBool;

-pub mod base_client;
 pub mod cover_traffic_stream;
-pub(crate) mod helpers;
 pub mod inbound_messages;
 pub mod key_manager;
 pub mod mix_traffic;
 pub mod real_messages_control;
 pub mod received_buffer;
-pub mod replies;
+pub mod reply_key_storage;
 pub mod topology_control;
-pub(crate) mod transmission_buffer;
+
+// This is *NOT* used to signal shutdown.
+// It's critical that we don't have any tasks finishing early, this is an additional safety check
+// that tasks exiting are doing so because shutdown has been signalled, and no other reason.
+// In particular for tasks that rely on their associated channel being closed to signal shutdown,
+// and don't have access to a shutdown listener channel.
+pub static SHUTDOWN_HAS_BEEN_SIGNALLED: AtomicBool = AtomicBool::new(false);
@@ -1,7 +1,7 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use super::action_controller::{AckActionSender, Action};
+use super::action_controller::{Action, ActionSender};
 use futures::StreamExt;
 use gateway_client::AcknowledgementReceiver;
 use log::*;
@@ -10,30 +10,34 @@ use nymsphinx::{
    chunking::fragment::{FragmentIdentifier, COVER_FRAG_ID},
 };
 use std::sync::Arc;
+use task::ShutdownListener;

 /// Module responsible for listening for any data resembling acknowledgements from the network
 /// and firing actions to remove them from the 'Pending' state.
 pub(super) struct AcknowledgementListener {
    ack_key: Arc<AckKey>,
    ack_receiver: AcknowledgementReceiver,
-    action_sender: AckActionSender,
+    action_sender: ActionSender,
+    shutdown: ShutdownListener,
 }

 impl AcknowledgementListener {
    pub(super) fn new(
        ack_key: Arc<AckKey>,
        ack_receiver: AcknowledgementReceiver,
-        action_sender: AckActionSender,
+        action_sender: ActionSender,
+        shutdown: ShutdownListener,
    ) -> Self {
        AcknowledgementListener {
            ack_key,
            ack_receiver,
            action_sender,
+            shutdown,
        }
    }

    async fn on_ack(&mut self, ack_content: Vec<u8>) {
-        trace!("Received an ack");
+        debug!("Received an ack");
        let frag_id = match recover_identifier(&self.ack_key, &ack_content)
            .map(FragmentIdentifier::try_from_bytes)
        {
@@ -49,6 +53,11 @@ impl AcknowledgementListener {
        if frag_id == COVER_FRAG_ID {
            trace!("Received an ack for a cover message - no need to do anything");
            return;
+        } else if frag_id.is_reply() {
+            info!("Received an ack for a reply message - no need to do anything! (don't know what to do!)");
+            // TODO: probably there will need to be some extra procedure here, something to notify
+            // user that his reply reached the recipient (since we got an ack)
+            return;
        }

        trace!("Received {} from the mix network", frag_id);
@@ -58,31 +67,28 @@ impl AcknowledgementListener {
            .unwrap();
    }

-    async fn handle_ack_receiver_item(&mut self, item: Vec<Vec<u8>>) {
-        // realistically we would only be getting one ack at the time
-        for ack in item {
-            self.on_ack(ack).await;
-        }
-    }
-
-    pub(super) async fn run_with_shutdown(&mut self, mut shutdown: task::TaskClient) {
-        debug!("Started AcknowledgementListener with graceful shutdown support");
-
-        while !shutdown.is_shutdown() {
+    pub(super) async fn run(&mut self) {
+        debug!("Started AcknowledgementListener");
+        while !self.shutdown.is_shutdown() {
            tokio::select! {
                acks = self.ack_receiver.next() => match acks {
-                    Some(acks) => self.handle_ack_receiver_item(acks).await,
+                    Some(acks) => {
+                        // realistically we would only be getting one ack at the time
+                        for ack in acks {
+                            self.on_ack(ack).await;
+                        }
+                    },
                    None => {
                        log::trace!("AcknowledgementListener: Stopping since channel closed");
                        break;
                    }
                },
-                _ = shutdown.recv_with_delay() => {
+                _ = self.shutdown.recv() => {
                    log::trace!("AcknowledgementListener: Received shutdown");
                }
            }
        }
-        shutdown.recv_timeout().await;
+        assert!(self.shutdown.is_shutdown_poll());
        log::debug!("AcknowledgementListener: Exiting");
    }
 }
@@ -3,7 +3,7 @@

 use super::PendingAcknowledgement;
 use crate::client::real_messages_control::acknowledgement_control::RetransmissionRequestSender;
-use futures::channel::mpsc;
+use futures::channel::mpsc::{self, UnboundedReceiver, UnboundedSender};
 use futures::StreamExt;
 use log::*;
 use nonexhaustive_delayqueue::{Expired, NonExhaustiveDelayQueue, QueueKey};
@@ -12,9 +12,9 @@ use nymsphinx::Delay as SphinxDelay;
 use std::collections::HashMap;
 use std::sync::Arc;
 use std::time::Duration;
+use task::ShutdownListener;

-pub(crate) type AckActionSender = mpsc::UnboundedSender<Action>;
-pub(crate) type AckActionReceiver = mpsc::UnboundedReceiver<Action>;
+pub(crate) type ActionSender = UnboundedSender<Action>;

 // The actual data being sent off as well as potential key to the delay queue
 type PendingAckEntry = (Arc<PendingAcknowledgement>, Option<QueueKey>);
@@ -96,25 +96,33 @@ pub(super) struct ActionController {
    pending_acks_timers: NonExhaustiveDelayQueue<FragmentIdentifier>,

    /// Channel for receiving `Action`s from other modules.
-    incoming_actions: AckActionReceiver,
+    incoming_actions: UnboundedReceiver<Action>,

    /// Channel for notifying `RetransmissionRequestListener` about expired acknowledgements.
    retransmission_sender: RetransmissionRequestSender,
+
+    /// Listen for shutdown notifications
+    shutdown: ShutdownListener,
 }

 impl ActionController {
    pub(super) fn new(
        config: Config,
        retransmission_sender: RetransmissionRequestSender,
-        incoming_actions: AckActionReceiver,
-    ) -> Self {
-        ActionController {
-            config,
-            pending_acks_data: HashMap::new(),
-            pending_acks_timers: NonExhaustiveDelayQueue::new(),
-            incoming_actions,
-            retransmission_sender,
-        }
+        shutdown: ShutdownListener,
+    ) -> (Self, ActionSender) {
+        let (sender, receiver) = mpsc::unbounded();
+        (
+            ActionController {
+                config,
+                pending_acks_data: HashMap::new(),
+                pending_acks_timers: NonExhaustiveDelayQueue::new(),
+                incoming_actions: receiver,
+                retransmission_sender,
+                shutdown,
+            },
+            sender,
+        )
    }

    fn handle_insert(&mut self, pending_acks: Vec<PendingAcknowledgement>) {
@@ -136,18 +144,13 @@ impl ActionController {
        trace!("{} is starting its timer", frag_id);

        if let Some((pending_ack_data, queue_key)) = self.pending_acks_data.get_mut(&frag_id) {
-            // the fact that this branch is now POSSIBLE is a sign of a need to refactor this whole
-            // retransmission procedure
-            //
-            // (it can happen as timer is started when ack expires to make sure it's not stuck in memory
-            // and the second instance can be fired when we finally get reply surbs for data we failed to retransmit)
-
-            // if queue_key.is_some() {
-            //     // this branch should be IMPOSSIBLE under ANY condition. It would imply starting
-            //     // timer TWICE for the SAME PendingAcknowledgement
-            //     panic!("Tried to start an already started ack timer!")
-            // }
-            let timeout = (pending_ack_data.delay * self.config.ack_wait_multiplier).to_duration()
+            if queue_key.is_some() {
+                // this branch should be IMPOSSIBLE under ANY condition. It would imply starting
+                // timer TWICE for the SAME PendingAcknowledgement
+                panic!("Tried to start an already started ack timer!")
+            }
+            let timeout = (pending_ack_data.delay.clone() * self.config.ack_wait_multiplier)
+                .to_duration()
                + self.config.ack_wait_addition;

            let new_queue_key = self.pending_acks_timers.insert(frag_id, timeout);
@@ -195,8 +198,7 @@ impl ActionController {
        trace!("{} is updating its delay", frag_id);
        // TODO: is it possible to solve this without either locking or temporarily removing the value?
        if let Some((pending_ack_data, queue_key)) = self.pending_acks_data.remove(&frag_id) {
-            // this Action is triggered by `RetransmissionRequestListener` (for 'normal' packets)
-            // or `ReplyController` (for 'reply' packets) which held the other potential
+            // this Action is triggered by `RetransmissionRequestListener` which held the other potential
            // reference to this Arc. HOWEVER, before the Action was pushed onto the queue, the reference
            // was dropped hence this unwrap is safe.
            let mut inner_data = Arc::try_unwrap(pending_ack_data).unwrap();
@@ -249,10 +251,8 @@ impl ActionController {
        }
    }

-    pub(super) async fn run_with_shutdown(&mut self, mut shutdown: task::TaskClient) {
-        debug!("Started ActionController with graceful shutdown support");
-
-        while !shutdown.is_shutdown() {
+    pub(super) async fn run(&mut self) {
+        while !self.shutdown.is_shutdown() {
            tokio::select! {
                action = self.incoming_actions.next() => match action {
                    Some(action) => self.process_action(action),
@@ -270,15 +270,12 @@ impl ActionController {
                        break;
                    }
                },
-                _ = shutdown.recv_with_delay() => {
+                _ = self.shutdown.recv() => {
                    log::trace!("ActionController: Received shutdown");
                }
            }
        }
-        #[cfg(not(target_arch = "wasm32"))]
-        tokio::time::timeout(Duration::from_secs(5), shutdown.recv())
-            .await
-            .expect("Task stopped without shutdown called");
+        assert!(self.shutdown.is_shutdown_poll());
        log::debug!("ActionController: Exiting");
    }
 }
@@ -1,14 +1,22 @@
-// Copyright 2021-2022 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::client::inbound_messages::{InputMessage, InputMessageReceiver};
-use crate::client::real_messages_control::message_handler::MessageHandler;
-use crate::client::replies::reply_controller::ReplyControllerSender;
-use client_connections::TransmissionLane;
+use super::action_controller::{Action, ActionSender};
+use super::PendingAcknowledgement;
+use crate::client::reply_key_storage::ReplyKeyStorage;
+use crate::client::{
+    inbound_messages::{InputMessage, InputMessageReceiver},
+    real_messages_control::real_traffic_stream::{BatchRealMessageSender, RealMessage},
+    topology_control::TopologyAccessor,
+};
+use futures::StreamExt;
 use log::*;
-use nymsphinx::addressing::clients::Recipient;
-use nymsphinx::anonymous_replies::requests::AnonymousSenderTag;
+use nymsphinx::anonymous_replies::ReplySurb;
+use nymsphinx::preparer::MessagePreparer;
+use nymsphinx::{acknowledgements::AckKey, addressing::clients::Recipient};
 use rand::{CryptoRng, Rng};
+use std::sync::Arc;
+use task::ShutdownListener;

 /// Module responsible for dealing with the received messages: splitting them, creating acknowledgements,
 /// putting everything into sphinx packets, etc.
@@ -17,9 +25,15 @@ pub(super) struct InputMessageListener<R>
 where
    R: CryptoRng + Rng,
 {
+    ack_key: Arc<AckKey>,
+    ack_recipient: Recipient,
    input_receiver: InputMessageReceiver,
-    message_handler: MessageHandler<R>,
-    reply_controller_sender: ReplyControllerSender,
+    message_preparer: MessagePreparer<R>,
+    action_sender: ActionSender,
+    real_message_sender: BatchRealMessageSender,
+    topology_access: TopologyAccessor,
+    reply_key_storage: ReplyKeyStorage,
+    shutdown: ShutdownListener,
 }

 impl<R> InputMessageListener<R>
@@ -30,91 +44,151 @@ where
    // some considerable refactoring
    #[allow(clippy::too_many_arguments)]
    pub(super) fn new(
+        ack_key: Arc<AckKey>,
+        ack_recipient: Recipient,
        input_receiver: InputMessageReceiver,
-        message_handler: MessageHandler<R>,
-        reply_controller_sender: ReplyControllerSender,
+        message_preparer: MessagePreparer<R>,
+        action_sender: ActionSender,
+        real_message_sender: BatchRealMessageSender,
+        topology_access: TopologyAccessor,
+        reply_key_storage: ReplyKeyStorage,
+        shutdown: ShutdownListener,
    ) -> Self {
        InputMessageListener {
+            ack_key,
+            ack_recipient,
            input_receiver,
-            message_handler,
-            reply_controller_sender,
+            message_preparer,
+            action_sender,
+            real_message_sender,
+            topology_access,
+            reply_key_storage,
+            shutdown,
        }
    }

-    async fn handle_reply(
-        &mut self,
-        recipient_tag: AnonymousSenderTag,
-        data: Vec<u8>,
-        lane: TransmissionLane,
-    ) {
-        // offload reply handling to the dedicated task
-        self.reply_controller_sender
-            .send_reply(recipient_tag, data, lane)
+    // we require topology for replies to generate surb_acks
+    async fn handle_reply(&mut self, reply_surb: ReplySurb, data: Vec<u8>) -> Option<RealMessage> {
+        let topology_permit = self.topology_access.get_read_permit().await;
+        let topology = match topology_permit.try_get_valid_topology_ref(&self.ack_recipient, None) {
+            Some(topology_ref) => topology_ref,
+            None => {
+                warn!("Could not process the message - the network topology is invalid");
+                return None;
+            }
+        };
+
+        match self
+            .message_preparer
+            .prepare_reply_for_use(data, reply_surb, topology, &self.ack_key)
+            .await
+        {
+            Ok((mix_packet, reply_id)) => {
+                // TODO: later probably write pending ack here
+                // and deal with them....
+                // ... somehow
+                Some(RealMessage::new(mix_packet, reply_id))
+            }
+            Err(err) => {
+                // TODO: should we have some mechanism to indicate to the user that the `reply_surb`
+                // could be reused since technically it wasn't used up here?
+                warn!("failed to deal with received reply surb - {:?}", err);
+                None
+            }
+        }
    }

-    async fn handle_plain_message(
+    async fn handle_fresh_message(
        &mut self,
        recipient: Recipient,
        content: Vec<u8>,
-        lane: TransmissionLane,
-    ) {
-        if let Err(err) = self
-            .message_handler
-            .try_send_plain_message(recipient, content, lane)
-            .await
+        with_reply_surb: bool,
+    ) -> Option<Vec<RealMessage>> {
+        let topology_permit = self.topology_access.get_read_permit().await;
+        let topology = match topology_permit
+            .try_get_valid_topology_ref(&self.ack_recipient, Some(&recipient))
        {
-            warn!("failed to send a plain message - {err}")
-        }
-    }
+            Some(topology_ref) => topology_ref,
+            None => {
+                warn!("Could not process the message - the network topology is invalid");
+                return None;
+            }
+        };

-    async fn handle_repliable_message(
-        &mut self,
-        recipient: Recipient,
-        content: Vec<u8>,
-        reply_surbs: u32,
-        lane: TransmissionLane,
-    ) {
-        if let Err(err) = self
-            .message_handler
-            .try_send_message_with_reply_surbs(recipient, content, reply_surbs, lane)
-            .await
-        {
-            warn!("failed to send a repliable message - {err}")
+        // split the message, attach optional reply surb
+        let (split_message, reply_key) = self
+            .message_preparer
+            .prepare_and_split_message(content, with_reply_surb, topology)
+            .expect("somehow the topology was invalid after all!");
+
+        if let Some(reply_key) = reply_key {
+            self.reply_key_storage
+                .insert_encryption_key(reply_key)
+                .expect("Failed to insert surb reply key to the store!")
        }
+
+        // encrypt chunks, put them inside sphinx packets and generate acks
+        let mut pending_acks = Vec::with_capacity(split_message.len());
+        let mut real_messages = Vec::with_capacity(split_message.len());
+        for message_chunk in split_message {
+            // we need to clone it because we need to keep it in memory in case we had to retransmit
+            // it. And then we'd need to recreate entire ACK again.
+            let chunk_clone = message_chunk.clone();
+            let prepared_fragment = self
+                .message_preparer
+                .prepare_chunk_for_sending(chunk_clone, topology, &self.ack_key, &recipient)
+                .unwrap();
+
+            real_messages.push(RealMessage::new(
+                prepared_fragment.mix_packet,
+                message_chunk.fragment_identifier(),
+            ));
+
+            pending_acks.push(PendingAcknowledgement::new(
+                message_chunk,
+                prepared_fragment.total_delay,
+                recipient,
+            ));
+        }
+
+        // tells the controller to put this into the hashmap
+        self.action_sender
+            .unbounded_send(Action::new_insert(pending_acks))
+            .unwrap();
+
+        Some(real_messages)
    }

    async fn on_input_message(&mut self, msg: InputMessage) {
-        match msg {
-            InputMessage::Regular {
+        let real_messages = match msg {
+            InputMessage::Fresh {
                recipient,
                data,
-                lane,
-            } => self.handle_plain_message(recipient, data, lane).await,
-            InputMessage::Anonymous {
-                recipient,
-                data,
-                reply_surbs,
-                lane,
+                with_reply_surb,
            } => {
-                self.handle_repliable_message(recipient, data, reply_surbs, lane)
+                self.handle_fresh_message(recipient, data, with_reply_surb)
                    .await
            }
-            InputMessage::Reply {
-                recipient_tag,
-                data,
-                lane,
-            } => {
-                self.handle_reply(recipient_tag, data, lane).await;
-            }
+            InputMessage::Reply { reply_surb, data } => self
+                .handle_reply(reply_surb, data)
+                .await
+                .map(|message| vec![message]),
        };
+
+        // there's no point in trying to send nothing
+        if let Some(real_messages) = real_messages {
+            // tells real message sender (with the poisson timer) to send this to the mix network
+            self.real_message_sender
+                .unbounded_send(real_messages)
+                .unwrap();
+        }
    }

-    pub(super) async fn run_with_shutdown(&mut self, mut shutdown: task::TaskClient) {
-        debug!("Started InputMessageListener with graceful shutdown support");
-
-        while !shutdown.is_shutdown() {
+    pub(super) async fn run(&mut self) {
+        debug!("Started InputMessageListener");
+        while !self.shutdown.is_shutdown() {
            tokio::select! {
-                input_msg = self.input_receiver.recv() => match input_msg {
+                input_msg = self.input_receiver.next() => match input_msg {
                    Some(input_msg) => {
                        self.on_input_message(input_msg).await;
                    },
@@ -123,12 +197,12 @@ where
                        break;
                    }
                },
-                _ = shutdown.recv_with_delay() => {
+                _ = self.shutdown.recv() => {
                    log::trace!("InputMessageListener: Received shutdown");
                }
            }
        }
-        shutdown.recv_timeout().await;
+        assert!(self.shutdown.is_shutdown_poll());
        log::debug!("InputMessageListener: Exiting");
    }
 }
@@ -7,20 +7,17 @@ use self::{
    retransmission_request_listener::RetransmissionRequestListener,
    sent_notification_listener::SentNotificationListener,
 };
-use crate::client::inbound_messages::InputMessageReceiver;
-use crate::client::real_messages_control::message_handler::MessageHandler;
-use crate::client::replies::reply_controller::ReplyControllerSender;
-use crate::spawn_future;
-use action_controller::AckActionReceiver;
+use super::real_traffic_stream::BatchRealMessageSender;
+use crate::client::reply_key_storage::ReplyKeyStorage;
+use crate::client::{inbound_messages::InputMessageReceiver, topology_control::TopologyAccessor};
 use futures::channel::mpsc;
 use gateway_client::AcknowledgementReceiver;
 use log::*;
-use nymsphinx::anonymous_replies::requests::AnonymousSenderTag;
-use nymsphinx::params::PacketSize;
 use nymsphinx::{
    acknowledgements::AckKey,
    addressing::clients::Recipient,
    chunking::fragment::{Fragment, FragmentIdentifier},
+    preparer::MessagePreparer,
    Delay as SphinxDelay,
 };
 use rand::{CryptoRng, Rng};
@@ -28,8 +25,8 @@ use std::{
    sync::{Arc, Weak},
    time::Duration,
 };
-
-pub(crate) use action_controller::{AckActionSender, Action};
+use task::ShutdownListener;
+use tokio::task::JoinHandle;

 mod acknowledgement_listener;
 mod action_controller;
@@ -51,64 +48,24 @@ pub(super) type SentPacketNotificationSender = mpsc::UnboundedSender<FragmentIde
 /// that it is about to be sent to the mix network and its timeout timer should be started.
 type SentPacketNotificationReceiver = mpsc::UnboundedReceiver<FragmentIdentifier>;

-#[derive(Debug)]
-pub(crate) enum PacketDestination {
-    Anonymous {
-        recipient_tag: AnonymousSenderTag,
-        // special flag to indicate whether this was an ack for requesting additional surbs,
-        // in that case we have to do everything we can to get it through, even if it means going
-        // below our stored reply surb threshold
-        extra_surb_request: bool,
-    },
-    KnownRecipient(Box<Recipient>),
-}
-
 /// Structure representing a data `Fragment` that is on-route to the specified `Recipient`
 #[derive(Debug)]
 pub(crate) struct PendingAcknowledgement {
    message_chunk: Fragment,
    delay: SphinxDelay,
-    destination: PacketDestination,
+    recipient: Recipient,
 }

 impl PendingAcknowledgement {
    /// Creates new instance of `PendingAcknowledgement` using the provided data.
-    pub(crate) fn new_known(
-        message_chunk: Fragment,
-        delay: SphinxDelay,
-        recipient: Recipient,
-    ) -> Self {
+    fn new(message_chunk: Fragment, delay: SphinxDelay, recipient: Recipient) -> Self {
        PendingAcknowledgement {
            message_chunk,
            delay,
-            destination: PacketDestination::KnownRecipient(recipient.into()),
+            recipient,
        }
    }

-    pub(crate) fn new_anonymous(
-        message_chunk: Fragment,
-        delay: SphinxDelay,
-        recipient_tag: AnonymousSenderTag,
-        extra_surb_request: bool,
-    ) -> Self {
-        PendingAcknowledgement {
-            message_chunk,
-            delay,
-            destination: PacketDestination::Anonymous {
-                recipient_tag,
-                extra_surb_request,
-            },
-        }
-    }
-
-    pub(crate) fn inner_fragment_identifier(&self) -> FragmentIdentifier {
-        self.message_chunk.fragment_identifier()
-    }
-
-    pub(crate) fn fragment_data(&self) -> Fragment {
-        self.message_chunk.clone()
-    }
-
    fn update_delay(&mut self, new_delay: SphinxDelay) {
        self.delay = new_delay;
    }
@@ -117,6 +74,10 @@ impl PendingAcknowledgement {
 /// AcknowledgementControllerConnectors represents set of channels for communication with
 /// other parts of the system in order to support acknowledgements and retransmission.
 pub(super) struct AcknowledgementControllerConnectors {
+    /// Channel used for forwarding prepared sphinx messages into the poisson sender
+    /// to be sent to the mix network.
+    real_message_sender: BatchRealMessageSender,
+
    /// Channel used for receiving raw messages from a client. The messages need to be put
    /// into sphinx packets first.
    input_receiver: InputMessageReceiver,
@@ -128,28 +89,20 @@ pub(super) struct AcknowledgementControllerConnectors {

    /// Channel used for receiving acknowledgements from the mix network.
    ack_receiver: AcknowledgementReceiver,
-
-    /// Channel used for sending request to `ActionController` to deal with anything ack-related,
-    ack_action_sender: AckActionSender,
-
-    /// Channel used for receiving request by `ActionController` to deal with anything ack-related,
-    ack_action_receiver: AckActionReceiver,
 }

 impl AcknowledgementControllerConnectors {
    pub(super) fn new(
+        real_message_sender: BatchRealMessageSender,
        input_receiver: InputMessageReceiver,
        sent_notifier: SentPacketNotificationReceiver,
        ack_receiver: AcknowledgementReceiver,
-        ack_action_sender: AckActionSender,
-        ack_action_receiver: AckActionReceiver,
    ) -> Self {
        AcknowledgementControllerConnectors {
+            real_message_sender,
            input_receiver,
            sent_notifier,
            ack_receiver,
-            ack_action_sender,
-            ack_action_receiver,
        }
    }
 }
@@ -162,135 +115,168 @@ pub(super) struct Config {
    /// Given ack timeout in the form a * BASE_DELAY + b, it specifies the multiplier `a`
    ack_wait_multiplier: f64,

-    /// Predefined packet size used for the encapsulated messages.
-    packet_size: PacketSize,
+    /// Average delay an acknowledgement packet is going to get delayed at a single mixnode.
+    average_ack_delay: Duration,
+
+    /// Average delay a data packet is going to get delayed at a single mixnode.
+    average_packet_delay: Duration,
 }

 impl Config {
-    pub(super) fn new(ack_wait_addition: Duration, ack_wait_multiplier: f64) -> Self {
+    pub(super) fn new(
+        ack_wait_addition: Duration,
+        ack_wait_multiplier: f64,
+        average_ack_delay: Duration,
+        average_packet_delay: Duration,
+    ) -> Self {
        Config {
            ack_wait_addition,
            ack_wait_multiplier,
-            packet_size: Default::default(),
+            average_ack_delay,
+            average_packet_delay,
        }
    }
-
-    pub fn with_custom_packet_size(mut self, packet_size: PacketSize) -> Self {
-        self.packet_size = packet_size;
-        self
-    }
 }

 pub(super) struct AcknowledgementController<R>
 where
    R: CryptoRng + Rng,
 {
-    acknowledgement_listener: AcknowledgementListener,
-    input_message_listener: InputMessageListener<R>,
-    retransmission_request_listener: RetransmissionRequestListener<R>,
-    sent_notification_listener: SentNotificationListener,
-    action_controller: ActionController,
+    acknowledgement_listener: Option<AcknowledgementListener>,
+    input_message_listener: Option<InputMessageListener<R>>,
+    retransmission_request_listener: Option<RetransmissionRequestListener<R>>,
+    sent_notification_listener: Option<SentNotificationListener>,
+    action_controller: Option<ActionController>,
 }

 impl<R> AcknowledgementController<R>
 where
-    R: 'static + CryptoRng + Rng + Clone + Send + Sync,
+    R: 'static + CryptoRng + Rng + Clone + Send,
 {
+    #[allow(clippy::too_many_arguments)]
    pub(super) fn new(
        config: Config,
+        rng: R,
+        topology_access: TopologyAccessor,
        ack_key: Arc<AckKey>,
+        ack_recipient: Recipient,
+        reply_key_storage: ReplyKeyStorage,
        connectors: AcknowledgementControllerConnectors,
-        message_handler: MessageHandler<R>,
-        reply_controller_sender: ReplyControllerSender,
+        shutdown: ShutdownListener,
    ) -> Self {
        let (retransmission_tx, retransmission_rx) = mpsc::unbounded();

        let action_config =
            action_controller::Config::new(config.ack_wait_addition, config.ack_wait_multiplier);
-        let action_controller = ActionController::new(
-            action_config,
-            retransmission_tx,
-            connectors.ack_action_receiver,
+        let (action_controller, action_sender) =
+            ActionController::new(action_config, retransmission_tx, shutdown.clone());
+
+        let message_preparer = MessagePreparer::new(
+            rng,
+            ack_recipient,
+            config.average_packet_delay,
+            config.average_ack_delay,
        );

        // will listen for any acks coming from the network
        let acknowledgement_listener = AcknowledgementListener::new(
            Arc::clone(&ack_key),
            connectors.ack_receiver,
-            connectors.ack_action_sender.clone(),
+            action_sender.clone(),
+            shutdown.clone(),
        );

        // will listen for any new messages from the client
        let input_message_listener = InputMessageListener::new(
+            Arc::clone(&ack_key),
+            ack_recipient,
            connectors.input_receiver,
-            message_handler.clone(),
-            reply_controller_sender.clone(),
+            message_preparer.clone(),
+            action_sender.clone(),
+            connectors.real_message_sender.clone(),
+            topology_access.clone(),
+            reply_key_storage,
+            shutdown.clone(),
        );

        // will listen for any ack timeouts and trigger retransmission
        let retransmission_request_listener = RetransmissionRequestListener::new(
-            connectors.ack_action_sender.clone(),
-            message_handler,
+            Arc::clone(&ack_key),
+            ack_recipient,
+            message_preparer,
+            action_sender.clone(),
+            connectors.real_message_sender,
            retransmission_rx,
-            reply_controller_sender,
+            topology_access,
+            shutdown.clone(),
        );

        // 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);
+            SentNotificationListener::new(connectors.sent_notifier, action_sender, shutdown);

        AcknowledgementController {
-            acknowledgement_listener,
-            input_message_listener,
-            retransmission_request_listener,
-            sent_notification_listener,
-            action_controller,
+            acknowledgement_listener: Some(acknowledgement_listener),
+            input_message_listener: Some(input_message_listener),
+            retransmission_request_listener: Some(retransmission_request_listener),
+            sent_notification_listener: Some(sent_notification_listener),
+            action_controller: Some(action_controller),
        }
    }

-    pub(super) fn start_with_shutdown(self, shutdown: task::TaskClient) {
-        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;
+    pub(super) async fn run(&mut self) {
+        let mut acknowledgement_listener = self.acknowledgement_listener.take().unwrap();
+        let mut input_message_listener = self.input_message_listener.take().unwrap();
+        let mut retransmission_request_listener =
+            self.retransmission_request_listener.take().unwrap();
+        let mut sent_notification_listener = self.sent_notification_listener.take().unwrap();
+        let mut action_controller = self.action_controller.take().unwrap();

-        let shutdown_handle = shutdown.clone();
-        spawn_future(async move {
-            acknowledgement_listener
-                .run_with_shutdown(shutdown_handle)
-                .await;
+        // the below are log messages are errors as at the current stage we do not expect any of
+        // the task to ever finish. This will of course change once we introduce
+        // graceful shutdowns.
+        let ack_listener_fut = tokio::spawn(async move {
+            acknowledgement_listener.run().await;
            debug!("The acknowledgement listener has finished execution!");
+            acknowledgement_listener
        });
-
-        let shutdown_handle = shutdown.clone();
-        spawn_future(async move {
-            input_message_listener
-                .run_with_shutdown(shutdown_handle)
-                .await;
+        let input_listener_fut = tokio::spawn(async move {
+            input_message_listener.run().await;
            debug!("The input listener has finished execution!");
+            input_message_listener
        });
-
-        let shutdown_handle = shutdown.clone();
-        spawn_future(async move {
-            retransmission_request_listener
-                .run_with_shutdown(shutdown_handle)
-                .await;
+        let retransmission_req_fut = tokio::spawn(async move {
+            retransmission_request_listener.run().await;
            debug!("The retransmission request listener has finished execution!");
+            retransmission_request_listener
        });
-
-        let shutdown_handle = shutdown.clone();
-        spawn_future(async move {
-            sent_notification_listener
-                .run_with_shutdown(shutdown_handle)
-                .await;
+        let sent_notification_fut = tokio::spawn(async move {
+            sent_notification_listener.run().await;
            debug!("The sent notification listener has finished execution!");
+            sent_notification_listener
+        });
+        let action_controller_fut = tokio::spawn(async move {
+            action_controller.run().await;
+            debug!("The controller has finished execution!");
+            action_controller
        });

-        spawn_future(async move {
-            action_controller.run_with_shutdown(shutdown).await;
-            debug!("The controller has finished execution!");
-        });
+        // technically we don't have to bring `AcknowledgementController` back to a valid state
+        // but we can do it, so why not? Perhaps it might be useful if we wanted to allow
+        // for restarts of certain modules without killing the entire process.
+        self.acknowledgement_listener = Some(ack_listener_fut.await.unwrap());
+        self.input_message_listener = Some(input_listener_fut.await.unwrap());
+        self.retransmission_request_listener = Some(retransmission_req_fut.await.unwrap());
+        self.sent_notification_listener = Some(sent_notification_fut.await.unwrap());
+        self.action_controller = Some(action_controller_fut.await.unwrap());
+    }
+
+    #[allow(dead_code)]
+    pub(super) fn start(mut self) -> JoinHandle<Self> {
+        tokio::spawn(async move {
+            self.run().await;
+            self
+        })
    }
 }
@@ -1,101 +1,82 @@
-// Copyright 2021-2022 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use super::{
-    action_controller::{AckActionSender, Action},
-    PendingAcknowledgement, RetransmissionRequestReceiver,
+use super::action_controller::{Action, ActionSender};
+use super::PendingAcknowledgement;
+use super::RetransmissionRequestReceiver;
+use crate::client::{
+    real_messages_control::real_traffic_stream::{BatchRealMessageSender, RealMessage},
+    topology_control::TopologyAccessor,
 };
-use crate::client::real_messages_control::acknowledgement_control::PacketDestination;
-use crate::client::real_messages_control::message_handler::{MessageHandler, PreparationError};
-use crate::client::real_messages_control::real_traffic_stream::RealMessage;
-use crate::client::replies::reply_controller::ReplyControllerSender;
-use client_connections::TransmissionLane;
 use futures::StreamExt;
 use log::*;
-use nymsphinx::addressing::clients::Recipient;
-use nymsphinx::chunking::fragment::Fragment;
-use nymsphinx::preparer::PreparedFragment;
+use nymsphinx::preparer::MessagePreparer;
+use nymsphinx::{acknowledgements::AckKey, addressing::clients::Recipient};
 use rand::{CryptoRng, Rng};
 use std::sync::{Arc, Weak};
+use task::ShutdownListener;

 // responsible for packet retransmission upon fired timer
-pub(super) struct RetransmissionRequestListener<R> {
-    action_sender: AckActionSender,
-    message_handler: MessageHandler<R>,
+pub(super) struct RetransmissionRequestListener<R>
+where
+    R: CryptoRng + Rng,
+{
+    ack_key: Arc<AckKey>,
+    ack_recipient: Recipient,
+    message_preparer: MessagePreparer<R>,
+    action_sender: ActionSender,
+    real_message_sender: BatchRealMessageSender,
    request_receiver: RetransmissionRequestReceiver,
-    reply_controller_sender: ReplyControllerSender,
+    topology_access: TopologyAccessor,
+    shutdown: ShutdownListener,
 }

 impl<R> RetransmissionRequestListener<R>
 where
    R: CryptoRng + Rng,
 {
+    #[allow(clippy::too_many_arguments)]
    pub(super) fn new(
-        action_sender: AckActionSender,
-        message_handler: MessageHandler<R>,
+        ack_key: Arc<AckKey>,
+        ack_recipient: Recipient,
+        message_preparer: MessagePreparer<R>,
+        action_sender: ActionSender,
+        real_message_sender: BatchRealMessageSender,
        request_receiver: RetransmissionRequestReceiver,
-        reply_controller_sender: ReplyControllerSender,
+        topology_access: TopologyAccessor,
+        shutdown: ShutdownListener,
    ) -> Self {
        RetransmissionRequestListener {
+            ack_key,
+            ack_recipient,
+            message_preparer,
            action_sender,
-            message_handler,
+            real_message_sender,
            request_receiver,
-            reply_controller_sender,
+            topology_access,
+            shutdown,
        }
    }

-    async fn prepare_normal_retransmission_chunk(
-        &mut self,
-        packet_recipient: Recipient,
-        chunk_data: Fragment,
-    ) -> Result<PreparedFragment, PreparationError> {
-        debug!("retransmitting normal packet...");
-
-        self.message_handler
-            .try_prepare_single_chunk_for_sending(packet_recipient, chunk_data)
-            .await
-    }
-
-    async fn on_retransmission_request(
-        &mut self,
-        weak_timed_out_ack: Weak<PendingAcknowledgement>,
-    ) {
-        let timed_out_ack = match weak_timed_out_ack.upgrade() {
+    async fn on_retransmission_request(&mut self, timed_out_ack: Weak<PendingAcknowledgement>) {
+        let timed_out_ack = match timed_out_ack.upgrade() {
            Some(timed_out_ack) => timed_out_ack,
            None => {
                debug!("We received an ack JUST as we were about to retransmit [1]");
                return;
            }
        };
+        let packet_recipient = &timed_out_ack.recipient;
+        let chunk_clone = timed_out_ack.message_chunk.clone();
+        let frag_id = chunk_clone.fragment_identifier();

-        let maybe_prepared_fragment = match &timed_out_ack.destination {
-            PacketDestination::Anonymous {
-                recipient_tag,
-                extra_surb_request,
-            } => {
-                // if this is retransmission for reply, offload it to the dedicated task
-                // that deals with all the surbs
-                return self.reply_controller_sender.send_retransmission_data(
-                    *recipient_tag,
-                    weak_timed_out_ack,
-                    *extra_surb_request,
-                );
-            }
-            PacketDestination::KnownRecipient(recipient) => {
-                self.prepare_normal_retransmission_chunk(
-                    **recipient,
-                    timed_out_ack.message_chunk.clone(),
-                )
-                .await
-            }
-        };
-
-        let frag_id = timed_out_ack.message_chunk.fragment_identifier();
-
-        let prepared_fragment = match maybe_prepared_fragment {
-            Ok(prepared_fragment) => prepared_fragment,
-            Err(err) => {
-                warn!("Could not retransmit the packet - {err}");
+        let topology_permit = self.topology_access.get_read_permit().await;
+        let topology_ref = match topology_permit
+            .try_get_valid_topology_ref(&self.ack_recipient, Some(packet_recipient))
+        {
+            Some(topology_ref) => topology_ref,
+            None => {
+                warn!("Could not retransmit the packet - the network topology is invalid");
                // we NEED to start timer here otherwise we will have this guy permanently stuck in memory
                self.action_sender
                    .unbounded_send(Action::new_start_timer(frag_id))
@@ -104,6 +85,11 @@ where
            }
        };

+        let prepared_fragment = self
+            .message_preparer
+            .prepare_chunk_for_sending(chunk_clone, topology_ref, &self.ack_key, packet_recipient)
+            .unwrap();
+
        // if we have the ONLY strong reference to the ack data, it means it was removed from the
        // pending acks
        if Arc::strong_count(&timed_out_ack) == 1 {
@@ -115,6 +101,7 @@ where
        // we no longer need the reference - let's drop it so that if somehow `UpdateTimer` action
        // reached the controller before this function terminated, the controller would not panic.
        drop(timed_out_ack);
+
        let new_delay = prepared_fragment.total_delay;

        // We know this update will be reflected by the `StartTimer` Action performed when this
@@ -129,18 +116,18 @@ where
            .unwrap();

        // send to `OutQueueControl` to eventually send to the mix network
-        self.message_handler
-            .forward_messages(
-                vec![RealMessage::new(prepared_fragment.mix_packet, frag_id)],
-                TransmissionLane::Retransmission,
-            )
-            .await
+        self.real_message_sender
+            .unbounded_send(vec![RealMessage::new(
+                prepared_fragment.mix_packet,
+                frag_id,
+            )])
+            .unwrap();
    }

-    pub(super) async fn run_with_shutdown(&mut self, mut shutdown: task::TaskClient) {
-        debug!("Started RetransmissionRequestListener with graceful shutdown support");
+    pub(super) async fn run(&mut self) {
+        debug!("Started RetransmissionRequestListener");

-        while !shutdown.is_shutdown() {
+        while !self.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).await,
@@ -149,12 +136,12 @@ where
                        break;
                    }
                },
-                _ = shutdown.recv() => {
+                _ = self.shutdown.recv() => {
                    log::trace!("RetransmissionRequestListener: Received shutdown");
                }
            }
        }
-        shutdown.recv_timeout().await;
+        assert!(self.shutdown.is_shutdown_poll());
        log::debug!("RetransmissionRequestListener: Exiting");
    }
 }
@@ -1,11 +1,12 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use super::action_controller::{AckActionSender, Action};
+use super::action_controller::{Action, ActionSender};
 use super::SentPacketNotificationReceiver;
 use futures::StreamExt;
 use log::*;
 use nymsphinx::chunking::fragment::{FragmentIdentifier, COVER_FRAG_ID};
+use task::ShutdownListener;

 /// Module responsible for starting up retransmission timers.
 /// It is required because when we send our packet to the `real traffic stream` controlled
@@ -13,17 +14,20 @@ use nymsphinx::chunking::fragment::{FragmentIdentifier, COVER_FRAG_ID};
 /// accidentally fire retransmission way quicker than we should have.
 pub(super) struct SentNotificationListener {
    sent_notifier: SentPacketNotificationReceiver,
-    action_sender: AckActionSender,
+    action_sender: ActionSender,
+    shutdown: ShutdownListener,
 }

 impl SentNotificationListener {
    pub(super) fn new(
        sent_notifier: SentPacketNotificationReceiver,
-        action_sender: AckActionSender,
+        action_sender: ActionSender,
+        shutdown: ShutdownListener,
    ) -> Self {
        SentNotificationListener {
            sent_notifier,
            action_sender,
+            shutdown,
        }
    }

@@ -31,16 +35,20 @@ impl SentNotificationListener {
        if frag_id == COVER_FRAG_ID {
            trace!("sent off a cover message - no need to start retransmission timer!");
            return;
+        } else if frag_id.is_reply() {
+            debug!("sent off a reply message - no need to start retransmission timer!");
+            // TODO: probably there will need to be some extra procedure here, like it would
+            // be nice to know that our reply actually reached the recipient (i.e. we got the ack)
+            return;
        }
        self.action_sender
            .unbounded_send(Action::new_start_timer(frag_id))
            .unwrap();
    }

-    pub(super) async fn run_with_shutdown(&mut self, mut shutdown: task::TaskClient) {
-        debug!("Started SentNotificationListener with graceful shutdown support");
-
-        while !shutdown.is_shutdown() {
+    pub(super) async fn run(&mut self) {
+        debug!("Started SentNotificationListener");
+        while !self.shutdown.is_shutdown() {
            tokio::select! {
                frag_id = self.sent_notifier.next() => match frag_id {
                    Some(frag_id) => {
@@ -51,12 +59,12 @@ impl SentNotificationListener {
                        break;
                    }
                },
-                _ = shutdown.recv_with_delay() => {
+                _ = self.shutdown.recv() => {
                    log::trace!("SentNotificationListener: Received shutdown");
                }
            }
        }
-        assert!(shutdown.is_shutdown_poll());
+        assert!(self.shutdown.is_shutdown_poll());
        log::debug!("SentNotificationListener: Exiting");
    }
 }
@@ -1,566 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::client::real_messages_control::acknowledgement_control::PendingAcknowledgement;
-use crate::client::real_messages_control::real_traffic_stream::{
-    BatchRealMessageSender, RealMessage,
-};
-use crate::client::real_messages_control::{AckActionSender, Action};
-use crate::client::replies::reply_storage::{ReceivedReplySurbsMap, SentReplyKeys, UsedSenderTags};
-use crate::client::topology_control::{TopologyAccessor, TopologyReadPermit};
-use client_connections::TransmissionLane;
-use log::{debug, error, info, trace, warn};
-use nymsphinx::acknowledgements::AckKey;
-use nymsphinx::addressing::clients::Recipient;
-use nymsphinx::anonymous_replies::requests::{AnonymousSenderTag, RepliableMessage, ReplyMessage};
-use nymsphinx::anonymous_replies::{ReplySurb, SurbEncryptionKey};
-use nymsphinx::chunking::fragment::{Fragment, FragmentIdentifier};
-use nymsphinx::message::NymMessage;
-use nymsphinx::params::{PacketSize, DEFAULT_NUM_MIX_HOPS};
-use nymsphinx::preparer::{MessagePreparer, PreparedFragment};
-use nymsphinx::Delay;
-use rand::{CryptoRng, Rng};
-use std::collections::HashMap;
-use std::sync::Arc;
-use std::time::Duration;
-use thiserror::Error;
-use topology::{NymTopology, NymTopologyError};
-
-// TODO: move that error elsewhere since it seems to be contaminating different files
-#[derive(Debug, Clone, Error)]
-pub enum PreparationError {
-    #[error(transparent)]
-    NymTopologyError(#[from] NymTopologyError),
-
-    #[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. We have {available} available and require at least {required}.")]
-    NotEnoughSurbs { available: usize, required: usize },
-}
-
-impl PreparationError {
-    fn return_surbs(self, returned_surbs: Vec<ReplySurb>) -> SurbWrappedPreparationError {
-        SurbWrappedPreparationError {
-            source: self,
-            returned_surbs: Some(returned_surbs),
-        }
-    }
-}
-
-#[derive(Debug, Error)]
-#[error("Failed to prepare packets - {source}. {} reply surbs will be returned", .returned_surbs.as_ref().map(|s| s.len()).unwrap_or_default())]
-pub struct SurbWrappedPreparationError {
-    #[source]
-    source: PreparationError,
-
-    returned_surbs: Option<Vec<ReplySurb>>,
-}
-
-impl<T> From<T> for SurbWrappedPreparationError
-where
-    T: Into<PreparationError>,
-{
-    fn from(err: T) -> Self {
-        SurbWrappedPreparationError {
-            source: err.into(),
-            returned_surbs: None,
-        }
-    }
-}
-
-impl SurbWrappedPreparationError {
-    pub(crate) fn return_unused_surbs(
-        self,
-        surb_storage: &ReceivedReplySurbsMap,
-        target: &AnonymousSenderTag,
-    ) -> PreparationError {
-        if let Some(reply_surbs) = self.returned_surbs {
-            surb_storage.insert_surbs(target, reply_surbs)
-        }
-        self.source
-    }
-}
-
-#[derive(Clone)]
-pub(crate) struct Config {
-    /// Key used to decrypt contents of received SURBAcks
-    ack_key: Arc<AckKey>,
-
-    /// Address of this client which also represent an address to which all acknowledgements
-    /// and surb-based are going to be sent.
-    sender_address: Recipient,
-
-    /// Average delay a data packet is going to get delay at a single mixnode.
-    average_packet_delay: Duration,
-
-    /// Average delay an acknowledgement packet is going to get delay at a single mixnode.
-    average_ack_delay: Duration,
-
-    /// Number of mix hops each packet ('real' message, ack, reply) is expected to take.
-    /// Note that it does not include gateway hops.
-    num_mix_hops: u8,
-
-    /// Predefined packet size used for the encapsulated messages.
-    packet_size: PacketSize,
-}
-
-impl Config {
-    pub fn new(
-        ack_key: Arc<AckKey>,
-        sender_address: Recipient,
-        average_packet_delay: Duration,
-        average_ack_delay: Duration,
-    ) -> Self {
-        Config {
-            ack_key,
-            sender_address,
-            average_packet_delay,
-            average_ack_delay,
-            num_mix_hops: DEFAULT_NUM_MIX_HOPS,
-            packet_size: PacketSize::default(),
-        }
-    }
-
-    /// Allows setting non-default number of expected mix hops in the network.
-    #[allow(dead_code)]
-    pub fn with_mix_hops(mut self, hops: u8) -> Self {
-        self.num_mix_hops = hops;
-        self
-    }
-
-    /// Allows setting non-default size of the sphinx packets sent out.
-    pub fn with_custom_packet_size(mut self, packet_size: PacketSize) -> Self {
-        self.packet_size = packet_size;
-        self
-    }
-}
-
-#[derive(Clone)]
-pub(crate) struct MessageHandler<R> {
-    config: Config,
-    rng: R,
-    message_preparer: MessagePreparer<R>,
-    action_sender: AckActionSender,
-    real_message_sender: BatchRealMessageSender,
-    topology_access: TopologyAccessor,
-    reply_key_storage: SentReplyKeys,
-    tag_storage: UsedSenderTags,
-}
-
-impl<R> MessageHandler<R>
-where
-    R: CryptoRng + Rng,
-{
-    pub(crate) fn new(
-        config: Config,
-        rng: R,
-        action_sender: AckActionSender,
-        real_message_sender: BatchRealMessageSender,
-        topology_access: TopologyAccessor,
-        reply_key_storage: SentReplyKeys,
-        tag_storage: UsedSenderTags,
-    ) -> Self
-    where
-        R: Copy,
-    {
-        let message_preparer = MessagePreparer::new(
-            rng,
-            config.sender_address,
-            config.average_packet_delay,
-            config.average_ack_delay,
-        )
-        .with_custom_real_message_packet_size(config.packet_size)
-        .with_mix_hops(config.num_mix_hops);
-
-        MessageHandler {
-            config,
-            rng,
-            message_preparer,
-            action_sender,
-            real_message_sender,
-            topology_access,
-            reply_key_storage,
-            tag_storage,
-        }
-    }
-
-    fn get_or_create_sender_tag(&mut self, recipient: &Recipient) -> AnonymousSenderTag {
-        if let Some(existing) = self.tag_storage.try_get_existing(recipient) {
-            trace!("we already had sender tag for {recipient}");
-            existing
-        } else {
-            info!("creating new sender tag for {recipient}");
-            let new_tag = AnonymousSenderTag::new_random(&mut self.rng);
-            self.tag_storage.insert_new(recipient, new_tag);
-            info!("we'll be using {new_tag} for all anonymous messages sent to {recipient}");
-            new_tag
-        }
-    }
-
-    fn get_topology<'a>(
-        &self,
-        permit: &'a TopologyReadPermit<'a>,
-    ) -> Result<&'a NymTopology, PreparationError> {
-        match permit.try_get_valid_topology_ref(&self.config.sender_address, None) {
-            Ok(topology_ref) => Ok(topology_ref),
-            Err(err) => {
-                warn!("Could not process the packet - the network topology is invalid - {err}");
-                Err(err.into())
-            }
-        }
-    }
-
-    async fn generate_reply_surbs_with_keys(
-        &mut self,
-        amount: usize,
-    ) -> Result<(Vec<ReplySurb>, Vec<SurbEncryptionKey>), PreparationError> {
-        let topology_permit = self.topology_access.get_read_permit().await;
-        let topology = self.get_topology(&topology_permit)?;
-
-        let reply_surbs = self
-            .message_preparer
-            .generate_reply_surbs(amount, topology)?;
-
-        let reply_keys = reply_surbs
-            .iter()
-            .map(|s| *s.encryption_key())
-            .collect::<Vec<_>>();
-
-        Ok((reply_surbs, reply_keys))
-    }
-
-    pub(crate) async fn try_send_single_surb_message(
-        &mut self,
-        target: AnonymousSenderTag,
-        message: ReplyMessage,
-        reply_surb: ReplySurb,
-        is_extra_surb_request: bool,
-    ) -> Result<(), SurbWrappedPreparationError> {
-        let mut fragment = self
-            .message_preparer
-            .pad_and_split_message(NymMessage::new_reply(message));
-        if fragment.len() > 1 {
-            // well, it's not a single surb message
-            return Err(SurbWrappedPreparationError {
-                source: PreparationError::MessageTooLongForSingleSurb {
-                    fragments: fragment.len(),
-                },
-                returned_surbs: Some(vec![reply_surb]),
-            });
-        }
-
-        let chunk = fragment.pop().unwrap();
-        let chunk_clone = chunk.clone();
-        let prepared_fragment = self
-            .try_prepare_single_reply_chunk_for_sending(reply_surb, chunk_clone)
-            .await?;
-
-        let real_messages =
-            RealMessage::new(prepared_fragment.mix_packet, chunk.fragment_identifier());
-        let delay = prepared_fragment.total_delay;
-        let pending_ack =
-            PendingAcknowledgement::new_anonymous(chunk, delay, target, is_extra_surb_request);
-
-        let lane = if is_extra_surb_request {
-            TransmissionLane::ReplySurbRequest
-        } else {
-            TransmissionLane::General
-        };
-
-        self.forward_messages(vec![real_messages], lane).await;
-        self.insert_pending_acks(vec![pending_ack]);
-        Ok(())
-    }
-
-    pub(crate) async fn try_request_additional_reply_surbs(
-        &mut self,
-        from: AnonymousSenderTag,
-        reply_surb: ReplySurb,
-        amount: u32,
-    ) -> Result<(), SurbWrappedPreparationError> {
-        debug!("requesting {amount} reply SURBs from {from}");
-
-        let surbs_request =
-            ReplyMessage::new_surb_request_message(self.config.sender_address, amount);
-        self.try_send_single_surb_message(from, surbs_request, reply_surb, true)
-            .await
-    }
-
-    // // TODO: this will require additional argument to make it use different variant of `ReplyMessage`
-    pub(crate) fn split_reply_message(&mut self, message: Vec<u8>) -> Vec<Fragment> {
-        self.message_preparer
-            .pad_and_split_message(NymMessage::new_reply(ReplyMessage::new_data_message(
-                message,
-            )))
-    }
-
-    pub(crate) async fn send_retransmission_reply_chunks(
-        &mut self,
-        prepared_fragments: Vec<PreparedFragment>,
-        lane: TransmissionLane,
-    ) {
-        let mut real_messages = Vec::with_capacity(prepared_fragments.len());
-
-        for prepared in prepared_fragments {
-            self.update_ack_delay(prepared.fragment_identifier, prepared.total_delay);
-            real_messages.push(prepared.into())
-        }
-
-        self.forward_messages(real_messages, lane).await;
-    }
-
-    pub(crate) async fn try_send_reply_chunks_on_lane(
-        &mut self,
-        target: AnonymousSenderTag,
-        fragments: Vec<Fragment>,
-        reply_surbs: Vec<ReplySurb>,
-        lane: TransmissionLane,
-    ) -> Result<(), SurbWrappedPreparationError> {
-        // TODO: technically this is performing an unnecessary cloning, but in the grand scheme of things
-        // is it really that bad?
-        self.try_send_reply_chunks(
-            target,
-            fragments.into_iter().map(|f| (lane, f)).collect(),
-            reply_surbs,
-        )
-        .await
-    }
-
-    pub(crate) async fn try_send_reply_chunks(
-        &mut self,
-        target: AnonymousSenderTag,
-        fragments: Vec<(TransmissionLane, Fragment)>,
-        reply_surbs: Vec<ReplySurb>,
-    ) -> Result<(), SurbWrappedPreparationError> {
-        let prepared_fragments = self
-            .prepare_reply_chunks_for_sending(
-                fragments.iter().map(|(_, f)| f.clone()).collect(),
-                reply_surbs,
-            )
-            .await?;
-
-        let mut pending_acks = Vec::with_capacity(fragments.len());
-        let mut to_forward: HashMap<_, Vec<_>> = HashMap::new();
-
-        for (raw, prepared) in fragments.into_iter().zip(prepared_fragments.into_iter()) {
-            let lane = raw.0;
-            let fragment = raw.1;
-
-            let real_message = RealMessage::new(prepared.mix_packet, prepared.fragment_identifier);
-            let delay = prepared.total_delay;
-            let pending_ack = PendingAcknowledgement::new_anonymous(fragment, delay, target, false);
-
-            let entry = to_forward.entry(lane).or_default();
-            entry.push(real_message);
-            pending_acks.push(pending_ack);
-        }
-
-        for (lane, real_messages) in to_forward {
-            self.forward_messages(real_messages, lane).await;
-        }
-
-        self.insert_pending_acks(pending_acks);
-        Ok(())
-    }
-
-    pub(crate) async fn try_send_plain_message(
-        &mut self,
-        recipient: Recipient,
-        message: Vec<u8>,
-        lane: TransmissionLane,
-    ) -> Result<(), PreparationError> {
-        let message = NymMessage::new_plain(message);
-        self.try_split_and_send_non_reply_message(message, recipient, lane)
-            .await
-    }
-
-    pub(crate) async fn try_split_and_send_non_reply_message(
-        &mut self,
-        message: NymMessage,
-        recipient: Recipient,
-        lane: TransmissionLane,
-    ) -> Result<(), PreparationError> {
-        // TODO: I really dislike existence of this assertion, it implies code has to be re-organised
-        debug_assert!(!matches!(message, NymMessage::Reply(_)));
-
-        // TODO2: it's really annoying we have to get topology permit again here due to borrow-checker
-        let topology_permit = self.topology_access.get_read_permit().await;
-        let topology = self.get_topology(&topology_permit)?;
-
-        let fragments = self.message_preparer.pad_and_split_message(message);
-
-        let mut pending_acks = Vec::with_capacity(fragments.len());
-        let mut real_messages = Vec::with_capacity(fragments.len());
-        for fragment in fragments {
-            // we need to clone it because we need to keep it in memory in case we had to retransmit
-            // it. And then we'd need to recreate entire ACK again.
-            let chunk_clone = fragment.clone();
-            let prepared_fragment = self.message_preparer.prepare_chunk_for_sending(
-                chunk_clone,
-                topology,
-                &self.config.ack_key,
-                &recipient,
-            )?;
-
-            let real_message =
-                RealMessage::new(prepared_fragment.mix_packet, fragment.fragment_identifier());
-            let delay = prepared_fragment.total_delay;
-            let pending_ack = PendingAcknowledgement::new_known(fragment, delay, recipient);
-
-            real_messages.push(real_message);
-            pending_acks.push(pending_ack);
-        }
-
-        self.insert_pending_acks(pending_acks);
-        self.forward_messages(real_messages, lane).await;
-
-        Ok(())
-    }
-
-    pub(crate) async fn try_send_additional_reply_surbs(
-        &mut self,
-        recipient: Recipient,
-        amount: u32,
-    ) -> Result<(), PreparationError> {
-        let sender_tag = self.get_or_create_sender_tag(&recipient);
-        let (reply_surbs, reply_keys) =
-            self.generate_reply_surbs_with_keys(amount as usize).await?;
-
-        let message = NymMessage::new_repliable(RepliableMessage::new_additional_surbs(
-            sender_tag,
-            reply_surbs,
-        ));
-
-        self.try_split_and_send_non_reply_message(
-            message,
-            recipient,
-            TransmissionLane::AdditionalReplySurbs,
-        )
-        .await?;
-
-        log::trace!("storing {} reply keys", reply_keys.len());
-        self.reply_key_storage.insert_multiple(reply_keys);
-
-        Ok(())
-    }
-
-    pub(crate) async fn try_send_message_with_reply_surbs(
-        &mut self,
-        recipient: Recipient,
-        message: Vec<u8>,
-        num_reply_surbs: u32,
-        lane: TransmissionLane,
-    ) -> Result<(), SurbWrappedPreparationError> {
-        let sender_tag = self.get_or_create_sender_tag(&recipient);
-        let (reply_surbs, reply_keys) = self
-            .generate_reply_surbs_with_keys(num_reply_surbs as usize)
-            .await?;
-
-        let message =
-            NymMessage::new_repliable(RepliableMessage::new_data(message, sender_tag, reply_surbs));
-
-        self.try_split_and_send_non_reply_message(message, recipient, lane)
-            .await?;
-
-        log::trace!("storing {} reply keys", reply_keys.len());
-        self.reply_key_storage.insert_multiple(reply_keys);
-
-        Ok(())
-    }
-
-    pub(crate) async fn try_prepare_single_chunk_for_sending(
-        &mut self,
-        recipient: Recipient,
-        chunk: Fragment,
-    ) -> Result<PreparedFragment, PreparationError> {
-        let topology_permit = self.topology_access.get_read_permit().await;
-        let topology = self.get_topology(&topology_permit)?;
-
-        let prepared_fragment = self
-            .message_preparer
-            .prepare_chunk_for_sending(chunk, topology, &self.config.ack_key, &recipient)
-            .unwrap();
-
-        Ok(prepared_fragment)
-    }
-
-    pub(crate) async fn prepare_reply_chunks_for_sending(
-        &mut self,
-        fragments: Vec<Fragment>,
-        reply_surbs: Vec<ReplySurb>,
-    ) -> Result<Vec<PreparedFragment>, SurbWrappedPreparationError> {
-        debug_assert_ne!(
-            fragments.len(),
-            reply_surbs.len(),
-            "attempted to send {} fragments with {} reply surbs",
-            fragments.len(),
-            reply_surbs.len()
-        );
-
-        let topology_permit = self.topology_access.get_read_permit().await;
-        let topology = match self.get_topology(&topology_permit) {
-            Ok(topology) => topology,
-            Err(err) => return Err(err.return_surbs(reply_surbs)),
-        };
-
-        Ok(fragments
-            .into_iter()
-            .zip(reply_surbs.into_iter())
-            .map(|(fragment, reply_surb)| {
-                // unwrap here is fine as we know we have a valid topology
-                self.message_preparer
-                    .prepare_reply_chunk_for_sending(
-                        fragment,
-                        topology,
-                        &self.config.ack_key,
-                        reply_surb,
-                    )
-                    .unwrap()
-            })
-            .collect())
-    }
-
-    pub(crate) async fn try_prepare_single_reply_chunk_for_sending(
-        &mut self,
-        reply_surb: ReplySurb,
-        chunk: Fragment,
-    ) -> Result<PreparedFragment, SurbWrappedPreparationError> {
-        let topology_permit = self.topology_access.get_read_permit().await;
-        let topology = match self.get_topology(&topology_permit) {
-            Ok(topology) => topology,
-            Err(err) => return Err(err.return_surbs(vec![reply_surb])),
-        };
-
-        let prepared_fragment = self
-            .message_preparer
-            .prepare_reply_chunk_for_sending(chunk, topology, &self.config.ack_key, reply_surb)
-            .unwrap();
-
-        Ok(prepared_fragment)
-    }
-
-    pub(crate) fn update_ack_delay(&self, id: FragmentIdentifier, new_delay: Delay) {
-        self.action_sender
-            .unbounded_send(Action::UpdateDelay(id, new_delay))
-            .expect("action control task has died")
-    }
-
-    pub(crate) fn insert_pending_acks(&self, pending_acks: Vec<PendingAcknowledgement>) {
-        self.action_sender
-            .unbounded_send(Action::new_insert(pending_acks))
-            .expect("action control task has died")
-    }
-
-    // tells real message sender (with the poisson timer) to send this to the mix network
-    pub(crate) async fn forward_messages(
-        &self,
-        messages: Vec<RealMessage>,
-        transmission_lane: TransmissionLane,
-    ) {
-        self.real_message_sender
-            .send((messages, transmission_lane))
-            .await
-            .expect("real message receiver task (OutQueueControl) has died");
-    }
-}
@@ -8,37 +8,25 @@
 use self::{
    acknowledgement_control::AcknowledgementController, real_traffic_stream::OutQueueControl,
 };
-use crate::client::real_messages_control::message_handler::MessageHandler;
-use crate::client::replies::reply_controller::{
-    ReplyController, ReplyControllerReceiver, ReplyControllerSender,
+use crate::client::real_messages_control::acknowledgement_control::AcknowledgementControllerConnectors;
+use crate::client::reply_key_storage::ReplyKeyStorage;
+use crate::client::{
+    inbound_messages::InputMessageReceiver, mix_traffic::BatchMixMessageSender,
+    topology_control::TopologyAccessor,
 };
-use crate::client::replies::reply_storage::CombinedReplyStorage;
-use crate::{
-    client::{
-        inbound_messages::InputMessageReceiver, mix_traffic::BatchMixMessageSender,
-        real_messages_control::acknowledgement_control::AcknowledgementControllerConnectors,
-        topology_control::TopologyAccessor,
-    },
-    spawn_future,
-};
-use client_connections::{ConnectionCommandReceiver, LaneQueueLengths};
 use futures::channel::mpsc;
 use gateway_client::AcknowledgementReceiver;
 use log::*;
 use nymsphinx::acknowledgements::AckKey;
 use nymsphinx::addressing::clients::Recipient;
-use nymsphinx::params::PacketSize;
 use rand::{rngs::OsRng, CryptoRng, Rng};
 use std::sync::Arc;
 use std::time::Duration;
+use task::ShutdownListener;
+use tokio::task::JoinHandle;

-use crate::client::replies::reply_controller;
-use crate::config;
-pub(crate) use acknowledgement_control::{AckActionSender, Action};
-
-pub(crate) mod acknowledgement_control;
-pub(crate) mod message_handler;
-pub(crate) mod real_traffic_stream;
+mod acknowledgement_control;
+mod real_traffic_stream;

 // TODO: ack_key and self_recipient shouldn't really be part of this config
 pub struct Config {
@@ -62,223 +50,133 @@ pub struct Config {

    /// Average delay an acknowledgement packet is going to get delayed at a single mixnode.
    average_ack_delay_duration: Duration,
-
-    /// Controls whether the main packet stream constantly produces packets according to the predefined
-    /// poisson distribution.
-    disable_main_poisson_packet_distribution: bool,
-
-    /// Predefined packet size used for the encapsulated messages.
-    packet_size: PacketSize,
-
-    /// Defines the minimum number of reply surbs the client would request.
-    minimum_reply_surb_request_size: u32,
-
-    /// Defines the maximum number of reply surbs the client would request.
-    maximum_reply_surb_request_size: u32,
-
-    /// Defines the maximum number of reply surbs a remote party is allowed to request from this client at once.
-    maximum_allowed_reply_surb_request_size: u32,
-
-    /// Defines maximum amount of time the client is going to wait for reply surbs before explicitly asking
-    /// for more even though in theory they wouldn't need to.
-    maximum_reply_surb_waiting_period: Duration,
-
-    /// Defines maximum amount of time given reply surb is going to be valid for.
-    /// This is going to be superseded by key rotation once implemented.
-    maximum_reply_surb_age: Duration,
-
-    /// Defines maximum amount of time given reply key is going to be valid for.
-    /// This is going to be superseded by key rotation once implemented.
-    maximum_reply_key_age: Duration,
-}
-
-impl<'a> From<&'a Config> for acknowledgement_control::Config {
-    fn from(cfg: &'a Config) -> Self {
-        acknowledgement_control::Config::new(cfg.ack_wait_addition, cfg.ack_wait_multiplier)
-            .with_custom_packet_size(cfg.packet_size)
-    }
-}
-
-impl<'a> From<&'a Config> for real_traffic_stream::Config {
-    fn from(cfg: &'a Config) -> Self {
-        real_traffic_stream::Config::new(
-            Arc::clone(&cfg.ack_key),
-            cfg.self_recipient,
-            cfg.average_ack_delay_duration,
-            cfg.average_packet_delay_duration,
-            cfg.average_message_sending_delay,
-            cfg.disable_main_poisson_packet_distribution,
-        )
-        .with_custom_cover_packet_size(cfg.packet_size)
-    }
-}
-
-impl<'a> From<&'a Config> for reply_controller::Config {
-    fn from(cfg: &'a Config) -> Self {
-        reply_controller::Config::new(
-            cfg.minimum_reply_surb_request_size,
-            cfg.maximum_reply_surb_request_size,
-            cfg.maximum_allowed_reply_surb_request_size,
-            cfg.maximum_reply_surb_waiting_period,
-            cfg.maximum_reply_surb_age,
-            cfg.maximum_reply_key_age,
-        )
-    }
-}
-
-impl<'a> From<&'a Config> for message_handler::Config {
-    fn from(cfg: &'a Config) -> Self {
-        message_handler::Config::new(
-            Arc::clone(&cfg.ack_key),
-            cfg.self_recipient,
-            cfg.average_packet_delay_duration,
-            cfg.average_ack_delay_duration,
-        )
-        .with_custom_packet_size(cfg.packet_size)
-    }
 }

 impl Config {
    pub fn new(
-        base_client_debug_config: &config::DebugConfig,
        ack_key: Arc<AckKey>,
+        ack_wait_multiplier: f64,
+        ack_wait_addition: Duration,
+        average_ack_delay_duration: Duration,
+        average_message_sending_delay: Duration,
+        average_packet_delay_duration: Duration,
        self_recipient: Recipient,
    ) -> Self {
        Config {
            ack_key,
+            ack_wait_addition,
+            ack_wait_multiplier,
            self_recipient,
-            packet_size: Default::default(),
-            ack_wait_addition: base_client_debug_config.ack_wait_addition,
-            ack_wait_multiplier: base_client_debug_config.ack_wait_multiplier,
-            average_message_sending_delay: base_client_debug_config.message_sending_average_delay,
-            average_packet_delay_duration: base_client_debug_config.average_packet_delay,
-            average_ack_delay_duration: base_client_debug_config.average_ack_delay,
-            disable_main_poisson_packet_distribution: base_client_debug_config
-                .disable_main_poisson_packet_distribution,
-            minimum_reply_surb_request_size: base_client_debug_config
-                .minimum_reply_surb_request_size,
-            maximum_reply_surb_request_size: base_client_debug_config
-                .maximum_reply_surb_request_size,
-            maximum_allowed_reply_surb_request_size: base_client_debug_config
-                .maximum_allowed_reply_surb_request_size,
-            maximum_reply_surb_waiting_period: base_client_debug_config
-                .maximum_reply_surb_waiting_period,
-            maximum_reply_surb_age: base_client_debug_config.maximum_reply_surb_age,
-            maximum_reply_key_age: base_client_debug_config.maximum_reply_key_age,
+            average_message_sending_delay,
+            average_packet_delay_duration,
+            average_ack_delay_duration,
        }
    }
-
-    pub fn set_custom_packet_size(&mut self, packet_size: PacketSize) {
-        self.packet_size = packet_size;
-    }
 }

-pub(crate) struct RealMessagesController<R>
+pub struct RealMessagesController<R>
 where
    R: CryptoRng + Rng,
 {
-    out_queue_control: OutQueueControl<R>,
-    ack_control: AcknowledgementController<R>,
-    reply_control: ReplyController<R>,
+    out_queue_control: Option<OutQueueControl<R>>,
+    ack_control: Option<AcknowledgementController<R>>,
 }

 // obviously when we finally make shared rng that is on 'higher' level, this should become
 // generic `R`
 impl RealMessagesController<OsRng> {
-    #[allow(clippy::too_many_arguments)]
-    pub(crate) fn new(
+    pub fn new(
        config: Config,
        ack_receiver: AcknowledgementReceiver,
        input_receiver: InputMessageReceiver,
        mix_sender: BatchMixMessageSender,
        topology_access: TopologyAccessor,
-        reply_storage: CombinedReplyStorage,
-        // so much refactoring needed, but this is temporary just to test things out
-        reply_controller_sender: ReplyControllerSender,
-        reply_controller_receiver: ReplyControllerReceiver,
-        lane_queue_lengths: LaneQueueLengths,
-        client_connection_rx: ConnectionCommandReceiver,
+        reply_key_storage: ReplyKeyStorage,
+        shutdown: ShutdownListener,
    ) -> Self {
        let rng = OsRng;

-        // create channels for inter-task communication
-        let (real_message_sender, real_message_receiver) = tokio::sync::mpsc::channel(1);
+        let (real_message_sender, real_message_receiver) = mpsc::unbounded();
        let (sent_notifier_tx, sent_notifier_rx) = mpsc::unbounded();
-        let (ack_action_tx, ack_action_rx) = mpsc::unbounded();
+
        let ack_controller_connectors = AcknowledgementControllerConnectors::new(
+            real_message_sender,
            input_receiver,
            sent_notifier_rx,
            ack_receiver,
-            ack_action_tx.clone(),
-            ack_action_rx,
        );

-        // create all configs for the components
-        let ack_control_config = (&config).into();
-        let out_queue_config = (&config).into();
-        let reply_controller_config = (&config).into();
-        let message_handler_config = (&config).into();
-
-        // create the actual components
-        let message_handler = MessageHandler::new(
-            message_handler_config,
-            rng,
-            ack_action_tx,
-            real_message_sender,
-            topology_access.clone(),
-            reply_storage.key_storage(),
-            reply_storage.tags_storage(),
+        let ack_control_config = acknowledgement_control::Config::new(
+            config.ack_wait_addition,
+            config.ack_wait_multiplier,
+            config.average_ack_delay_duration,
+            config.average_packet_delay_duration,
        );

        let ack_control = AcknowledgementController::new(
            ack_control_config,
+            rng,
+            topology_access.clone(),
            Arc::clone(&config.ack_key),
+            config.self_recipient,
+            reply_key_storage,
            ack_controller_connectors,
-            message_handler.clone(),
-            reply_controller_sender,
+            shutdown.clone(),
        );

-        let reply_control = ReplyController::new(
-            reply_controller_config,
-            message_handler,
-            reply_storage,
-            reply_controller_receiver,
+        let out_queue_config = real_traffic_stream::Config::new(
+            config.average_ack_delay_duration,
+            config.average_packet_delay_duration,
+            config.average_message_sending_delay,
        );

        let out_queue_control = OutQueueControl::new(
            out_queue_config,
-            rng,
+            Arc::clone(&config.ack_key),
            sent_notifier_tx,
            mix_sender,
            real_message_receiver,
+            rng,
+            config.self_recipient,
            topology_access,
-            lane_queue_lengths,
-            client_connection_rx,
+            shutdown,
        );

        RealMessagesController {
-            out_queue_control,
-            ack_control,
-            reply_control,
+            out_queue_control: Some(out_queue_control),
+            ack_control: Some(ack_control),
        }
    }

-    pub fn start_with_shutdown(self, shutdown: task::TaskClient) {
-        let mut out_queue_control = self.out_queue_control;
-        let ack_control = self.ack_control;
-        let mut reply_control = self.reply_control;
+    pub(super) async fn run(&mut self) {
+        let mut out_queue_control = self.out_queue_control.take().unwrap();
+        let mut ack_control = self.ack_control.take().unwrap();

-        let shutdown_handle = shutdown.clone();
-        spawn_future(async move {
-            out_queue_control.run_with_shutdown(shutdown_handle).await;
+        // the below are log messages are errors as at the current stage we do not expect any of
+        // the task to ever finish. This will of course change once we introduce
+        // graceful shutdowns.
+        let out_queue_control_fut = tokio::spawn(async move {
+            out_queue_control.run_out_queue_control().await;
            debug!("The out queue controller has finished execution!");
+            out_queue_control
        });
-        let shutdown_handle = shutdown.clone();
-        spawn_future(async move {
-            reply_control.run_with_shutdown(shutdown_handle).await;
-            debug!("The reply controller has finished execution!");
+        let ack_control_fut = tokio::spawn(async move {
+            ack_control.run().await;
+            debug!("The acknowledgement controller has finished execution!");
+            ack_control
        });

-        ack_control.start_with_shutdown(shutdown);
+        // technically we don't have to bring `RealMessagesController` back to a valid state
+        // but we can do it, so why not? Perhaps it might be useful if we wanted to allow
+        // for restarts of certain modules without killing the entire process.
+        self.out_queue_control = Some(out_queue_control_fut.await.unwrap());
+        self.ack_control = Some(ack_control_fut.await.unwrap());
+    }
+
+    pub fn start(mut self) -> JoinHandle<Self> {
+        tokio::spawn(async move {
+            self.run().await;
+            self
+        })
    }
 }
@@ -1,14 +1,10 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use self::sending_delay_controller::SendingDelayController;
 use crate::client::mix_traffic::BatchMixMessageSender;
 use crate::client::real_messages_control::acknowledgement_control::SentPacketNotificationSender;
 use crate::client::topology_control::TopologyAccessor;
-use crate::client::transmission_buffer::TransmissionBuffer;
-use client_connections::{
-    ConnectionCommand, ConnectionCommandReceiver, ConnectionId, LaneQueueLengths, TransmissionLane,
-};
+use futures::channel::mpsc;
 use futures::task::{Context, Poll};
 use futures::{Future, Stream, StreamExt};
 use log::*;
@@ -17,30 +13,17 @@ use nymsphinx::addressing::clients::Recipient;
 use nymsphinx::chunking::fragment::FragmentIdentifier;
 use nymsphinx::cover::generate_loop_cover_packet;
 use nymsphinx::forwarding::packet::MixPacket;
-use nymsphinx::params::PacketSize;
-use nymsphinx::preparer::PreparedFragment;
 use nymsphinx::utils::sample_poisson_duration;
 use rand::{CryptoRng, Rng};
+use std::collections::VecDeque;
 use std::pin::Pin;
 use std::sync::Arc;
 use std::time::Duration;
-
-#[cfg(not(target_arch = "wasm32"))]
+use task::ShutdownListener;
 use tokio::time;

-#[cfg(target_arch = "wasm32")]
-use wasm_timer;
-
-mod sending_delay_controller;
-
 /// Configurable parameters of the `OutQueueControl`
 pub(crate) struct Config {
-    /// Key used to encrypt and decrypt content of an ACK packet.
-    ack_key: Arc<AckKey>,
-
-    /// Represents full address of this client.
-    our_full_destination: Recipient,
-
    /// Average delay an acknowledgement packet is going to get delay at a single mixnode.
    average_ack_delay: Duration,

@@ -49,39 +32,20 @@ pub(crate) struct Config {

    /// Average delay between sending subsequent packets.
    average_message_sending_delay: Duration,
-
-    /// Controls whether the stream constantly produces packets according to the predefined
-    /// poisson distribution.
-    disable_poisson_packet_distribution: bool,
-
-    /// Predefined packet size used for the loop cover messages.
-    cover_packet_size: PacketSize,
 }

 impl Config {
    pub(crate) fn new(
-        ack_key: Arc<AckKey>,
-        our_full_destination: Recipient,
        average_ack_delay: Duration,
        average_packet_delay: Duration,
        average_message_sending_delay: Duration,
-        disable_poisson_packet_distribution: bool,
    ) -> Self {
        Config {
-            ack_key,
-            our_full_destination,
            average_ack_delay,
            average_packet_delay,
            average_message_sending_delay,
-            disable_poisson_packet_distribution,
-            cover_packet_size: Default::default(),
        }
    }
-
-    pub fn with_custom_cover_packet_size(mut self, packet_size: PacketSize) -> Self {
-        self.cover_packet_size = packet_size;
-        self
-    }
 }

 pub(crate) struct OutQueueControl<R>
@@ -91,20 +55,15 @@ where
    /// Configurable parameters of the `ActionController`
    config: Config,

+    /// Key used to encrypt and decrypt content of an ACK packet.
+    ack_key: Arc<AckKey>,
+
    /// Channel used for notifying of a real packet being sent out. Used to start up retransmission timer.
    sent_notifier: SentPacketNotificationSender,

    /// Internal state, determined by `average_message_sending_delay`,
    /// used to keep track of when a next packet should be sent out.
-    #[cfg(not(target_arch = "wasm32"))]
-    next_delay: Option<Pin<Box<time::Sleep>>>,
-
-    #[cfg(target_arch = "wasm32")]
-    next_delay: Option<Pin<Box<wasm_timer::Delay>>>,
-
-    // To make sure we don't overload the mix_tx channel, we limit the rate we are pushing
-    // messages.
-    sending_delay_controller: SendingDelayController,
+    next_delay: Pin<Box<time::Sleep>>,

    /// Channel used for sending prepared sphinx packets to `MixTrafficController` that sends them
    /// out to the network without any further delays.
@@ -114,45 +73,28 @@ where
    /// before being sent out into the network.
    real_receiver: BatchRealMessageReceiver,

+    /// Represents full address of this client.
+    our_full_destination: Recipient,
+
    /// Instance of a cryptographically secure random number generator.
    rng: R,

    /// Accessor to the common instance of network topology.
    topology_access: TopologyAccessor,

-    /// Buffer containing all incoming real messages keyed by transmission lane, that we will send
-    /// out to the mixnet.
-    transmission_buffer: TransmissionBuffer<RealMessage>,
+    /// Buffer containing all real messages received. It is first exhausted before more are pulled.
+    received_buffer: VecDeque<RealMessage>,

-    /// Incoming channel for being notified of closed connections, so that we can close lanes
-    /// corresponding to connections. To avoid sending traffic unnecessary
-    client_connection_rx: ConnectionCommandReceiver,
-
-    /// Report queue lengths so that upstream can backoff sending data, and keep connections open.
-    lane_queue_lengths: LaneQueueLengths,
+    /// Listens for shutdown signals
+    shutdown: ShutdownListener,
 }

-#[derive(Debug)]
 pub(crate) struct RealMessage {
    mix_packet: MixPacket,
    fragment_id: FragmentIdentifier,
-    // TODO: add info about it being constructed with reply-surb
-}
-
-impl From<PreparedFragment> for RealMessage {
-    fn from(fragment: PreparedFragment) -> Self {
-        RealMessage {
-            mix_packet: fragment.mix_packet,
-            fragment_id: fragment.fragment_identifier,
-        }
-    }
 }

 impl RealMessage {
-    pub(crate) fn packet_size(&self) -> usize {
-        self.mix_packet.sphinx_packet().len()
-    }
-
    pub(crate) fn new(mix_packet: MixPacket, fragment_id: FragmentIdentifier) -> Self {
        RealMessage {
            mix_packet,
@@ -163,15 +105,63 @@ impl RealMessage {

 // messages are already prepared, etc. the real point of it is to forward it to mix_traffic
 // after sufficient delay
-pub(crate) type BatchRealMessageSender =
-    tokio::sync::mpsc::Sender<(Vec<RealMessage>, TransmissionLane)>;
-type BatchRealMessageReceiver = tokio::sync::mpsc::Receiver<(Vec<RealMessage>, TransmissionLane)>;
+pub(crate) type BatchRealMessageSender = mpsc::UnboundedSender<Vec<RealMessage>>;
+type BatchRealMessageReceiver = mpsc::UnboundedReceiver<Vec<RealMessage>>;

 pub(crate) enum StreamMessage {
    Cover,
    Real(Box<RealMessage>),
 }

+impl<R> Stream for OutQueueControl<R>
+where
+    R: CryptoRng + Rng + Unpin,
+{
+    type Item = StreamMessage;
+
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        // it is not yet time to return a message
+        if self.next_delay.as_mut().poll(cx).is_pending() {
+            return Poll::Pending;
+        };
+
+        // we know it's time to send a message, so let's prepare delay for the next one
+        // Get the `now` by looking at the current `delay` deadline
+        let avg_delay = self.config.average_message_sending_delay;
+        let now = self.next_delay.deadline();
+        let next_poisson_delay = sample_poisson_duration(&mut self.rng, avg_delay);
+
+        // The next interval value is `next_poisson_delay` after the one that just
+        // yielded.
+        let next = now + next_poisson_delay;
+        self.next_delay.as_mut().reset(next);
+
+        // check if we have anything immediately available
+        if let Some(real_available) = self.received_buffer.pop_front() {
+            return Poll::Ready(Some(StreamMessage::Real(Box::new(real_available))));
+        }
+
+        // decide what kind of message to send
+        match Pin::new(&mut self.real_receiver).poll_next(cx) {
+            // in the case our real message channel stream was closed, we should also indicate we are closed
+            // (and whoever is using the stream should panic)
+            Poll::Ready(None) => Poll::Ready(None),
+
+            // if there are more messages available, return first one and store the rest
+            Poll::Ready(Some(real_messages)) => {
+                self.received_buffer = real_messages.into();
+                // we MUST HAVE received at least ONE message
+                Poll::Ready(Some(StreamMessage::Real(Box::new(
+                    self.received_buffer.pop_front().unwrap(),
+                ))))
+            }
+
+            // otherwise construct a dummy one
+            Poll::Pending => Poll::Ready(Some(StreamMessage::Cover)),
+        }
+    }
+}
+
 impl<R> OutQueueControl<R>
 where
    R: CryptoRng + Rng + Unpin,
@@ -181,26 +171,27 @@ where
    #[allow(clippy::too_many_arguments)]
    pub(crate) fn new(
        config: Config,
-        rng: R,
+        ack_key: Arc<AckKey>,
        sent_notifier: SentPacketNotificationSender,
        mix_tx: BatchMixMessageSender,
        real_receiver: BatchRealMessageReceiver,
+        rng: R,
+        our_full_destination: Recipient,
        topology_access: TopologyAccessor,
-        lane_queue_lengths: LaneQueueLengths,
-        client_connection_rx: ConnectionCommandReceiver,
+        shutdown: ShutdownListener,
    ) -> Self {
        OutQueueControl {
            config,
+            ack_key,
            sent_notifier,
-            next_delay: None,
-            sending_delay_controller: Default::default(),
+            next_delay: Box::pin(time::sleep(Default::default())),
            mix_tx,
            real_receiver,
+            our_full_destination,
            rng,
            topology_access,
-            transmission_buffer: TransmissionBuffer::new(),
-            client_connection_rx,
-            lane_queue_lengths,
+            received_buffer: VecDeque::with_capacity(0), // we won't be putting any data into this guy directly
+            shutdown,
        }
    }

@@ -215,359 +206,95 @@ where
    async fn on_message(&mut self, next_message: StreamMessage) {
        trace!("created new message");

-        let (next_message, fragment_id) = match next_message {
+        let next_message = match next_message {
            StreamMessage::Cover => {
                // TODO for way down the line: in very rare cases (during topology update) we might have
                // to wait a really tiny bit before actually obtaining the permit hence messing with our
                // poisson delay, but is it really a problem?
                let topology_permit = self.topology_access.get_read_permit().await;
                // the ack is sent back to ourselves (and then ignored)
-                let topology_ref = match topology_permit.try_get_valid_topology_ref(
-                    &self.config.our_full_destination,
-                    Some(&self.config.our_full_destination),
-                ) {
-                    Ok(topology) => topology,
-                    Err(err) => {
-                        warn!("We're not going to send any loop cover message this time, as the current topology seem to be invalid - {err}");
-                        return;
-                    }
-                };
+                let topology_ref_option = topology_permit.try_get_valid_topology_ref(
+                    &self.our_full_destination,
+                    Some(&self.our_full_destination),
+                );
+                if topology_ref_option.is_none() {
+                    warn!(
+                        "No valid topology detected - won't send any loop cover message this time"
+                    );
+                    return;
+                }
+                let topology_ref = topology_ref_option.unwrap();

-                (
-                    generate_loop_cover_packet(
-                        &mut self.rng,
-                        topology_ref,
-                        &self.config.ack_key,
-                        &self.config.our_full_destination,
-                        self.config.average_ack_delay,
-                        self.config.average_packet_delay,
-                        self.config.cover_packet_size,
-                    )
-                    .expect(
-                        "Somehow failed to generate a loop cover message with a valid topology",
-                    ),
-                    None,
+                generate_loop_cover_packet(
+                    &mut self.rng,
+                    topology_ref,
+                    &*self.ack_key,
+                    &self.our_full_destination,
+                    self.config.average_ack_delay,
+                    self.config.average_packet_delay,
                )
+                .expect("Somehow failed to generate a loop cover message with a valid topology")
            }
            StreamMessage::Real(real_message) => {
-                (real_message.mix_packet, Some(real_message.fragment_id))
+                self.sent_notify(real_message.fragment_id);
+                real_message.mix_packet
            }
        };

-        if let Err(err) = self.mix_tx.send(vec![next_message]).await {
-            log::error!("Failed to send: {err}");
+        // if this one fails, there's no retrying because it means that either:
+        // - we run out of memory
+        // - the receiver channel is closed
+        // in either case there's no recovery and we can only panic
+        if let Err(err) = self.mix_tx.unbounded_send(vec![next_message]) {
+            if self.shutdown.is_shutdown_poll() {
+                log::info!("Failed to send (shutdown detected)");
+            } else {
+                // We don't try to limp along, panic to avoid continuing in a potentially
+                // inconsistent state
+                panic!("{err}");
+            }
        }

-        // notify ack controller about sending our message only after we actually managed to push it
-        // through the channel
-        if let Some(fragment_id) = fragment_id {
-            self.sent_notify(fragment_id);
-        }
-
-        // In addition to closing connections on receiving messages throught client_connection_rx,
-        // also close connections when sufficiently stale.
-        self.transmission_buffer.prune_stale_connections();
-
        // JS: Not entirely sure why or how it fixes stuff, but without the yield call,
        // the UnboundedReceiver [of mix_rx] will not get a chance to read anything
        // JS2: Basically it was the case that with high enough rate, the stream had already a next value
        // ready and hence was immediately re-scheduled causing other tasks to be starved;
        // yield makes it go back the scheduling queue regardless of its value availability
-
-        // TODO: temporary and BAD workaround for wasm (we should find a way to yield here in wasm)
-        #[cfg(not(target_arch = "wasm32"))]
        tokio::task::yield_now().await;
    }

-    fn on_close_connection(&mut self, connection_id: ConnectionId) {
-        log::debug!("Removing lane for connection: {connection_id}");
-        self.transmission_buffer
-            .remove(&TransmissionLane::ConnectionId(connection_id));
-    }
+    // Send messages at certain rate and if no real traffic is available, send cover message.
+    async fn run_normal_out_queue(&mut self) {
+        // we should set initial delay only when we actually start the stream
+        self.next_delay = Box::pin(time::sleep(sample_poisson_duration(
+            &mut self.rng,
+            self.config.average_message_sending_delay,
+        )));

-    fn current_average_message_sending_delay(&self) -> Duration {
-        self.config.average_message_sending_delay
-            * self.sending_delay_controller.current_multiplier()
-    }
-
-    fn adjust_current_average_message_sending_delay(&mut self) {
-        let used_slots = self.mix_tx.max_capacity() - self.mix_tx.capacity();
-        log::trace!(
-            "used_slots: {used_slots}, current_multiplier: {}",
-            self.sending_delay_controller.current_multiplier()
-        );
-
-        // Even just a single used slot is enough to signal backpressure
-        if used_slots > 0 {
-            log::trace!("Backpressure detected");
-            self.sending_delay_controller.record_backpressure_detected();
-        }
-
-        // If the buffer is running out, slow down the sending rate
-        if self.mix_tx.capacity() == 0
-            && self.sending_delay_controller.not_increased_delay_recently()
-        {
-            self.sending_delay_controller.increase_delay_multiplier();
-        }
-
-        // Very carefully step up the sending rate in case it seems like we can solidly handle the
-        // current rate.
-        if self.sending_delay_controller.is_sending_reliable() {
-            self.sending_delay_controller.decrease_delay_multiplier();
-        }
-    }
-
-    fn pop_next_message(&mut self) -> Option<RealMessage> {
-        // Pop the next message from the transmission buffer
-        let (lane, real_next) = self
-            .transmission_buffer
-            .pop_next_message_at_random(&mut self.rng)?;
-
-        // Update the published queue length
-        let lane_length = self.transmission_buffer.lane_length(&lane);
-        self.lane_queue_lengths.set(&lane, lane_length);
-
-        Some(real_next)
-    }
-
-    fn poll_poisson(&mut self, cx: &mut Context<'_>) -> Poll<Option<StreamMessage>> {
-        // The average delay could change depending on if backpressure in the downstream channel
-        // (mix_tx) was detected.
-        self.adjust_current_average_message_sending_delay();
-        let avg_delay = self.current_average_message_sending_delay();
-
-        // Start by checking if we have any incoming messages about closed connections
-        // NOTE: this feels a bit iffy, the `OutQueueControl` is getting ripe for a rewrite to
-        // something simpler.
-        if let Poll::Ready(Some(id)) = Pin::new(&mut self.client_connection_rx).poll_next(cx) {
-            match id {
-                ConnectionCommand::Close(id) => self.on_close_connection(id),
-                ConnectionCommand::ActiveConnections(_) => panic!(),
-            }
-        }
-
-        if let Some(ref mut next_delay) = &mut self.next_delay {
-            // it is not yet time to return a message
-            if next_delay.as_mut().poll(cx).is_pending() {
-                return Poll::Pending;
-            };
-
-            // we know it's time to send a message, so let's prepare delay for the next one
-            // Get the `now` by looking at the current `delay` deadline
-            let next_poisson_delay = sample_poisson_duration(&mut self.rng, avg_delay);
-
-            // The next interval value is `next_poisson_delay` after the one that just
-            // yielded.
-            #[cfg(not(target_arch = "wasm32"))]
-            {
-                let now = next_delay.deadline();
-                let next = now + next_poisson_delay;
-                next_delay.as_mut().reset(next);
-            }
-
-            #[cfg(target_arch = "wasm32")]
-            {
-                next_delay.as_mut().reset(next_poisson_delay);
-            }
-
-            // On every iteration we get new messages from upstream. Given that these come bunched
-            // in `Vec`, this ensures that on average we will fetch messages faster than we can
-            // send, which is a condition for being able to multiplex sphinx packets from multiple
-            // data streams.
-            match Pin::new(&mut self.real_receiver).poll_recv(cx) {
-                // in the case our real message channel stream was closed, we should also indicate we are closed
-                // (and whoever is using the stream should panic)
-                Poll::Ready(None) => Poll::Ready(None),
-
-                Poll::Ready(Some((real_messages, conn_id))) => {
-                    log::trace!("handling real_messages: size: {}", real_messages.len());
-
-                    self.transmission_buffer.store(&conn_id, real_messages);
-                    let real_next = self.pop_next_message().expect("Just stored one");
-
-                    Poll::Ready(Some(StreamMessage::Real(Box::new(real_next))))
+        let mut shutdown = self.shutdown.clone();
+        while !shutdown.is_shutdown() {
+            tokio::select! {
+                biased;
+                _ = shutdown.recv() => {
+                    log::trace!("OutQueueControl: Received shutdown");
                }
-
-                Poll::Pending => {
-                    if let Some(real_next) = self.pop_next_message() {
-                        Poll::Ready(Some(StreamMessage::Real(Box::new(real_next))))
-                    } else {
-                        // otherwise construct a dummy one
-                        Poll::Ready(Some(StreamMessage::Cover))
-                    }
-                }
-            }
-        } else {
-            // we never set an initial delay - let's do it now
-            cx.waker().wake_by_ref();
-
-            let sampled =
-                sample_poisson_duration(&mut self.rng, self.config.average_message_sending_delay);
-
-            #[cfg(not(target_arch = "wasm32"))]
-            let next_delay = Box::pin(time::sleep(sampled));
-
-            #[cfg(target_arch = "wasm32")]
-            let next_delay = Box::pin(wasm_timer::Delay::new(sampled));
-
-            self.next_delay = Some(next_delay);
-
-            Poll::Pending
-        }
-    }
-
-    fn poll_immediate(&mut self, cx: &mut Context<'_>) -> Poll<Option<StreamMessage>> {
-        // Start by checking if we have any incoming messages about closed connections
-        if let Poll::Ready(Some(id)) = Pin::new(&mut self.client_connection_rx).poll_next(cx) {
-            match id {
-                ConnectionCommand::Close(id) => self.on_close_connection(id),
-                ConnectionCommand::ActiveConnections(_) => panic!(),
-            }
-        }
-
-        match Pin::new(&mut self.real_receiver).poll_recv(cx) {
-            // in the case our real message channel stream was closed, we should also indicate we are closed
-            // (and whoever is using the stream should panic)
-            Poll::Ready(None) => Poll::Ready(None),
-
-            Poll::Ready(Some((real_messages, conn_id))) => {
-                log::trace!("handling real_messages: size: {}", real_messages.len());
-
-                // First store what we got for the given connection id
-                self.transmission_buffer.store(&conn_id, real_messages);
-                let real_next = self.pop_next_message().expect("we just added one");
-
-                Poll::Ready(Some(StreamMessage::Real(Box::new(real_next))))
-            }
-
-            Poll::Pending => {
-                if let Some(real_next) = self.pop_next_message() {
-                    Poll::Ready(Some(StreamMessage::Real(Box::new(real_next))))
-                } else {
-                    Poll::Pending
-                }
-            }
-        }
-    }
-
-    fn poll_next_message(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<StreamMessage>> {
-        if self.config.disable_poisson_packet_distribution {
-            self.poll_immediate(cx)
-        } else {
-            self.poll_poisson(cx)
-        }
-    }
-
-    #[cfg(not(target_arch = "wasm32"))]
-    fn log_status(&self, shutdown: &mut task::TaskClient) {
-        use crate::error::ClientCoreStatusMessage;
-
-        let packets = self.transmission_buffer.total_size();
-        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 status_str = if self.config.disable_poisson_packet_distribution {
-            format!(
-                "Status: {lanes} lanes, backlog: {:.2} kiB ({packets}), no delay",
-                backlog
-            )
-        } else {
-            format!(
-                "Status: {lanes} lanes, backlog: {:.2} kiB ({packets}), avg delay: {}ms ({mult})",
-                backlog, delay
-            )
-        };
-        if packets > 1000 {
-            log::warn!("{status_str}");
-        } else if packets > 0 {
-            log::info!("{status_str}");
-        } else {
-            log::debug!("{status_str}");
-        }
-
-        // Send status message to whoever is listening (possibly UI)
-        if mult == self.sending_delay_controller.max_multiplier() {
-            shutdown.send_status_msg(Box::new(ClientCoreStatusMessage::GatewayIsVerySlow));
-        } else if mult > self.sending_delay_controller.min_multiplier() {
-            shutdown.send_status_msg(Box::new(ClientCoreStatusMessage::GatewayIsSlow));
-        }
-    }
-
-    #[cfg(not(target_arch = "wasm32"))]
-    fn log_status_infrequent(&self) {
-        if self.sending_delay_controller.current_multiplier() > 1 {
-            log::warn!(
-                "Unable to send packets at the default rate - rate reduced by setting the delay multiplier set to: {}",
-                self.sending_delay_controller.current_multiplier()
-            );
-        }
-    }
-
-    pub(super) async fn run_with_shutdown(&mut self, mut shutdown: task::TaskClient) {
-        debug!("Started OutQueueControl with graceful shutdown support");
-
-        #[cfg(not(target_arch = "wasm32"))]
-        {
-            let mut status_timer = tokio::time::interval(Duration::from_secs(5));
-            let mut infrequent_status_timer = tokio::time::interval(Duration::from_secs(60));
-
-            while !shutdown.is_shutdown() {
-                tokio::select! {
-                    biased;
-                    _ = shutdown.recv_with_delay() => {
-                        log::trace!("OutQueueControl: Received shutdown");
-                    }
-                    _ = status_timer.tick() => {
-                        self.log_status(&mut shutdown);
-                    }
-                    _ = infrequent_status_timer.tick() => {
-                        self.log_status_infrequent();
-                    }
-                    next_message = self.next() => if let Some(next_message) = next_message {
+                next_message = self.next() => match next_message {
+                    Some(next_message) => {
                        self.on_message(next_message).await;
-                    } else {
-                        log::trace!("OutQueueControl: Stopping since channel closed");
-                        break;
-                    }
-                }
-            }
-            tokio::time::timeout(Duration::from_secs(5), shutdown.recv())
-                .await
-                .expect("Task stopped without shutdown called");
-        }
-
-        #[cfg(target_arch = "wasm32")]
-        {
-            while !shutdown.is_shutdown() {
-                tokio::select! {
-                    biased;
-                    _ = shutdown.recv() => {
-                        log::trace!("OutQueueControl: Received shutdown");
-                    }
-                    next_message = self.next() => if let Some(next_message) = next_message {
-                        self.on_message(next_message).await;
-                    } else {
+                    },
+                    None => {
                        log::trace!("OutQueueControl: Stopping since channel closed");
                        break;
                    }
                }
            }
        }
+        assert!(shutdown.is_shutdown_poll());
        log::debug!("OutQueueControl: Exiting");
    }
-}

-impl<R> Stream for OutQueueControl<R>
-where
-    R: CryptoRng + Rng + Unpin,
-{
-    type Item = StreamMessage;
-
-    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        self.poll_next_message(cx)
+    pub(crate) async fn run_out_queue_control(&mut self) {
+        debug!("Starting out queue controller...");
+        self.run_normal_out_queue().await
    }
 }
@@ -1,121 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::client::helpers::{get_time_now, Instant};
-use std::time::Duration;
-
-// The minimum time between increasing the average delay between packets. If we hit the ceiling in
-// the available buffer space we want to take somewhat swift action, but we still need to give a
-// short time to give the channel a chance reduce pressure.
-const INCREASE_DELAY_MIN_CHANGE_INTERVAL_SECS: u64 = 1;
-// The minimum time between decreasing the average delay between packets. We don't want to change
-// to quickly to keep things somewhat stable. Also there are buffers downstreams meaning we need to
-// wait a little to see the effect before we decrease further.
-const DECREASE_DELAY_MIN_CHANGE_INTERVAL_SECS: u64 = 30;
-// If we enough time passes without any sign of backpressure in the channel, we can consider
-// lowering the average delay. The goal is to keep somewhat stable, rather than maxing out
-// bandwidth at all times.
-const ACCEPTABLE_TIME_WITHOUT_BACKPRESSURE_SECS: u64 = 30;
-// The maximum multiplier we apply to the base average Poisson delay.
-const MAX_DELAY_MULTIPLIER: u32 = 6;
-// The minium multiplier we apply to the base average Poisson delay.
-const MIN_DELAY_MULTIPLIER: u32 = 1;
-
-pub(crate) struct SendingDelayController {
-    /// Multiply the average sending delay.
-    /// This is normally set to unity, but if we detect backpressure we increase this
-    /// multiplier. We use discrete steps.
-    current_multiplier: u32,
-
-    /// Maximum delay multiplier
-    upper_bound: u32,
-
-    /// Minimum delay multiplier
-    lower_bound: u32,
-
-    /// To make sure we don't change the multiplier to fast, we limit a change to some duration
-    time_when_changed: Instant,
-
-    /// If we have a long enough time without any backpressure detected we try reducing the sending
-    /// delay multiplier
-    time_when_backpressure_detected: Instant,
-}
-
-impl Default for SendingDelayController {
-    fn default() -> Self {
-        SendingDelayController::new(MIN_DELAY_MULTIPLIER, MAX_DELAY_MULTIPLIER)
-    }
-}
-
-impl SendingDelayController {
-    pub(crate) fn new(lower_bound: u32, upper_bound: u32) -> Self {
-        assert!(lower_bound <= upper_bound);
-        let now = get_time_now();
-        SendingDelayController {
-            current_multiplier: MIN_DELAY_MULTIPLIER,
-            upper_bound,
-            lower_bound,
-            time_when_changed: now,
-            time_when_backpressure_detected: now,
-        }
-    }
-
-    pub(crate) fn current_multiplier(&self) -> u32 {
-        self.current_multiplier
-    }
-
-    #[cfg(not(target_arch = "wasm32"))]
-    pub(crate) fn min_multiplier(&self) -> u32 {
-        self.lower_bound
-    }
-
-    #[cfg(not(target_arch = "wasm32"))]
-    pub(crate) fn max_multiplier(&self) -> u32 {
-        self.upper_bound
-    }
-
-    pub(crate) fn increase_delay_multiplier(&mut self) {
-        if self.current_multiplier < self.upper_bound {
-            self.current_multiplier =
-                (self.current_multiplier + 1).clamp(self.lower_bound, self.upper_bound);
-            self.time_when_changed = get_time_now();
-            log::warn!(
-                "Increasing sending delay multiplier to: {}",
-                self.current_multiplier
-            );
-        } else {
-            log::warn!("Trying to increase delay multipler higher than allowed");
-        }
-    }
-
-    pub(crate) fn decrease_delay_multiplier(&mut self) {
-        if self.current_multiplier > self.lower_bound {
-            self.current_multiplier =
-                (self.current_multiplier - 1).clamp(self.lower_bound, self.upper_bound);
-            self.time_when_changed = get_time_now();
-            log::debug!(
-                "Decreasing sending delay multiplier to: {}",
-                self.current_multiplier
-            );
-        }
-    }
-
-    pub(crate) fn record_backpressure_detected(&mut self) {
-        self.time_when_backpressure_detected = get_time_now();
-    }
-
-    pub(crate) fn not_increased_delay_recently(&self) -> bool {
-        get_time_now()
-            > self.time_when_changed + Duration::from_secs(INCREASE_DELAY_MIN_CHANGE_INTERVAL_SECS)
-    }
-
-    pub(crate) fn is_sending_reliable(&self) -> bool {
-        let now = get_time_now();
-        let delay_change_interval = Duration::from_secs(DECREASE_DELAY_MIN_CHANGE_INTERVAL_SECS);
-        let acceptable_time_without_backpressure =
-            Duration::from_secs(ACCEPTABLE_TIME_WITHOUT_BACKPRESSURE_SECS);
-
-        now > self.time_when_backpressure_detected + acceptable_time_without_backpressure
-            && now > self.time_when_changed + delay_change_interval
-    }
-}
@@ -1,25 +1,24 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::client::replies::reply_controller::ReplyControllerSender;
-use crate::client::replies::reply_storage::SentReplyKeys;
-use crate::spawn_future;
+use crate::client::reply_key_storage::ReplyKeyStorage;
+use crate::client::SHUTDOWN_HAS_BEEN_SIGNALLED;
 use crypto::asymmetric::encryption;
+use crypto::symmetric::stream_cipher;
 use crypto::Digest;
 use futures::channel::mpsc;
 use futures::lock::Mutex;
 use futures::StreamExt;
 use gateway_client::MixnetMessageReceiver;
 use log::*;
-use nymsphinx::anonymous_replies::requests::{
-    RepliableMessage, RepliableMessageContent, ReplyMessage, ReplyMessageContent,
-};
 use nymsphinx::anonymous_replies::{encryption_key::EncryptionKeyDigest, SurbEncryptionKey};
-use nymsphinx::message::{NymMessage, PlainMessage};
-use nymsphinx::params::ReplySurbKeyDigestAlgorithm;
+use nymsphinx::params::{ReplySurbEncryptionAlgorithm, ReplySurbKeyDigestAlgorithm};
 use nymsphinx::receiver::{MessageReceiver, MessageRecoveryError, ReconstructedMessage};
 use std::collections::HashSet;
+use std::sync::atomic::Ordering;
 use std::sync::Arc;
+use task::ShutdownListener;
+use tokio::task::JoinHandle;

 // Buffer Requests to say "hey, send any reconstructed messages to this channel"
 // or to say "hey, I'm going offline, don't send anything more to me. Just buffer them instead"
@@ -46,15 +45,26 @@ struct ReceivedMessagesBufferInner {
 }

 impl ReceivedMessagesBufferInner {
-    fn recover_from_fragment(&mut self, fragment_data: &[u8]) -> Option<NymMessage> {
-        if nymsphinx::cover::is_cover(fragment_data) {
+    fn process_received_fragment(&mut self, raw_fragment: Vec<u8>) -> Option<ReconstructedMessage> {
+        let fragment_data = match self
+            .message_receiver
+            .recover_plaintext(self.local_encryption_keypair.private_key(), raw_fragment)
+        {
+            Err(e) => {
+                warn!("failed to recover fragment data: {:?}. The whole underlying message might be corrupted and unrecoverable!", e);
+                return None;
+            }
+            Ok(frag_data) => frag_data,
+        };
+
+        if nymsphinx::cover::is_cover(&fragment_data) {
            trace!("The message was a loop cover message! Skipping it");
            return None;
        }

-        let fragment = match self.message_receiver.recover_fragment(fragment_data) {
-            Err(err) => {
-                warn!("failed to recover fragment from raw data: {err}. The whole underlying message might be corrupted and unrecoverable!");
+        let fragment = match self.message_receiver.recover_fragment(&fragment_data) {
+            Err(e) => {
+                warn!("failed to recover fragment from raw data: {:?}. The whole underlying message might be corrupted and unrecoverable!", e);
                return None;
            }
            Ok(frag) => frag,
@@ -68,10 +78,9 @@ impl ReceivedMessagesBufferInner {
        // if we returned an error the underlying message is malformed in some way
        match self.message_receiver.insert_new_fragment(fragment) {
            Err(err) => match err {
-                MessageRecoveryError::MalformedReconstructedMessage { source, used_sets } => {
-                    error!("message reconstruction failed - {source}. Attempting to re-use the message sets...");
+                MessageRecoveryError::MalformedReconstructedMessage(message_sets) => {
                    // TODO: should we really insert reconstructed sets? could this be abused for some attack?
-                    for set_id in used_sets {
+                    for set_id in message_sets {
                        if !self.recently_reconstructed.insert(set_id) {
                            // or perhaps we should even panic at this point?
                            error!("Reconstructed another message containing already used set id!")
@@ -97,34 +106,6 @@ impl ReceivedMessagesBufferInner {
            },
        }
    }
-
-    fn process_received_reply(
-        &mut self,
-        reply_ciphertext: &mut [u8],
-        reply_key: SurbEncryptionKey,
-    ) -> Option<NymMessage> {
-        // note: this performs decryption IN PLACE without extra allocation
-        self.message_receiver
-            .recover_plaintext_from_reply(reply_ciphertext, reply_key);
-        let fragment_data = reply_ciphertext;
-
-        self.recover_from_fragment(fragment_data)
-    }
-
-    fn process_received_regular_packet(&mut self, mut raw_fragment: Vec<u8>) -> Option<NymMessage> {
-        let fragment_data = match self.message_receiver.recover_plaintext_from_regular_packet(
-            self.local_encryption_keypair.private_key(),
-            &mut raw_fragment,
-        ) {
-            Err(err) => {
-                warn!("failed to recover fragment data: {err}. The whole underlying message might be corrupted and unrecoverable!");
-                return None;
-            }
-            Ok(frag_data) => frag_data,
-        };
-
-        self.recover_from_fragment(fragment_data)
-    }
 }

 #[derive(Debug, Clone)]
@@ -132,15 +113,16 @@ impl ReceivedMessagesBufferInner {
 // You should always use .clone() to create additional instances
 struct ReceivedMessagesBuffer {
    inner: Arc<Mutex<ReceivedMessagesBufferInner>>,
-    reply_key_storage: SentReplyKeys,
-    reply_controller_sender: ReplyControllerSender,
+
+    /// Storage containing keys to all [`ReplySURB`]s ever sent out that we did not receive back.
+    // There's no need to put it behind a Mutex since it's already properly concurrent
+    reply_key_storage: ReplyKeyStorage,
 }

 impl ReceivedMessagesBuffer {
    fn new(
        local_encryption_keypair: Arc<encryption::KeyPair>,
-        reply_key_storage: SentReplyKeys,
-        reply_controller_sender: ReplyControllerSender,
+        reply_key_storage: ReplyKeyStorage,
    ) -> Self {
        ReceivedMessagesBuffer {
            inner: Arc::new(Mutex::new(ReceivedMessagesBufferInner {
@@ -151,7 +133,6 @@ impl ReceivedMessagesBuffer {
                recently_reconstructed: HashSet::new(),
            })),
            reply_key_storage,
-            reply_controller_sender,
        }
    }

@@ -193,143 +174,37 @@ impl ReceivedMessagesBuffer {
        guard.message_sender = Some(sender);
    }

-    fn handle_reconstructed_plain_messages(
-        &mut self,
-        msgs: Vec<PlainMessage>,
-    ) -> Vec<ReconstructedMessage> {
-        msgs.into_iter().map(Into::into).collect()
+    async fn add_reconstructed_messages(&mut self, msgs: Vec<ReconstructedMessage>) {
+        debug!("Adding {:?} new messages to the buffer!", msgs.len());
+        trace!("Adding new messages to the buffer! {:?}", msgs);
+        self.inner.lock().await.messages.extend(msgs)
    }

-    fn handle_reconstructed_repliable_messages(
-        &mut self,
-        msgs: Vec<RepliableMessage>,
-    ) -> Vec<ReconstructedMessage> {
-        let mut reconstructed = Vec::new();
-        for msg in msgs {
-            let (reply_surbs, from_surb_request) = match msg.content {
-                RepliableMessageContent::Data {
-                    message,
-                    reply_surbs,
-                } => {
-                    trace!(
-                        "received message that also contained additional {} reply surbs from {:?}!",
-                        reply_surbs.len(),
-                        msg.sender_tag
-                    );
+    fn process_received_reply(
+        reply_ciphertext: &[u8],
+        reply_key: SurbEncryptionKey,
+    ) -> Option<ReconstructedMessage> {
+        let zero_iv = stream_cipher::zero_iv::<ReplySurbEncryptionAlgorithm>();

-                    reconstructed.push(ReconstructedMessage::new(message, msg.sender_tag));
-
-                    (reply_surbs, false)
-                }
-                RepliableMessageContent::AdditionalSurbs { reply_surbs } => {
-                    trace!(
-                        "received additional {} reply surbs from {:?}!",
-                        reply_surbs.len(),
-                        msg.sender_tag
-                    );
-                    (reply_surbs, true)
-                }
-                RepliableMessageContent::Heartbeat {
-                    additional_reply_surbs,
-                } => {
-                    error!("received a repliable heartbeat message - we don't know how to handle it yet (and we won't know until future PRs)");
-                    (additional_reply_surbs, false)
-                }
-            };
-
-            self.reply_controller_sender.send_additional_surbs(
-                msg.sender_tag,
-                reply_surbs,
-                from_surb_request,
-            )
-        }
-        reconstructed
-    }
-
-    fn handle_reconstructed_reply_messages(
-        &mut self,
-        msgs: Vec<ReplyMessage>,
-    ) -> Vec<ReconstructedMessage> {
-        let mut reconstructed = Vec::new();
-        for msg in msgs {
-            match msg.content {
-                ReplyMessageContent::Data { message } => reconstructed.push(message.into()),
-                ReplyMessageContent::SurbRequest { recipient, amount } => {
-                    debug!("received request for {amount} additional reply SURBs from {recipient}");
-                    self.reply_controller_sender
-                        .send_additional_surbs_request(*recipient, amount);
-                }
-            }
-        }
-        reconstructed
-    }
-
-    async fn handle_reconstructed_messages(&mut self, msgs: Vec<NymMessage>) {
-        if msgs.is_empty() {
-            return;
-        }
-
-        let mut plain_messages = Vec::new();
-        let mut repliable_messages = Vec::new();
-        let mut reply_messages = Vec::new();
-
-        for msg in msgs {
-            match msg {
-                NymMessage::Plain(plain) => plain_messages.push(plain),
-                NymMessage::Repliable(repliable) => repliable_messages.push(repliable),
-                NymMessage::Reply(reply) => reply_messages.push(reply),
-            }
-        }
-
-        let mut reconstructed_messages = self.handle_reconstructed_plain_messages(plain_messages);
-        reconstructed_messages
-            .append(&mut self.handle_reconstructed_repliable_messages(repliable_messages));
-        reconstructed_messages
-            .append(&mut self.handle_reconstructed_reply_messages(reply_messages));
-
-        let mut inner_guard = self.inner.lock().await;
-        debug!(
-            "Adding {:?} new messages to the buffer!",
-            reconstructed_messages.len()
+        let mut reply_msg = stream_cipher::decrypt::<ReplySurbEncryptionAlgorithm>(
+            reply_key.inner(),
+            &zero_iv,
+            reply_ciphertext,
        );
-
-        if let Some(sender) = &inner_guard.message_sender {
-            trace!("Sending reconstructed messages to announced sender");
-            if let Err(err) = sender.unbounded_send(reconstructed_messages) {
-                warn!("The reconstructed message receiver went offline without explicit notification (relevant error: - {err})");
-                inner_guard.message_sender = None;
-                inner_guard.messages.extend(err.into_inner());
-            }
+        if let Err(err) = MessageReceiver::remove_padding(&mut reply_msg) {
+            warn!("Received reply had malformed padding! - {:?}", err);
+            None
        } else {
-            trace!("No sender available - buffering reconstructed messages");
-            inner_guard.messages.extend(reconstructed_messages)
-        }
-    }
-
-    // this function doesn't really belong here...
-    fn get_reply_key<'a>(
-        &self,
-        raw_message: &'a mut [u8],
-    ) -> Option<(SurbEncryptionKey, &'a mut [u8])> {
-        let reply_surb_digest_size = ReplySurbKeyDigestAlgorithm::output_size();
-        if raw_message.len() < reply_surb_digest_size {
-            return None;
-        }
-
-        let possible_key_digest =
-            EncryptionKeyDigest::clone_from_slice(&raw_message[..reply_surb_digest_size]);
-        self.reply_key_storage
-            .try_pop(possible_key_digest)
-            .map(|reply_encryption_key| {
-                (
-                    *reply_encryption_key,
-                    &mut raw_message[reply_surb_digest_size..],
-                )
+            // TODO: perhaps having to say it doesn't have a surb an indication the type should be changed?
+            Some(ReconstructedMessage {
+                message: reply_msg,
+                reply_surb: None,
            })
+        }
    }

    async fn handle_new_received(&mut self, msgs: Vec<Vec<u8>>) {
-        trace!(
+        debug!(
            "Processing {:?} new message that might get added to the buffer!",
            msgs.len()
        );
@@ -337,28 +212,58 @@ impl ReceivedMessagesBuffer {
        let mut completed_messages = Vec::new();
        let mut inner_guard = self.inner.lock().await;

+        let reply_surb_digest_size = ReplySurbKeyDigestAlgorithm::output_size();
+
        // first check if this is a reply or a chunked message
-        // note: there's a possible information leakage associated with this check https://github.com/nymtech/nym/issues/296
-        for mut msg in msgs {
+        // TODO: verify with @AP if this way of doing it is safe or whether it could
+        // cause some attacks due to, I don't know, stupid edge case collisions?
+        // Update: this DOES introduce a possible leakage: https://github.com/nymtech/nym/issues/296
+        for msg in msgs {
+            let possible_key_digest =
+                EncryptionKeyDigest::clone_from_slice(&msg[..reply_surb_digest_size]);
+
            // check first `HasherOutputSize` bytes if they correspond to known encryption key
            // if yes - this is a reply message
-            let completed_message =
-                if let Some((reply_key, reply_message)) = self.get_reply_key(&mut msg) {
-                    inner_guard.process_received_reply(reply_message, reply_key)
-                } else {
-                    inner_guard.process_received_regular_packet(msg)
-                };

-            if let Some(completed) = completed_message {
-                info!("received {completed}");
-                completed_messages.push(completed)
+            // TODO: this might be a bottleneck - since the keys are stored on disk we, presumably,
+            // are doing a disk operation every single received fragment
+            if let Some(reply_encryption_key) = self
+                .reply_key_storage
+                .get_and_remove_encryption_key(possible_key_digest)
+                .expect("storage operation failed!")
+            {
+                if let Some(completed_message) = Self::process_received_reply(
+                    &msg[reply_surb_digest_size..],
+                    reply_encryption_key,
+                ) {
+                    completed_messages.push(completed_message)
+                }
+            } else {
+                // otherwise - it's a 'normal' message
+                if let Some(completed_message) = inner_guard.process_received_fragment(msg) {
+                    completed_messages.push(completed_message)
+                }
            }
        }

-        drop(inner_guard);
-
        if !completed_messages.is_empty() {
-            self.handle_reconstructed_messages(completed_messages).await
+            if let Some(sender) = &inner_guard.message_sender {
+                trace!("Sending reconstructed messages to announced sender");
+                if let Err(err) = sender.unbounded_send(completed_messages) {
+                    warn!("The reconstructed message receiver went offline without explicit notification (relevant error: - {:?})", err);
+                    // make sure to drop the lock to not deadlock
+                    // (it is required by `add_reconstructed_messages`)
+                    inner_guard.message_sender = None;
+                    drop(inner_guard);
+                    self.add_reconstructed_messages(err.into_inner()).await;
+                }
+            } else {
+                // make sure to drop the lock to not deadlock
+                // (it is required by `add_reconstructed_messages`)
+                drop(inner_guard);
+                trace!("No sender available - buffering reconstructed messages");
+                self.add_reconstructed_messages(completed_messages).await;
+            }
        }
    }
 }
@@ -388,118 +293,104 @@ impl RequestReceiver {
        }
    }

-    async fn handle_message(&mut self, message: ReceivedBufferMessage) {
-        match message {
-            ReceivedBufferMessage::ReceiverAnnounce(sender) => {
-                self.received_buffer.connect_sender(sender).await;
+    fn start(mut self) -> JoinHandle<()> {
+        tokio::spawn(async move {
+            loop {
+                tokio::select! {
+                    request = self.query_receiver.next() => {
+                        match request {
+                            Some(ReceivedBufferMessage::ReceiverAnnounce(sender)) => {
+                                self.received_buffer.connect_sender(sender).await;
+                            }
+                            Some(ReceivedBufferMessage::ReceiverDisconnect) => {
+                                self.received_buffer.disconnect_sender().await
+                            }
+                            None => {
+                                log::trace!("RequestReceiver: Stopping since channel closed");
+                                break;
+                            },
+                        }
+                    },
+                };
            }
-            ReceivedBufferMessage::ReceiverDisconnect => {
-                self.received_buffer.disconnect_sender().await
-            }
-        }
-    }

-    async fn run_with_shutdown(&mut self, mut shutdown: task::TaskClient) {
-        debug!("Started RequestReceiver with graceful shutdown support");
-        while !shutdown.is_shutdown() {
-            tokio::select! {
-                biased;
-                _ = shutdown.recv_with_delay() => {
-                    log::trace!("RequestReceiver: Received shutdown");
-                }
-                request = self.query_receiver.next() => {
-                    if let Some(message) = request {
-                        self.handle_message(message).await
-                    } else {
-                        log::trace!("RequestReceiver: Stopping since channel closed");
-                        break;
-                    }
-                },
-            }
-        }
-        shutdown.recv_timeout().await;
-        log::debug!("RequestReceiver: Exiting");
+            assert!(SHUTDOWN_HAS_BEEN_SIGNALLED.load(Ordering::Relaxed));
+            log::debug!("RequestReceiver: Exiting");
+        })
    }
 }

 struct FragmentedMessageReceiver {
    received_buffer: ReceivedMessagesBuffer,
    mixnet_packet_receiver: MixnetMessageReceiver,
+    shutdown: ShutdownListener,
 }

 impl FragmentedMessageReceiver {
    fn new(
        received_buffer: ReceivedMessagesBuffer,
        mixnet_packet_receiver: MixnetMessageReceiver,
+        shutdown: ShutdownListener,
    ) -> Self {
        FragmentedMessageReceiver {
            received_buffer,
            mixnet_packet_receiver,
+            shutdown,
        }
    }
-
-    async fn run_with_shutdown(&mut self, mut shutdown: task::TaskClient) {
-        debug!("Started FragmentedMessageReceiver with graceful shutdown support");
-        while !shutdown.is_shutdown() {
-            tokio::select! {
-                new_messages = self.mixnet_packet_receiver.next() => {
-                    if let Some(new_messages) = new_messages {
-                        self.received_buffer.handle_new_received(new_messages).await;
-                    } else {
-                        log::trace!("FragmentedMessageReceiver: Stopping since channel closed");
-                        break;
+    fn start(mut self) -> JoinHandle<()> {
+        tokio::spawn(async move {
+            while !self.shutdown.is_shutdown() {
+                tokio::select! {
+                    new_messages = self.mixnet_packet_receiver.next() => match new_messages {
+                        Some(new_messages) => {
+                            self.received_buffer.handle_new_received(new_messages).await;
+                        }
+                        None => {
+                            log::trace!("FragmentedMessageReceiver: Stopping since channel closed");
+                            break;
+                        }
+                    },
+                    _ = self.shutdown.recv() => {
+                        log::trace!("FragmentedMessageReceiver: Received shutdown");
                    }
-                },
-                _ = shutdown.recv_with_delay() => {
-                    log::trace!("FragmentedMessageReceiver: Received shutdown");
                }
            }
-        }
-        shutdown.recv_timeout().await;
-        log::debug!("FragmentedMessageReceiver: Exiting");
+            assert!(self.shutdown.is_shutdown_poll());
+            log::debug!("FragmentedMessageReceiver: Exiting");
+        })
    }
 }

-pub(crate) struct ReceivedMessagesBufferController {
+pub struct ReceivedMessagesBufferController {
    fragmented_message_receiver: FragmentedMessageReceiver,
    request_receiver: RequestReceiver,
 }

 impl ReceivedMessagesBufferController {
-    pub(crate) fn new(
+    pub fn new(
        local_encryption_keypair: Arc<encryption::KeyPair>,
        query_receiver: ReceivedBufferRequestReceiver,
        mixnet_packet_receiver: MixnetMessageReceiver,
-        reply_key_storage: SentReplyKeys,
-        reply_controller_sender: ReplyControllerSender,
+        reply_key_storage: ReplyKeyStorage,
+        shutdown: ShutdownListener,
    ) -> Self {
-        let received_buffer = ReceivedMessagesBuffer::new(
-            local_encryption_keypair,
-            reply_key_storage,
-            reply_controller_sender,
-        );
+        let received_buffer =
+            ReceivedMessagesBuffer::new(local_encryption_keypair, reply_key_storage);

        ReceivedMessagesBufferController {
            fragmented_message_receiver: FragmentedMessageReceiver::new(
                received_buffer.clone(),
                mixnet_packet_receiver,
+                shutdown,
            ),
            request_receiver: RequestReceiver::new(received_buffer, query_receiver),
        }
    }

-    pub fn start_with_shutdown(self, shutdown: task::TaskClient) {
-        let mut fragmented_message_receiver = self.fragmented_message_receiver;
-        let mut request_receiver = self.request_receiver;
-
-        let shutdown_handle = shutdown.clone();
-        spawn_future(async move {
-            fragmented_message_receiver
-                .run_with_shutdown(shutdown_handle)
-                .await;
-        });
-        spawn_future(async move {
-            request_receiver.run_with_shutdown(shutdown).await;
-        });
+    pub fn start(self) {
+        // TODO: should we do anything with JoinHandle(s) returned by start methods?
+        self.fragmented_message_receiver.start();
+        self.request_receiver.start();
    }
 }
@@ -1,5 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-pub mod reply_controller;
-pub mod reply_storage;
@@ -1,865 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::client::real_messages_control::acknowledgement_control::PendingAcknowledgement;
-use crate::client::real_messages_control::message_handler::{MessageHandler, PreparationError};
-use crate::client::replies::reply_storage::CombinedReplyStorage;
-use client_connections::{ConnectionId, TransmissionLane};
-use futures::channel::oneshot;
-use futures::StreamExt;
-use log::{debug, error, info, trace, warn};
-use nymsphinx::addressing::clients::Recipient;
-use nymsphinx::anonymous_replies::requests::AnonymousSenderTag;
-use nymsphinx::anonymous_replies::ReplySurb;
-use nymsphinx::chunking::fragment::{Fragment, FragmentIdentifier};
-use rand::{CryptoRng, Rng};
-use std::cmp::{max, min};
-use std::collections::btree_map::Entry;
-use std::collections::{BTreeMap, HashMap};
-use std::sync::{Arc, Weak};
-use std::time::Duration;
-use time::OffsetDateTime;
-
-use crate::client::helpers::new_interval_stream;
-use crate::client::transmission_buffer::TransmissionBuffer;
-pub(crate) use requests::{ReplyControllerMessage, ReplyControllerReceiver, ReplyControllerSender};
-
-pub mod requests;
-
-pub struct Config {
-    min_surb_request_size: u32,
-    max_surb_request_size: u32,
-    maximum_allowed_reply_surb_request_size: u32,
-    max_surb_waiting_period: Duration,
-    max_reply_surb_age: Duration,
-    max_reply_key_age: Duration,
-}
-
-impl Config {
-    pub(crate) fn new(
-        min_surb_request_size: u32,
-        max_surb_request_size: u32,
-        maximum_allowed_reply_surb_request_size: u32,
-        max_surb_waiting_period: Duration,
-        max_reply_surb_age: Duration,
-        max_reply_key_age: Duration,
-    ) -> Self {
-        Self {
-            min_surb_request_size,
-            max_surb_request_size,
-            maximum_allowed_reply_surb_request_size,
-            max_surb_waiting_period,
-            max_reply_surb_age,
-            max_reply_key_age,
-        }
-    }
-}
-
-// the purpose of this task:
-// - buffers split messages from input message listener if there were insufficient surbs to send them
-// - upon getting extra surbs, resends them
-// - so I guess it will handle all 'RepliableMessage' and requests from 'ReplyMessage'
-// - replies to "give additional surbs" requests
-// - will reply to future heartbeats
-
-// TODO: this should be split into ingress and egress controllers
-// because currently its trying to perform two distinct jobs
-pub struct ReplyController<R> {
-    config: Config,
-
-    // TODO: incorporate that field at some point
-    // and use binomial distribution to determine the expected required number
-    // of surbs required to send the message through
-    // expected_reliability: f32,
-    request_receiver: ReplyControllerReceiver,
-    pending_replies: HashMap<AnonymousSenderTag, TransmissionBuffer<Fragment>>,
-
-    /// Retransmission packets that have already timed out and are waiting for additional reply SURBs
-    /// so that they could be sent back to the network. Once we receive more SURBs, we should send them ASAP.
-    // TODO: when purging stale entries, we must take extra care to also purge all pending ACK data!!
-    pending_retransmissions:
-        HashMap<AnonymousSenderTag, BTreeMap<FragmentIdentifier, Weak<PendingAcknowledgement>>>,
-
-    message_handler: MessageHandler<R>,
-    full_reply_storage: CombinedReplyStorage,
-}
-
-impl<R> ReplyController<R>
-where
-    R: CryptoRng + Rng,
-{
-    pub(crate) fn new(
-        config: Config,
-        message_handler: MessageHandler<R>,
-        full_reply_storage: CombinedReplyStorage,
-        request_receiver: ReplyControllerReceiver,
-    ) -> Self {
-        ReplyController {
-            config,
-            request_receiver,
-            pending_replies: HashMap::new(),
-            pending_retransmissions: HashMap::new(),
-            message_handler,
-            full_reply_storage,
-        }
-    }
-
-    fn insert_pending_replies<I: IntoIterator<Item = Fragment>>(
-        &mut self,
-        recipient: &AnonymousSenderTag,
-        fragments: I,
-        lane: TransmissionLane,
-    ) {
-        self.pending_replies
-            .entry(*recipient)
-            .or_insert_with(TransmissionBuffer::new)
-            .store(&lane, fragments)
-    }
-
-    fn re_insert_pending_replies(
-        &mut self,
-        recipient: &AnonymousSenderTag,
-        fragments: Vec<(TransmissionLane, Fragment)>,
-    ) {
-        // the buffer should ALWAYS exist at this point, if it doesn't, it's a bug...
-        self.pending_replies
-            .entry(*recipient)
-            .or_insert_with(TransmissionBuffer::new)
-            .store_multiple(fragments)
-    }
-
-    fn re_insert_pending_retransmission(
-        &mut self,
-        recipient: &AnonymousSenderTag,
-        data: Vec<Arc<PendingAcknowledgement>>,
-    ) {
-        // the underlying entry MUST exist as we've just got data from there
-        let map_entry = self
-            .pending_retransmissions
-            .get_mut(recipient)
-            .expect("our pending retransmission entry is somehow gone!");
-
-        for pending in data {
-            // if it's 0, we don't need to do anything - we just got that ack!
-            if Arc::strong_count(&pending) > 1 {
-                let id = pending.inner_fragment_identifier();
-                let downgraded = Arc::downgrade(&pending);
-                map_entry.insert(id, downgraded);
-            }
-        }
-    }
-
-    fn should_request_more_surbs(&self, target: &AnonymousSenderTag) -> bool {
-        trace!("checking if we should request more surbs from {:?}", target);
-
-        let pending_queue_size = self
-            .pending_replies
-            .get(target)
-            .map(|pending_queue| pending_queue.total_size())
-            .unwrap_or_default();
-
-        let retransmission_queue = self
-            .pending_retransmissions
-            .get(target)
-            .map(|pending_queue| pending_queue.len())
-            .unwrap_or_default();
-
-        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()
-            .available_surbs(target);
-        let pending_surbs = self
-            .full_reply_storage
-            .surbs_storage_ref()
-            .pending_reception(target) as usize;
-        let min_surbs_threshold = self
-            .full_reply_storage
-            .surbs_storage_ref()
-            .min_surb_threshold();
-        let max_surbs_threshold = self
-            .full_reply_storage
-            .surbs_storage_ref()
-            .max_surb_threshold();
-
-        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}");
-
-        (pending_surbs + available_surbs) < max_surbs_threshold
-            && (pending_surbs + available_surbs) < (total_queue + min_surbs_threshold)
-    }
-
-    async fn handle_send_reply(
-        &mut self,
-        recipient_tag: AnonymousSenderTag,
-        data: Vec<u8>,
-        lane: TransmissionLane,
-    ) {
-        if !self
-            .full_reply_storage
-            .surbs_storage_ref()
-            .contains_surbs_for(&recipient_tag)
-        {
-            warn!("received reply request for {:?} but we don't have any surbs stored for that recipient!", recipient_tag);
-            return;
-        }
-
-        trace!("handling reply to {:?}", recipient_tag);
-        let mut fragments = self.message_handler.split_reply_message(data);
-        let total_size = fragments.len();
-        trace!("This reply requires {:?} SURBs", total_size);
-
-        let available_surbs = self
-            .full_reply_storage
-            .surbs_storage_ref()
-            .available_surbs(&recipient_tag);
-        let min_surbs_threshold = self
-            .full_reply_storage
-            .surbs_storage_ref()
-            .min_surb_threshold();
-
-        let max_to_send = if available_surbs > min_surbs_threshold {
-            min(fragments.len(), available_surbs - min_surbs_threshold)
-        } else {
-            0
-        };
-
-        if max_to_send > 0 {
-            let (surbs, _surbs_left) = self
-                .full_reply_storage
-                .surbs_storage_ref()
-                .get_reply_surbs(&recipient_tag, max_to_send);
-
-            if let Some(reply_surbs) = surbs {
-                let to_send = fragments.drain(..max_to_send).collect::<Vec<_>>();
-                if let Err(err) = self
-                    .message_handler
-                    .try_send_reply_chunks_on_lane(
-                        recipient_tag,
-                        to_send.clone(),
-                        reply_surbs,
-                        lane,
-                    )
-                    .await
-                {
-                    let err = err.return_unused_surbs(
-                        self.full_reply_storage.surbs_storage_ref(),
-                        &recipient_tag,
-                    );
-                    warn!("failed to send reply to {recipient_tag}: {err}");
-                    self.insert_pending_replies(&recipient_tag, to_send, lane);
-                }
-            }
-        }
-
-        // if there's leftover data we didn't send because we didn't have enough (or any) surbs - buffer it
-        if !fragments.is_empty() {
-            self.insert_pending_replies(&recipient_tag, fragments, lane);
-        }
-
-        if self.should_request_more_surbs(&recipient_tag) {
-            self.request_reply_surbs_for_queue_clearing(recipient_tag)
-                .await;
-        }
-    }
-
-    async fn request_additional_reply_surbs(
-        &mut self,
-        target: AnonymousSenderTag,
-        amount: u32,
-    ) -> Result<(), PreparationError> {
-        let reply_surb = self
-            .full_reply_storage
-            .surbs_storage_ref()
-            .get_reply_surb_ignoring_threshold(&target)
-            .and_then(|(reply_surb, _)| reply_surb)
-            .ok_or(PreparationError::NotEnoughSurbs {
-                available: 0,
-                required: 1,
-            })?;
-
-        if let Err(err) = self
-            .message_handler
-            .try_request_additional_reply_surbs(target, reply_surb, amount)
-            .await
-        {
-            let err = err.return_unused_surbs(self.full_reply_storage.surbs_storage_ref(), &target);
-            warn!(
-                "failed to request additional surbs from {:?} - {err}",
-                target
-            );
-            return Err(err);
-        } else {
-            self.full_reply_storage
-                .surbs_storage_ref()
-                .increment_pending_reception(&target, amount);
-        }
-
-        Ok(())
-    }
-
-    async fn try_clear_pending_retransmission(&mut self, target: AnonymousSenderTag) {
-        trace!("trying to clear pending retransmission queue");
-        let available_surbs = self
-            .full_reply_storage
-            .surbs_storage_ref()
-            .available_surbs(&target);
-        let min_surbs_threshold = self
-            .full_reply_storage
-            .surbs_storage_ref()
-            .min_surb_threshold();
-
-        let max_to_clear = if available_surbs > min_surbs_threshold {
-            available_surbs - min_surbs_threshold
-        } else {
-            trace!("we don't have enough surbs for retransmission queue clearing...");
-            return;
-        };
-        trace!("we can clear up to {max_to_clear} entries");
-
-        let Some(pending) = self.pending_retransmissions.get_mut(&target) else {
-            trace!("there are no pending retransmissions for {target}!");
-            return;
-        };
-
-        let mut to_take = Vec::new();
-
-        while to_take.len() < max_to_clear {
-            if let Some((_, data)) = pending.pop_first() {
-                // no need to do anything if we failed to upgrade the reference,
-                // it means we got the ack while the data was waiting in the queue
-                if let Some(upgraded) = data.upgrade() {
-                    to_take.push(upgraded)
-                }
-            } else {
-                // our map is empty!
-                break;
-            }
-        }
-
-        if to_take.is_empty() {
-            // no need to do anything
-            return;
-        }
-
-        let (surbs_for_reply, _) = self
-            .full_reply_storage
-            .surbs_storage_ref()
-            .get_reply_surbs(&target, to_take.len());
-
-        let Some(surbs_for_reply) = surbs_for_reply else {
-            error!("somehow different task has stolen our reply surbs! - this should have been impossible");
-            self.re_insert_pending_retransmission(&target, to_take);
-            return;
-        };
-
-        let to_send_vec = to_take.iter().map(|ack| ack.fragment_data()).collect();
-
-        let prepared_fragments = match self
-            .message_handler
-            .prepare_reply_chunks_for_sending(to_send_vec, surbs_for_reply)
-            .await
-        {
-            Ok(prepared) => prepared,
-            Err(err) => {
-                let err =
-                    err.return_unused_surbs(self.full_reply_storage.surbs_storage_ref(), &target);
-                self.re_insert_pending_retransmission(&target, to_take);
-
-                warn!(
-                    "failed to clear pending retransmission queue for {:?} - {err}",
-                    target
-                );
-                return;
-            }
-        };
-
-        // we can't fail at this point, so drop all references to acks so that timer updates wouldn't blow up
-        drop(to_take);
-
-        self.message_handler
-            .send_retransmission_reply_chunks(prepared_fragments, TransmissionLane::Retransmission)
-            .await;
-    }
-
-    fn pop_at_most_pending_replies(
-        &mut self,
-        from: &AnonymousSenderTag,
-        amount: usize,
-    ) -> Option<Vec<(TransmissionLane, Fragment)>> {
-        // if possible, pop all pending replies, if not, pop only entries for which we'd have a reply surb
-        let total = self.pending_replies.get(from)?.total_size();
-        trace!("pending queue has {total} elements");
-        if total == 0 {
-            return None;
-        }
-        self.pending_replies
-            .get_mut(from)?
-            .pop_at_most_n_next_messages_at_random(amount)
-    }
-
-    async fn try_clear_pending_queue(&mut self, target: AnonymousSenderTag) {
-        trace!("trying to clear pending queue");
-        let available_surbs = self
-            .full_reply_storage
-            .surbs_storage_ref()
-            .available_surbs(&target);
-        let min_surbs_threshold = self
-            .full_reply_storage
-            .surbs_storage_ref()
-            .min_surb_threshold();
-
-        let max_to_clear = if available_surbs > min_surbs_threshold {
-            available_surbs - min_surbs_threshold
-        } else {
-            trace!("we don't have enough surbs for queue clearing...");
-            return;
-        };
-        trace!("we can clear up to {max_to_clear} entries");
-
-        // we're guaranteed to not get more entries than we have reply surbs for
-        if let Some(to_send) = self.pop_at_most_pending_replies(&target, max_to_clear) {
-            let to_send_clone = to_send.clone();
-
-            if to_send_clone.is_empty() {
-                panic!(
-                    "please let the devs know if you ever see this message (reply_controller.rs)"
-                );
-            }
-
-            let (surbs_for_reply, _) = self
-                .full_reply_storage
-                .surbs_storage_ref()
-                .get_reply_surbs(&target, to_send_clone.len());
-
-            let Some(surbs_for_reply) = surbs_for_reply else {
-                error!("somehow different task has stolen our reply surbs! - this should have been impossible");
-                self.re_insert_pending_replies(&target, to_send);
-                return;
-            };
-
-            if let Err(err) = self
-                .message_handler
-                .try_send_reply_chunks(target, to_send_clone, surbs_for_reply)
-                .await
-            {
-                let err =
-                    err.return_unused_surbs(self.full_reply_storage.surbs_storage_ref(), &target);
-                self.re_insert_pending_replies(&target, to_send);
-                warn!("failed to clear pending queue for {:?} - {err}", target);
-            }
-        } else {
-            trace!("the pending queue is empty");
-        }
-    }
-
-    async fn handle_received_surbs(
-        &mut self,
-        from: AnonymousSenderTag,
-        reply_surbs: Vec<ReplySurb>,
-        from_surb_request: bool,
-    ) {
-        trace!("handling received surbs");
-
-        // clear the requesting flag since we should have been asking for surbs
-        self.full_reply_storage
-            .surbs_storage_ref()
-            .reset_surbs_last_received_at(&from);
-        if from_surb_request {
-            self.full_reply_storage
-                .surbs_storage_ref()
-                .decrement_pending_reception(&from, reply_surbs.len() as u32);
-        }
-
-        // store received surbs
-        self.full_reply_storage
-            .surbs_storage_ref()
-            .insert_surbs(&from, reply_surbs);
-
-        // use as many as we can for clearing pending retransmission queue
-        self.try_clear_pending_retransmission(from).await;
-
-        // use as many as we can for clearing pending 'normal' queue
-        self.try_clear_pending_queue(from).await;
-
-        // if we have to, request more
-        if self.should_request_more_surbs(&from) {
-            self.request_reply_surbs_for_queue_clearing(from).await;
-        }
-    }
-
-    async fn handle_surb_request(&mut self, recipient: Recipient, mut amount: u32) {
-        // 1. check whether we sent any surbs in the past to this recipient, otherwise
-        // they have no business in asking for more
-        if !self
-            .full_reply_storage
-            .tags_storage_ref()
-            .exists(&recipient)
-        {
-            warn!("{recipient} asked us for reply SURBs even though we never sent them any anonymous messages before!");
-            return;
-        }
-
-        // 2. check whether the requested amount is within sane range
-        if amount > self.config.maximum_allowed_reply_surb_request_size {
-            warn!("The requested reply surb amount is larger than our maximum allowed ({amount} > {}). Lowering it to a more sane value...", self.config.maximum_allowed_reply_surb_request_size);
-            amount = self.config.maximum_allowed_reply_surb_request_size;
-        }
-
-        // 3. construct and send the surbs away
-        // (send them in smaller batches to make the experience a bit smoother
-        let mut remaining = amount;
-        while remaining > 0 {
-            let to_send = min(remaining, 100);
-            if let Err(err) = self
-                .message_handler
-                .try_send_additional_reply_surbs(recipient, to_send)
-                .await
-            {
-                warn!("failed to send additional surbs to {recipient} - {err}");
-            } else {
-                trace!("sent {to_send} reply SURBs to {recipient}");
-            }
-
-            remaining -= to_send;
-        }
-    }
-
-    fn buffer_pending_ack(
-        &mut self,
-        recipient: AnonymousSenderTag,
-        ack_ref: Arc<PendingAcknowledgement>,
-        weak_ack_ref: Weak<PendingAcknowledgement>,
-    ) {
-        let frag_id = ack_ref.inner_fragment_identifier();
-        if let Some(existing) = self.pending_retransmissions.get_mut(&recipient) {
-            if let Entry::Vacant(e) = existing.entry(frag_id) {
-                e.insert(weak_ack_ref);
-            } else {
-                warn!("we're already trying to retransmit {frag_id}. We must be really behind in surbs!");
-            }
-        } else {
-            let mut inner = BTreeMap::new();
-            inner.insert(frag_id, weak_ack_ref);
-            self.pending_retransmissions.insert(recipient, inner);
-        }
-    }
-
-    async fn handle_reply_retransmission(
-        &mut self,
-        recipient_tag: AnonymousSenderTag,
-        timed_out_ack: Weak<PendingAcknowledgement>,
-        extra_surbs_request: bool,
-    ) {
-        // seems we got the ack in the end
-        let ack_ref = match timed_out_ack.upgrade() {
-            Some(ack) => ack,
-            None => {
-                debug!("we received the ack for one of the reply packets as we were putting it in the retransmission queue");
-                return;
-            }
-        };
-
-        // if this is retransmission for obtaining additional reply surbs,
-        // we can dip below the storage threshold
-        let (maybe_reply_surb, _) = if extra_surbs_request {
-            self.full_reply_storage
-                .surbs_storage_ref()
-                .get_reply_surb_ignoring_threshold(&recipient_tag)
-        } else {
-            self.full_reply_storage
-                .surbs_storage_ref()
-                .get_reply_surb(&recipient_tag)
-        }
-        .expect("attempted to retransmit a packet to an unknown recipient - we shouldn't have sent the original packet in the first place!");
-
-        if let Some(reply_surb) = maybe_reply_surb {
-            match self
-                .message_handler
-                .try_prepare_single_reply_chunk_for_sending(reply_surb, ack_ref.fragment_data())
-                .await
-            {
-                Ok(prepared) => {
-                    // drop the ack ref so that controller would not panic on `UpdateTimer` if that task
-                    // got to handle the action before this function terminated (which is very much
-                    // possible if `forward_messages` takes a while)
-                    drop(ack_ref);
-
-                    self.message_handler
-                        .update_ack_delay(prepared.fragment_identifier, prepared.total_delay);
-                    self.message_handler
-                        .forward_messages(vec![prepared.into()], TransmissionLane::Retransmission)
-                        .await;
-                }
-                Err(err) => {
-                    let err = err.return_unused_surbs(
-                        self.full_reply_storage.surbs_storage_ref(),
-                        &recipient_tag,
-                    );
-                    warn!("failed to prepare message for retransmission - {err}");
-                    // we buffer that packet and to try another day
-                    self.buffer_pending_ack(recipient_tag, ack_ref, timed_out_ack);
-
-                    if self.should_request_more_surbs(&recipient_tag) {
-                        self.request_reply_surbs_for_queue_clearing(recipient_tag)
-                            .await;
-                    }
-                }
-            };
-        } else {
-            self.buffer_pending_ack(recipient_tag, ack_ref, timed_out_ack);
-
-            if self.should_request_more_surbs(&recipient_tag) {
-                self.request_reply_surbs_for_queue_clearing(recipient_tag)
-                    .await;
-            }
-        }
-    }
-
-    // to be honest this doesn't make a lot of sense in the context of `connection_id`,
-    // it should really be asked per tag
-    fn handle_lane_queue_length(
-        &self,
-        connection_id: ConnectionId,
-        response_channel: oneshot::Sender<usize>,
-    ) {
-        // TODO: if we ever have duplicate ids for different senders, it means our rng is super weak
-        // thus I don't think we have to worry about it?
-        let lane = TransmissionLane::ConnectionId(connection_id);
-        for buf in self.pending_replies.values() {
-            if let Some(length) = buf.lane_length(&lane) {
-                if response_channel.send(length).is_err() {
-                    error!("the requester for lane queue length has dropped the response channel!")
-                }
-                return;
-            }
-        }
-        // make sure that if we didn't find that lane, we reply with 0
-        if response_channel.send(0).is_err() {
-            error!("the requester for lane queue length has dropped the response channel!")
-        }
-    }
-
-    async fn handle_request(&mut self, request: ReplyControllerMessage) {
-        match request {
-            ReplyControllerMessage::RetransmitReply {
-                recipient,
-                timed_out_ack,
-                extra_surb_request,
-            } => {
-                self.handle_reply_retransmission(recipient, timed_out_ack, extra_surb_request)
-                    .await
-            }
-            ReplyControllerMessage::SendReply {
-                recipient,
-                message,
-                lane,
-            } => self.handle_send_reply(recipient, message, lane).await,
-            ReplyControllerMessage::AdditionalSurbs {
-                sender_tag,
-                reply_surbs,
-                from_surb_request,
-            } => {
-                self.handle_received_surbs(sender_tag, reply_surbs, from_surb_request)
-                    .await
-            }
-            ReplyControllerMessage::LaneQueueLength {
-                connection_id,
-                response_channel,
-            } => self.handle_lane_queue_length(connection_id, response_channel),
-            ReplyControllerMessage::AdditionalSurbsRequest { recipient, amount } => {
-                self.handle_surb_request(*recipient, amount).await
-            }
-        }
-    }
-
-    // TODO: modify this method to more accurately determine the amount of surbs it needs to request
-    // 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 queues clearing");
-
-        let pending_queue_size = self
-            .pending_replies
-            .get(&target)
-            .map(|pending_queue| pending_queue.total_size())
-            .unwrap_or_default();
-
-        let retransmission_queue = self
-            .pending_retransmissions
-            .get(&target)
-            .map(|pending_queue| pending_queue.len())
-            .unwrap_or_default();
-
-        let total_queue = (pending_queue_size + retransmission_queue) as u32;
-
-        if total_queue == 0 {
-            trace!("the pending queues for {:?} are already empty", target);
-            return;
-        }
-
-        let request_size = min(
-            self.config.max_surb_request_size,
-            max(total_queue, self.config.min_surb_request_size),
-        );
-
-        if let Err(err) = self
-            .request_additional_reply_surbs(target, request_size)
-            .await
-        {
-            warn!("failed to request additional surbs... - {err}")
-        }
-    }
-
-    async fn inspect_stale_entries(&mut self) {
-        let mut to_request = Vec::new();
-        let mut to_remove = Vec::new();
-
-        let now = OffsetDateTime::now_utc();
-        for (pending_reply_target, vals) in &self.pending_replies {
-            if vals.is_empty() {
-                continue;
-            }
-
-            let Some(last_received) = self.full_reply_storage.surbs_storage_ref().surbs_last_received_at(pending_reply_target) else {
-                error!("we have {} pending replies for {pending_reply_target}, but we somehow never received any reply surbs from them!", vals.total_size());
-                to_remove.push(*pending_reply_target);
-                continue;
-            };
-
-            // this should never ever happen (famous last words, eh?), but in case it DOES happen eventually
-            // purge that malformed data
-            let Ok(last_received_time) = OffsetDateTime::from_unix_timestamp(last_received) else {
-                error!("somehow our stored timestamp ({last_received}) for surbs from {pending_reply_target} is corrupted!. Going to remove all the associated entries");
-                to_remove.push(*pending_reply_target);
-                continue;
-            };
-
-            let diff = now - last_received_time;
-
-            if diff > self.config.max_surb_waiting_period {
-                warn!("We haven't received any surbs in {:?} from {pending_reply_target}. Going to explicitly ask for more", diff);
-                to_request.push(*pending_reply_target);
-            }
-        }
-
-        for pending_reply_target in to_request {
-            self.request_reply_surbs_for_queue_clearing(pending_reply_target)
-                .await;
-            self.full_reply_storage
-                .surbs_storage_ref()
-                .reset_pending_reception(&pending_reply_target)
-        }
-        for to_remove in to_remove {
-            self.pending_replies.remove(&to_remove);
-        }
-    }
-
-    async fn invalidate_old_data(&self) {
-        let now = OffsetDateTime::now_utc();
-
-        let mut to_remove_surbs = Vec::new();
-        let mut to_remove_keys = Vec::new();
-        for map_ref in self.full_reply_storage.surbs_storage_ref().as_raw_iter() {
-            let (sender, received) = map_ref.pair();
-            // TODO: handle the following edge case:
-            // there's a malicious client sending us exactly one reply surb just before we should have invalidated
-            // the data thus making us keep everything in memory
-            // possible solution: keep timestamp PER reply surb (but that seems like an overkill)
-            // but I doubt this is ever going to be a problem...
-            // ...
-            // However, if you're reading this message, it probably became a legit problem,
-            // so I guess add timestamp per surb then? chop-chop.
-
-            let last_received = received.surbs_last_received_at();
-            // this should never ever happen (famous last words, eh?), but in case it DOES happen eventually
-            // purge that malformed data
-            let Ok(last_received_time) = OffsetDateTime::from_unix_timestamp(last_received) else {
-                error!("somehow our stored timestamp ({last_received}) for surbs from {sender} is corrupted!. Going to remove all the associated entries");
-                to_remove_surbs.push(*sender);
-                continue;
-            };
-            let diff = now - last_received_time;
-
-            if diff > self.config.max_reply_surb_age {
-                info!("it's been {diff:?} since we last received any reply surb from {sender}. Going to remove all stored entries...");
-
-                to_remove_surbs.push(*sender);
-            }
-        }
-
-        for map_ref in self.full_reply_storage.key_storage_ref().as_raw_iter() {
-            let (digest, reply_key) = map_ref.pair();
-
-            // this should never ever happen (famous last words, eh?), but in case it DOES happen eventually
-            // purge that malformed data
-            let Ok(sent_at) = OffsetDateTime::from_unix_timestamp(reply_key.sent_at_timestamp) else {
-                error!("somehow our stored timestamp ({}) for one of our reply key is corrupted!. Going to remove all the entry", reply_key.sent_at_timestamp);
-                to_remove_keys.push(*digest);
-                continue;
-            };
-
-            let diff = now - sent_at;
-
-            if diff > self.config.max_reply_key_age {
-                debug!("it's been {diff:?} since we created this reply key. it's probably never going to get used, so we're going to purge it...");
-                to_remove_keys.push(*digest);
-            }
-        }
-
-        for to_remove in to_remove_surbs {
-            self.full_reply_storage
-                .surbs_storage_ref()
-                .remove(&to_remove);
-        }
-
-        for to_remove in to_remove_keys {
-            self.full_reply_storage.key_storage().remove(to_remove)
-        }
-    }
-
-    // #[cfg(not(target_arch = "wasm32"))]
-    // async fn log_status(&self) {
-    //     todo!()
-    // }
-
-    pub(crate) async fn run_with_shutdown(&mut self, mut shutdown: task::TaskClient) {
-        debug!("Started ReplyController with graceful shutdown support");
-
-        let polling_rate = Duration::from_secs(5);
-        let mut stale_inspection = new_interval_stream(polling_rate);
-
-        // this is in the order of hours/days so we don't have to poll it that often
-        let polling_rate = Duration::from_secs(self.config.max_reply_surb_age.as_secs() / 10);
-        let mut invalidation_inspection = new_interval_stream(polling_rate);
-
-        while !shutdown.is_shutdown() {
-            tokio::select! {
-                biased;
-                _ = shutdown.recv_with_delay() => {
-                    log::trace!("ReplyController: Received shutdown");
-                },
-                req = self.request_receiver.next() => match req {
-                    Some(req) => self.handle_request(req).await,
-                    None => {
-                        log::trace!("ReplyController: Stopping since channel closed");
-                        break;
-                    }
-                },
-                _ = stale_inspection.next() => {
-                    self.inspect_stale_entries().await
-                },
-                _ = invalidation_inspection.next() => {
-                    self.invalidate_old_data().await
-                }
-            }
-        }
-        assert!(shutdown.is_shutdown_poll());
-        log::debug!("ReplyController: Exiting");
-    }
-}
@@ -1,136 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::client::real_messages_control::acknowledgement_control::PendingAcknowledgement;
-use client_connections::{ConnectionId, TransmissionLane};
-use futures::channel::{mpsc, oneshot};
-use log::error;
-use nymsphinx::addressing::clients::Recipient;
-use nymsphinx::anonymous_replies::requests::AnonymousSenderTag;
-use nymsphinx::anonymous_replies::ReplySurb;
-use std::sync::Weak;
-
-pub(crate) fn new_control_channels() -> (ReplyControllerSender, ReplyControllerReceiver) {
-    let (tx, rx) = mpsc::unbounded();
-    (tx.into(), rx)
-}
-
-#[derive(Debug, Clone)]
-pub struct ReplyControllerSender(mpsc::UnboundedSender<ReplyControllerMessage>);
-
-impl From<mpsc::UnboundedSender<ReplyControllerMessage>> for ReplyControllerSender {
-    fn from(inner: mpsc::UnboundedSender<ReplyControllerMessage>) -> Self {
-        ReplyControllerSender(inner)
-    }
-}
-
-impl ReplyControllerSender {
-    pub(crate) fn send_retransmission_data(
-        &self,
-        recipient: AnonymousSenderTag,
-        timed_out_ack: Weak<PendingAcknowledgement>,
-        extra_surb_request: bool,
-    ) {
-        self.0
-            .unbounded_send(ReplyControllerMessage::RetransmitReply {
-                recipient,
-                timed_out_ack,
-                extra_surb_request,
-            })
-            .expect("ReplyControllerReceiver has died!")
-    }
-
-    pub(crate) fn send_reply(
-        &self,
-        recipient: AnonymousSenderTag,
-        message: Vec<u8>,
-        lane: TransmissionLane,
-    ) {
-        self.0
-            .unbounded_send(ReplyControllerMessage::SendReply {
-                recipient,
-                message,
-                lane,
-            })
-            .expect("ReplyControllerReceiver has died!")
-    }
-
-    pub(crate) fn send_additional_surbs(
-        &self,
-        sender_tag: AnonymousSenderTag,
-        reply_surbs: Vec<ReplySurb>,
-        from_surb_request: bool,
-    ) {
-        self.0
-            .unbounded_send(ReplyControllerMessage::AdditionalSurbs {
-                sender_tag,
-                reply_surbs,
-                from_surb_request,
-            })
-            .expect("ReplyControllerReceiver has died!")
-    }
-
-    pub(crate) fn send_additional_surbs_request(&self, recipient: Recipient, amount: u32) {
-        self.0
-            .unbounded_send(ReplyControllerMessage::AdditionalSurbsRequest {
-                recipient: Box::new(recipient),
-                amount,
-            })
-            .expect("ReplyControllerReceiver has died!")
-    }
-
-    pub async fn get_lane_queue_length(&self, connection_id: ConnectionId) -> usize {
-        let (response_tx, response_rx) = oneshot::channel();
-        self.0
-            .unbounded_send(ReplyControllerMessage::LaneQueueLength {
-                connection_id,
-                response_channel: response_tx,
-            })
-            .expect("ReplyControllerReceiver has died!");
-
-        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
-            }
-        }
-    }
-}
-
-pub(crate) type ReplyControllerReceiver = mpsc::UnboundedReceiver<ReplyControllerMessage>;
-
-#[derive(Debug)]
-pub(crate) enum ReplyControllerMessage {
-    RetransmitReply {
-        recipient: AnonymousSenderTag,
-        timed_out_ack: Weak<PendingAcknowledgement>,
-        extra_surb_request: bool,
-    },
-
-    SendReply {
-        recipient: AnonymousSenderTag,
-        message: Vec<u8>,
-        lane: TransmissionLane,
-    },
-
-    AdditionalSurbs {
-        sender_tag: AnonymousSenderTag,
-        reply_surbs: Vec<ReplySurb>,
-        from_surb_request: bool,
-    },
-
-    // this one doesn't belong here either...
-    LaneQueueLength {
-        connection_id: ConnectionId,
-        response_channel: oneshot::Sender<usize>,
-    },
-
-    // Should this also be handled in here? it's technically a completely different side of the pipe
-    // let's see how it works when combined, might split it before creating PR
-    AdditionalSurbsRequest {
-        recipient: Box<Recipient>,
-        amount: u32,
-    },
-}
@@ -1,43 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::client::replies::reply_storage::backend::Empty;
-use crate::client::replies::reply_storage::{CombinedReplyStorage, ReplyStorageBackend};
-use async_trait::async_trait;
-
-// well, right now we don't have the browser storage : (
-// so we keep everything in memory
-pub struct Backend {
-    empty: Empty,
-}
-
-impl Backend {
-    pub fn new(min_surb_threshold: usize, max_surb_threshold: usize) -> Self {
-        Backend {
-            empty: Empty {
-                min_surb_threshold,
-                max_surb_threshold,
-            },
-        }
-    }
-}
-
-#[async_trait]
-impl ReplyStorageBackend for Backend {
-    type StorageError = <Empty as ReplyStorageBackend>::StorageError;
-
-    async fn flush_surb_storage(
-        &mut self,
-        storage: &CombinedReplyStorage,
-    ) -> Result<(), Self::StorageError> {
-        self.empty.flush_surb_storage(storage).await
-    }
-
-    async fn init_fresh(&mut self, fresh: &CombinedReplyStorage) -> Result<(), Self::StorageError> {
-        self.empty.init_fresh(fresh).await
-    }
-
-    async fn load_surb_storage(&self) -> Result<CombinedReplyStorage, Self::StorageError> {
-        self.empty.load_surb_storage().await
-    }
-}
@@ -1,53 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use std::io;
-use std::path::PathBuf;
-use thiserror::Error;
-
-#[derive(Debug, Error)]
-pub enum StorageError {
-    #[error("the provided database path doesn't have a filename defined")]
-    DatabasePathWithoutFilename { provided_path: PathBuf },
-
-    #[error("failed to rename our databse file - {source}")]
-    DatabaseRenameError {
-        #[source]
-        source: io::Error,
-    },
-
-    #[error("failed to rename our old databse file - {source}")]
-    DatabaseOldFileRemoveError {
-        #[source]
-        source: io::Error,
-    },
-
-    #[error("failed to perform sqlx migration: {source}")]
-    MigrationError {
-        #[source]
-        #[from]
-        source: sqlx::migrate::MigrateError,
-    },
-
-    #[error("failed to connect to the underlying connection pool: {source}")]
-    DatabaseConnectionError {
-        #[source]
-        source: sqlx::error::Error,
-    },
-
-    #[error("failed to run the SQL query: {source}")]
-    QueryError {
-        #[source]
-        #[from]
-        source: sqlx::error::Error,
-    },
-
-    #[error("The loaded data is inconsistent - it seems that on the last shutdown the client hasn't finished the data flush. You may have to remove the entire storage manually")]
-    IncompleteDataFlush,
-
-    #[error("data retrieved from the underlying storage is corrupted: {details}")]
-    CorruptedData {
-        details: String,
-        // err: Option<Box<dyn std::error::Error>>
-    },
-}
@@ -1,257 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::client::replies::reply_storage::backend::fs_backend::error::StorageError;
-use crate::client::replies::reply_storage::backend::fs_backend::models::{
-    ReplySurbStorageMetadata, StoredReplyKey, StoredReplySurb, StoredSenderTag, StoredSurbSender,
-};
-use log::{error, info};
-use sqlx::ConnectOptions;
-use std::path::Path;
-
-#[derive(Debug, Clone)]
-pub(crate) struct StorageManager {
-    pub(crate) connection_pool: sqlx::SqlitePool,
-}
-
-// all SQL goes here
-impl StorageManager {
-    pub(crate) async fn init<P: AsRef<Path>>(
-        database_path: P,
-        fresh: bool,
-    ) -> Result<Self, StorageError> {
-        let mut opts = sqlx::sqlite::SqliteConnectOptions::new()
-            .filename(database_path)
-            .create_if_missing(fresh);
-
-        opts.disable_statement_logging();
-
-        let connection_pool = match sqlx::SqlitePool::connect_with(opts).await {
-            Ok(pool) => pool,
-            Err(err) => {
-                error!("Failed to connect to SQLx database: {err}");
-                return Err(StorageError::DatabaseConnectionError { source: err });
-            }
-        };
-
-        if let Err(err) = sqlx::migrate!("./fs_surbs_migrations")
-            .run(&connection_pool)
-            .await
-        {
-            error!("Failed to initialize SQLx database: {err}");
-            return Err(err.into());
-        }
-
-        info!("Database migration finished!");
-        Ok(StorageManager { connection_pool })
-    }
-
-    #[allow(dead_code)]
-    pub(crate) async fn status_table_exists(&self) -> Result<bool, sqlx::Error> {
-        sqlx::query!("SELECT name FROM sqlite_master WHERE type='table' AND name='status'")
-            .fetch_optional(&self.connection_pool)
-            .await
-            .map(|r| r.is_some())
-    }
-
-    pub(crate) async fn create_status_table(&self) -> Result<(), sqlx::Error> {
-        sqlx::query!("INSERT INTO status(flush_in_progress, previous_flush_timestamp, client_in_use) VALUES (0, 0, 1)")
-            .execute(&self.connection_pool)
-            .await?;
-        Ok(())
-    }
-
-    pub(crate) async fn get_flush_status(&self) -> Result<bool, sqlx::Error> {
-        sqlx::query!("SELECT flush_in_progress FROM status;")
-            .fetch_one(&self.connection_pool)
-            .await
-            .map(|r| r.flush_in_progress > 0)
-    }
-
-    pub(crate) async fn set_previous_flush_timestamp(
-        &self,
-        timestamp: i64,
-    ) -> Result<(), sqlx::Error> {
-        sqlx::query!("UPDATE status SET previous_flush_timestamp = ?", timestamp)
-            .execute(&self.connection_pool)
-            .await?;
-        Ok(())
-    }
-
-    pub(crate) async fn get_previous_flush_timestamp(&self) -> Result<i64, sqlx::Error> {
-        sqlx::query!("SELECT previous_flush_timestamp FROM status;")
-            .fetch_one(&self.connection_pool)
-            .await
-            .map(|r| r.previous_flush_timestamp)
-    }
-
-    pub(crate) async fn set_flush_status(&self, in_progress: bool) -> Result<(), sqlx::Error> {
-        let in_progress_int = i64::from(in_progress);
-        sqlx::query!("UPDATE status SET flush_in_progress = ?", in_progress_int)
-            .execute(&self.connection_pool)
-            .await?;
-        Ok(())
-    }
-
-    pub(crate) async fn get_client_in_use_status(&self) -> Result<bool, sqlx::Error> {
-        sqlx::query!("SELECT client_in_use FROM status;")
-            .fetch_one(&self.connection_pool)
-            .await
-            .map(|r| r.client_in_use > 0)
-    }
-
-    pub(crate) async fn set_client_in_use_status(&self, in_use: bool) -> Result<(), sqlx::Error> {
-        let in_use_int = i64::from(in_use);
-        sqlx::query!("UPDATE status SET client_in_use = ?", in_use_int)
-            .execute(&self.connection_pool)
-            .await?;
-        Ok(())
-    }
-
-    pub(crate) async fn delete_all_tags(&self) -> Result<(), sqlx::Error> {
-        sqlx::query!("DELETE FROM sender_tag;")
-            .execute(&self.connection_pool)
-            .await?;
-        Ok(())
-    }
-
-    pub(crate) async fn get_tags(&self) -> Result<Vec<StoredSenderTag>, sqlx::Error> {
-        sqlx::query_as!(StoredSenderTag, "SELECT * FROM sender_tag;",)
-            .fetch_all(&self.connection_pool)
-            .await
-    }
-
-    pub(crate) async fn insert_tag(&self, stored_tag: StoredSenderTag) -> Result<(), sqlx::Error> {
-        sqlx::query!(
-            r#"
-                INSERT INTO sender_tag(recipient, tag) VALUES (?, ?);
-            "#,
-            stored_tag.recipient,
-            stored_tag.tag
-        )
-        .execute(&self.connection_pool)
-        .await?;
-        Ok(())
-    }
-
-    pub(crate) async fn delete_all_reply_keys(&self) -> Result<(), sqlx::Error> {
-        sqlx::query!("DELETE FROM reply_key;")
-            .execute(&self.connection_pool)
-            .await?;
-        Ok(())
-    }
-
-    pub(crate) async fn get_reply_keys(&self) -> Result<Vec<StoredReplyKey>, sqlx::Error> {
-        sqlx::query_as!(StoredReplyKey, "SELECT * FROM reply_key;",)
-            .fetch_all(&self.connection_pool)
-            .await
-    }
-
-    pub(crate) async fn insert_reply_key(
-        &self,
-        stored_reply_key: StoredReplyKey,
-    ) -> Result<(), sqlx::Error> {
-        sqlx::query!(
-            r#"
-                INSERT INTO reply_key(key_digest, reply_key, sent_at_timestamp) VALUES (?, ?, ?);
-            "#,
-            stored_reply_key.key_digest,
-            stored_reply_key.reply_key,
-            stored_reply_key.sent_at_timestamp
-        )
-        .execute(&self.connection_pool)
-        .await?;
-        Ok(())
-    }
-
-    pub(crate) async fn get_surb_senders(&self) -> Result<Vec<StoredSurbSender>, sqlx::Error> {
-        sqlx::query_as!(StoredSurbSender, "SELECT * FROM reply_surb_sender;",)
-            .fetch_all(&self.connection_pool)
-            .await
-    }
-
-    pub(crate) async fn insert_surb_sender(
-        &self,
-        stored_surb_sender: StoredSurbSender,
-    ) -> Result<i64, sqlx::Error> {
-        let id = sqlx::query!(
-            r#"
-                INSERT INTO reply_surb_sender(tag, last_sent_timestamp) VALUES (?, ?);
-            "#,
-            stored_surb_sender.tag,
-            stored_surb_sender.last_sent_timestamp
-        )
-        .execute(&self.connection_pool)
-        .await?
-        .last_insert_rowid();
-        Ok(id)
-    }
-
-    pub(crate) async fn get_reply_surbs(
-        &self,
-        sender_id: i64,
-    ) -> Result<Vec<StoredReplySurb>, sqlx::Error> {
-        sqlx::query_as!(
-            StoredReplySurb,
-            "SELECT * FROM reply_surb WHERE reply_surb_sender_id = ?",
-            sender_id
-        )
-        .fetch_all(&self.connection_pool)
-        .await
-    }
-
-    pub(crate) async fn delete_all_reply_surb_data(&self) -> Result<(), sqlx::Error> {
-        sqlx::query!("DELETE FROM reply_surb;")
-            .execute(&self.connection_pool)
-            .await?;
-
-        sqlx::query!("DELETE FROM reply_surb_sender;")
-            .execute(&self.connection_pool)
-            .await?;
-
-        Ok(())
-    }
-
-    pub(crate) async fn insert_reply_surb(
-        &self,
-        stored_reply_surb: StoredReplySurb,
-    ) -> Result<(), sqlx::Error> {
-        sqlx::query!(
-            r#"
-                INSERT INTO reply_surb(reply_surb_sender_id, reply_surb) VALUES (?, ?);
-            "#,
-            stored_reply_surb.reply_surb_sender_id,
-            stored_reply_surb.reply_surb
-        )
-        .execute(&self.connection_pool)
-        .await?;
-        Ok(())
-    }
-
-    pub(crate) async fn get_reply_surb_storage_metadata(
-        &self,
-    ) -> Result<ReplySurbStorageMetadata, sqlx::Error> {
-        sqlx::query_as!(
-            ReplySurbStorageMetadata,
-             r#"
-                SELECT min_reply_surb_threshold as "min_reply_surb_threshold: u32", max_reply_surb_threshold as "max_reply_surb_threshold: u32" FROM reply_surb_storage_metadata;
-             "#,
-        )
-            .fetch_one(&self.connection_pool)
-            .await
-    }
-
-    pub(crate) async fn insert_reply_surb_storage_metadata(
-        &self,
-        metadata: ReplySurbStorageMetadata,
-    ) -> Result<(), sqlx::Error> {
-        sqlx::query!(r#"
-            INSERT INTO reply_surb_storage_metadata(min_reply_surb_threshold, max_reply_surb_threshold)
-            VALUES (?, ?);
-        "#,
-            metadata.min_reply_surb_threshold,
-            metadata.max_reply_surb_threshold,
-        ).execute(&self.connection_pool).await?;
-        Ok(())
-    }
-}
@@ -1,348 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::client::replies::reply_storage::backend::fs_backend::manager::StorageManager;
-use crate::client::replies::reply_storage::backend::fs_backend::models::{
-    ReplySurbStorageMetadata, StoredReplyKey, StoredReplySurb, StoredSenderTag, StoredSurbSender,
-};
-use crate::client::replies::reply_storage::surb_storage::ReceivedReplySurbs;
-use crate::client::replies::reply_storage::{
-    CombinedReplyStorage, ReceivedReplySurbsMap, ReplyStorageBackend, SentReplyKeys, UsedSenderTags,
-};
-use async_trait::async_trait;
-use log::{error, info, warn};
-use nymsphinx::anonymous_replies::requests::AnonymousSenderTag;
-use std::fs;
-use std::path::{Path, PathBuf};
-use time::OffsetDateTime;
-
-pub use self::error::StorageError;
-
-mod error;
-mod manager;
-mod models;
-
-#[derive(Debug)]
-pub struct Backend {
-    temporary_old_path: Option<PathBuf>,
-    database_path: PathBuf,
-    manager: StorageManager,
-}
-
-impl Backend {
-    const OLD_EXTENSION: &'static str = "old";
-
-    pub async fn init<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 {
-                provided_path: owned_path,
-            });
-        }
-
-        let backend = Backend {
-            temporary_old_path: None,
-            database_path: owned_path,
-            manager: StorageManager::init(database_path, true).await?,
-        };
-
-        backend.manager.create_status_table().await?;
-
-        Ok(backend)
-    }
-
-    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 {
-                provided_path: owned_path,
-            });
-        }
-
-        let manager = StorageManager::init(database_path, false).await?;
-
-        // the database flush wasn't fully finished and thus the data is in inconsistent state
-        // (we don't really know what's properly saved or what's not)
-        if manager.get_flush_status().await? {
-            return Err(StorageError::IncompleteDataFlush);
-        }
-
-        let last_flush_timestamp = manager.get_previous_flush_timestamp().await?;
-        if last_flush_timestamp == 0 {
-            // either this client has been running since 1970 or the flush failed
-            return Err(StorageError::IncompleteDataFlush);
-        }
-
-        // the process has gone down without full graceful shutdown,
-        // meaning the database doesn't contain valid data anymore
-        // so we have to purge it
-        if manager.get_client_in_use_status().await? {
-            error!("the client hasn't undergone through graceful shutdown the last time it's gone down - we can't trust its reply surbs or stored encryption keys. They shall get purged");
-            manager.delete_all_reply_surb_data().await?;
-            manager.delete_all_reply_keys().await?;
-        }
-
-        if let Err(err) = manager.get_reply_surb_storage_metadata().await {
-            // we can't recover here, we HAVE TO initialise fresh (because we don't know correct starting metadata)
-            error!("it seems the client has been shutdown gracefully - we're missing valid surb data dump. the existing database cannot be used");
-            return Err(err.into());
-        }
-
-        let last_flush = match OffsetDateTime::from_unix_timestamp(last_flush_timestamp) {
-            Ok(last_flush) => last_flush,
-            Err(err) => {
-                return Err(StorageError::CorruptedData {
-                    details: format!("failed to parse stored timestamp - {err}"),
-                });
-            }
-        };
-
-        // in theory clients can use our reply surbs whenever they want, even a year in the future
-        // (assuming no key rotation has happened)
-        // but the way it's currently coded, everyone will purge old data
-        let since_last_flush = OffsetDateTime::now_utc() - last_flush;
-        if since_last_flush.whole_days() > 0 {
-            info!("it's been over {} days and {} hours since we last used our data store. our reply surbs are already outdated - we're going to purge them now.", since_last_flush.whole_days(), since_last_flush.whole_hours());
-            manager.delete_all_reply_surb_data().await?;
-        }
-
-        if since_last_flush.whole_days() > 1 {
-            info!("it's been over {} days and {} hours since we last used our data store. our reply keys are already outdated - we're going to purge them now.", since_last_flush.whole_days(), since_last_flush.whole_hours());
-            manager.delete_all_reply_keys().await?;
-        }
-
-        if since_last_flush.whole_days() > 2 {
-            info!("it's been over {} days and {} hours since we last used our data store. our used sender tags are already outdated - we're going to purge them now.", since_last_flush.whole_days(), since_last_flush.whole_hours());
-            manager.delete_all_tags().await?;
-        }
-
-        Ok(Backend {
-            temporary_old_path: None,
-            database_path: owned_path,
-            manager,
-        })
-    }
-
-    async fn close_pool(&mut self) {
-        self.manager.connection_pool.close().await;
-    }
-
-    async fn rotate(&mut self) -> Result<(), StorageError> {
-        self.close_pool().await;
-
-        let new_extension = if let Some(existing_extension) =
-            self.database_path.extension().and_then(|ext| ext.to_str())
-        {
-            format!("{existing_extension}.{}", Self::OLD_EXTENSION)
-        } else {
-            Self::OLD_EXTENSION.to_string()
-        };
-
-        let mut temp_old = self.database_path.clone();
-        temp_old.set_extension(new_extension);
-
-        fs::rename(&self.database_path, &temp_old)
-            .map_err(|err| StorageError::DatabaseRenameError { source: err })?;
-        self.manager = StorageManager::init(&self.database_path, true).await?;
-        self.manager.create_status_table().await?;
-
-        self.temporary_old_path = Some(temp_old);
-        Ok(())
-    }
-
-    fn remove_old(&mut self) -> Result<(), StorageError> {
-        if let Some(old_path) = self.temporary_old_path.take() {
-            fs::remove_file(old_path)
-                .map_err(|err| StorageError::DatabaseOldFileRemoveError { source: err })
-        } else {
-            warn!("the old database file doesn't seem to exist!");
-            Ok(())
-        }
-    }
-
-    async fn start_storage_flush(&self) -> Result<(), StorageError> {
-        Ok(self.manager.set_flush_status(true).await?)
-    }
-
-    async fn end_storage_flush(&self) -> Result<(), StorageError> {
-        self.manager
-            .set_previous_flush_timestamp(OffsetDateTime::now_utc().unix_timestamp())
-            .await?;
-        Ok(self.manager.set_flush_status(false).await?)
-    }
-
-    async fn start_client_use(&self) -> Result<(), StorageError> {
-        Ok(self.manager.set_client_in_use_status(true).await?)
-    }
-
-    async fn stop_client_use(&self) -> Result<(), StorageError> {
-        Ok(self.manager.set_client_in_use_status(false).await?)
-    }
-
-    async fn get_stored_tags(&self) -> Result<UsedSenderTags, StorageError> {
-        let stored = self.manager.get_tags().await?;
-
-        // stop at the first instance of corruption. if even a single entry is malformed,
-        // something weird has happened and we can't trust the rest of the data
-        let raw = stored
-            .into_iter()
-            .map(TryInto::try_into)
-            .collect::<Result<_, _>>()?;
-
-        Ok(UsedSenderTags::from_raw(raw))
-    }
-
-    async fn dump_sender_tags(&self, tags: &UsedSenderTags) -> Result<(), StorageError> {
-        for map_ref in tags.as_raw_iter() {
-            let (recipient, tag) = map_ref.pair();
-            self.manager
-                .insert_tag(StoredSenderTag::new(*recipient, *tag))
-                .await?;
-        }
-        Ok(())
-    }
-
-    async fn get_stored_reply_keys(&self) -> Result<SentReplyKeys, StorageError> {
-        let stored = self.manager.get_reply_keys().await?;
-
-        // stop at the first instance of corruption. if even a single entry is malformed,
-        // something weird has happened and we can't trust the rest of the data
-        let raw = stored
-            .into_iter()
-            .map(TryInto::try_into)
-            .collect::<Result<_, _>>()?;
-
-        Ok(SentReplyKeys::from_raw(raw))
-    }
-
-    async fn dump_sender_reply_keys(&self, reply_keys: &SentReplyKeys) -> Result<(), StorageError> {
-        for map_ref in reply_keys.as_raw_iter() {
-            let (digest, key) = map_ref.pair();
-            self.manager
-                .insert_reply_key(StoredReplyKey::new(*digest, *key))
-                .await?;
-        }
-        Ok(())
-    }
-
-    async fn get_stored_reply_surbs(&self) -> Result<ReceivedReplySurbsMap, StorageError> {
-        let surb_senders = self.manager.get_surb_senders().await?;
-
-        let metadata = self.get_reply_surb_storage_metadata().await?;
-        let mut received_surbs = Vec::with_capacity(surb_senders.len());
-        for sender in surb_senders {
-            let sender_id = sender.id;
-            let (sender_tag, surbs_last_received_at_timestamp): (AnonymousSenderTag, i64) =
-                sender.try_into()?;
-            let stored_surbs = self
-                .manager
-                .get_reply_surbs(sender_id)
-                .await?
-                .into_iter()
-                .map(|raw| raw.try_into())
-                .collect::<Result<_, _>>()?;
-
-            received_surbs.push((
-                sender_tag,
-                ReceivedReplySurbs::new_retrieved(stored_surbs, surbs_last_received_at_timestamp),
-            ))
-        }
-
-        Ok(ReceivedReplySurbsMap::from_raw(
-            metadata.min_reply_surb_threshold as usize,
-            metadata.max_reply_surb_threshold as usize,
-            received_surbs,
-        ))
-    }
-
-    async fn dump_reply_surbs(
-        &self,
-        reply_surbs: &ReceivedReplySurbsMap,
-    ) -> Result<(), StorageError> {
-        for map_ref in reply_surbs.as_raw_iter() {
-            let (tag, received_surbs) = map_ref.pair();
-            let sender_id = self
-                .manager
-                .insert_surb_sender(StoredSurbSender::new(
-                    *tag,
-                    received_surbs.surbs_last_received_at(),
-                ))
-                .await?;
-
-            for reply_surb in received_surbs.surbs_ref() {
-                self.manager
-                    .insert_reply_surb(StoredReplySurb::new(sender_id, reply_surb))
-                    .await?
-            }
-        }
-        Ok(())
-    }
-
-    async fn get_reply_surb_storage_metadata(
-        &self,
-    ) -> Result<ReplySurbStorageMetadata, StorageError> {
-        self.manager
-            .get_reply_surb_storage_metadata()
-            .await
-            .map_err(Into::into)
-    }
-
-    async fn dump_reply_surb_storage_metadata(
-        &self,
-        reply_surbs: &ReceivedReplySurbsMap,
-    ) -> Result<(), StorageError> {
-        self.manager
-            .insert_reply_surb_storage_metadata(ReplySurbStorageMetadata::new(
-                reply_surbs.min_surb_threshold(),
-                reply_surbs.max_surb_threshold(),
-            ))
-            .await
-            .map_err(Into::into)
-    }
-}
-
-#[async_trait]
-impl ReplyStorageBackend for Backend {
-    type StorageError = error::StorageError;
-
-    async fn start_storage_session(&self) -> Result<(), Self::StorageError> {
-        self.start_client_use().await
-    }
-
-    async fn flush_surb_storage(
-        &mut self,
-        storage: &CombinedReplyStorage,
-    ) -> Result<(), Self::StorageError> {
-        // close all connections (there should be none! and rename the file to contain .old extension)
-        self.rotate().await?;
-        self.start_storage_flush().await?;
-
-        self.dump_sender_tags(storage.tags_storage_ref()).await?;
-        self.dump_sender_reply_keys(storage.key_storage_ref())
-            .await?;
-        let surbs_ref = storage.surbs_storage_ref();
-        self.dump_reply_surb_storage_metadata(surbs_ref).await?;
-        self.dump_reply_surbs(surbs_ref).await?;
-
-        self.remove_old()?;
-        self.end_storage_flush().await
-    }
-
-    async fn init_fresh(&mut self, fresh: &CombinedReplyStorage) -> Result<(), Self::StorageError> {
-        // for now nothing more to do apart from dumping the metadata
-        self.dump_reply_surb_storage_metadata(fresh.surbs_storage_ref())
-            .await
-    }
-
-    async fn load_surb_storage(&self) -> Result<CombinedReplyStorage, Self::StorageError> {
-        let reply_keys = self.get_stored_reply_keys().await?;
-        let tags = self.get_stored_tags().await?;
-        let reply_surbs = self.get_stored_reply_surbs().await?;
-
-        Ok(CombinedReplyStorage::load(reply_keys, reply_surbs, tags))
-    }
-
-    async fn stop_storage_session(self) -> Result<(), Self::StorageError> {
-        self.stop_client_use().await
-    }
-}
@@ -1,185 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::client::replies::reply_storage::backend::fs_backend::error::StorageError;
-use crate::client::replies::reply_storage::key_storage::UsedReplyKey;
-use crypto::generic_array::typenum::Unsigned;
-use crypto::Digest;
-use nymsphinx::addressing::clients::{Recipient, RecipientBytes};
-use nymsphinx::anonymous_replies::encryption_key::EncryptionKeyDigest;
-use nymsphinx::anonymous_replies::requests::{AnonymousSenderTag, SENDER_TAG_SIZE};
-use nymsphinx::anonymous_replies::{ReplySurb, SurbEncryptionKey, SurbEncryptionKeySize};
-use nymsphinx::params::ReplySurbKeyDigestAlgorithm;
-
-#[derive(Debug, Clone)]
-pub(crate) struct StoredSenderTag {
-    pub(crate) recipient: Vec<u8>,
-    pub(crate) tag: Vec<u8>,
-}
-
-impl StoredSenderTag {
-    pub(crate) fn new(recipient: RecipientBytes, tag: AnonymousSenderTag) -> StoredSenderTag {
-        StoredSenderTag {
-            recipient: recipient.to_vec(),
-            tag: tag.to_bytes().to_vec(),
-        }
-    }
-}
-
-impl TryFrom<StoredSenderTag> for (RecipientBytes, AnonymousSenderTag) {
-    type Error = StorageError;
-
-    fn try_from(value: StoredSenderTag) -> Result<Self, Self::Error> {
-        let recipient_len = value.recipient.len();
-        let Ok(recipient_bytes) = value.recipient.try_into() else {
-            return Err(StorageError::CorruptedData {
-                details: format!(
-                    "the retrieved recipient has length of {recipient_len} while {} was expected",
-                    Recipient::LEN
-                ),
-            });
-        };
-
-        let tag_len = value.tag.len();
-        let Ok(sender_tag_bytes) = value.tag.try_into() else {
-            return Err(StorageError::CorruptedData {
-                details: format!(
-                    "the retrieved sender tag has length of {tag_len} while {} was expected",
-                    SENDER_TAG_SIZE
-                ),
-            });
-        };
-
-        Ok((
-            recipient_bytes,
-            AnonymousSenderTag::from_bytes(sender_tag_bytes),
-        ))
-    }
-}
-
-#[derive(Debug, Clone)]
-pub(crate) struct StoredReplyKey {
-    pub(crate) key_digest: Vec<u8>,
-    pub(crate) reply_key: Vec<u8>,
-    pub(crate) sent_at_timestamp: i64,
-}
-
-impl StoredReplyKey {
-    pub(crate) fn new(key_digest: EncryptionKeyDigest, reply_key: UsedReplyKey) -> StoredReplyKey {
-        StoredReplyKey {
-            key_digest: key_digest.to_vec(),
-            reply_key: (*reply_key).to_bytes(),
-            sent_at_timestamp: reply_key.sent_at_timestamp,
-        }
-    }
-}
-
-impl TryFrom<StoredReplyKey> for (EncryptionKeyDigest, UsedReplyKey) {
-    type Error = StorageError;
-
-    fn try_from(value: StoredReplyKey) -> Result<Self, Self::Error> {
-        let expected_reply_key_digest_size = ReplySurbKeyDigestAlgorithm::output_size();
-        let reply_key_digest_size = value.key_digest.len();
-
-        let Some(digest) = EncryptionKeyDigest::from_exact_iter(value.key_digest) else {
-            return Err(StorageError::CorruptedData {
-                details: format!(
-                    "the reply surb digest has length of {reply_key_digest_size} while {expected_reply_key_digest_size} was expected",
-                ),
-            });
-        };
-
-        let reply_key_len = value.reply_key.len();
-        let Ok(reply_key) = SurbEncryptionKey::try_from_bytes(&value.reply_key) else {
-            return Err(StorageError::CorruptedData {
-                details: format!(
-                    "the reply key has length of {reply_key_len} while {} was expected",
-                    SurbEncryptionKeySize::USIZE
-                ),
-            });
-        };
-
-        Ok((
-            digest,
-            UsedReplyKey::new(reply_key, value.sent_at_timestamp),
-        ))
-    }
-}
-
-pub(crate) struct StoredSurbSender {
-    pub(crate) id: i64,
-    pub(crate) tag: Vec<u8>,
-    pub(crate) last_sent_timestamp: i64,
-}
-
-impl StoredSurbSender {
-    pub(crate) fn new(tag: AnonymousSenderTag, last_sent_timestamp: i64) -> Self {
-        StoredSurbSender {
-            // for the purposes of STORING data,
-            // we ignore that field anyway
-            id: 0,
-            tag: tag.to_bytes().to_vec(),
-            last_sent_timestamp,
-        }
-    }
-}
-
-impl TryFrom<StoredSurbSender> for (AnonymousSenderTag, i64) {
-    type Error = StorageError;
-
-    fn try_from(value: StoredSurbSender) -> Result<Self, Self::Error> {
-        let tag_len = value.tag.len();
-        let Ok(sender_tag_bytes) = value.tag.try_into() else {
-            return Err(StorageError::CorruptedData {
-                details: format!(
-                    "the retrieved sender tag has length of {tag_len} while {} was expected",
-                    SENDER_TAG_SIZE
-                ),
-            });
-        };
-
-        Ok((
-            AnonymousSenderTag::from_bytes(sender_tag_bytes),
-            value.last_sent_timestamp,
-        ))
-    }
-}
-
-pub(crate) struct StoredReplySurb {
-    pub(crate) reply_surb_sender_id: i64,
-    pub(crate) reply_surb: Vec<u8>,
-}
-
-impl StoredReplySurb {
-    pub(crate) fn new(reply_surb_sender_id: i64, reply_surb: &ReplySurb) -> Self {
-        StoredReplySurb {
-            reply_surb_sender_id,
-            reply_surb: reply_surb.to_bytes(),
-        }
-    }
-}
-
-impl TryFrom<StoredReplySurb> for ReplySurb {
-    type Error = StorageError;
-
-    fn try_from(value: StoredReplySurb) -> Result<Self, Self::Error> {
-        ReplySurb::from_bytes(&value.reply_surb).map_err(|err| StorageError::CorruptedData {
-            details: format!("failed to recover the reply surb: {err}"),
-        })
-    }
-}
-
-#[derive(Copy, Clone)]
-pub(crate) struct ReplySurbStorageMetadata {
-    pub(crate) min_reply_surb_threshold: u32,
-    pub(crate) max_reply_surb_threshold: u32,
-}
-
-impl ReplySurbStorageMetadata {
-    pub(crate) fn new(min_reply_surb_threshold: usize, max_reply_surb_threshold: usize) -> Self {
-        Self {
-            min_reply_surb_threshold: min_reply_surb_threshold as u32,
-            max_reply_surb_threshold: max_reply_surb_threshold as u32,
-        }
-    }
-}
@@ -1,78 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::client::replies::reply_storage::CombinedReplyStorage;
-use async_trait::async_trait;
-use std::error::Error;
-use thiserror::Error;
-
-#[cfg(target_arch = "wasm32")]
-pub mod browser_backend;
-
-#[cfg(all(not(target_arch = "wasm32"), feature = "fs-surb-storage"))]
-pub mod fs_backend;
-
-// #[cfg(all(test, feature = "std"))]
-// third case: node with actual filesystem
-
-#[derive(Debug, Error)]
-#[error("no information provided")]
-pub struct UndefinedError;
-
-pub struct Empty {
-    // we need to keep 'basic' metadata here to "load" the CombinedReplyStorage
-    min_surb_threshold: usize,
-    max_surb_threshold: usize,
-}
-
-#[async_trait]
-impl ReplyStorageBackend for Empty {
-    type StorageError = UndefinedError;
-
-    async fn flush_surb_storage(
-        &mut self,
-        _storage: &CombinedReplyStorage,
-    ) -> Result<(), Self::StorageError> {
-        Ok(())
-    }
-
-    async fn init_fresh(
-        &mut self,
-        _fresh: &CombinedReplyStorage,
-    ) -> Result<(), Self::StorageError> {
-        Ok(())
-    }
-
-    async fn load_surb_storage(&self) -> Result<CombinedReplyStorage, Self::StorageError> {
-        Ok(CombinedReplyStorage::new(
-            self.min_surb_threshold,
-            self.max_surb_threshold,
-        ))
-    }
-}
-
-#[async_trait]
-pub trait ReplyStorageBackend: Sized {
-    type StorageError: Error + 'static;
-
-    async fn start_storage_session(&self) -> Result<(), Self::StorageError> {
-        Ok(())
-    }
-
-    // reply keys and surbs would need additional field set when data is loaded
-    // so if there's some failure, we'd trash it all
-    async fn flush_surb_storage(
-        &mut self,
-        storage: &CombinedReplyStorage,
-    ) -> Result<(), Self::StorageError>;
-
-    /// The purpose of this call is to save any metadata that might be present.
-    /// (such as surb thresholds)
-    async fn init_fresh(&mut self, fresh: &CombinedReplyStorage) -> Result<(), Self::StorageError>;
-
-    async fn load_surb_storage(&self) -> Result<CombinedReplyStorage, Self::StorageError>;
-
-    async fn stop_storage_session(self) -> Result<(), Self::StorageError> {
-        Ok(())
-    }
-}
@@ -1,60 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::client::replies::reply_storage::{ReceivedReplySurbsMap, SentReplyKeys, UsedSenderTags};
-
-#[derive(Debug, Clone)]
-pub struct CombinedReplyStorage {
-    sent_reply_keys: SentReplyKeys,
-    received_reply_surbs: ReceivedReplySurbsMap,
-    used_tags: UsedSenderTags,
-}
-
-impl CombinedReplyStorage {
-    pub fn new(min_surb_threshold: usize, max_surb_threshold: usize) -> CombinedReplyStorage {
-        CombinedReplyStorage {
-            sent_reply_keys: SentReplyKeys::new(),
-            received_reply_surbs: ReceivedReplySurbsMap::new(
-                min_surb_threshold,
-                max_surb_threshold,
-            ),
-            used_tags: UsedSenderTags::new(),
-        }
-    }
-
-    pub fn load(
-        sent_reply_keys: SentReplyKeys,
-        received_reply_surbs: ReceivedReplySurbsMap,
-        used_tags: UsedSenderTags,
-    ) -> Self {
-        CombinedReplyStorage {
-            sent_reply_keys,
-            received_reply_surbs,
-            used_tags,
-        }
-    }
-
-    pub fn key_storage(&self) -> SentReplyKeys {
-        self.sent_reply_keys.clone()
-    }
-
-    pub fn surbs_storage(&self) -> ReceivedReplySurbsMap {
-        self.received_reply_surbs.clone()
-    }
-
-    pub fn tags_storage(&self) -> UsedSenderTags {
-        self.used_tags.clone()
-    }
-
-    pub fn key_storage_ref(&self) -> &SentReplyKeys {
-        &self.sent_reply_keys
-    }
-
-    pub fn surbs_storage_ref(&self) -> &ReceivedReplySurbsMap {
-        &self.received_reply_surbs
-    }
-
-    pub fn tags_storage_ref(&self) -> &UsedSenderTags {
-        &self.used_tags
-    }
-}
@@ -1,86 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use dashmap::iter::Iter;
-use dashmap::DashMap;
-use nymsphinx::anonymous_replies::encryption_key::EncryptionKeyDigest;
-use nymsphinx::anonymous_replies::SurbEncryptionKey;
-use std::ops::Deref;
-use std::sync::Arc;
-use time::OffsetDateTime;
-
-#[derive(Debug, Clone)]
-pub struct SentReplyKeys {
-    inner: Arc<SentReplyKeysInner>,
-}
-
-#[derive(Debug)]
-struct SentReplyKeysInner {
-    data: DashMap<EncryptionKeyDigest, UsedReplyKey>,
-}
-
-impl SentReplyKeys {
-    pub(crate) fn new() -> SentReplyKeys {
-        SentReplyKeys {
-            inner: Arc::new(SentReplyKeysInner {
-                data: DashMap::new(),
-            }),
-        }
-    }
-
-    #[cfg(all(not(target_arch = "wasm32"), feature = "fs-surb-storage"))]
-    pub(crate) fn from_raw(raw: Vec<(EncryptionKeyDigest, UsedReplyKey)>) -> SentReplyKeys {
-        SentReplyKeys {
-            inner: Arc::new(SentReplyKeysInner {
-                data: raw.into_iter().collect(),
-            }),
-        }
-    }
-
-    pub(crate) fn as_raw_iter(&self) -> Iter<'_, EncryptionKeyDigest, UsedReplyKey> {
-        self.inner.data.iter()
-    }
-
-    pub(crate) fn insert_multiple(&self, keys: Vec<SurbEncryptionKey>) {
-        let now = OffsetDateTime::now_utc().unix_timestamp();
-        for key in keys {
-            self.insert(UsedReplyKey::new(key, now))
-        }
-    }
-
-    pub(crate) fn insert(&self, key: UsedReplyKey) {
-        self.inner.data.insert(key.compute_digest(), key);
-    }
-
-    pub(crate) fn try_pop(&self, digest: EncryptionKeyDigest) -> Option<UsedReplyKey> {
-        self.inner.data.remove(&digest).map(|(_k, v)| v)
-    }
-
-    pub(crate) fn remove(&self, digest: EncryptionKeyDigest) {
-        self.inner.data.remove(&digest);
-    }
-}
-
-#[derive(Debug, Copy, Clone)]
-pub(crate) struct UsedReplyKey {
-    key: SurbEncryptionKey,
-    // the purpose of this field is to perform invalidation at relatively very long intervals
-    pub(crate) sent_at_timestamp: i64,
-}
-
-impl UsedReplyKey {
-    pub(crate) fn new(key: SurbEncryptionKey, sent_at_timestamp: i64) -> Self {
-        UsedReplyKey {
-            key,
-            sent_at_timestamp,
-        }
-    }
-}
-
-impl Deref for UsedReplyKey {
-    type Target = SurbEncryptionKey;
-
-    fn deref(&self) -> &Self::Target {
-        &self.key
-    }
-}
@@ -1,64 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-pub use crate::client::replies::reply_storage::combined::CombinedReplyStorage;
-pub use crate::client::replies::reply_storage::key_storage::SentReplyKeys;
-pub use crate::client::replies::reply_storage::surb_storage::ReceivedReplySurbsMap;
-pub use crate::client::replies::reply_storage::tag_storage::UsedSenderTags;
-pub use backend::*;
-
-mod backend;
-mod combined;
-mod key_storage;
-mod surb_storage;
-mod tag_storage;
-
-// only really exists to get information about shutdown and save data to the backing storage
-pub struct PersistentReplyStorage<T = backend::Empty>
-where
-    T: ReplyStorageBackend,
-{
-    backend: T,
-}
-
-impl<T> PersistentReplyStorage<T>
-where
-    T: ReplyStorageBackend + Send + Sync,
-{
-    pub fn new(backend: T) -> Self {
-        PersistentReplyStorage { backend }
-    }
-
-    pub async fn load_state_from_backend(&self) -> Result<CombinedReplyStorage, T::StorageError> {
-        self.backend.load_surb_storage().await
-    }
-
-    // this will have to get enabled after merging develop
-    pub async fn flush_on_shutdown(
-        mut self,
-        mem_state: CombinedReplyStorage,
-        mut shutdown: task::TaskClient,
-    ) {
-        use log::{debug, error, info, warn};
-
-        debug!("Started PersistentReplyStorage");
-        if let Err(err) = self.backend.start_storage_session().await {
-            error!("failed to start the storage session - {err}");
-            return;
-        }
-
-        shutdown.recv().await;
-
-        info!("PersistentReplyStorage is flushing all reply-related data to underlying storage");
-        warn!("you MUST NOT forcefully shutdown now or you risk data corruption!");
-        if let Err(err) = self.backend.flush_surb_storage(&mem_state).await {
-            error!("failed to flush our reply-related data to the persistent storage: {err}")
-        } else {
-            info!("Data flush is complete")
-        }
-
-        if let Err(err) = self.backend.stop_storage_session().await {
-            error!("failed to properly stop the storage session - {err}. We might not be able to smoothly restore it")
-        }
-    }
-}
@@ -1,278 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use dashmap::iter::Iter;
-use dashmap::DashMap;
-use log::trace;
-use nymsphinx::anonymous_replies::requests::AnonymousSenderTag;
-use nymsphinx::anonymous_replies::ReplySurb;
-use std::collections::VecDeque;
-use std::sync::atomic::{AtomicUsize, Ordering};
-use std::sync::Arc;
-use time::OffsetDateTime;
-
-#[derive(Debug, Clone)]
-pub struct ReceivedReplySurbsMap {
-    inner: Arc<ReceivedReplySurbsMapInner>,
-}
-
-#[derive(Debug)]
-struct ReceivedReplySurbsMapInner {
-    data: DashMap<AnonymousSenderTag, ReceivedReplySurbs>,
-
-    // the minimum amount of surbs that have to be kept in storage for requests for more surbs
-    min_surb_threshold: AtomicUsize,
-
-    // the maximum amount of surbs that we want to keep in storage so that we don't over-request them
-    max_surb_threshold: AtomicUsize,
-}
-
-impl ReceivedReplySurbsMap {
-    pub(crate) fn new(
-        min_surb_threshold: usize,
-        max_surb_threshold: usize,
-    ) -> ReceivedReplySurbsMap {
-        ReceivedReplySurbsMap {
-            inner: Arc::new(ReceivedReplySurbsMapInner {
-                data: DashMap::new(),
-                min_surb_threshold: AtomicUsize::new(min_surb_threshold),
-                max_surb_threshold: AtomicUsize::new(max_surb_threshold),
-            }),
-        }
-    }
-
-    #[cfg(all(not(target_arch = "wasm32"), feature = "fs-surb-storage"))]
-    pub(crate) fn from_raw(
-        min_surb_threshold: usize,
-        max_surb_threshold: usize,
-        raw: Vec<(AnonymousSenderTag, ReceivedReplySurbs)>,
-    ) -> ReceivedReplySurbsMap {
-        ReceivedReplySurbsMap {
-            inner: Arc::new(ReceivedReplySurbsMapInner {
-                data: raw.into_iter().collect(),
-                min_surb_threshold: AtomicUsize::new(min_surb_threshold),
-                max_surb_threshold: AtomicUsize::new(max_surb_threshold),
-            }),
-        }
-    }
-
-    pub(crate) fn as_raw_iter(&self) -> Iter<'_, AnonymousSenderTag, ReceivedReplySurbs> {
-        self.inner.data.iter()
-    }
-
-    pub(crate) fn remove(&self, target: &AnonymousSenderTag) {
-        self.inner.data.remove(target);
-    }
-
-    pub(crate) fn reset_surbs_last_received_at(&self, target: &AnonymousSenderTag) {
-        if let Some(mut entry) = self.inner.data.get_mut(target) {
-            entry.surbs_last_received_at_timestamp = OffsetDateTime::now_utc().unix_timestamp();
-        }
-    }
-
-    pub(crate) fn surbs_last_received_at(&self, target: &AnonymousSenderTag) -> Option<i64> {
-        self.inner
-            .data
-            .get(target)
-            .map(|e| e.surbs_last_received_at())
-    }
-
-    pub(crate) fn pending_reception(&self, target: &AnonymousSenderTag) -> u32 {
-        self.inner
-            .data
-            .get(target)
-            .map(|e| e.pending_reception())
-            .unwrap_or_default()
-    }
-
-    pub(crate) fn increment_pending_reception(
-        &self,
-        target: &AnonymousSenderTag,
-        amount: u32,
-    ) -> Option<u32> {
-        self.inner
-            .data
-            .get_mut(target)
-            .map(|mut e| e.increment_pending_reception(amount))
-    }
-
-    pub(crate) fn decrement_pending_reception(
-        &self,
-        target: &AnonymousSenderTag,
-        amount: u32,
-    ) -> Option<u32> {
-        self.inner
-            .data
-            .get_mut(target)
-            .map(|mut e| e.decrement_pending_reception(amount))
-    }
-
-    pub(crate) fn reset_pending_reception(&self, target: &AnonymousSenderTag) {
-        if let Some(mut e) = self.inner.data.get_mut(target) {
-            e.reset_pending_reception()
-        }
-    }
-
-    pub(crate) fn min_surb_threshold(&self) -> usize {
-        self.inner.min_surb_threshold.load(Ordering::Relaxed)
-    }
-
-    pub(crate) fn max_surb_threshold(&self) -> usize {
-        self.inner.max_surb_threshold.load(Ordering::Relaxed)
-    }
-
-    pub(crate) fn available_surbs(&self, target: &AnonymousSenderTag) -> usize {
-        self.inner
-            .data
-            .get(target)
-            .map(|entry| entry.items_left())
-            .unwrap_or_default()
-    }
-
-    pub(crate) fn contains_surbs_for(&self, target: &AnonymousSenderTag) -> bool {
-        self.inner.data.contains_key(target)
-    }
-
-    pub(crate) fn get_reply_surbs(
-        &self,
-        target: &AnonymousSenderTag,
-        amount: usize,
-    ) -> (Option<Vec<ReplySurb>>, usize) {
-        if let Some(mut entry) = self.inner.data.get_mut(target) {
-            let surbs_left = entry.items_left();
-            if surbs_left < self.min_surb_threshold() + amount {
-                (None, surbs_left)
-            } else {
-                entry.get_reply_surbs(amount)
-            }
-        } else {
-            (None, 0)
-        }
-    }
-
-    pub(crate) fn get_reply_surb_ignoring_threshold(
-        &self,
-        target: &AnonymousSenderTag,
-    ) -> Option<(Option<ReplySurb>, usize)> {
-        self.inner
-            .data
-            .get_mut(target)
-            .map(|mut s| s.get_reply_surb())
-    }
-
-    pub(crate) fn get_reply_surb(
-        &self,
-        target: &AnonymousSenderTag,
-    ) -> Option<(Option<ReplySurb>, usize)> {
-        self.inner.data.get_mut(target).map(|mut entry| {
-            let surbs_left = entry.items_left();
-            if surbs_left < self.min_surb_threshold() {
-                (None, surbs_left)
-            } else {
-                entry.get_reply_surb()
-            }
-        })
-    }
-
-    pub(crate) fn insert_surbs<I: IntoIterator<Item = ReplySurb>>(
-        &self,
-        target: &AnonymousSenderTag,
-        surbs: I,
-    ) {
-        if let Some(mut existing_data) = self.inner.data.get_mut(target) {
-            existing_data.insert_reply_surbs(surbs)
-        } else {
-            let new_entry = ReceivedReplySurbs::new(surbs.into_iter().collect());
-            self.inner.data.insert(*target, new_entry);
-        }
-    }
-}
-
-#[derive(Debug)]
-pub(crate) struct ReceivedReplySurbs {
-    // in the future we'd probably want to put extra data here to indicate when the SURBs got received
-    // so we could invalidate entries from the previous key rotations
-    data: VecDeque<ReplySurb>,
-
-    pending_reception: u32,
-    surbs_last_received_at_timestamp: i64,
-}
-
-impl ReceivedReplySurbs {
-    fn new(initial_surbs: VecDeque<ReplySurb>) -> Self {
-        ReceivedReplySurbs {
-            data: initial_surbs,
-            pending_reception: 0,
-            surbs_last_received_at_timestamp: OffsetDateTime::now_utc().unix_timestamp(),
-        }
-    }
-
-    #[cfg(all(not(target_arch = "wasm32"), feature = "fs-surb-storage"))]
-    pub(crate) fn new_retrieved(
-        surbs: Vec<ReplySurb>,
-        surbs_last_received_at_timestamp: i64,
-    ) -> ReceivedReplySurbs {
-        ReceivedReplySurbs {
-            data: surbs.into(),
-            pending_reception: 0,
-            surbs_last_received_at_timestamp,
-        }
-    }
-
-    #[cfg(all(not(target_arch = "wasm32"), feature = "fs-surb-storage"))]
-    pub(crate) fn surbs_ref(&self) -> &VecDeque<ReplySurb> {
-        &self.data
-    }
-
-    pub(crate) fn surbs_last_received_at(&self) -> i64 {
-        self.surbs_last_received_at_timestamp
-    }
-
-    pub(crate) fn pending_reception(&self) -> u32 {
-        self.pending_reception
-    }
-
-    pub(crate) fn increment_pending_reception(&mut self, amount: u32) -> u32 {
-        self.pending_reception += amount;
-        self.pending_reception
-    }
-
-    pub(crate) fn decrement_pending_reception(&mut self, amount: u32) -> u32 {
-        self.pending_reception = self.pending_reception.saturating_sub(amount);
-        self.pending_reception
-    }
-
-    pub(crate) fn reset_pending_reception(&mut self) {
-        self.pending_reception = 0;
-    }
-
-    pub(crate) fn get_reply_surbs(&mut self, amount: usize) -> (Option<Vec<ReplySurb>>, usize) {
-        if self.items_left() < amount {
-            (None, self.items_left())
-        } else {
-            let surbs = self.data.drain(..amount).collect();
-            (Some(surbs), self.items_left())
-        }
-    }
-
-    pub(crate) fn get_reply_surb(&mut self) -> (Option<ReplySurb>, usize) {
-        (self.pop_surb(), self.items_left())
-    }
-
-    fn pop_surb(&mut self) -> Option<ReplySurb> {
-        self.data.pop_front()
-    }
-
-    fn items_left(&self) -> usize {
-        self.data.len()
-    }
-
-    // realistically we're always going to be getting multiple surbs at once
-    pub(crate) fn insert_reply_surbs<I: IntoIterator<Item = ReplySurb>>(&mut self, surbs: I) {
-        let mut v = surbs.into_iter().collect::<VecDeque<_>>();
-        trace!("storing {} surbs in the storage", v.len());
-        self.data.append(&mut v);
-        self.surbs_last_received_at_timestamp = OffsetDateTime::now_utc().unix_timestamp();
-        trace!("we now have {} surbs!", self.data.len());
-    }
-}
@@ -1,59 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use dashmap::DashMap;
-use nymsphinx::addressing::clients::{Recipient, RecipientBytes};
-use nymsphinx::anonymous_replies::requests::AnonymousSenderTag;
-use std::sync::Arc;
-
-#[cfg(all(not(target_arch = "wasm32"), feature = "fs-surb-storage"))]
-use dashmap::iter::Iter;
-
-#[derive(Debug, Clone)]
-pub struct UsedSenderTags {
-    inner: Arc<UsedSenderTagsInner>,
-}
-
-#[derive(Debug)]
-struct UsedSenderTagsInner {
-    data: DashMap<RecipientBytes, AnonymousSenderTag>,
-}
-
-impl UsedSenderTags {
-    pub(crate) fn new() -> UsedSenderTags {
-        UsedSenderTags {
-            inner: Arc::new(UsedSenderTagsInner {
-                data: DashMap::new(),
-            }),
-        }
-    }
-
-    #[cfg(all(not(target_arch = "wasm32"), feature = "fs-surb-storage"))]
-    pub(crate) fn from_raw(raw: Vec<(RecipientBytes, AnonymousSenderTag)>) -> UsedSenderTags {
-        UsedSenderTags {
-            inner: Arc::new(UsedSenderTagsInner {
-                data: raw.into_iter().collect(),
-            }),
-        }
-    }
-
-    #[cfg(all(not(target_arch = "wasm32"), feature = "fs-surb-storage"))]
-    pub(crate) fn as_raw_iter(&self) -> Iter<'_, RecipientBytes, AnonymousSenderTag> {
-        self.inner.data.iter()
-    }
-
-    pub(crate) fn insert_new(&self, recipient: &Recipient, tag: AnonymousSenderTag) {
-        self.inner.data.insert(recipient.to_bytes(), tag);
-    }
-
-    pub(crate) fn try_get_existing(&self, recipient: &Recipient) -> Option<AnonymousSenderTag> {
-        self.inner
-            .data
-            .get(&recipient.to_bytes())
-            .map(|r| *r.value())
-    }
-
-    pub(crate) fn exists(&self, recipient: &Recipient) -> bool {
-        self.inner.data.contains_key(&recipient.to_bytes())
-    }
-}
@@ -0,0 +1,94 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crypto::generic_array::typenum::Unsigned;
+use log::*;
+use nymsphinx::anonymous_replies::{
+    encryption_key::EncryptionKeyDigest, SurbEncryptionKey, SurbEncryptionKeySize,
+};
+use std::path::Path;
+
+#[derive(Debug)]
+pub enum ReplyKeyStorageError {
+    DbReadError(sled::Error),
+    DbWriteError(sled::Error),
+    DbOpenError(sled::Error),
+}
+
+/// Permanent storage for keys in all sent [`ReplySURB`]
+///
+/// Each sent out [`ReplySURB`] has a new key associated with it that is going to be used for
+/// payload encryption. In order to -decrypt whatever reply we receive, we need to know which
+/// key to use for that purpose. We do it based on received `H(t)` which has to be included
+/// with each reply.
+/// Moreover, there is no restriction when the [`ReplySURB`] might get used so we need to
+/// have a permanent storage for all the keys that we might ever see in the future.
+#[derive(Debug, Clone)]
+pub struct ReplyKeyStorage {
+    db: sled::Db,
+}
+
+impl ReplyKeyStorage {
+    pub fn load<P: AsRef<Path>>(path: P) -> Result<Self, ReplyKeyStorageError> {
+        let db = match sled::open(path) {
+            Err(e) => return Err(ReplyKeyStorageError::DbOpenError(e)),
+            Ok(db) => db,
+        };
+
+        Ok(ReplyKeyStorage { db })
+    }
+
+    fn read_encryption_key(&self, raw_key: sled::IVec) -> SurbEncryptionKey {
+        let key_bytes_ref = raw_key.as_ref();
+        // if this fails it means we have some database corruption and we
+        // absolutely can't continue
+
+        if key_bytes_ref.len() != SurbEncryptionKeySize::USIZE {
+            error!("REPLY KEY STORAGE DATA CORRUPTION - ENCRYPTION KEY HAS INVALID LENGTH");
+            panic!("REPLY KEY STORAGE DATA CORRUPTION - ENCRYPTION KEY HAS INVALID LENGTH");
+        }
+
+        // this can only fail if the bytes have invalid length but we already asserted it
+        SurbEncryptionKey::try_from_bytes(key_bytes_ref).unwrap()
+    }
+
+    // TOOD: perhaps we could also store some part of original message here too?
+    pub fn insert_encryption_key(
+        &mut self,
+        encryption_key: SurbEncryptionKey,
+    ) -> Result<(), ReplyKeyStorageError> {
+        let digest = encryption_key.compute_digest();
+
+        let insertion_result = match self.db.insert(digest, encryption_key.to_bytes()) {
+            Err(e) => Err(ReplyKeyStorageError::DbWriteError(e)),
+            Ok(existing_key) => {
+                if existing_key.is_some() {
+                    panic!("HASH COLLISION DETECTED")
+                };
+                Ok(())
+            }
+        };
+
+        // TODO: perhaps we could implement some batching mechanism to avoid frequent flushes?
+        self.db.flush().unwrap();
+        insertion_result
+    }
+
+    // Once we use key once, we do not expect to use it again
+    pub fn get_and_remove_encryption_key(
+        &self,
+        key_digest: EncryptionKeyDigest,
+    ) -> Result<Option<SurbEncryptionKey>, ReplyKeyStorageError> {
+        let removal_result = match self.db.remove(key_digest) {
+            Err(e) => Err(ReplyKeyStorageError::DbReadError(e)),
+            Ok(existing_key) => {
+                Ok(existing_key.map(|existing_key| self.read_encryption_key(existing_key)))
+            }
+        };
+
+        // TODO: not sure how to feel about flushing it every single time here...
+        // same with insertion
+        self.db.flush().unwrap();
+        removal_result
+    }
+}
@@ -1,8 +1,6 @@
-// Copyright 2021-2022 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::spawn_future;
-use futures::StreamExt;
 use log::*;
 use nymsphinx::addressing::clients::Recipient;
 use nymsphinx::params::DEFAULT_NUM_MIX_HOPS;
@@ -10,9 +8,12 @@ use rand::seq::SliceRandom;
 use rand::thread_rng;
 use std::ops::Deref;
 use std::sync::Arc;
+use std::time;
 use std::time::Duration;
+use task::ShutdownListener;
 use tokio::sync::{RwLock, RwLockReadGuard};
-use topology::{nym_topology_from_detailed, NymTopology, NymTopologyError};
+use tokio::task::JoinHandle;
+use topology::{nym_topology_from_bonds, NymTopology};
 use url::Url;

 // I'm extremely curious why compiler NEVER complained about lack of Debug here before
@@ -54,36 +55,27 @@ impl<'a> TopologyReadPermit<'a> {
        &'a self,
        ack_recipient: &Recipient,
        packet_recipient: Option<&Recipient>,
-    ) -> Result<&'a NymTopology, NymTopologyError> {
-        // 1. Have we managed to get anything from the refresher, i.e. have the nym-api queries gone through?
-        let topology = self
-            .permit
-            .as_ref()
-            .as_ref()
-            .ok_or(NymTopologyError::EmptyNetworkTopology)?;
-
-        // 2. does it have any mixnode at all?
-        // 3. does it have any gateways at all?
-        // 4. does it have a mixnode on each layer?
-        topology.ensure_can_construct_path_through(DEFAULT_NUM_MIX_HOPS)?;
-
-        // 5. does it contain OUR gateway (so that we could create an ack packet)?
-        if !topology.gateway_exists(ack_recipient.gateway()) {
-            return Err(NymTopologyError::NonExistentGatewayError {
-                identity_key: ack_recipient.gateway().to_base58_string(),
-            });
-        }
-
-        // 6. for our target recipient, does it contain THEIR gateway (so that we could create
-        if let Some(recipient) = packet_recipient {
-            if !topology.gateway_exists(recipient.gateway()) {
-                return Err(NymTopologyError::NonExistentGatewayError {
-                    identity_key: recipient.gateway().to_base58_string(),
-                });
+    ) -> Option<&'a NymTopology> {
+        // Note: implicit deref with Deref for TopologyReadPermit is happening here
+        let topology_ref_option = self.permit.as_ref();
+        match topology_ref_option {
+            None => None,
+            Some(topology_ref) => {
+                // see if it's possible to route the packet to both gateways
+                if !topology_ref.can_construct_path_through(DEFAULT_NUM_MIX_HOPS)
+                    || !topology_ref.gateway_exists(ack_recipient.gateway())
+                    || if let Some(packet_recipient) = packet_recipient {
+                        !topology_ref.gateway_exists(packet_recipient.gateway())
+                    } else {
+                        false
+                    }
+                {
+                    None
+                } else {
+                    Some(topology_ref)
+                }
            }
        }
-
-        Ok(topology)
    }
 }

@@ -121,10 +113,10 @@ impl TopologyAccessor {

    // only used by the client at startup to get a slightly more reasonable error message
    // (currently displays as unused because health checker is disabled due to required changes)
-    pub async fn ensure_is_routable(&self) -> Result<(), NymTopologyError> {
+    pub async fn is_routable(&self) -> bool {
        match &self.inner.read().await.0 {
-            None => Err(NymTopologyError::EmptyNetworkTopology),
-            Some(ref topology) => topology.ensure_can_construct_path_through(DEFAULT_NUM_MIX_HOPS),
+            None => false,
+            Some(ref topology) => topology.can_construct_path_through(DEFAULT_NUM_MIX_HOPS),
        }
    }
 }
@@ -136,15 +128,19 @@ impl Default for TopologyAccessor {
 }

 pub struct TopologyRefresherConfig {
-    nym_api_urls: Vec<Url>,
-    refresh_rate: Duration,
+    validator_api_urls: Vec<Url>,
+    refresh_rate: time::Duration,
    client_version: String,
 }

 impl TopologyRefresherConfig {
-    pub fn new(nym_api_urls: Vec<Url>, refresh_rate: Duration, client_version: String) -> Self {
+    pub fn new(
+        validator_api_urls: Vec<Url>,
+        refresh_rate: time::Duration,
+        client_version: String,
+    ) -> Self {
        TopologyRefresherConfig {
-            nym_api_urls,
+            validator_api_urls,
            refresh_rate,
            client_version,
        }
@@ -152,10 +148,10 @@ impl TopologyRefresherConfig {
 }

 pub struct TopologyRefresher {
-    validator_client: validator_client::client::ApiClient,
+    validator_client: validator_client::ApiClient,
    client_version: String,

-    nym_api_urls: Vec<Url>,
+    validator_api_urls: Vec<Url>,
    topology_accessor: TopologyAccessor,
    refresh_rate: Duration,

@@ -165,12 +161,12 @@ pub struct TopologyRefresher {

 impl TopologyRefresher {
    pub fn new(mut cfg: TopologyRefresherConfig, topology_accessor: TopologyAccessor) -> Self {
-        cfg.nym_api_urls.shuffle(&mut thread_rng());
+        cfg.validator_api_urls.shuffle(&mut thread_rng());

        TopologyRefresher {
-            validator_client: validator_client::client::ApiClient::new(cfg.nym_api_urls[0].clone()),
+            validator_client: validator_client::ApiClient::new(cfg.validator_api_urls[0].clone()),
            client_version: cfg.client_version,
-            nym_api_urls: cfg.nym_api_urls,
+            validator_api_urls: cfg.validator_api_urls,
            topology_accessor,
            refresh_rate: cfg.refresh_rate,
            currently_used_api: 0,
@@ -178,15 +174,15 @@ impl TopologyRefresher {
        }
    }

-    fn use_next_nym_api(&mut self) {
-        if self.nym_api_urls.len() == 1 {
-            warn!("There's only a single nym API available - it won't be possible to use a different one");
+    fn use_next_validator_api(&mut self) {
+        if self.validator_api_urls.len() == 1 {
+            warn!("There's only a single validator API available - it won't be possible to use a different one");
            return;
        }

-        self.currently_used_api = (self.currently_used_api + 1) % self.nym_api_urls.len();
+        self.currently_used_api = (self.currently_used_api + 1) % self.validator_api_urls.len();
        self.validator_client
-            .change_nym_api(self.nym_api_urls[self.currently_used_api].clone())
+            .change_validator_api(self.validator_api_urls[self.currently_used_api].clone())
    }

    /// Verifies whether nodes a reasonably distributed among all mix layers.
@@ -198,10 +194,13 @@ impl TopologyRefresher {
    /// # Arguments
    ///
    /// * `topology`: active topology constructed from validator api data
-    fn check_layer_distribution(&self, active_topology: &NymTopology) -> bool {
+    /// * `mixnodes_count`: total number of active mixnodes
+    fn check_layer_distribution(
+        &self,
+        active_topology: &NymTopology,
+        mixnodes_count: usize,
+    ) -> bool {
        let mixes = active_topology.mixes();
-        let mixnodes_count = active_topology.num_mixnodes();
-
        if active_topology.gateways().is_empty() {
            return false;
        }
@@ -252,7 +251,7 @@ impl TopologyRefresher {

        let mixnodes = match self.validator_client.get_cached_active_mixnodes().await {
            Err(err) => {
-                error!("failed to get network mixnodes - {err}");
+                error!("failed to get network mixnodes - {}", err);
                return None;
            }
            Ok(mixes) => mixes,
@@ -260,16 +259,17 @@ impl TopologyRefresher {

        let gateways = match self.validator_client.get_cached_gateways().await {
            Err(err) => {
-                error!("failed to get network gateways - {err}");
+                error!("failed to get network gateways - {}", err);
                return None;
            }
            Ok(gateways) => gateways,
        };

-        let topology = nym_topology_from_detailed(mixnodes, gateways)
-            .filter_system_version(&self.client_version);
+        let mixnodes_count = mixnodes.len();
+        let topology =
+            nym_topology_from_bonds(mixnodes, gateways).filter_system_version(&self.client_version);

-        if !self.check_layer_distribution(&topology) {
+        if !self.check_layer_distribution(&topology, mixnodes_count) {
            warn!("The current filtered active topology has extremely skewed layer distribution. It cannot be used.");
            None
        } else {
@@ -282,7 +282,7 @@ impl TopologyRefresher {
        let new_topology = self.get_current_compatible_topology().await;

        if new_topology.is_none() {
-            self.use_next_nym_api();
+            self.use_next_validator_api();
        }

        if new_topology.is_none() && self.was_latest_valid {
@@ -300,26 +300,15 @@ impl TopologyRefresher {
            .await;
    }

-    pub async fn ensure_topology_is_routable(&self) -> Result<(), NymTopologyError> {
-        self.topology_accessor.ensure_is_routable().await
+    pub async fn is_topology_routable(&self) -> bool {
+        self.topology_accessor.is_routable().await
    }

-    pub fn start_with_shutdown(mut self, mut shutdown: task::TaskClient) {
-        spawn_future(async move {
-            debug!("Started TopologyRefresher with graceful shutdown support");
-
-            #[cfg(not(target_arch = "wasm32"))]
-            let mut interval = tokio_stream::wrappers::IntervalStream::new(tokio::time::interval(
-                self.refresh_rate,
-            ));
-
-            #[cfg(target_arch = "wasm32")]
-            let mut interval =
-                gloo_timers::future::IntervalStream::new(self.refresh_rate.as_millis() as u32);
-
+    pub fn start(mut self, mut shutdown: ShutdownListener) -> JoinHandle<()> {
+        tokio::spawn(async move {
            while !shutdown.is_shutdown() {
                tokio::select! {
-                    _ = interval.next() => {
+                    _ = tokio::time::sleep(self.refresh_rate) => {
                        self.refresh().await;
                    },
                    _ = shutdown.recv() => {
@@ -327,7 +316,7 @@ impl TopologyRefresher {
                    },
                }
            }
-            shutdown.recv_timeout().await;
+            assert!(shutdown.is_shutdown_poll());
            log::debug!("TopologyRefresher: Exiting");
        })
    }
@@ -1,287 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::client::helpers::{get_time_now, Instant};
-use crate::client::real_messages_control::real_traffic_stream::RealMessage;
-use client_connections::TransmissionLane;
-use nymsphinx::chunking::fragment::Fragment;
-use rand::{seq::SliceRandom, Rng};
-use std::{
-    collections::{HashMap, HashSet, VecDeque},
-    time::Duration,
-};
-
-// The number of lanes included in the oldest set. Used when we need to prioritize traffic.
-const OLDEST_LANE_SET_SIZE: usize = 4;
-// As a way of prune connections we also check for timeouts.
-const MSG_CONSIDERED_STALE_AFTER_SECS: u64 = 10 * 60;
-
-pub(crate) trait SizedData {
-    fn data_size(&self) -> usize;
-}
-
-impl SizedData for RealMessage {
-    fn data_size(&self) -> usize {
-        self.packet_size()
-    }
-}
-
-impl SizedData for Fragment {
-    fn data_size(&self) -> usize {
-        // note that raw `Fragment` is smaller than sphinx packet payload
-        // as it doesn't include surb-ack or the [shared] key materials
-        self.payload_size()
-    }
-}
-
-#[derive(Default)]
-pub(crate) struct TransmissionBuffer<T> {
-    buffer: HashMap<TransmissionLane, LaneBufferEntry<T>>,
-}
-
-impl<T> TransmissionBuffer<T> {
-    pub(crate) fn new() -> Self {
-        TransmissionBuffer {
-            buffer: HashMap::new(),
-        }
-    }
-
-    #[allow(unused)]
-    pub(crate) fn is_empty(&self) -> bool {
-        self.buffer.is_empty()
-    }
-
-    pub(crate) fn remove(&mut self, lane: &TransmissionLane) -> Option<LaneBufferEntry<T>> {
-        self.buffer.remove(lane)
-    }
-
-    #[cfg(not(target_arch = "wasm32"))]
-    pub(crate) fn num_lanes(&self) -> usize {
-        self.buffer.keys().count()
-    }
-
-    pub(crate) fn lane_length(&self, lane: &TransmissionLane) -> Option<usize> {
-        self.buffer.get(lane).map(LaneBufferEntry::len)
-    }
-
-    #[allow(unused)]
-    pub(crate) fn connections(&self) -> HashSet<u64> {
-        self.buffer
-            .keys()
-            .filter_map(|lane| match lane {
-                TransmissionLane::ConnectionId(id) => Some(id),
-                _ => None,
-            })
-            .copied()
-            .collect()
-    }
-
-    pub(crate) fn total_size(&self) -> usize {
-        self.buffer.values().map(LaneBufferEntry::len).sum()
-    }
-
-    #[cfg(not(target_arch = "wasm32"))]
-    pub(crate) fn total_size_in_bytes(&self) -> usize
-    where
-        T: SizedData,
-    {
-        self.buffer
-            .values()
-            .map(|lane_buffer_entry| {
-                lane_buffer_entry
-                    .items
-                    .iter()
-                    .map(|item| item.data_size())
-                    .sum::<usize>()
-            })
-            .sum()
-    }
-
-    fn get_oldest_set(&self) -> Vec<TransmissionLane> {
-        let mut buffer: Vec<_> = self
-            .buffer
-            .iter()
-            .map(|(k, v)| (k, v.messages_transmitted))
-            .collect();
-        buffer.sort_by_key(|v| v.1);
-        buffer
-            .iter()
-            .rev()
-            .map(|(k, _)| *k)
-            .take(OLDEST_LANE_SET_SIZE)
-            .copied()
-            .collect()
-    }
-
-    pub(crate) fn store<I: IntoIterator<Item = T>>(&mut self, lane: &TransmissionLane, items: I) {
-        if let Some(lane_buffer_entry) = self.buffer.get_mut(lane) {
-            lane_buffer_entry.extend(items);
-        } else {
-            self.buffer
-                .insert(*lane, LaneBufferEntry::new(items.into_iter().collect()));
-        }
-    }
-
-    pub(crate) fn store_multiple(&mut self, items: Vec<(TransmissionLane, T)>) {
-        for (lane, item) in items {
-            self.buffer
-                .entry(lane)
-                .or_insert_with(LaneBufferEntry::new_empty)
-                .push_item(item)
-        }
-    }
-
-    fn pick_random_lane<R: Rng + ?Sized>(&self, rng: &mut R) -> Option<&TransmissionLane> {
-        let lanes: Vec<&TransmissionLane> = self.buffer.keys().collect();
-        lanes.choose(rng).copied()
-    }
-
-    fn pick_random_small_lane<R: Rng + ?Sized>(&self, rng: &mut R) -> Option<&TransmissionLane> {
-        let lanes: Vec<&TransmissionLane> = self
-            .buffer
-            .iter()
-            .filter(|(_, v)| v.is_small())
-            .map(|(k, _)| k)
-            .collect();
-        lanes.choose(rng).copied()
-    }
-
-    // 2/3 chance to pick from the old lanes
-    fn pick_random_old_lane<R: Rng + ?Sized>(&self, rng: &mut R) -> Option<TransmissionLane> {
-        let rand = &mut rand::thread_rng();
-        if rand.gen_ratio(2, 3) {
-            let lanes = self.get_oldest_set();
-            lanes.choose(rand).copied()
-        } else {
-            self.pick_random_lane(rng).copied()
-        }
-    }
-
-    fn pop_front_from_lane(&mut self, lane: &TransmissionLane) -> Option<T> {
-        let real_msgs_queued = self.buffer.get_mut(lane)?;
-        let real_next = real_msgs_queued.pop_front()?;
-        real_msgs_queued.messages_transmitted += 1;
-        if real_msgs_queued.is_empty() {
-            self.buffer.remove(lane);
-        }
-        Some(real_next)
-    }
-
-    pub(crate) fn pop_at_most_n_next_messages_at_random(
-        &mut self,
-        n: usize,
-    ) -> Option<Vec<(TransmissionLane, T)>> {
-        // let start = Instant::now();
-
-        if self.buffer.is_empty() {
-            return None;
-        }
-
-        let rng = &mut rand::thread_rng();
-        let mut items = Vec::with_capacity(n);
-
-        while items.len() < n {
-            let Some(next) = self.pop_next_message_at_random(rng) else {
-               break
-            };
-            items.push(next)
-        }
-
-        // todo!("time time taken");
-
-        Some(items)
-    }
-
-    pub(crate) fn pop_next_message_at_random<R: Rng + ?Sized>(
-        &mut self,
-        // turns out the caller always have access to some rng, so no point in instantiating new one
-        rng: &mut R,
-    ) -> Option<(TransmissionLane, T)> {
-        if self.buffer.is_empty() {
-            return None;
-        }
-
-        // Very basic heuristic where we prioritize according to small lanes first, the older lanes
-        // to try to finish lanes when possible, then the rest.
-        let lane = if let Some(small_lane) = self.pick_random_small_lane(rng) {
-            *small_lane
-        } else if let Some(old_lane) = self.pick_random_old_lane(rng) {
-            old_lane
-        } else {
-            *self.pick_random_lane(rng)?
-        };
-
-        let msg = self.pop_front_from_lane(&lane)?;
-        log::trace!("picking to send from lane: {:?}", lane);
-        Some((lane, msg))
-    }
-
-    pub(crate) fn prune_stale_connections(&mut self) {
-        let stale_entries: Vec<_> = self
-            .buffer
-            .iter()
-            .filter_map(|(lane, entry)| if entry.is_stale() { Some(lane) } else { None })
-            .copied()
-            .collect();
-
-        for lane in stale_entries {
-            self.remove(&lane);
-        }
-    }
-}
-
-pub(crate) struct LaneBufferEntry<T> {
-    pub items: VecDeque<T>,
-    pub messages_transmitted: usize,
-    pub time_for_last_activity: Instant,
-}
-
-impl<T> LaneBufferEntry<T> {
-    fn new_empty() -> Self {
-        LaneBufferEntry {
-            items: VecDeque::new(),
-            messages_transmitted: 0,
-            time_for_last_activity: get_time_now(),
-        }
-    }
-
-    fn new(items: VecDeque<T>) -> Self {
-        LaneBufferEntry {
-            items,
-            messages_transmitted: 0,
-            time_for_last_activity: get_time_now(),
-        }
-    }
-
-    fn push_item(&mut self, item: T) {
-        self.items.push_back(item);
-        // I'm not updating time here on purpose. This method is called just after `new_empty`,
-        // where the time is already set. Furthermore, this method is called there multiple times at once
-    }
-
-    fn extend<I: IntoIterator<Item = T>>(&mut self, items: I) {
-        self.items.extend(items);
-        self.time_for_last_activity = get_time_now();
-    }
-
-    fn pop_front(&mut self) -> Option<T> {
-        self.items.pop_front()
-    }
-
-    fn is_small(&self) -> bool {
-        self.items.len() < 100
-    }
-
-    fn is_stale(&self) -> bool {
-        get_time_now() - self.time_for_last_activity
-            > Duration::from_secs(MSG_CONSIDERED_STALE_AFTER_SECS)
-    }
-
-    fn len(&self) -> usize {
-        self.items.len()
-    }
-
-    fn is_empty(&self) -> bool {
-        self.items.is_empty()
-    }
-}
@@ -1,17 +1,13 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use config::{NymConfig, DB_FILE_NAME};
-use nymsphinx::params::PacketSize;
+use config::NymConfig;
 use serde::{Deserialize, Serialize};
 use std::marker::PhantomData;
 use std::path::PathBuf;
 use std::time::Duration;
 use url::Url;

-#[cfg(target_arch = "wasm32")]
-use wasm_bindgen::prelude::*;
-
 pub mod persistence;

 pub const MISSING_VALUE: &str = "MISSING VALUE";
@@ -30,37 +26,11 @@ const DEFAULT_TOPOLOGY_RESOLUTION_TIMEOUT: Duration = Duration::from_millis(5_00
 // bandwidth bridging protocol, we can come back to a smaller timeout value
 const DEFAULT_GATEWAY_RESPONSE_TIMEOUT: Duration = Duration::from_secs(5 * 60);

-// reply-surbs related:
-
-// define when to request
-// 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;
-
-// 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 = 100;
-
-const DEFAULT_MAXIMUM_ALLOWED_SURB_REQUEST_SIZE: u32 = 500;
-
-const DEFAULT_MAXIMUM_REPLY_SURB_WAITING_PERIOD: Duration = Duration::from_secs(10);
-
-// 12 hours
-const DEFAULT_MAXIMUM_REPLY_SURB_AGE: Duration = Duration::from_secs(12 * 60 * 60);
-
-// 24 hours
-const DEFAULT_MAXIMUM_REPLY_KEY_AGE: Duration = Duration::from_secs(24 * 60 * 60);
-
 pub fn missing_string_value() -> String {
    MISSING_VALUE.to_string()
 }

-pub trait ClientCoreConfigTrait {
-    fn get_gateway_endpoint(&self) -> &GatewayEndpointConfig;
-}
-
-#[derive(Debug, Clone, Deserialize, PartialEq, Serialize)]
+#[derive(Debug, Deserialize, PartialEq, Serialize)]
 #[serde(deny_unknown_fields)]
 pub struct Config<T> {
    client: Client<T>,
@@ -68,48 +38,27 @@ pub struct Config<T> {
    #[serde(default)]
    logging: Logging,
    #[serde(default)]
-    debug: DebugConfig,
-}
-impl<T> ClientCoreConfigTrait for Config<T> {
-    fn get_gateway_endpoint(&self) -> &GatewayEndpointConfig {
-        &self.client.gateway_endpoint
-    }
+    debug: Debug,
 }

-impl<T> Config<T> {
-    pub fn new<S: Into<String>>(id: S) -> Self
-    where
-        T: NymConfig,
-    {
-        Config::default().with_id(id)
+impl<T: NymConfig> Config<T> {
+    pub fn new<S: Into<String>>(id: S) -> Self {
+        let mut cfg = Config::default();
+        cfg.with_id(id);
+        cfg
    }

-    pub fn with_id<S: Into<String>>(mut self, id: S) -> Self
-    where
-        T: NymConfig,
-    {
-        self.client.id = id.into();
-        self.set_empty_fields_to_defaults();
-        self
-    }
-
-    pub fn set_empty_fields_to_defaults(&mut self) -> bool
-    where
-        T: NymConfig,
-    {
-        let id = &self.client.id;
-        let mut changes_made = false;
+    pub fn with_id<S: Into<String>>(&mut self, id: S) {
+        let id = id.into();

        // identity key setting
        if self.client.private_identity_key_file.as_os_str().is_empty() {
-            changes_made = true;
            self.client.private_identity_key_file =
-                self::Client::<T>::default_private_identity_key_file(id);
+                self::Client::<T>::default_private_identity_key_file(&id);
        }
        if self.client.public_identity_key_file.as_os_str().is_empty() {
-            changes_made = true;
            self.client.public_identity_key_file =
-                self::Client::<T>::default_public_identity_key_file(id);
+                self::Client::<T>::default_public_identity_key_file(&id);
        }

        // encryption key setting
@@ -119,9 +68,8 @@ impl<T> Config<T> {
            .as_os_str()
            .is_empty()
        {
-            changes_made = true;
            self.client.private_encryption_key_file =
-                self::Client::<T>::default_private_encryption_key_file(id);
+                self::Client::<T>::default_private_encryption_key_file(&id);
        }
        if self
            .client
@@ -129,42 +77,43 @@ impl<T> Config<T> {
            .as_os_str()
            .is_empty()
        {
-            changes_made = true;
            self.client.public_encryption_key_file =
-                self::Client::<T>::default_public_encryption_key_file(id);
+                self::Client::<T>::default_public_encryption_key_file(&id);
        }

        // shared gateway key setting
        if self.client.gateway_shared_key_file.as_os_str().is_empty() {
-            changes_made = true;
            self.client.gateway_shared_key_file =
-                self::Client::<T>::default_gateway_shared_key_file(id);
+                self::Client::<T>::default_gateway_shared_key_file(&id);
        }

        // ack key setting
        if self.client.ack_key_file.as_os_str().is_empty() {
-            changes_made = true;
-            self.client.ack_key_file = self::Client::<T>::default_ack_key_file(id);
+            self.client.ack_key_file = self::Client::<T>::default_ack_key_file(&id);
        }

-        if self.client.reply_surb_database_path.as_os_str().is_empty() {
-            changes_made = true;
-            self.client.reply_surb_database_path =
-                self::Client::<T>::default_reply_surb_database_path(id);
+        if self
+            .client
+            .reply_encryption_key_store_path
+            .as_os_str()
+            .is_empty()
+        {
+            self.client.reply_encryption_key_store_path =
+                self::Client::<T>::default_reply_encryption_key_store_path(&id);
        }

        if self.client.database_path.as_os_str().is_empty() {
-            changes_made = true;
-            self.client.database_path = self::Client::<T>::default_database_path(id);
+            self.client.database_path = self::Client::<T>::default_database_path(&id);
        }
-        changes_made
+
+        self.client.id = id;
    }

    pub fn with_disabled_credentials(&mut self, disabled_credentials_mode: bool) {
        self.client.disabled_credentials_mode = disabled_credentials_mode;
    }

-    pub fn with_gateway_endpoint(&mut self, gateway_endpoint: GatewayEndpointConfig) {
+    pub fn with_gateway_endpoint(&mut self, gateway_endpoint: GatewayEndpoint) {
        self.client.gateway_endpoint = gateway_endpoint;
    }

@@ -172,25 +121,24 @@ impl<T> Config<T> {
        self.client.gateway_endpoint.gateway_id = id.into();
    }

-    pub fn set_custom_validators(&mut self, validator_urls: Vec<Url>) {
-        self.client.validator_urls = validator_urls;
+    #[cfg(not(feature = "coconut"))]
+    pub fn with_eth_private_key<S: Into<String>>(&mut self, eth_private_key: S) {
+        self.client.eth_private_key = eth_private_key.into();
    }

-    pub fn set_custom_nym_apis(&mut self, nym_api_urls: Vec<Url>) {
-        self.client.nym_api_urls = nym_api_urls;
+    #[cfg(not(feature = "coconut"))]
+    pub fn with_eth_endpoint<S: Into<String>>(&mut self, eth_endpoint: S) {
+        self.client.eth_endpoint = eth_endpoint.into();
+    }
+
+    pub fn set_custom_validator_apis(&mut self, validator_api_urls: Vec<Url>) {
+        self.client.validator_api_urls = validator_api_urls;
    }

    pub fn set_high_default_traffic_volume(&mut self) {
        self.debug.average_packet_delay = Duration::from_millis(10);
-        // basically don't really send cover messages
-        self.debug.loop_cover_traffic_average_delay = Duration::from_millis(2_000_000);
-        // 250 "real" messages / s
-        self.debug.message_sending_average_delay = Duration::from_millis(4);
-    }
-
-    pub fn set_no_cover_traffic(&mut self) {
-        self.debug.disable_loop_cover_traffic_stream = true;
-        self.debug.disable_main_poisson_packet_distribution = true;
+        self.debug.loop_cover_traffic_average_delay = Duration::from_millis(2_000_000); // basically don't really send cover messages
+        self.debug.message_sending_average_delay = Duration::from_millis(4); // 250 "real" messages / s
    }

    pub fn set_custom_version(&mut self, version: &str) {
@@ -229,16 +177,16 @@ impl<T> Config<T> {
        self.client.gateway_shared_key_file.clone()
    }

+    pub fn get_reply_encryption_key_store_path(&self) -> PathBuf {
+        self.client.reply_encryption_key_store_path.clone()
+    }
+
    pub fn get_ack_key_file(&self) -> PathBuf {
        self.client.ack_key_file.clone()
    }

-    pub fn get_validator_endpoints(&self) -> Vec<Url> {
-        self.client.validator_urls.clone()
-    }
-
-    pub fn get_nym_api_endpoints(&self) -> Vec<Url> {
-        self.client.nym_api_urls.clone()
+    pub fn get_validator_api_endpoints(&self) -> Vec<Url> {
+        self.client.validator_api_urls.clone()
    }

    pub fn get_gateway_id(&self) -> String {
@@ -253,7 +201,7 @@ impl<T> Config<T> {
        self.client.gateway_endpoint.gateway_listener.clone()
    }

-    pub fn get_gateway_endpoint_config(&self) -> &GatewayEndpointConfig {
+    pub fn get_gateway_endpoint(&self) -> &GatewayEndpoint {
        &self.client.gateway_endpoint
    }

@@ -261,19 +209,17 @@ impl<T> Config<T> {
        self.client.database_path.clone()
    }

-    pub fn get_reply_surb_database_path(&self) -> PathBuf {
-        self.client.reply_surb_database_path.clone()
+    #[cfg(not(feature = "coconut"))]
+    pub fn get_eth_endpoint(&self) -> String {
+        self.client.eth_endpoint.clone()
    }

-    pub fn get_version(&self) -> &str {
-        &self.client.version
+    #[cfg(not(feature = "coconut"))]
+    pub fn get_eth_private_key(&self) -> String {
+        self.client.eth_private_key.clone()
    }

    // Debug getters
-    pub fn get_debug_config(&self) -> &DebugConfig {
-        &self.debug
-    }
-
    pub fn get_average_packet_delay(&self) -> Duration {
        self.debug.average_packet_delay
    }
@@ -310,48 +256,8 @@ impl<T> Config<T> {
        self.debug.topology_resolution_timeout
    }

-    pub fn get_disabled_loop_cover_traffic_stream(&self) -> bool {
-        self.debug.disable_loop_cover_traffic_stream
-    }
-
-    pub fn get_disabled_main_poisson_packet_distribution(&self) -> bool {
-        self.debug.disable_main_poisson_packet_distribution
-    }
-
-    pub fn get_use_extended_packet_size(&self) -> Option<ExtendedPacketSize> {
-        self.debug.use_extended_packet_size
-    }
-
-    pub fn get_minimum_reply_surb_storage_threshold(&self) -> usize {
-        self.debug.minimum_reply_surb_storage_threshold
-    }
-
-    pub fn get_maximum_reply_surb_storage_threshold(&self) -> usize {
-        self.debug.maximum_reply_surb_storage_threshold
-    }
-
-    pub fn get_minimum_reply_surb_request_size(&self) -> u32 {
-        self.debug.minimum_reply_surb_request_size
-    }
-
-    pub fn get_maximum_reply_surb_request_size(&self) -> u32 {
-        self.debug.maximum_reply_surb_request_size
-    }
-
-    pub fn get_maximum_allowed_reply_surb_request_size(&self) -> u32 {
-        self.debug.maximum_allowed_reply_surb_request_size
-    }
-
-    pub fn get_maximum_reply_surb_waiting_period(&self) -> Duration {
-        self.debug.maximum_reply_surb_waiting_period
-    }
-
-    pub fn get_maximum_reply_surb_age(&self) -> Duration {
-        self.debug.maximum_reply_surb_age
-    }
-
-    pub fn get_maximum_reply_key_age(&self) -> Duration {
-        self.debug.maximum_reply_key_age
+    pub fn get_version(&self) -> &str {
+        &self.client.version
    }
 }

@@ -366,8 +272,7 @@ impl<T: NymConfig> Default for Config<T> {
 }

 #[derive(Clone, Debug, Default, Deserialize, PartialEq, Eq, Serialize)]
-#[cfg_attr(target_arch = "wasm32", wasm_bindgen(getter_with_clone))]
-pub struct GatewayEndpointConfig {
+pub struct GatewayEndpoint {
    /// gateway_id specifies ID of the gateway to which the client should send messages.
    /// If initially omitted, a random gateway will be chosen from the available topology.
    pub gateway_id: String,
@@ -379,26 +284,10 @@ pub struct GatewayEndpointConfig {
    pub gateway_listener: String,
 }

-#[cfg_attr(target_arch = "wasm32", wasm_bindgen)]
-impl GatewayEndpointConfig {
-    #[cfg_attr(target_arch = "wasm32", wasm_bindgen(constructor))]
-    pub fn new(
-        gateway_id: String,
-        gateway_owner: String,
-        gateway_listener: String,
-    ) -> GatewayEndpointConfig {
-        GatewayEndpointConfig {
-            gateway_id,
-            gateway_owner,
-            gateway_listener,
-        }
-    }
-}
-
-impl From<topology::gateway::Node> for GatewayEndpointConfig {
-    fn from(node: topology::gateway::Node) -> GatewayEndpointConfig {
+impl From<topology::gateway::Node> for GatewayEndpoint {
+    fn from(node: topology::gateway::Node) -> GatewayEndpoint {
        let gateway_listener = node.clients_address();
-        GatewayEndpointConfig {
+        GatewayEndpoint {
            gateway_id: node.identity_key.to_base58_string(),
            gateway_owner: node.owner,
            gateway_listener,
@@ -406,7 +295,7 @@ impl From<topology::gateway::Node> for GatewayEndpointConfig {
    }
 }

-#[derive(Debug, Clone, Deserialize, PartialEq, Eq, Serialize)]
+#[derive(Debug, Deserialize, PartialEq, Eq, Serialize)]
 pub struct Client<T> {
    /// Version of the client for which this configuration was created.
    #[serde(default = "missing_string_value")]
@@ -420,13 +309,8 @@ pub struct Client<T> {
    #[serde(default)]
    disabled_credentials_mode: bool,

-    /// Addresses to nymd validators via which the client can communicate with the chain.
-    #[serde(default)]
-    validator_urls: Vec<Url>,
-
    /// Addresses to APIs running on validator from which the client gets the view of the network.
-    #[serde(alias = "validator_api_urls")]
-    nym_api_urls: Vec<Url>,
+    validator_api_urls: Vec<Url>,

    /// Path to file containing private identity key.
    private_identity_key_file: PathBuf,
@@ -448,18 +332,23 @@ pub struct Client<T> {
    /// acknowledgement so that nobody besides the client knows which packet it refers to.
    ack_key_file: PathBuf,

+    /// Full path to file containing reply encryption keys of all reply-SURBs we have ever
+    /// sent but not received back.
+    reply_encryption_key_store_path: PathBuf,
+
    /// Information regarding how the client should send data to gateway.
-    gateway_endpoint: GatewayEndpointConfig,
+    gateway_endpoint: GatewayEndpoint,

    /// Path to the database containing bandwidth credentials of this client.
    database_path: PathBuf,

-    /// Path to the persistent store for received reply surbs, unused encryption keys and used sender tags.
-    // this was set to use #[serde(default)] for the purposes of compatibility for multi-surbs introduced in 1.1.4.
-    // if you're reading this message and we have already introduced some breaking changes, feel free
-    // to remove that attribute since at this point the client configs should have gotten regenerated
-    #[serde(default)]
-    reply_surb_database_path: PathBuf,
+    /// Ethereum private key.
+    #[cfg(not(feature = "coconut"))]
+    eth_private_key: String,
+
+    /// Address to an Ethereum full node.
+    #[cfg(not(feature = "coconut"))]
+    eth_endpoint: String,

    /// nym_home_directory specifies absolute path to the home nym Clients directory.
    /// It is expected to use default value and hence .toml file should not redefine this field.
@@ -476,17 +365,20 @@ impl<T: NymConfig> Default for Client<T> {
            version: env!("CARGO_PKG_VERSION").to_string(),
            id: "".to_string(),
            disabled_credentials_mode: true,
-            validator_urls: vec![],
-            nym_api_urls: vec![],
+            validator_api_urls: vec![],
            private_identity_key_file: Default::default(),
            public_identity_key_file: Default::default(),
            private_encryption_key_file: Default::default(),
            public_encryption_key_file: Default::default(),
            gateway_shared_key_file: Default::default(),
            ack_key_file: Default::default(),
+            reply_encryption_key_store_path: Default::default(),
            gateway_endpoint: Default::default(),
            database_path: Default::default(),
-            reply_surb_database_path: Default::default(),
+            #[cfg(not(feature = "coconut"))]
+            eth_private_key: "".to_string(),
+            #[cfg(not(feature = "coconut"))]
+            eth_endpoint: "".to_string(),
            nym_root_directory: T::default_root_directory(),
            super_struct: Default::default(),
        }
@@ -518,129 +410,78 @@ impl<T: NymConfig> Client<T> {
        T::default_data_directory(Some(id)).join("ack_key.pem")
    }

-    fn default_reply_surb_database_path(id: &str) -> PathBuf {
-        T::default_data_directory(Some(id)).join("persistent_reply_store.sqlite")
+    fn default_reply_encryption_key_store_path(id: &str) -> PathBuf {
+        T::default_data_directory(Some(id)).join("reply_key_store")
    }
-
    fn default_database_path(id: &str) -> PathBuf {
-        T::default_data_directory(Some(id)).join(DB_FILE_NAME)
+        T::default_data_directory(Some(id)).join("db.sqlite")
    }
 }

-#[derive(Debug, Clone, Default, Deserialize, PartialEq, Eq, Serialize)]
+#[derive(Debug, Default, Deserialize, PartialEq, Eq, Serialize)]
 #[serde(deny_unknown_fields)]
 pub struct Logging {}

-#[derive(Debug, Clone, Deserialize, PartialEq, Serialize)]
+#[derive(Debug, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct DebugConfig {
+pub struct Debug {
    /// The parameter of Poisson distribution determining how long, on average,
    /// sent packet is going to be delayed at any given mix node.
    /// So for a packet going through three mix nodes, on average, it will take three times this value
    /// until the packet reaches its destination.
    #[serde(with = "humantime_serde")]
-    pub average_packet_delay: Duration,
+    average_packet_delay: Duration,

    /// The parameter of Poisson distribution determining how long, on average,
    /// sent acknowledgement is going to be delayed at any given mix node.
    /// So for an ack going through three mix nodes, on average, it will take three times this value
    /// until the packet reaches its destination.
    #[serde(with = "humantime_serde")]
-    pub average_ack_delay: Duration,
+    average_ack_delay: Duration,

    /// Value multiplied with the expected round trip time of an acknowledgement packet before
    /// it is assumed it was lost and retransmission of the data packet happens.
    /// In an ideal network with 0 latency, this value would have been 1.
-    pub ack_wait_multiplier: f64,
+    ack_wait_multiplier: f64,

    /// Value added to the expected round trip time of an acknowledgement packet before
    /// it is assumed it was lost and retransmission of the data packet happens.
    /// In an ideal network with 0 latency, this value would have been 0.
    #[serde(with = "humantime_serde")]
-    pub ack_wait_addition: Duration,
+    ack_wait_addition: Duration,

    /// The parameter of Poisson distribution determining how long, on average,
    /// it is going to take for another loop cover traffic message to be sent.
    #[serde(with = "humantime_serde")]
-    pub loop_cover_traffic_average_delay: Duration,
+    loop_cover_traffic_average_delay: Duration,

    /// The parameter of Poisson distribution determining how long, on average,
    /// it is going to take another 'real traffic stream' message to be sent.
    /// If no real packets are available and cover traffic is enabled,
    /// a loop cover message is sent instead in order to preserve the rate.
    #[serde(with = "humantime_serde")]
-    pub message_sending_average_delay: Duration,
+    message_sending_average_delay: Duration,

    /// How long we're willing to wait for a response to a message sent to the gateway,
    /// before giving up on it.
    #[serde(with = "humantime_serde")]
-    pub gateway_response_timeout: Duration,
+    gateway_response_timeout: Duration,

    /// The uniform delay every which clients are querying the directory server
    /// to try to obtain a compatible network topology to send sphinx packets through.
    #[serde(with = "humantime_serde")]
-    pub topology_refresh_rate: Duration,
+    topology_refresh_rate: Duration,

    /// During topology refresh, test packets are sent through every single possible network
    /// path. This timeout determines waiting period until it is decided that the packet
    /// did not reach its destination.
    #[serde(with = "humantime_serde")]
-    pub topology_resolution_timeout: Duration,
-
-    /// Controls whether the dedicated loop cover traffic stream should be enabled.
-    /// (and sending packets, on average, every [Self::loop_cover_traffic_average_delay])
-    pub disable_loop_cover_traffic_stream: bool,
-
-    /// Controls whether the main packet stream constantly produces packets according to the predefined
-    /// poisson distribution.
-    pub disable_main_poisson_packet_distribution: bool,
-
-    /// Controls whether the sent sphinx packet use a NON-DEFAULT bigger size.
-    pub use_extended_packet_size: Option<ExtendedPacketSize>,
-
-    /// Defines the minimum number of reply surbs the client wants to keep in its storage at all times.
-    /// It can only allow to go below that value if its to request additional reply surbs.
-    pub minimum_reply_surb_storage_threshold: usize,
-
-    /// 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 minimum number of reply surbs the client would request.
-    pub minimum_reply_surb_request_size: u32,
-
-    /// Defines the maximum number of reply surbs the client would request.
-    pub maximum_reply_surb_request_size: u32,
-
-    /// Defines the maximum number of reply surbs a remote party is allowed to request from this client at once.
-    pub maximum_allowed_reply_surb_request_size: u32,
-
-    /// Defines maximum amount of time the client is going to wait for reply surbs before explicitly asking
-    /// for more even though in theory they wouldn't need to.
-    #[serde(with = "humantime_serde")]
-    pub maximum_reply_surb_waiting_period: Duration,
-
-    /// Defines maximum amount of time given reply surb is going to be valid for.
-    /// This is going to be superseded by key rotation once implemented.
-    #[serde(with = "humantime_serde")]
-    pub maximum_reply_surb_age: Duration,
-
-    /// Defines maximum amount of time given reply key is going to be valid for.
-    /// This is going to be superseded by key rotation once implemented.
-    #[serde(with = "humantime_serde")]
-    pub maximum_reply_key_age: Duration,
+    topology_resolution_timeout: Duration,
 }

-#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq, Eq)]
-#[serde(rename_all = "lowercase")]
-pub enum ExtendedPacketSize {
-    Extended8,
-    Extended16,
-    Extended32,
-}
-
-impl Default for DebugConfig {
+impl Default for Debug {
    fn default() -> Self {
-        DebugConfig {
+        Debug {
            average_packet_delay: DEFAULT_AVERAGE_PACKET_DELAY,
            average_ack_delay: DEFAULT_AVERAGE_PACKET_DELAY,
            ack_wait_multiplier: DEFAULT_ACK_WAIT_MULTIPLIER,
@@ -650,27 +491,6 @@ impl Default for DebugConfig {
            gateway_response_timeout: DEFAULT_GATEWAY_RESPONSE_TIMEOUT,
            topology_refresh_rate: DEFAULT_TOPOLOGY_REFRESH_RATE,
            topology_resolution_timeout: DEFAULT_TOPOLOGY_RESOLUTION_TIMEOUT,
-            disable_loop_cover_traffic_stream: false,
-            disable_main_poisson_packet_distribution: false,
-            use_extended_packet_size: None,
-            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_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,
-            maximum_reply_surb_waiting_period: DEFAULT_MAXIMUM_REPLY_SURB_WAITING_PERIOD,
-            maximum_reply_surb_age: DEFAULT_MAXIMUM_REPLY_SURB_AGE,
-            maximum_reply_key_age: DEFAULT_MAXIMUM_REPLY_KEY_AGE,
-        }
-    }
-}
-
-impl From<ExtendedPacketSize> for PacketSize {
-    fn from(size: ExtendedPacketSize) -> PacketSize {
-        match size {
-            ExtendedPacketSize::Extended8 => PacketSize::ExtendedPacket8,
-            ExtendedPacketSize::Extended16 => PacketSize::ExtendedPacket16,
-            ExtendedPacketSize::Extended32 => PacketSize::ExtendedPacket32,
        }
    }
 }
@@ -1,68 +1,27 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::client::replies::reply_storage::ReplyStorageBackend;
 use crypto::asymmetric::identity::Ed25519RecoveryError;
 use gateway_client::error::GatewayClientError;
-use topology::NymTopologyError;
 use validator_client::ValidatorClientError;

 #[derive(thiserror::Error, Debug)]
-pub enum ClientCoreError<B: ReplyStorageBackend> {
+pub enum ClientCoreError {
    #[error("I/O error: {0}")]
    IoError(#[from] std::io::Error),
-
    #[error("Gateway client error: {0}")]
    GatewayClientError(#[from] GatewayClientError),
-
    #[error("Ed25519 error: {0}")]
    Ed25519RecoveryError(#[from] Ed25519RecoveryError),
-
    #[error("Validator client error: {0}")]
    ValidatorClientError(#[from] ValidatorClientError),

    #[error("No gateway with id: {0}")]
    NoGatewayWithId(String),
-
    #[error("No gateways on network")]
    NoGatewaysOnNetwork,
-
-    #[error("Failed to setup gateway")]
-    FailedToSetupGateway,
-
-    #[error("List of nym apis is empty")]
-    ListOfNymApisIsEmpty,
-
+    #[error("List of validator apis is empty")]
+    ListOfValidatorApisIsEmpty,
    #[error("Could not load existing gateway configuration: {0}")]
    CouldNotLoadExistingGatewayConfiguration(std::io::Error),
-
-    #[error("The current network topology seem to be insufficient to route any packets through")]
-    InsufficientNetworkTopology(#[from] NymTopologyError),
-
-    #[error("experienced a failure with our reply surb persistent storage: {source}")]
-    SurbStorageError { source: B::StorageError },
-
-    #[error("The gateway id is invalid - {0}")]
-    UnableToCreatePublicKeyFromGatewayId(Ed25519RecoveryError),
-
-    #[error("The identity of the gateway is unknwown - did you run init?")]
-    GatewayIdUnknown,
-
-    #[error("The owner of the gateway is unknown - did you run init?")]
-    GatewayOwnerUnknown,
-
-    #[error("The address of the gateway is unknown - did you run init?")]
-    GatwayAddressUnknown,
-
-    #[error("Unexpected exit")]
-    UnexpectedExit,
-}
-
-/// Set of messages that the client can send to listeners via the task manager
-#[derive(thiserror::Error, Debug)]
-pub enum ClientCoreStatusMessage {
-    #[error("The connected gateway is slow, or the connection to it is slow")]
-    GatewayIsSlow,
-    #[error("The connected gateway is very slow, or the connection to it is very slow")]
-    GatewayIsVerySlow,
 }
@@ -1,35 +1,39 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::client::replies::reply_storage::ReplyStorageBackend;
+//! Collection of initialization steps used by client implementations
+
+use std::{sync::Arc, time::Duration};
+
+use config::NymConfig;
+use crypto::asymmetric::{encryption, identity};
+use gateway_client::GatewayClient;
+use gateway_requests::registration::handshake::SharedKeys;
+use nymsphinx::addressing::clients::Recipient;
+use nymsphinx::addressing::nodes::NodeIdentity;
+use rand::rngs::OsRng;
+use rand::seq::SliceRandom;
+use rand::thread_rng;
+use tap::TapFallible;
+use topology::{filter::VersionFilterable, gateway};
+use url::Url;
+
 use crate::{
    client::key_manager::KeyManager,
    config::{persistence::key_pathfinder::ClientKeyPathfinder, Config},
    error::ClientCoreError,
 };
-use config::NymConfig;
-use crypto::asymmetric::identity;
-use gateway_client::GatewayClient;
-use gateway_requests::registration::handshake::SharedKeys;
-use rand::{rngs::OsRng, seq::SliceRandom, thread_rng};
-use std::{sync::Arc, time::Duration};
-use tap::TapFallible;
-use topology::{filter::VersionFilterable, gateway};
-use url::Url;

-pub(super) async fn query_gateway_details<B>(
+pub async fn query_gateway_details(
    validator_servers: Vec<Url>,
-    chosen_gateway_id: Option<String>,
-) -> Result<gateway::Node, ClientCoreError<B>>
-where
-    B: ReplyStorageBackend,
-{
-    let nym_api = validator_servers
+    chosen_gateway_id: Option<&str>,
+) -> Result<gateway::Node, ClientCoreError> {
+    let validator_api = validator_servers
        .choose(&mut thread_rng())
-        .ok_or(ClientCoreError::ListOfNymApisIsEmpty)?;
-    let validator_client = validator_client::client::ApiClient::new(nym_api.clone());
+        .ok_or(ClientCoreError::ListOfValidatorApisIsEmpty)?;
+    let validator_client = validator_client::ApiClient::new(validator_api.clone());

-    log::trace!("Fetching list of gateways from: {}", nym_api);
+    log::trace!("Fetching list of gateways from: {}", validator_api);
    let gateways = validator_client.get_cached_gateways().await?;
    let valid_gateways = gateways
        .into_iter()
@@ -55,39 +59,12 @@ where
    }
 }

-async fn register_with_gateway<B>(
-    gateway: &gateway::Node,
-    our_identity: Arc<identity::KeyPair>,
-) -> Result<Arc<SharedKeys>, ClientCoreError<B>>
-where
-    B: ReplyStorageBackend,
-{
-    let timeout = Duration::from_millis(1500);
-    let mut gateway_client = GatewayClient::new_init(
-        gateway.clients_address(),
-        gateway.identity_key,
-        gateway.owner.clone(),
-        our_identity.clone(),
-        timeout,
-    );
-    gateway_client
-        .establish_connection()
-        .await
-        .tap_err(|_| log::warn!("Failed to establish connection with gateway!"))?;
-    let shared_keys = gateway_client
-        .perform_initial_authentication()
-        .await
-        .tap_err(|_| log::warn!("Failed to register with the gateway!"))?;
-    Ok(shared_keys)
-}
-
-pub(super) async fn register_with_gateway_and_store_keys<T, B>(
+pub async fn register_with_gateway_and_store_keys<T>(
    gateway_details: gateway::Node,
    config: &Config<T>,
-) -> Result<(), ClientCoreError<B>>
+) -> Result<(), ClientCoreError>
 where
    T: NymConfig,
-    B: ReplyStorageBackend,
 {
    let mut rng = OsRng;
    let mut key_manager = KeyManager::new(&mut rng);
@@ -101,3 +78,71 @@ where
        .store_keys(&pathfinder)
        .tap_err(|err| log::error!("Failed to generate keys: {err}"))?)
 }
+
+async fn register_with_gateway(
+    gateway: &gateway::Node,
+    our_identity: Arc<identity::KeyPair>,
+) -> Result<Arc<SharedKeys>, ClientCoreError> {
+    let timeout = Duration::from_millis(1500);
+    let mut gateway_client = GatewayClient::new_init(
+        gateway.clients_address(),
+        gateway.identity_key,
+        gateway.owner.clone(),
+        our_identity.clone(),
+        timeout,
+        None,
+    );
+    gateway_client
+        .establish_connection()
+        .await
+        .tap_err(|_| log::warn!("Failed to establish connection with gateway!"))?;
+    let shared_keys = gateway_client
+        .perform_initial_authentication()
+        .await
+        .tap_err(|_| log::warn!("Failed to register with the gateway!"))?;
+    Ok(shared_keys)
+}
+
+pub fn show_address<T>(config: &Config<T>) -> Result<(), ClientCoreError>
+where
+    T: config::NymConfig,
+{
+    fn load_identity_keys(
+        pathfinder: &ClientKeyPathfinder,
+    ) -> Result<identity::KeyPair, ClientCoreError> {
+        let identity_keypair: identity::KeyPair =
+            pemstore::load_keypair(&pemstore::KeyPairPath::new(
+                pathfinder.private_identity_key().to_owned(),
+                pathfinder.public_identity_key().to_owned(),
+            ))
+            .tap_err(|_| log::error!("Failed to read stored identity key files"))?;
+        Ok(identity_keypair)
+    }
+
+    fn load_sphinx_keys(
+        pathfinder: &ClientKeyPathfinder,
+    ) -> Result<encryption::KeyPair, ClientCoreError> {
+        let sphinx_keypair: encryption::KeyPair =
+            pemstore::load_keypair(&pemstore::KeyPairPath::new(
+                pathfinder.private_encryption_key().to_owned(),
+                pathfinder.public_encryption_key().to_owned(),
+            ))
+            .tap_err(|_| log::error!("Failed to read stored sphinx key files"))?;
+        Ok(sphinx_keypair)
+    }
+
+    let pathfinder = ClientKeyPathfinder::new_from_config(config);
+    let identity_keypair = load_identity_keys(&pathfinder)?;
+    let sphinx_keypair = load_sphinx_keys(&pathfinder)?;
+
+    let client_recipient = Recipient::new(
+        *identity_keypair.public_key(),
+        *sphinx_keypair.public_key(),
+        // TODO: below only works under assumption that gateway address == gateway id
+        // (which currently is true)
+        NodeIdentity::from_base58_string(config.get_gateway_id())?,
+    );
+
+    println!("\nThe address of this client is: {}", client_recipient);
+    Ok(())
+}
@@ -1,213 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-//! Collection of initialization steps used by client implementations
-
-use std::fmt::Display;
-
-use nymsphinx::addressing::{clients::Recipient, nodes::NodeIdentity};
-use serde::Serialize;
-use tap::TapFallible;
-
-use config::NymConfig;
-use crypto::asymmetric::{encryption, identity};
-
-use crate::client::replies::reply_storage::ReplyStorageBackend;
-use crate::{
-    config::{
-        persistence::key_pathfinder::ClientKeyPathfinder, ClientCoreConfigTrait, Config,
-        GatewayEndpointConfig,
-    },
-    error::ClientCoreError,
-    init::helpers::{query_gateway_details, register_with_gateway_and_store_keys},
-};
-
-mod helpers;
-
-#[derive(Debug, Serialize)]
-pub struct InitResults {
-    version: String,
-    id: String,
-    identity_key: String,
-    encryption_key: String,
-    gateway_id: String,
-    gateway_listener: String,
-}
-
-impl InitResults {
-    pub fn new<T>(config: &Config<T>, address: &Recipient) -> Self
-    where
-        T: NymConfig,
-    {
-        Self {
-            version: config.get_version().to_string(),
-            id: config.get_id(),
-            identity_key: address.identity().to_base58_string(),
-            encryption_key: address.encryption_key().to_base58_string(),
-            gateway_id: config.get_gateway_id(),
-            gateway_listener: config.get_gateway_listener(),
-        }
-    }
-}
-
-impl Display for InitResults {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        writeln!(f, "Version: {}", self.version)?;
-        writeln!(f, "ID: {}", self.id)?;
-        writeln!(f, "Identity key: {}", self.identity_key)?;
-        writeln!(f, "Encryption: {}", self.encryption_key)?;
-        writeln!(f, "Gateway ID: {}", self.gateway_id)?;
-        write!(f, "Gateway: {}", self.gateway_listener)
-    }
-}
-
-/// Convenience function for setting up the gateway for a client. Depending on the arguments given
-/// it will do the sensible thing.
-pub async fn setup_gateway<B, C, T>(
-    register_gateway: bool,
-    user_chosen_gateway_id: Option<String>,
-    config: &Config<T>,
-) -> Result<GatewayEndpointConfig, ClientCoreError<B>>
-where
-    B: ReplyStorageBackend,
-    C: NymConfig + ClientCoreConfigTrait,
-    T: NymConfig,
-{
-    let id = config.get_id();
-    if register_gateway {
-        register_with_gateway(user_chosen_gateway_id, config).await
-    } else if let Some(user_chosen_gateway_id) = user_chosen_gateway_id {
-        config_gateway_with_existing_keys(user_chosen_gateway_id, config).await
-    } else {
-        reuse_existing_gateway_config::<B, C>(&id)
-    }
-}
-
-/// Get the gateway details by querying the validator-api. Either pick one at random or use
-/// the chosen one if it's among the available ones.
-/// Saves keys to disk, specified by the paths in `config`.
-pub async fn register_with_gateway<B, T>(
-    user_chosen_gateway_id: Option<String>,
-    config: &Config<T>,
-) -> Result<GatewayEndpointConfig, ClientCoreError<B>>
-where
-    B: ReplyStorageBackend,
-    T: NymConfig,
-{
-    println!("Configuring gateway");
-    let gateway =
-        query_gateway_details(config.get_nym_api_endpoints(), user_chosen_gateway_id).await?;
-    log::debug!("Querying gateway gives: {}", gateway);
-
-    // Registering with gateway by setting up and writing shared keys to disk
-    log::trace!("Registering gateway");
-    register_with_gateway_and_store_keys(gateway.clone(), config).await?;
-    println!("Saved all generated keys");
-
-    Ok(gateway.into())
-}
-
-/// Set the gateway using the usual procedue of querying the validator-api, but don't register or
-/// create any keys.
-/// This assumes that the user knows what they are doing, and that the existing keys are valid for
-/// the gateway being used
-pub async fn config_gateway_with_existing_keys<B, T>(
-    user_chosen_gateway_id: String,
-    config: &Config<T>,
-) -> Result<GatewayEndpointConfig, ClientCoreError<B>>
-where
-    B: ReplyStorageBackend,
-    T: NymConfig,
-{
-    println!("Using gateway provided by user, keeping existing keys");
-    let gateway =
-        query_gateway_details(config.get_nym_api_endpoints(), Some(user_chosen_gateway_id)).await?;
-    log::debug!("Querying gateway gives: {}", gateway);
-    Ok(gateway.into())
-}
-
-/// Read and reuse the existing gateway configuration from a file that was generate earlier.
-pub fn reuse_existing_gateway_config<B, T>(
-    id: &str,
-) -> Result<GatewayEndpointConfig, ClientCoreError<B>>
-where
-    B: ReplyStorageBackend,
-    T: NymConfig + ClientCoreConfigTrait,
-{
-    println!("Not registering gateway, will reuse existing config and keys");
-    T::load_from_file(Some(id))
-        .map(|existing_config| existing_config.get_gateway_endpoint().clone())
-        .map_err(|err| {
-            log::error!(
-                "Unable to configure gateway: {err}. \n
-                Seems like the client was already initialized but it was not possible to read \
-                the existing configuration file. \n
-                CAUTION: Consider backing up your gateway keys and try force gateway registration, or \
-                removing the existing configuration and starting over."
-            );
-            ClientCoreError::CouldNotLoadExistingGatewayConfiguration(err)
-        })
-}
-
-/// Get the client address by loading the keys from stored files.
-pub fn get_client_address_from_stored_keys<B, T>(
-    config: &Config<T>,
-) -> Result<Recipient, ClientCoreError<B>>
-where
-    T: config::NymConfig,
-    B: ReplyStorageBackend,
-{
-    fn load_identity_keys<B>(
-        pathfinder: &ClientKeyPathfinder,
-    ) -> Result<identity::KeyPair, ClientCoreError<B>>
-    where
-        B: ReplyStorageBackend,
-    {
-        let identity_keypair: identity::KeyPair =
-            pemstore::load_keypair(&pemstore::KeyPairPath::new(
-                pathfinder.private_identity_key().to_owned(),
-                pathfinder.public_identity_key().to_owned(),
-            ))
-            .tap_err(|_| log::error!("Failed to read stored identity key files"))?;
-        Ok(identity_keypair)
-    }
-
-    fn load_sphinx_keys<B>(
-        pathfinder: &ClientKeyPathfinder,
-    ) -> Result<encryption::KeyPair, ClientCoreError<B>>
-    where
-        B: ReplyStorageBackend,
-    {
-        let sphinx_keypair: encryption::KeyPair =
-            pemstore::load_keypair(&pemstore::KeyPairPath::new(
-                pathfinder.private_encryption_key().to_owned(),
-                pathfinder.public_encryption_key().to_owned(),
-            ))
-            .tap_err(|_| log::error!("Failed to read stored sphinx key files"))?;
-        Ok(sphinx_keypair)
-    }
-
-    let pathfinder = ClientKeyPathfinder::new_from_config(config);
-    let identity_keypair = load_identity_keys(&pathfinder)?;
-    let sphinx_keypair = load_sphinx_keys(&pathfinder)?;
-
-    let client_recipient = Recipient::new(
-        *identity_keypair.public_key(),
-        *sphinx_keypair.public_key(),
-        // TODO: below only works under assumption that gateway address == gateway id
-        // (which currently is true)
-        NodeIdentity::from_base58_string(config.get_gateway_id())?,
-    );
-
-    Ok(client_recipient)
-}
-
-pub fn output_to_json<T: Serialize>(init_results: &T, output_file: &str) {
-    match std::fs::File::create(output_file) {
-        Ok(file) => match serde_json::to_writer_pretty(file, init_results) {
-            Ok(_) => println!("Saved: {}", output_file),
-            Err(err) => eprintln!("Could not save {}: {err}", output_file),
-        },
-        Err(err) => eprintln!("Could not save {}: {err}", output_file),
-    }
-}
@@ -1,23 +1,4 @@
-use std::future::Future;
-
 pub mod client;
 pub mod config;
 pub mod error;
 pub mod init;
-
-#[cfg(target_arch = "wasm32")]
-pub(crate) fn spawn_future<F>(future: F)
-where
-    F: Future<Output = ()> + 'static,
-{
-    wasm_bindgen_futures::spawn_local(future);
-}
-
-#[cfg(not(target_arch = "wasm32"))]
-pub(crate) fn spawn_future<F>(future: F)
-where
-    F: Future + Send + 'static,
-    F::Output: Send + 'static,
-{
-    tokio::spawn(future);
-}
@@ -6,18 +6,19 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [dependencies]
+async-trait = "0.1.52"
 bip39 = "1.0.1"
 cfg-if = "0.1"
-clap = { version = "3.2", features = ["cargo", "derive"] }
+clap = { version = "3.0.10", features = ["cargo", "derive"] }
+pickledb = "0.4.1"
 rand = "0.7.3"
 serde = { version = "1.0", features = ["derive"] }
 thiserror = "1.0"
 url = "2.2"
-tokio = { version = "1.21.2", features = ["rt-multi-thread", "net", "signal", "macros"] } # async runtime
+tokio = { version = "1.19.1", features = ["rt-multi-thread", "net", "signal", "macros"] } # async runtime

 coconut-interface = { path = "../../common/coconut-interface" }
 config = { path = "../../common/config" }
-completions = { path = "../../common/completions" }
 credentials = { path = "../../common/credentials" }
 credential-storage = { path = "../../common/credential-storage" }
 crypto = { path = "../../common/crypto", features = ["rand", "asymmetric", "symmetric", "aes", "hashing"] }
@@ -1,113 +1,192 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

+use async_trait::async_trait;
 use clap::{Args, Subcommand};
-use completions::ArgShell;
+use pickledb::PickleDb;
 use rand::rngs::OsRng;
 use std::str::FromStr;

-use coconut_interface::{Base58, Parameters};
+use coconut_interface::{Attribute, Base58, BlindSignRequest, Bytable, Parameters};
 use credential_storage::storage::Storage;
 use credential_storage::PersistentStorage;
 use credentials::coconut::bandwidth::{BandwidthVoucher, TOTAL_ATTRIBUTES};
 use credentials::coconut::utils::obtain_aggregate_signature;
 use crypto::asymmetric::{encryption, identity};
-use network_defaults::{NymNetworkDetails, VOUCHER_INFO};
+use network_defaults::VOUCHER_INFO;
 use validator_client::nymd::tx::Hash;
-use validator_client::{CoconutApiClient, Config};

 use crate::client::Client;
 use crate::error::{CredentialClientError, Result};
-use crate::state::{KeyPair, State};
+use crate::state::{KeyPair, RequestData, State};

 #[derive(Subcommand)]
-pub(crate) enum Command {
-    /// Run the binary
-    Run(Run),
-
-    /// Generate shell completions
-    Completions(ArgShell),
-
-    /// Generate Fig specification
-    GenerateFigSpec,
+pub(crate) enum Commands {
+    /// Deposit funds for buying coconut credential
+    Deposit(Deposit),
+    /// Lists the tx hashes of previous deposits
+    ListDeposits(ListDeposits),
+    /// Get a credential for a given deposit
+    GetCredential(GetCredential),
 }

-#[derive(Args)]
-pub(crate) struct Run {
-    /// Home directory of the client that is supposed to use the credential.
-    #[clap(long)]
-    pub(crate) client_home_directory: std::path::PathBuf,
+#[async_trait]
+pub(crate) trait Execute {
+    async fn execute(&self, db: &mut PickleDb, shared_storage: PersistentStorage) -> Result<()>;
+}

+#[derive(Args, Clone)]
+pub(crate) struct Deposit {
    /// The nymd URL that should be used
    #[clap(long)]
-    pub(crate) nymd_url: String,
-
-    /// A mnemonic for the account that buys the credential
+    nymd_url: String,
+    /// A mnemonic for the account that does the deposit
    #[clap(long)]
-    pub(crate) mnemonic: String,
-
-    /// The amount of utokens the credential will hold
+    mnemonic: String,
+    /// The amount that needs to be deposited
    #[clap(long)]
-    pub(crate) amount: u64,
+    amount: u64,
 }

-pub(crate) async fn deposit(nymd_url: &str, mnemonic: &str, amount: u64) -> Result<State> {
-    let mut rng = OsRng;
-    let signing_keypair = KeyPair::from(identity::KeyPair::new(&mut rng));
-    let encryption_keypair = KeyPair::from(encryption::KeyPair::new(&mut rng));
+#[async_trait]
+impl Execute for Deposit {
+    async fn execute(&self, db: &mut PickleDb, _shared_storage: PersistentStorage) -> Result<()> {
+        let mut rng = OsRng;
+        let signing_keypair = KeyPair::from(identity::KeyPair::new(&mut rng));
+        let encryption_keypair = KeyPair::from(encryption::KeyPair::new(&mut rng));

-    let client = Client::new(nymd_url, mnemonic);
-    let tx_hash = client
-        .deposit(
-            amount,
-            signing_keypair.public_key.clone(),
-            encryption_keypair.public_key.clone(),
-            None,
-        )
-        .await?;
+        let client = Client::new(&self.nymd_url, &self.mnemonic);
+        let tx_hash = client
+            .deposit(
+                self.amount,
+                signing_keypair.public_key.clone(),
+                encryption_keypair.public_key.clone(),
+                None,
+            )
+            .await?;

-    let state = State {
-        amount,
-        tx_hash,
-        signing_keypair,
-        encryption_keypair,
-    };
+        let state = State {
+            amount: self.amount,
+            tx_hash: tx_hash.clone(),
+            signing_keypair,
+            encryption_keypair,
+            blind_request_data: None,
+            signature: None,
+        };
+        db.set(&tx_hash, &state).unwrap();

-    Ok(state)
+        println!("{:?}", state);
+
+        Ok(())
+    }
 }

-pub(crate) async fn get_credential(state: &State, shared_storage: PersistentStorage) -> Result<()> {
-    let network_details = NymNetworkDetails::new_from_env();
-    let config = Config::try_from_nym_network_details(&network_details)?;
-    let client = validator_client::Client::new_query(config)?;
-    let coconut_api_clients = CoconutApiClient::all_coconut_api_clients(&client).await?;
+#[derive(Args, Clone)]
+pub(crate) struct ListDeposits {}

-    let params = Parameters::new(TOTAL_ATTRIBUTES).unwrap();
-    let bandwidth_credential_attributes = BandwidthVoucher::new(
-        &params,
-        state.amount.to_string(),
-        VOUCHER_INFO.to_string(),
-        Hash::from_str(&state.tx_hash).map_err(|_| CredentialClientError::InvalidTxHash)?,
-        identity::PrivateKey::from_base58_string(&state.signing_keypair.private_key)?,
-        encryption::PrivateKey::from_base58_string(&state.encryption_keypair.private_key)?,
-    );
+#[async_trait]
+impl Execute for ListDeposits {
+    async fn execute(&self, db: &mut PickleDb, _shared_storage: PersistentStorage) -> Result<()> {
+        for kv in db.iter() {
+            println!("{:?}", kv.get_value::<State>());
+        }

-    let signature = obtain_aggregate_signature(
-        &params,
-        &bandwidth_credential_attributes,
-        &coconut_api_clients,
-    )
-    .await?;
-    println!("Signature: {:?}", signature.to_bs58());
-    shared_storage
-        .insert_coconut_credential(
-            state.amount.to_string(),
-            VOUCHER_INFO.to_string(),
-            bandwidth_credential_attributes.get_private_attributes()[0].to_bs58(),
-            bandwidth_credential_attributes.get_private_attributes()[1].to_bs58(),
-            signature.to_bs58(),
-        )
-        .await?;
-
-    Ok(())
+        Ok(())
+    }
+}
+
+#[derive(Args, Clone)]
+pub(crate) struct GetCredential {
+    /// The hash of a successful deposit transaction
+    #[clap(long)]
+    tx_hash: String,
+    /// The URLs to the validator-api endpoints the are run as coconut signer authorities, separated
+    /// by comma (,)
+    #[clap(long)]
+    signer_authorities: String,
+    /// If we want to get the signature without attaching a blind sign request; it is expected that
+    /// there is already a signature stored on the signer
+    #[clap(long, parse(from_flag))]
+    __no_request: bool,
+}
+
+#[async_trait]
+impl Execute for GetCredential {
+    async fn execute(&self, db: &mut PickleDb, shared_storage: PersistentStorage) -> Result<()> {
+        let mut state = db
+            .get::<State>(&self.tx_hash)
+            .ok_or(CredentialClientError::NoDeposit)?;
+
+        let urls = config::parse_validators(&self.signer_authorities);
+
+        let params = Parameters::new(TOTAL_ATTRIBUTES).unwrap();
+        let bandwidth_credential_attributes = if self.__no_request {
+            if let Some(blind_request_data) = state.blind_request_data {
+                let serial_number =
+                    Attribute::try_from_byte_slice(&blind_request_data.serial_number)
+                        .map_err(|_| CredentialClientError::CorruptedBlindSignRequest)?;
+                let binding_number =
+                    Attribute::try_from_byte_slice(&blind_request_data.binding_number)
+                        .map_err(|_| CredentialClientError::CorruptedBlindSignRequest)?;
+                let pedersen_commitments_openings = vec![
+                    Attribute::try_from_byte_slice(&blind_request_data.first_attribute)
+                        .map_err(|_| CredentialClientError::CorruptedBlindSignRequest)?,
+                    Attribute::try_from_byte_slice(&blind_request_data.second_attribute)
+                        .map_err(|_| CredentialClientError::CorruptedBlindSignRequest)?,
+                ];
+                let blind_sign_request =
+                    BlindSignRequest::from_bytes(blind_request_data.blind_sign_req.as_slice())
+                        .map_err(|_| CredentialClientError::CorruptedBlindSignRequest)?;
+                BandwidthVoucher::new_with_blind_sign_req(
+                    [serial_number, binding_number],
+                    [&state.amount.to_string(), VOUCHER_INFO],
+                    Hash::from_str(&self.tx_hash)
+                        .map_err(|_| CredentialClientError::InvalidTxHash)?,
+                    identity::PrivateKey::from_base58_string(&state.signing_keypair.private_key)?,
+                    encryption::PrivateKey::from_base58_string(
+                        &state.encryption_keypair.private_key,
+                    )?,
+                    pedersen_commitments_openings,
+                    blind_sign_request,
+                )
+            } else {
+                return Err(CredentialClientError::NoLocalBlindSignRequest);
+            }
+        } else {
+            BandwidthVoucher::new(
+                &params,
+                state.amount.to_string(),
+                VOUCHER_INFO.to_string(),
+                Hash::from_str(&self.tx_hash).map_err(|_| CredentialClientError::InvalidTxHash)?,
+                identity::PrivateKey::from_base58_string(&state.signing_keypair.private_key)?,
+                encryption::PrivateKey::from_base58_string(&state.encryption_keypair.private_key)?,
+            )
+        };
+
+        // Back up the blind sign req data, in case of sporadic failures
+        state.blind_request_data = Some(RequestData::new(
+            bandwidth_credential_attributes.get_private_attributes(),
+            bandwidth_credential_attributes.pedersen_commitments_openings(),
+            bandwidth_credential_attributes.blind_sign_request(),
+        )?);
+        db.set(&self.tx_hash, &state).unwrap();
+
+        let signature =
+            obtain_aggregate_signature(&params, &bandwidth_credential_attributes, &urls).await?;
+        shared_storage
+            .insert_coconut_credential(
+                state.amount.to_string(),
+                VOUCHER_INFO.to_string(),
+                bandwidth_credential_attributes.get_private_attributes()[0].to_bs58(),
+                bandwidth_credential_attributes.get_private_attributes()[1].to_bs58(),
+                signature.to_bs58(),
+            )
+            .await?;
+        state.signature = Some(signature.to_bs58());
+        db.set(&self.tx_hash, &state).unwrap();
+
+        println!("Signature: {:?}", state.signature);
+
+        Ok(())
+    }
 }
@@ -8,7 +8,6 @@ use credentials::error::Error as CredentialError;
 use crypto::asymmetric::encryption::KeyRecoveryError;
 use crypto::asymmetric::identity::Ed25519RecoveryError;
 use validator_client::nymd::error::NymdError;
-use validator_client::ValidatorClientError;

 pub type Result<T> = std::result::Result<T, CredentialClientError>;

@@ -17,12 +16,21 @@ pub enum CredentialClientError {
    #[error("Nymd error: {0}")]
    Nymd(#[from] NymdError),

-    #[error("Validator client error: {0}")]
-    ValidatorClientError(#[from] ValidatorClientError),
-
    #[error("Credential error: {0}")]
    Credential(#[from] CredentialError),

+    #[error("No previous deposit with that tx hash")]
+    NoDeposit,
+
+    #[error("Wrong number of attributes")]
+    WrongAttributeNumber,
+
+    #[error("Could not find any backed up blind sign request data")]
+    NoLocalBlindSignRequest,
+
+    #[error("The local blind sign request data is corrupted")]
+    CorruptedBlindSignRequest,
+
    #[error("The tx hash provided is not valid")]
    InvalidTxHash,

@@ -9,41 +9,53 @@ cfg_if::cfg_if! {
        mod error;
        mod state;

+        use commands::{Commands, Execute};
        use error::Result;
        use network_defaults::setup_env;
-        use completions::fig_generate;
-        use commands::*;
-        use config::{DATA_DIR, DB_FILE_NAME};

-        use clap::{CommandFactory, Parser};
+        use clap::Parser;
+        use pickledb::{PickleDb, PickleDbDumpPolicy, SerializationMethod};

        #[derive(Parser)]
        #[clap(author = "Nymtech", version, about)]
        struct Cli {
            /// Path pointing to an env file that configures the client.
-            #[clap(short, long)]
+            #[clap(long)]
            pub(crate) config_env_file: Option<std::path::PathBuf>,

+            /// Path where the sqlite credental database will be located.
+            /// It should point to a $HOME/$CLIENT_ID/data/db.sqlite file of
+            /// the client that is supposed to use the credential.
+            #[clap(long)]
+            pub(crate) credential_db_path: std::path::PathBuf,
+
            #[clap(subcommand)]
-            pub(crate) command: Command,
+            command: Commands,
        }

        #[tokio::main]
        async fn main() -> Result<()> {
            let args = Cli::parse();
            setup_env(args.config_env_file.clone());
-            let bin_name = "nym-credential-client";

-            match args.command {
-                Command::Run(r) => {
-                    let db_path = r.client_home_directory.join(DATA_DIR).join(DB_FILE_NAME);
-                    let shared_storage = credential_storage::initialise_storage(db_path).await;
+            let shared_storage = credential_storage::initialise_storage(args.credential_db_path.clone()).await;
+            let mut db = match PickleDb::load(
+                "credential.db",
+                PickleDbDumpPolicy::AutoDump,
+                SerializationMethod::Json,
+            ) {
+                Ok(db) => db,
+                Err(_) => PickleDb::new(
+                    "credential.db",
+                    PickleDbDumpPolicy::AutoDump,
+                    SerializationMethod::Json,
+                ),
+            };

-                    let state = deposit(&r.nymd_url, &r.mnemonic, r.amount).await?;
-                    get_credential(&state, shared_storage).await?;
-                }
-                Command::Completions(c) => c.generate(&mut crate::Cli::into_app(), bin_name),
-                Command::GenerateFigSpec => fig_generate(&mut crate::Cli::into_app(), bin_name)
+            match &args.command {
+                Commands::Deposit(m) => m.execute(&mut db, shared_storage).await?,
+                Commands::ListDeposits(m) => m.execute(&mut db, shared_storage).await?,
+                Commands::GetCredential(m) => m.execute(&mut db, shared_storage).await?,
            }

            Ok(())
@@ -1,10 +1,13 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

+use coconut_interface::{Attribute, BlindSignRequest, Bytable, PrivateAttribute};
 use serde::{Deserialize, Serialize};

 use crypto::asymmetric::{encryption, identity};

+use crate::error::{CredentialClientError, Result};
+
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub(crate) struct KeyPair {
    pub public_key: String,
@@ -35,4 +38,35 @@ pub(crate) struct State {
    pub tx_hash: String,
    pub signing_keypair: KeyPair,
    pub encryption_keypair: KeyPair,
+    pub blind_request_data: Option<RequestData>,
+    pub signature: Option<String>,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub(crate) struct RequestData {
+    pub serial_number: Vec<u8>,
+    pub binding_number: Vec<u8>,
+    pub first_attribute: Vec<u8>,
+    pub second_attribute: Vec<u8>,
+    pub blind_sign_req: Vec<u8>,
+}
+
+impl RequestData {
+    pub fn new(
+        private_attributes: Vec<PrivateAttribute>,
+        attributes: &[Attribute],
+        blind_sign_request: &BlindSignRequest,
+    ) -> Result<Self> {
+        if private_attributes.len() != 2 || attributes.len() != 2 {
+            Err(CredentialClientError::WrongAttributeNumber)
+        } else {
+            Ok(RequestData {
+                serial_number: private_attributes[0].to_byte_vec(),
+                binding_number: private_attributes[1].to_byte_vec(),
+                first_attribute: attributes[0].to_byte_vec(),
+                second_attribute: attributes[1].to_byte_vec(),
+                blind_sign_req: blind_sign_request.to_bytes(),
+            })
+        }
+    }
 }
@@ -1,10 +1,10 @@
 [package]
 name = "nym-client"
-version = "1.1.4"
+version = "1.0.2"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>", "Jędrzej Stuczyński <andrew@nymtech.net>"]
 description = "Implementation of the Nym Client"
 edition = "2021"
-rust-version = "1.65"
+rust-version = "1.56"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

@@ -20,28 +20,23 @@ futures = "0.3" # bunch of futures stuff, however, now that I think about it, it
 # and the single instance of abortable we have should really be refactored anyway
 url = "2.2"

-clap = { version = "3.2", features = ["cargo", "derive"] }
+clap = { version = "3.2.8", features = ["cargo", "derive"] }
 dirs = "4.0"
 log = "0.4" # self explanatory
 pretty_env_logger = "0.4" # for formatting log messages
 rand = { version = "0.7.3", features = ["wasm-bindgen"] } # rng-related traits + some rng implementation to use
 serde = { version = "1.0.104", features = ["derive"] } # for config serialization/deserialization
-serde_json = "1.0"
-thiserror = "1.0.34"
-tap = "1.0.1"
-tokio = { version = "1.21.2", features = ["rt-multi-thread", "net", "signal"] } # async runtime
+sled = "0.34" # for storage of replySURB decryption keys
+tokio = { version = "1.19.1", features = ["rt-multi-thread", "net", "signal"] } # async runtime
 tokio-tungstenite = "0.14" # websocket

 ## internal
-client-core = { path = "../client-core", features = ["fs-surb-storage"] }
-client-connections = { path = "../../common/client-connections" }
+client-core = { path = "../client-core" }
 coconut-interface = { path = "../../common/coconut-interface", optional = true }
 config = { path = "../../common/config" }
-completions = { path = "../../common/completions" }
 credential-storage = { path = "../../common/credential-storage" }
 credentials = { path = "../../common/credentials", optional = true }
 crypto = { path = "../../common/crypto" }
-logging = { path = "../../common/logging"}
 gateway-client = { path = "../../common/client-libs/gateway-client" }
 gateway-requests = { path = "../../gateway/gateway-requests" }
 network-defaults = { path = "../../common/network-defaults" }
@@ -55,6 +50,7 @@ websocket-requests = { path = "websocket-requests" }

 [features]
 coconut = ["coconut-interface", "credentials", "credentials/coconut", "gateway-requests/coconut", "gateway-client/coconut", "client-core/coconut"]
+eth = []

 [dev-dependencies]
 serde_json = "1.0" # for the "textsend" example
@@ -27,58 +27,6 @@
        "node": ">=10.0.0"
      }
    },
-    "node_modules/@jridgewell/gen-mapping": {
-      "version": "0.3.2",
-      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.2.tgz",
-      "integrity": "sha512-mh65xKQAzI6iBcFzwv28KVWSmCkdRBWoOh+bYQGW3+6OZvbbN3TqMGo5hqYxQniRcH9F2VZIoJCm4pa3BPDK/A==",
-      "dependencies": {
-        "@jridgewell/set-array": "^1.0.1",
-        "@jridgewell/sourcemap-codec": "^1.4.10",
-        "@jridgewell/trace-mapping": "^0.3.9"
-      },
-      "engines": {
-        "node": ">=6.0.0"
-      }
-    },
-    "node_modules/@jridgewell/resolve-uri": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.0.tgz",
-      "integrity": "sha512-F2msla3tad+Mfht5cJq7LSXcdudKTWCVYUgw6pLFOOHSTtZlj6SWNYAp+AhuqLmWdBO2X5hPrLcu8cVP8fy28w==",
-      "engines": {
-        "node": ">=6.0.0"
-      }
-    },
-    "node_modules/@jridgewell/set-array": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/@jridgewell/set-array/-/set-array-1.1.2.tgz",
-      "integrity": "sha512-xnkseuNADM0gt2bs+BvhO0p78Mk762YnZdsuzFV018NoG1Sj1SCQvpSqa7XUaTam5vAGasABV9qXASMKnFMwMw==",
-      "engines": {
-        "node": ">=6.0.0"
-      }
-    },
-    "node_modules/@jridgewell/source-map": {
-      "version": "0.3.2",
-      "resolved": "https://registry.npmjs.org/@jridgewell/source-map/-/source-map-0.3.2.tgz",
-      "integrity": "sha512-m7O9o2uR8k2ObDysZYzdfhb08VuEml5oWGiosa1VdaPZ/A6QyPkAJuwN0Q1lhULOf6B7MtQmHENS743hWtCrgw==",
-      "dependencies": {
-        "@jridgewell/gen-mapping": "^0.3.0",
-        "@jridgewell/trace-mapping": "^0.3.9"
-      }
-    },
-    "node_modules/@jridgewell/sourcemap-codec": {
-      "version": "1.4.14",
-      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.14.tgz",
-      "integrity": "sha512-XPSJHWmi394fuUuzDnGz1wiKqWfo1yXecHQMRf2l6hztTO+nPru658AyDngaBe7isIxEkRsPR3FZh+s7iVa4Uw=="
-    },
-    "node_modules/@jridgewell/trace-mapping": {
-      "version": "0.3.15",
-      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.15.tgz",
-      "integrity": "sha512-oWZNOULl+UbhsgB51uuZzglikfIKSUBO/M9W2OfEjn7cmqoAiCgmv9lyACTUacZwBz0ITnJ2NqjU8Tx0DHL88g==",
-      "dependencies": {
-        "@jridgewell/resolve-uri": "^3.0.3",
-        "@jridgewell/sourcemap-codec": "^1.4.10"
-      }
-    },
    "node_modules/@nodelib/fs.scandir": {
      "version": "2.1.5",
      "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
@@ -3581,13 +3529,13 @@
      }
    },
    "node_modules/terser": {
-      "version": "5.15.0",
-      "resolved": "https://registry.npmjs.org/terser/-/terser-5.15.0.tgz",
-      "integrity": "sha512-L1BJiXVmheAQQy+as0oF3Pwtlo4s3Wi1X2zNZ2NxOB4wx9bdS9Vk67XQENLFdLYGCK/Z2di53mTj/hBafR+dTA==",
+      "version": "5.12.1",
+      "resolved": "https://registry.npmjs.org/terser/-/terser-5.12.1.tgz",
+      "integrity": "sha512-NXbs+7nisos5E+yXwAD+y7zrcTkMqb0dEJxIGtSKPdCBzopf7ni4odPul2aechpV7EXNvOudYOX2bb5tln1jbQ==",
      "dependencies": {
-        "@jridgewell/source-map": "^0.3.2",
        "acorn": "^8.5.0",
        "commander": "^2.20.0",
+        "source-map": "~0.7.2",
        "source-map-support": "~0.5.20"
      },
      "bin": {
@@ -3635,6 +3583,14 @@
      "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz",
      "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ=="
    },
+    "node_modules/terser/node_modules/source-map": {
+      "version": "0.7.3",
+      "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.7.3.tgz",
+      "integrity": "sha512-CkCj6giN3S+n9qrYiBTX5gystlENnRW5jZeNLHpe6aue+SrHcG5VYwujhW9s4dY31mEGsxBDrHR6oI69fTXsaQ==",
+      "engines": {
+        "node": ">= 8"
+      }
+    },
    "node_modules/thunky": {
      "version": "1.1.0",
      "resolved": "https://registry.npmjs.org/thunky/-/thunky-1.1.0.tgz",
@@ -4374,49 +4330,6 @@
      "integrity": "sha512-dBVuXR082gk3jsFp7Rd/JI4kytwGHecnCoTtXFb7DB6CNHp4rg5k1bhg0nWdLGLnOV71lmDzGQaLMy8iPLY0pw==",
      "dev": true
    },
-    "@jridgewell/gen-mapping": {
-      "version": "0.3.2",
-      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.2.tgz",
-      "integrity": "sha512-mh65xKQAzI6iBcFzwv28KVWSmCkdRBWoOh+bYQGW3+6OZvbbN3TqMGo5hqYxQniRcH9F2VZIoJCm4pa3BPDK/A==",
-      "requires": {
-        "@jridgewell/set-array": "^1.0.1",
-        "@jridgewell/sourcemap-codec": "^1.4.10",
-        "@jridgewell/trace-mapping": "^0.3.9"
-      }
-    },
-    "@jridgewell/resolve-uri": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.0.tgz",
-      "integrity": "sha512-F2msla3tad+Mfht5cJq7LSXcdudKTWCVYUgw6pLFOOHSTtZlj6SWNYAp+AhuqLmWdBO2X5hPrLcu8cVP8fy28w=="
-    },
-    "@jridgewell/set-array": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/@jridgewell/set-array/-/set-array-1.1.2.tgz",
-      "integrity": "sha512-xnkseuNADM0gt2bs+BvhO0p78Mk762YnZdsuzFV018NoG1Sj1SCQvpSqa7XUaTam5vAGasABV9qXASMKnFMwMw=="
-    },
-    "@jridgewell/source-map": {
-      "version": "0.3.2",
-      "resolved": "https://registry.npmjs.org/@jridgewell/source-map/-/source-map-0.3.2.tgz",
-      "integrity": "sha512-m7O9o2uR8k2ObDysZYzdfhb08VuEml5oWGiosa1VdaPZ/A6QyPkAJuwN0Q1lhULOf6B7MtQmHENS743hWtCrgw==",
-      "requires": {
-        "@jridgewell/gen-mapping": "^0.3.0",
-        "@jridgewell/trace-mapping": "^0.3.9"
-      }
-    },
-    "@jridgewell/sourcemap-codec": {
-      "version": "1.4.14",
-      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.14.tgz",
-      "integrity": "sha512-XPSJHWmi394fuUuzDnGz1wiKqWfo1yXecHQMRf2l6hztTO+nPru658AyDngaBe7isIxEkRsPR3FZh+s7iVa4Uw=="
-    },
-    "@jridgewell/trace-mapping": {
-      "version": "0.3.15",
-      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.15.tgz",
-      "integrity": "sha512-oWZNOULl+UbhsgB51uuZzglikfIKSUBO/M9W2OfEjn7cmqoAiCgmv9lyACTUacZwBz0ITnJ2NqjU8Tx0DHL88g==",
-      "requires": {
-        "@jridgewell/resolve-uri": "^3.0.3",
-        "@jridgewell/sourcemap-codec": "^1.4.10"
-      }
-    },
    "@nodelib/fs.scandir": {
      "version": "2.1.5",
      "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
@@ -7145,13 +7058,13 @@
      "integrity": "sha512-GNzQvQTOIP6RyTfE2Qxb8ZVlNmw0n88vp1szwWRimP02mnTsx3Wtn5qRdqY9w2XduFNUgvOwhNnQsjwCp+kqaQ=="
    },
    "terser": {
-      "version": "5.15.0",
-      "resolved": "https://registry.npmjs.org/terser/-/terser-5.15.0.tgz",
-      "integrity": "sha512-L1BJiXVmheAQQy+as0oF3Pwtlo4s3Wi1X2zNZ2NxOB4wx9bdS9Vk67XQENLFdLYGCK/Z2di53mTj/hBafR+dTA==",
+      "version": "5.12.1",
+      "resolved": "https://registry.npmjs.org/terser/-/terser-5.12.1.tgz",
+      "integrity": "sha512-NXbs+7nisos5E+yXwAD+y7zrcTkMqb0dEJxIGtSKPdCBzopf7ni4odPul2aechpV7EXNvOudYOX2bb5tln1jbQ==",
      "requires": {
-        "@jridgewell/source-map": "^0.3.2",
        "acorn": "^8.5.0",
        "commander": "^2.20.0",
+        "source-map": "~0.7.2",
        "source-map-support": "~0.5.20"
      },
      "dependencies": {
@@ -7159,6 +7072,11 @@
          "version": "2.20.3",
          "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz",
          "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ=="
+        },
+        "source-map": {
+          "version": "0.7.3",
+          "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.7.3.tgz",
+          "integrity": "sha512-CkCj6giN3S+n9qrYiBTX5gystlENnRW5jZeNLHpe6aue+SrHcG5VYwujhW9s4dY31mEGsxBDrHR6oI69fTXsaQ=="
        }
      }
    },
@@ -25,59 +25,57 @@ async fn get_self_address(ws_stream: &mut WebSocketStream<MaybeTlsStream<TcpStre
    let response = send_message_and_get_response(ws_stream, self_address_request).await;

    match response {
-        ServerResponse::SelfAddress(recipient) => *recipient,
+        ServerResponse::SelfAddress(recipient) => recipient,
        _ => panic!("received an unexpected response!"),
    }
 }

 async fn send_file_with_reply() {
-    todo!("reimplement surb usage here : )")
-    // let uri = "ws://localhost:1977";
-    // let (mut ws_stream, _) = connect_async(uri).await.unwrap();
-    //
-    // let recipient = get_self_address(&mut ws_stream).await;
-    // println!("our full address is: {}", recipient);
-    //
-    // let read_data = std::fs::read("examples/dummy_file").unwrap();
-    //
-    // let send_request = ClientRequest::Send {
-    //     recipient,
-    //     message: read_data,
-    //     with_reply_surb: true,
-    //     connection_id: Some(0),
-    // };
-    //
-    // println!("sending content of 'dummy_file' over the mix network...");
-    // let response = send_message_and_get_response(&mut ws_stream, send_request.serialize()).await;
-    //
-    // let received = match response {
-    //     ServerResponse::Received(received) => received,
-    //     _ => panic!("received an unexpected response!"),
-    // };
-    //
-    // println!("writing the file back to the disk!");
-    // std::fs::write("examples/received_file_withreply", received.message).unwrap();
-    //
-    // let reply_message = b"hello from reply SURB! - thanks for sending me the file!".to_vec();
-    // let reply_request = ClientRequest::Reply {
-    //     message: reply_message.clone(),
-    //     reply_surb: received.reply_surb.unwrap(),
-    // };
-    //
-    // println!(
-    //     "sending {:?} (using reply SURB!) over the mix network...",
-    //     String::from_utf8(reply_message).unwrap()
-    // );
-    // let response = send_message_and_get_response(&mut ws_stream, reply_request.serialize()).await;
-    // let received = match response {
-    //     ServerResponse::Received(received) => received,
-    //     _ => panic!("received an unexpected response!"),
-    // };
-    //
-    // println!(
-    //     "received {:#?} from the mix network!",
-    //     String::from_utf8(received.message).unwrap()
-    // );
+    let uri = "ws://localhost:1977";
+    let (mut ws_stream, _) = connect_async(uri).await.unwrap();
+
+    let recipient = get_self_address(&mut ws_stream).await;
+    println!("our full address is: {}", recipient);
+
+    let read_data = std::fs::read("examples/dummy_file").unwrap();
+
+    let send_request = ClientRequest::Send {
+        recipient,
+        message: read_data,
+        with_reply_surb: true,
+    };
+
+    println!("sending content of 'dummy_file' over the mix network...");
+    let response = send_message_and_get_response(&mut ws_stream, send_request.serialize()).await;
+
+    let received = match response {
+        ServerResponse::Received(received) => received,
+        _ => panic!("received an unexpected response!"),
+    };
+
+    println!("writing the file back to the disk!");
+    std::fs::write("examples/received_file_withreply", received.message).unwrap();
+
+    let reply_message = b"hello from reply SURB! - thanks for sending me the file!".to_vec();
+    let reply_request = ClientRequest::Reply {
+        message: reply_message.clone(),
+        reply_surb: received.reply_surb.unwrap(),
+    };
+
+    println!(
+        "sending {:?} (using reply SURB!) over the mix network...",
+        String::from_utf8(reply_message).unwrap()
+    );
+    let response = send_message_and_get_response(&mut ws_stream, reply_request.serialize()).await;
+    let received = match response {
+        ServerResponse::Received(received) => received,
+        _ => panic!("received an unexpected response!"),
+    };
+
+    println!(
+        "received {:#?} from the mix network!",
+        String::from_utf8(received.message).unwrap()
+    );
 }

 async fn send_file_without_reply() {
@@ -92,7 +90,7 @@ async fn send_file_without_reply() {
    let send_request = ClientRequest::Send {
        recipient,
        message: read_data,
-        connection_id: Some(0),
+        with_reply_surb: false,
    };

    println!("sending content of 'dummy_file' over the mix network...");
@@ -2,8 +2,8 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::client::config::template::config_template;
+use client_core::config::Config as BaseConfig;
 pub use client_core::config::MISSING_VALUE;
-use client_core::config::{ClientCoreConfigTrait, Config as BaseConfig, DebugConfig};
 use config::defaults::DEFAULT_WEBSOCKET_LISTENING_PORT;
 use config::NymConfig;
 use serde::{Deserialize, Serialize};
@@ -27,10 +27,6 @@ impl SocketType {
            _ => SocketType::None,
        }
    }
-
-    pub fn is_websocket(&self) -> bool {
-        matches!(self, SocketType::WebSocket)
-    }
 }

 #[derive(Debug, Default, Deserialize, PartialEq, Serialize)]
@@ -73,12 +69,6 @@ impl NymConfig for Config {
    }
 }

-impl ClientCoreConfigTrait for Config {
-    fn get_gateway_endpoint(&self) -> &client_core::config::GatewayEndpointConfig {
-        self.base.get_gateway_endpoint()
-    }
-}
-
 impl Config {
    pub fn new<S: Into<String>>(id: S) -> Self {
        Config {
@@ -110,10 +100,6 @@ impl Config {
        &mut self.base
    }

-    pub fn get_debug_settings(&self) -> &DebugConfig {
-        self.get_base().get_debug_config()
-    }
-
    pub fn get_socket_type(&self) -> SocketType {
        self.socket.socket_type
    }
@@ -23,16 +23,9 @@ id = '{{ client.id }}'
 # to claim bandwidth without presenting bandwidth credentials.
 disabled_credentials_mode = {{ client.disabled_credentials_mode }}

-# Addresses to nymd validators via which the client can communicate with the chain.
-validator_urls = [
-    {{#each client.validator_urls }}
-        '{{this}}',
-    {{/each}}
-]
-
 # Addresses to APIs running on validator from which the client gets the view of the network.
-nym_api_urls = [
-    {{#each client.nym_api_urls }}
+validator_api_urls = [
+    {{#each client.validator_api_urls }}
        '{{this}}',
    {{/each}}
 ]
@@ -49,11 +42,18 @@ private_encryption_key_file = '{{ client.private_encryption_key_file }}'
 # Path to file containing public encryption key.
 public_encryption_key_file = '{{ client.public_encryption_key_file }}'

+# Full path to file containing reply encryption keys of all reply-SURBs we have ever
+# sent but not received back.
+reply_encryption_key_store_path = '{{ client.reply_encryption_key_store_path }}'
+
 # Path to the database containing bandwidth credentials
 database_path = '{{ client.database_path }}'

-# Path to the persistent store for received reply surbs, unused encryption keys and used sender tags.
-reply_surb_database_path = '{{ client.reply_surb_database_path }}'
+# Ethereum private key.
+eth_private_key = '{{ client.eth_private_key }}'
+
+# Addess to an Ethereum full node.
+eth_endpoint = '{{ client.eth_endpoint }}'

 ##### additional client config options #####

@@ -1,265 +1,306 @@
-// Copyright 2021-2022 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use std::error::Error;
-
-use crate::client::config::Config;
-use crate::error::ClientError;
-use crate::websocket;
-use client_connections::TransmissionLane;
-use client_core::client::base_client::{
-    non_wasm_helpers, BaseClientBuilder, ClientInput, ClientOutput,
+use client_core::client::cover_traffic_stream::LoopCoverTrafficStream;
+use client_core::client::inbound_messages::{
+    InputMessage, InputMessageReceiver, InputMessageSender,
 };
-use client_core::client::inbound_messages::InputMessage;
 use client_core::client::key_manager::KeyManager;
-use client_core::client::received_buffer::{ReceivedBufferMessage, ReconstructedMessagesReceiver};
-use client_core::client::replies::reply_controller::requests::ReplyControllerSender;
+use client_core::client::mix_traffic::{
+    BatchMixMessageReceiver, BatchMixMessageSender, MixTrafficController,
+};
+use client_core::client::real_messages_control;
+use client_core::client::real_messages_control::RealMessagesController;
+use client_core::client::received_buffer::{
+    ReceivedBufferMessage, ReceivedBufferRequestReceiver, ReceivedBufferRequestSender,
+    ReceivedMessagesBufferController, ReconstructedMessagesReceiver,
+};
+use client_core::client::reply_key_storage::ReplyKeyStorage;
+use client_core::client::topology_control::{
+    TopologyAccessor, TopologyRefresher, TopologyRefresherConfig,
+};
 use client_core::config::persistence::key_pathfinder::ClientKeyPathfinder;
+use crypto::asymmetric::identity;
 use futures::channel::mpsc;
 use gateway_client::bandwidth::BandwidthController;
+use gateway_client::{
+    AcknowledgementReceiver, AcknowledgementSender, GatewayClient, MixnetMessageReceiver,
+    MixnetMessageSender,
+};
 use log::*;
 use nymsphinx::addressing::clients::Recipient;
-use nymsphinx::anonymous_replies::requests::AnonymousSenderTag;
+use nymsphinx::addressing::nodes::NodeIdentity;
+use nymsphinx::anonymous_replies::ReplySurb;
 use nymsphinx::receiver::ReconstructedMessage;
-use task::TaskManager;
+use task::{wait_for_signal, ShutdownListener, ShutdownNotifier};
+
+use crate::client::config::{Config, SocketType};
+use crate::websocket;

 pub(crate) mod config;

-pub struct SocketClient {
+pub struct NymClient {
    /// Client configuration options, including, among other things, packet sending rates,
    /// key filepaths, etc.
    config: Config,

    /// KeyManager object containing smart pointers to all relevant keys used by the client.
    key_manager: KeyManager,
+
+    /// Channel used for transforming 'raw' messages into sphinx packets and sending them
+    /// through the mix network.
+    /// It is only available if the client started with the websocket listener disabled.
+    input_tx: Option<InputMessageSender>,
+
+    /// Channel used for obtaining reconstructed messages received from the mix network.
+    /// It is only available if the client started with the websocket listener disabled.
+    receive_tx: Option<ReconstructedMessagesReceiver>,
 }

-impl SocketClient {
+impl NymClient {
    pub fn new(config: Config) -> Self {
        let pathfinder = ClientKeyPathfinder::new_from_config(config.get_base());
        let key_manager = KeyManager::load_keys(&pathfinder).expect("failed to load stored keys");

-        SocketClient {
+        NymClient {
            config,
            key_manager,
+            input_tx: None,
+            receive_tx: None,
        }
    }

-    async fn create_bandwidth_controller(config: &Config) -> BandwidthController {
+    pub fn as_mix_recipient(&self) -> Recipient {
+        Recipient::new(
+            *self.key_manager.identity_keypair().public_key(),
+            *self.key_manager.encryption_keypair().public_key(),
+            // TODO: below only works under assumption that gateway address == gateway id
+            // (which currently is true)
+            NodeIdentity::from_base58_string(self.config.get_base().get_gateway_id()).unwrap(),
+        )
+    }
+
+    // future constantly pumping loop cover traffic at some specified average rate
+    // the pumped traffic goes to the MixTrafficController
+    fn start_cover_traffic_stream(
+        &self,
+        topology_accessor: TopologyAccessor,
+        mix_tx: BatchMixMessageSender,
+        shutdown: ShutdownListener,
+    ) {
+        info!("Starting loop cover traffic stream...");
+
+        LoopCoverTrafficStream::new(
+            self.key_manager.ack_key(),
+            self.config.get_base().get_average_ack_delay(),
+            self.config.get_base().get_average_packet_delay(),
+            self.config
+                .get_base()
+                .get_loop_cover_traffic_average_delay(),
+            mix_tx,
+            self.as_mix_recipient(),
+            topology_accessor,
+            shutdown,
+        )
+        .start();
+    }
+
+    fn start_real_traffic_controller(
+        &self,
+        topology_accessor: TopologyAccessor,
+        reply_key_storage: ReplyKeyStorage,
+        ack_receiver: AcknowledgementReceiver,
+        input_receiver: InputMessageReceiver,
+        mix_sender: BatchMixMessageSender,
+        shutdown: ShutdownListener,
+    ) {
+        let controller_config = real_messages_control::Config::new(
+            self.key_manager.ack_key(),
+            self.config.get_base().get_ack_wait_multiplier(),
+            self.config.get_base().get_ack_wait_addition(),
+            self.config.get_base().get_average_ack_delay(),
+            self.config.get_base().get_message_sending_average_delay(),
+            self.config.get_base().get_average_packet_delay(),
+            self.as_mix_recipient(),
+        );
+
+        info!("Starting real traffic stream...");
+
+        RealMessagesController::new(
+            controller_config,
+            ack_receiver,
+            input_receiver,
+            mix_sender,
+            topology_accessor,
+            reply_key_storage,
+            shutdown,
+        )
+        .start();
+    }
+
+    // buffer controlling all messages fetched from provider
+    // required so that other components would be able to use them (say the websocket)
+    fn start_received_messages_buffer_controller(
+        &self,
+        query_receiver: ReceivedBufferRequestReceiver,
+        mixnet_receiver: MixnetMessageReceiver,
+        reply_key_storage: ReplyKeyStorage,
+        shutdown: ShutdownListener,
+    ) {
+        info!("Starting received messages buffer controller...");
+        ReceivedMessagesBufferController::new(
+            self.key_manager.encryption_keypair(),
+            query_receiver,
+            mixnet_receiver,
+            reply_key_storage,
+            shutdown,
+        )
+        .start()
+    }
+
+    async fn start_gateway_client(
+        &mut self,
+        mixnet_message_sender: MixnetMessageSender,
+        ack_sender: AcknowledgementSender,
+        shutdown: ShutdownListener,
+    ) -> GatewayClient {
+        let gateway_id = self.config.get_base().get_gateway_id();
+        if gateway_id.is_empty() {
+            panic!("The identity of the gateway is unknown - did you run `nym-client` init?")
+        }
+        let gateway_owner = self.config.get_base().get_gateway_owner();
+        if gateway_owner.is_empty() {
+            panic!("The owner of the gateway is unknown - did you run `nym-client` init?")
+        }
+        let gateway_address = self.config.get_base().get_gateway_listener();
+        if gateway_address.is_empty() {
+            panic!("The address of the gateway is unknown - did you run `nym-client` init?")
+        }
+
+        let gateway_identity = identity::PublicKey::from_base58_string(gateway_id)
+            .expect("provided gateway id is invalid!");
+
        #[cfg(feature = "coconut")]
-        let bandwidth_controller = {
-            let details = network_defaults::NymNetworkDetails::new_from_env();
-            let mut client_config =
-                validator_client::Config::try_from_nym_network_details(&details)
-                    .expect("failed to construct validator client config");
-            let nymd_url = config
-                .get_base()
-                .get_validator_endpoints()
-                .pop()
-                .expect("No nymd validator endpoint provided");
-            let api_url = config
-                .get_base()
-                .get_nym_api_endpoints()
-                .pop()
-                .expect("No validator api endpoint provided");
-            // overwrite env configuration with config URLs
-            client_config = client_config.with_urls(nymd_url, api_url);
-            let client = validator_client::Client::new_query(client_config)
-                .expect("Could not construct query client");
-            let coconut_api_clients =
-                validator_client::CoconutApiClient::all_coconut_api_clients(&client)
-                    .await
-                    .expect("Could not query api clients");
-            BandwidthController::new(
-                credential_storage::initialise_storage(config.get_base().get_database_path()).await,
-                coconut_api_clients,
-            )
-        };
+        let bandwidth_controller = BandwidthController::new(
+            credential_storage::initialise_storage(self.config.get_base().get_database_path())
+                .await,
+            self.config.get_base().get_validator_api_endpoints(),
+        );
        #[cfg(not(feature = "coconut"))]
        let bandwidth_controller = BandwidthController::new(
-            credential_storage::initialise_storage(config.get_base().get_database_path()).await,
+            credential_storage::initialise_storage(self.config.get_base().get_database_path())
+                .await,
+            self.config.get_base().get_eth_endpoint(),
+            self.config.get_base().get_eth_private_key(),
        )
        .expect("Could not create bandwidth controller");
-        bandwidth_controller
+
+        let mut gateway_client = GatewayClient::new(
+            gateway_address,
+            self.key_manager.identity_keypair(),
+            gateway_identity,
+            gateway_owner,
+            Some(self.key_manager.gateway_shared_key()),
+            mixnet_message_sender,
+            ack_sender,
+            self.config.get_base().get_gateway_response_timeout(),
+            Some(bandwidth_controller),
+            Some(shutdown),
+        );
+
+        gateway_client
+            .set_disabled_credentials_mode(self.config.get_base().get_disabled_credentials_mode());
+
+        gateway_client
+            .authenticate_and_start()
+            .await
+            .expect("could not authenticate and start up the gateway connection");
+
+        gateway_client
+    }
+
+    // future responsible for periodically polling directory server and updating
+    // the current global view of topology
+    async fn start_topology_refresher(
+        &mut self,
+        topology_accessor: TopologyAccessor,
+        shutdown: ShutdownListener,
+    ) {
+        let topology_refresher_config = TopologyRefresherConfig::new(
+            self.config.get_base().get_validator_api_endpoints(),
+            self.config.get_base().get_topology_refresh_rate(),
+            env!("CARGO_PKG_VERSION").to_string(),
+        );
+        let mut topology_refresher =
+            TopologyRefresher::new(topology_refresher_config, topology_accessor);
+        // before returning, block entire runtime to refresh the current network view so that any
+        // components depending on topology would see a non-empty view
+        info!("Obtaining initial network topology");
+        topology_refresher.refresh().await;
+
+        // TODO: a slightly more graceful termination here
+        if !topology_refresher.is_topology_routable().await {
+            panic!(
+                "The current network topology seem to be insufficient to route any packets through\
+                - check if enough nodes and a gateway are online"
+            );
+        }
+
+        info!("Starting topology refresher...");
+        topology_refresher.start(shutdown);
+    }
+
+    // controller for sending sphinx packets to mixnet (either real traffic or cover traffic)
+    // TODO: if we want to send control messages to gateway_client, this CAN'T take the ownership
+    // over it. Perhaps GatewayClient needs to be thread-shareable or have some channel for
+    // requests?
+    fn start_mix_traffic_controller(
+        &mut self,
+        mix_rx: BatchMixMessageReceiver,
+        gateway_client: GatewayClient,
+        shutdown: ShutdownListener,
+    ) {
+        info!("Starting mix traffic controller...");
+        MixTrafficController::new(mix_rx, gateway_client, shutdown).start();
    }

    fn start_websocket_listener(
-        config: &Config,
-        client_input: ClientInput,
-        client_output: ClientOutput,
-        self_address: &Recipient,
-        reply_controller_sender: ReplyControllerSender,
-        shutdown: task::TaskClient,
+        &self,
+        buffer_requester: ReceivedBufferRequestSender,
+        msg_input: InputMessageSender,
    ) {
        info!("Starting websocket listener...");

-        let ClientInput {
-            connection_command_sender,
-            input_sender,
-        } = client_input;
+        let websocket_handler =
+            websocket::Handler::new(msg_input, buffer_requester, self.as_mix_recipient());

-        let ClientOutput {
-            shared_lane_queue_lengths,
-            received_buffer_request_sender,
-        } = client_output;
-
-        let websocket_handler = websocket::HandlerBuilder::new(
-            input_sender,
-            connection_command_sender,
-            received_buffer_request_sender,
-            self_address,
-            shared_lane_queue_lengths,
-            reply_controller_sender,
-        );
-
-        websocket::Listener::new(config.get_listening_port()).start(websocket_handler, shutdown);
-    }
-
-    /// blocking version of `start_socket` method. Will run forever (or until SIGINT is sent)
-    pub async fn run_socket_forever(self) -> Result<(), Box<dyn Error + Send + Sync>> {
-        let mut shutdown = self.start_socket().await?;
-
-        let res = task::wait_for_signal_and_error(&mut shutdown).await;
-
-        log::info!("Sending shutdown");
-        shutdown.signal_shutdown().ok();
-
-        log::info!("Waiting for tasks to finish... (Press ctrl-c to force)");
-        shutdown.wait_for_shutdown().await;
-
-        log::info!("Stopping nym-client");
-        res
-    }
-
-    pub async fn start_socket(self) -> Result<TaskManager, ClientError> {
-        if !self.config.get_socket_type().is_websocket() {
-            return Err(ClientError::InvalidSocketMode);
-        }
-
-        let base_builder = BaseClientBuilder::new_from_base_config(
-            self.config.get_base(),
-            self.key_manager,
-            Some(Self::create_bandwidth_controller(&self.config).await),
-            non_wasm_helpers::setup_fs_reply_surb_backend(
-                self.config.get_base().get_reply_surb_database_path(),
-                self.config.get_debug_settings(),
-            )
-            .await?,
-        );
-
-        let self_address = base_builder.as_mix_recipient();
-        let mut started_client = base_builder.start_base().await?;
-        let client_input = started_client.client_input.register_producer();
-        let client_output = started_client.client_output.register_consumer();
-
-        Self::start_websocket_listener(
-            &self.config,
-            client_input,
-            client_output,
-            &self_address,
-            started_client.reply_controller_sender,
-            started_client.task_manager.subscribe(),
-        );
-
-        info!("Client startup finished!");
-        info!("The address of this client is: {}", self_address);
-
-        Ok(started_client.task_manager)
-    }
-
-    pub async fn start_direct(self) -> Result<DirectClient, ClientError> {
-        if self.config.get_socket_type().is_websocket() {
-            return Err(ClientError::InvalidSocketMode);
-        }
-
-        let base_client = BaseClientBuilder::new_from_base_config(
-            self.config.get_base(),
-            self.key_manager,
-            Some(Self::create_bandwidth_controller(&self.config).await),
-            non_wasm_helpers::setup_fs_reply_surb_backend(
-                self.config.get_base().get_reply_surb_database_path(),
-                self.config.get_debug_settings(),
-            )
-            .await?,
-        );
-
-        let mut started_client = base_client.start_base().await?;
-        let client_input = started_client.client_input.register_producer();
-        let client_output = started_client.client_output.register_consumer();
-
-        // register our receiver
-        let (reconstructed_sender, reconstructed_receiver) = mpsc::unbounded();
-
-        // tell the buffer to start sending stuff to us
-        client_output
-            .received_buffer_request_sender
-            .unbounded_send(ReceivedBufferMessage::ReceiverAnnounce(
-                reconstructed_sender,
-            ))
-            .expect("the buffer request failed!");
-
-        Ok(DirectClient {
-            client_input,
-            reconstructed_receiver,
-            _shutdown_notifier: started_client.task_manager,
-        })
-    }
-}
-
-pub struct DirectClient {
-    client_input: ClientInput,
-    reconstructed_receiver: ReconstructedMessagesReceiver,
-
-    // we need to keep reference to this guy otherwise things will start dropping
-    _shutdown_notifier: TaskManager,
-}
-
-impl DirectClient {
-    /// EXPERIMENTAL DIRECT RUST API
-    /// It's untested and there are absolutely no guarantees about it (but seems to have worked
-    /// well enough in local tests)
-    pub async fn send_regular_message(&mut self, recipient: Recipient, message: Vec<u8>) {
-        let lane = TransmissionLane::General;
-        let input_msg = InputMessage::new_regular(recipient, message, lane);
-
-        self.client_input
-            .input_sender
-            .send(input_msg)
-            .await
-            .expect("InputMessageReceiver has stopped receiving!");
+        websocket::Listener::new(self.config.get_listening_port()).start(websocket_handler);
    }

    /// EXPERIMENTAL DIRECT RUST API
    /// It's untested and there are absolutely no guarantees about it (but seems to have worked
    /// well enough in local tests)
-    pub async fn send_anonymous_message(
-        &mut self,
-        recipient: Recipient,
-        message: Vec<u8>,
-        reply_surbs: u32,
-    ) {
-        let lane = TransmissionLane::General;
-        let input_msg = InputMessage::new_anonymous(recipient, message, reply_surbs, lane);
+    pub fn send_message(&mut self, recipient: Recipient, message: Vec<u8>, with_reply_surb: bool) {
+        let input_msg = InputMessage::new_fresh(recipient, message, with_reply_surb);

-        self.client_input
-            .input_sender
-            .send(input_msg)
-            .await
-            .expect("InputMessageReceiver has stopped receiving!");
+        self.input_tx
+            .as_ref()
+            .expect("start method was not called before!")
+            .unbounded_send(input_msg)
+            .unwrap();
    }

    /// EXPERIMENTAL DIRECT RUST API
    /// It's untested and there are absolutely no guarantees about it (but seems to have worked
    /// well enough in local tests)
-    pub async fn send_reply(&mut self, recipient_tag: AnonymousSenderTag, message: Vec<u8>) {
-        let lane = TransmissionLane::General;
-        let input_msg = InputMessage::new_reply(recipient_tag, message, lane);
+    pub fn send_reply(&mut self, reply_surb: ReplySurb, message: Vec<u8>) {
+        let input_msg = InputMessage::new_reply(reply_surb, message);

-        self.client_input
-            .input_sender
-            .send(input_msg)
-            .await
-            .expect("InputMessageReceiver has stopped receiving!");
+        self.input_tx
+            .as_ref()
+            .expect("start method was not called before!")
+            .unbounded_send(input_msg)
+            .unwrap();
    }

    /// EXPERIMENTAL DIRECT RUST API
@@ -271,9 +312,127 @@ impl DirectClient {
    pub async fn wait_for_messages(&mut self) -> Vec<ReconstructedMessage> {
        use futures::StreamExt;

-        self.reconstructed_receiver
+        self.receive_tx
+            .as_mut()
+            .expect("start method was not called before!")
            .next()
            .await
            .expect("buffer controller seems to have somehow died!")
    }
+
+    /// blocking version of `start` method. Will run forever (or until SIGINT is sent)
+    pub async fn run_forever(&mut self) {
+        let shutdown = self.start().await;
+        wait_for_signal().await;
+
+        println!(
+            "Received signal - the client will terminate now (threads are not yet nicely stopped, if you see stack traces that's alright)."
+        );
+
+        log::info!("Sending shutdown");
+        shutdown.signal_shutdown().ok();
+
+        // Some of these components have shutdown signalling implemented as part of socks5 work,
+        // but since it's not fully implemented (yet) for all the components of the native client,
+        // we don't try to wait and instead just stop immediately.
+        //log::info!("Waiting for tasks to finish... (Press ctrl-c to force)");
+        //shutdown.wait_for_shutdown().await;
+
+        log::info!("Stopping nym-client");
+    }
+
+    pub async fn start(&mut self) -> ShutdownNotifier {
+        info!("Starting nym client");
+        // channels for inter-component communication
+        // TODO: make the channels be internally created by the relevant components
+        // rather than creating them here, so say for example the buffer controller would create the request channels
+        // and would allow anyone to clone the sender channel
+
+        // sphinx_message_sender is the transmitter for any component generating sphinx packets that are to be sent to the mixnet
+        // they are used by cover traffic stream and real traffic stream
+        // sphinx_message_receiver is the receiver used by MixTrafficController that sends the actual traffic
+        let (sphinx_message_sender, sphinx_message_receiver) = mpsc::unbounded();
+
+        // unwrapped_sphinx_sender is the transmitter of mixnet messages received from the gateway
+        // unwrapped_sphinx_receiver is the receiver for said messages - used by ReceivedMessagesBuffer
+        let (mixnet_messages_sender, mixnet_messages_receiver) = mpsc::unbounded();
+
+        // used for announcing connection or disconnection of a channel for pushing re-assembled messages to
+        let (received_buffer_request_sender, received_buffer_request_receiver) = mpsc::unbounded();
+
+        // channels responsible for controlling real messages
+        let (input_sender, input_receiver) = mpsc::unbounded::<InputMessage>();
+
+        // channels responsible for controlling ack messages
+        let (ack_sender, ack_receiver) = mpsc::unbounded();
+        let shared_topology_accessor = TopologyAccessor::new();
+
+        let reply_key_storage =
+            ReplyKeyStorage::load(self.config.get_base().get_reply_encryption_key_store_path())
+                .expect("Failed to load reply key storage!");
+
+        // Shutdown notifier for signalling tasks to stop
+        let shutdown = ShutdownNotifier::default();
+
+        // the components are started in very specific order. Unless you know what you are doing,
+        // do not change that.
+        self.start_topology_refresher(shared_topology_accessor.clone(), shutdown.subscribe())
+            .await;
+        self.start_received_messages_buffer_controller(
+            received_buffer_request_receiver,
+            mixnet_messages_receiver,
+            reply_key_storage.clone(),
+            shutdown.subscribe(),
+        );
+
+        let gateway_client = self
+            .start_gateway_client(mixnet_messages_sender, ack_sender, shutdown.subscribe())
+            .await;
+
+        self.start_mix_traffic_controller(
+            sphinx_message_receiver,
+            gateway_client,
+            shutdown.subscribe(),
+        );
+        self.start_real_traffic_controller(
+            shared_topology_accessor.clone(),
+            reply_key_storage,
+            ack_receiver,
+            input_receiver,
+            sphinx_message_sender.clone(),
+            shutdown.subscribe(),
+        );
+
+        self.start_cover_traffic_stream(
+            shared_topology_accessor,
+            sphinx_message_sender,
+            shutdown.subscribe(),
+        );
+
+        match self.config.get_socket_type() {
+            SocketType::WebSocket => {
+                self.start_websocket_listener(received_buffer_request_sender, input_sender)
+            }
+            SocketType::None => {
+                // if we did not start the socket, it means we're running (supposedly) in the native mode
+                // and hence we should announce 'ourselves' to the buffer
+                let (reconstructed_sender, reconstructed_receiver) = mpsc::unbounded();
+
+                // tell the buffer to start sending stuff to us
+                received_buffer_request_sender
+                    .unbounded_send(ReceivedBufferMessage::ReceiverAnnounce(
+                        reconstructed_sender,
+                    ))
+                    .expect("the buffer request failed!");
+
+                self.receive_tx = Some(reconstructed_receiver);
+                self.input_tx = Some(input_sender);
+            }
+        }
+
+        info!("Client startup finished!");
+        info!("The address of this client is: {}", self.as_mix_recipient());
+
+        shutdown
+    }
 }
@@ -1,17 +1,17 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

+use clap::Args;
+use client_core::{config::GatewayEndpoint, error::ClientCoreError};
+use config::NymConfig;
+
 use crate::{
    client::config::Config,
    commands::{override_config, OverrideConfig},
-    error::ClientError,
 };
-use clap::Args;
-use config::NymConfig;
-use nymsphinx::addressing::clients::Recipient;
-use serde::Serialize;
-use std::fmt::Display;
-use tap::TapFallible;
+
+#[cfg(all(feature = "eth", not(feature = "coconut")))]
+use crate::commands::{DEFAULT_ETH_ENDPOINT, DEFAULT_ETH_PRIVATE_KEY};

 #[derive(Args, Clone)]
 pub(crate) struct Init {
@@ -28,13 +28,9 @@ pub(crate) struct Init {
    #[clap(long)]
    force_register_gateway: bool,

-    /// Comma separated list of rest endpoints of the nymd validators
+    /// Comma separated list of rest endpoints of the validators
    #[clap(long)]
-    nymd_validators: Option<String>,
-
-    /// Comma separated list of rest endpoints of the API validators
-    #[clap(long)]
-    api_validators: Option<String>,
+    validators: Option<String>,

    /// Whether to not start the websocket
    #[clap(long)]
@@ -49,61 +45,52 @@ pub(crate) struct Init {
    #[clap(long, hidden = true)]
    fastmode: bool,

-    /// Disable loop cover traffic and the Poisson rate limiter (for debugging only)
-    #[clap(long, hidden = true)]
-    no_cover: bool,
-
    /// Set this client to work in a enabled credentials mode that would attempt to use gateway
    /// with bandwidth credential requirement.
-    #[cfg(feature = "coconut")]
+    #[cfg(any(feature = "eth", feature = "coconut"))]
    #[clap(long)]
    enabled_credentials_mode: bool,

-    /// Save a summary of the initialization to a json file
-    #[clap(long)]
-    output_json: bool,
+    /// URL of an Ethereum full node that we want to use for getting bandwidth tokens from ERC20
+    /// tokens. If you don't want to set this value, use --enabled-credentials-mode instead
+    #[cfg(all(feature = "eth", not(feature = "coconut")))]
+    #[clap(
+        long,
+        default_value_if("enabled-credentials-mode", None, Some(DEFAULT_ETH_ENDPOINT))
+    )]
+    eth_endpoint: String,
+
+    /// Ethereum private key used for obtaining bandwidth tokens from ERC20 tokens. If you don't
+    /// want to set this value, use --enabled-credentials-mode instead")
+    #[cfg(all(feature = "eth", not(feature = "coconut")))]
+    #[clap(
+        long,
+        default_value_if("enabled-credentials-mode", None, Some(DEFAULT_ETH_PRIVATE_KEY))
+    )]
+    eth_private_key: String,
 }

 impl From<Init> for OverrideConfig {
    fn from(init_config: Init) -> Self {
        OverrideConfig {
-            nymd_validators: init_config.nymd_validators,
-            api_validators: init_config.api_validators,
+            validators: init_config.validators,
            disable_socket: init_config.disable_socket,
            port: init_config.port,
            fastmode: init_config.fastmode,
-            no_cover: init_config.no_cover,

-            #[cfg(feature = "coconut")]
+            #[cfg(any(feature = "eth", feature = "coconut"))]
            enabled_credentials_mode: init_config.enabled_credentials_mode,
+
+            #[cfg(all(feature = "eth", not(feature = "coconut")))]
+            eth_private_key: Some(init_config.eth_private_key),
+
+            #[cfg(all(feature = "eth", not(feature = "coconut")))]
+            eth_endpoint: Some(init_config.eth_endpoint),
        }
    }
 }

-#[derive(Debug, Serialize)]
-pub struct InitResults {
-    #[serde(flatten)]
-    client_core: client_core::init::InitResults,
-    client_listening_port: String,
-}
-
-impl InitResults {
-    fn new(config: &Config, address: &Recipient) -> Self {
-        Self {
-            client_core: client_core::init::InitResults::new(config.get_base(), address),
-            client_listening_port: config.get_listening_port().to_string(),
-        }
-    }
-}
-
-impl Display for InitResults {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        writeln!(f, "{}", self.client_core)?;
-        write!(f, "Client listening port: {}", self.client_listening_port)
-    }
-}
-
-pub(crate) async fn execute(args: &Init) -> Result<(), ClientError> {
+pub(crate) async fn execute(args: &Init) {
    println!("Initialising client...");

    let id = &args.id;
@@ -127,44 +114,25 @@ pub(crate) async fn execute(args: &Init) -> Result<(), ClientError> {
    let register_gateway = !already_init || user_wants_force_register;

    // Attempt to use a user-provided gateway, if possible
-    let user_chosen_gateway_id = args.gateway.clone();
+    let user_chosen_gateway_id = args.gateway.as_deref();

-    // Load and potentially override config
-    let mut config = override_config(Config::new(id), OverrideConfig::from(args.clone()));
-
-    // Setup gateway by either registering a new one, or creating a new config from the selected
-    // one but with keys kept, or reusing the gateway configuration.
-    let gateway = client_core::init::setup_gateway::<_, Config, _>(
-        register_gateway,
-        user_chosen_gateway_id,
-        config.get_base(),
-    )
-    .await
-    .tap_err(|err| eprintln!("Failed to setup gateway\nError: {err}"))?;
+    let mut config = Config::new(id);
+    let override_config_fields = OverrideConfig::from(args.clone());
+    config = override_config(config, override_config_fields);

+    let gateway = setup_gateway(id, register_gateway, user_chosen_gateway_id, &config)
+        .await
+        .unwrap_or_else(|err| {
+            eprintln!("Failed to setup gateway\nError: {err}");
+            std::process::exit(1)
+        });
    config.get_base_mut().with_gateway_endpoint(gateway);

-    config.save_to_file(None).tap_err(|_| {
-        log::error!("Failed to save the config file");
-    })?;
-
-    print_saved_config(&config);
-
-    let address = client_core::init::get_client_address_from_stored_keys(config.get_base())?;
-    let init_results = InitResults::new(&config, &address);
-    println!("{}", init_results);
-
-    // Output summary to a json file, if specified
-    if args.output_json {
-        client_core::init::output_to_json(&init_results, "client_init_results.json");
-    }
-
-    println!("\nThe address of this client is: {}\n", address);
-    Ok(())
-}
-
-fn print_saved_config(config: &Config) {
    let config_save_location = config.get_config_file_save_location();
+    config
+        .save_to_file(None)
+        .expect("Failed to save the config file");
+
    println!("Saved configuration file to {:?}", config_save_location);
    println!("Using gateway: {}", config.get_base().get_gateway_id());
    log::debug!("Gateway id: {}", config.get_base().get_gateway_id());
@@ -173,5 +141,63 @@ fn print_saved_config(config: &Config) {
        "Gateway listener: {}",
        config.get_base().get_gateway_listener()
    );
-    println!("Client configuration completed.\n");
+    println!("Client configuration completed.");
+
+    client_core::init::show_address(config.get_base()).unwrap_or_else(|err| {
+        eprintln!("Failed to show address\nError: {err}");
+        std::process::exit(1)
+    });
+}
+
+async fn setup_gateway(
+    id: &str,
+    register: bool,
+    user_chosen_gateway_id: Option<&str>,
+    config: &Config,
+) -> Result<GatewayEndpoint, ClientCoreError> {
+    if register {
+        // Get the gateway details by querying the validator-api. Either pick one at random or use
+        // the chosen one if it's among the available ones.
+        println!("Configuring gateway");
+        let gateway = client_core::init::query_gateway_details(
+            config.get_base().get_validator_api_endpoints(),
+            user_chosen_gateway_id,
+        )
+        .await?;
+        log::debug!("Querying gateway gives: {}", gateway);
+
+        // Registering with gateway by setting up and writing shared keys to disk
+        log::trace!("Registering gateway");
+        client_core::init::register_with_gateway_and_store_keys(gateway.clone(), config.get_base())
+            .await?;
+        println!("Saved all generated keys");
+
+        Ok(gateway.into())
+    } else if user_chosen_gateway_id.is_some() {
+        // Just set the config, don't register or create any keys
+        // This assumes that the user knows what they are doing, and that the existing keys are
+        // valid for the gateway being used
+        println!("Using gateway provided by user, keeping existing keys");
+        let gateway = client_core::init::query_gateway_details(
+            config.get_base().get_validator_api_endpoints(),
+            user_chosen_gateway_id,
+        )
+        .await?;
+        log::debug!("Querying gateway gives: {}", gateway);
+        Ok(gateway.into())
+    } else {
+        println!("Not registering gateway, will reuse existing config and keys");
+        let existing_config = Config::load_from_file(Some(id)).map_err(|err| {
+            log::error!(
+                "Unable to configure gateway: {err}. \n
+                Seems like the client was already initialized but it was not possible to read \
+                the existing configuration file. \n
+                CAUTION: Consider backing up your gateway keys and try force gateway registration, or \
+                removing the existing configuration and starting over."
+            );
+            ClientCoreError::CouldNotLoadExistingGatewayConfiguration(err)
+        })?;
+
+        Ok(existing_config.get_base().get_gateway_endpoint().clone())
+    }
 }
@@ -1,12 +1,15 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use std::error::Error;
-
 use crate::client::config::{Config, SocketType};
-use clap::CommandFactory;
 use clap::{Parser, Subcommand};
-use completions::{fig_generate, ArgShell};
+
+#[cfg(not(feature = "coconut"))]
+pub(crate) const DEFAULT_ETH_ENDPOINT: &str =
+    "https://rinkeby.infura.io/v3/00000000000000000000000000000000";
+#[cfg(not(feature = "coconut"))]
+pub(crate) const DEFAULT_ETH_PRIVATE_KEY: &str =
+    "0000000000000000000000000000000000000000000000000000000000000001";

 pub(crate) mod init;
 pub(crate) mod run;
@@ -51,7 +54,7 @@ fn long_version_static() -> &'static str {
 #[clap(author = "Nymtech", version, long_version = long_version_static(), about)]
 pub(crate) struct Cli {
    /// Path pointing to an env file that configures the client.
-    #[clap(short, long)]
+    #[clap(long)]
    pub(crate) config_env_file: Option<std::path::PathBuf>,

    #[clap(subcommand)]
@@ -66,62 +69,44 @@ pub(crate) enum Commands {
    Run(run::Run),
    /// Try to upgrade the client
    Upgrade(upgrade::Upgrade),
-
-    /// Generate shell completions
-    Completions(ArgShell),
-
-    /// Generate Fig specification
-    GenerateFigSpec,
 }

 // Configuration that can be overridden.
 pub(crate) struct OverrideConfig {
-    nymd_validators: Option<String>,
-    api_validators: Option<String>,
+    validators: Option<String>,
    disable_socket: bool,
    port: Option<u16>,
    fastmode: bool,
-    no_cover: bool,

-    #[cfg(feature = "coconut")]
+    #[cfg(any(feature = "eth", feature = "coconut"))]
    enabled_credentials_mode: bool,
+
+    #[cfg(all(feature = "eth", not(feature = "coconut")))]
+    eth_private_key: Option<String>,
+
+    #[cfg(all(feature = "eth", not(feature = "coconut")))]
+    eth_endpoint: Option<String>,
 }

-pub(crate) async fn execute(args: &Cli) -> Result<(), Box<dyn Error + Send + Sync>> {
-    let bin_name = "nym-native-client";
-
+pub(crate) async fn execute(args: &Cli) {
    match &args.command {
-        Commands::Init(m) => init::execute(m).await?,
-        Commands::Run(m) => run::execute(m).await?,
+        Commands::Init(m) => init::execute(m).await,
+        Commands::Run(m) => run::execute(m).await,
        Commands::Upgrade(m) => upgrade::execute(m),
-        Commands::Completions(s) => s.generate(&mut Cli::into_app(), bin_name),
-        Commands::GenerateFigSpec => fig_generate(&mut Cli::into_app(), bin_name),
    }
-    Ok(())
 }

 pub(crate) fn override_config(mut config: Config, args: OverrideConfig) -> Config {
-    if let Some(raw_validators) = args.nymd_validators {
+    if let Some(raw_validators) = args.validators {
        config
            .get_base_mut()
-            .set_custom_validators(config::parse_validators(&raw_validators));
-    } else if std::env::var(network_defaults::var_names::CONFIGURED).is_ok() {
-        let raw_validators = std::env::var(network_defaults::var_names::NYMD_VALIDATOR)
-            .expect("nymd validator not set");
-        config
-            .get_base_mut()
-            .set_custom_validators(config::parse_validators(&raw_validators));
-    }
-    if let Some(raw_validators) = args.api_validators {
-        config
-            .get_base_mut()
-            .set_custom_nym_apis(config::parse_validators(&raw_validators));
+            .set_custom_validator_apis(config::parse_validators(&raw_validators));
    } else if std::env::var(network_defaults::var_names::CONFIGURED).is_ok() {
        let raw_validators = std::env::var(network_defaults::var_names::API_VALIDATOR)
            .expect("api validator not set");
        config
            .get_base_mut()
-            .set_custom_nym_apis(config::parse_validators(&raw_validators));
+            .set_custom_validator_apis(config::parse_validators(&raw_validators));
    }

    if args.disable_socket {
@@ -132,19 +117,34 @@ pub(crate) fn override_config(mut config: Config, args: OverrideConfig) -> Confi
        config = config.with_port(port);
    }

-    #[cfg(feature = "coconut")]
+    #[cfg(all(not(feature = "eth"), not(feature = "coconut")))]
+    {
+        config
+            .get_base_mut()
+            .with_eth_endpoint(DEFAULT_ETH_ENDPOINT.to_string());
+        config
+            .get_base_mut()
+            .with_eth_private_key(DEFAULT_ETH_PRIVATE_KEY.to_string());
+    }
+    #[cfg(any(feature = "eth", feature = "coconut"))]
    {
        if args.enabled_credentials_mode {
            config.get_base_mut().with_disabled_credentials(false)
        }
    }

-    if args.fastmode {
-        config.get_base_mut().set_high_default_traffic_volume();
+    #[cfg(all(feature = "eth", not(feature = "coconut")))]
+    {
+        if let Some(eth_endpoint) = args.eth_endpoint {
+            config.get_base_mut().with_eth_endpoint(eth_endpoint);
+        }
+        if let Some(eth_private_key) = args.eth_private_key {
+            config.get_base_mut().with_eth_private_key(eth_private_key);
+        }
    }

-    if args.no_cover {
-        config.get_base_mut().set_no_cover_traffic();
+    if args.fastmode {
+        config.get_base_mut().set_high_default_traffic_volume();
    }

    config
@@ -1,12 +1,9 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use std::error::Error;
-
 use crate::{
-    client::{config::Config, SocketClient},
+    client::{config::Config, NymClient},
    commands::{override_config, OverrideConfig},
-    error::ClientError,
 };

 use clap::Args;
@@ -20,13 +17,9 @@ pub(crate) struct Run {
    #[clap(long)]
    id: String,

-    /// Comma separated list of rest endpoints of the nymd validators
+    /// Comma separated list of rest endpoints of the validators
    #[clap(long)]
-    nymd_validators: Option<String>,
-
-    /// Comma separated list of rest endpoints of the API validators
-    #[clap(long)]
-    api_validators: Option<String>,
+    validators: Option<String>,

    /// Id of the gateway we want to connect to. If overridden, it is user's responsibility to
    /// ensure prior registration happened
@@ -41,33 +34,41 @@ pub(crate) struct Run {
    #[clap(short, long)]
    port: Option<u16>,

-    /// Mostly debug-related option to increase default traffic rate so that you would not need to
-    /// modify config post init
-    #[clap(long, hidden = true)]
-    fastmode: bool,
-
-    /// Disable loop cover traffic and the Poisson rate limiter (for debugging only)
-    #[clap(long, hidden = true)]
-    no_cover: bool,
-
    /// Set this client to work in a enabled credentials mode that would attempt to use gateway
    /// with bandwidth credential requirement.
-    #[cfg(feature = "coconut")]
+    #[cfg(any(feature = "eth", feature = "coconut"))]
    #[clap(long)]
    enabled_credentials_mode: bool,
+
+    /// URL of an Ethereum full node that we want to use for getting bandwidth tokens from ERC20
+    /// tokens. If you don't want to set this value, use --enabled-credentials-mode instead
+    #[cfg(all(feature = "eth", not(feature = "coconut")))]
+    #[clap(long)]
+    eth_endpoint: Option<String>,
+
+    /// Ethereum private key used for obtaining bandwidth tokens from ERC20 tokens. If you don't
+    /// want to set this value, use --enabled-credentials-mode instead")
+    #[cfg(all(feature = "eth", not(feature = "coconut")))]
+    #[clap(long)]
+    eth_private_key: Option<String>,
 }

 impl From<Run> for OverrideConfig {
    fn from(run_config: Run) -> Self {
        OverrideConfig {
-            nymd_validators: run_config.nymd_validators,
-            api_validators: run_config.api_validators,
+            validators: run_config.validators,
            disable_socket: run_config.disable_socket,
            port: run_config.port,
-            fastmode: run_config.fastmode,
-            no_cover: run_config.no_cover,
-            #[cfg(feature = "coconut")]
+            fastmode: false,
+
+            #[cfg(any(feature = "eth", feature = "coconut"))]
            enabled_credentials_mode: run_config.enabled_credentials_mode,
+
+            #[cfg(all(feature = "eth", not(feature = "coconut")))]
+            eth_private_key: run_config.eth_private_key,
+
+            #[cfg(all(feature = "eth", not(feature = "coconut")))]
+            eth_endpoint: run_config.eth_endpoint,
        }
    }
 }
@@ -91,28 +92,24 @@ fn version_check(cfg: &Config) -> bool {
    }
 }

-pub(crate) async fn execute(args: &Run) -> Result<(), Box<dyn Error + Send + Sync>> {
+pub(crate) async fn execute(args: &Run) {
    let id = &args.id;

    let mut config = match Config::load_from_file(Some(id)) {
        Ok(cfg) => cfg,
        Err(err) => {
-            error!("Failed to load config for {}. Are you sure you have run `init` before? (Error was: {err})", id);
-            return Err(Box::new(ClientError::FailedToLoadConfig(id.to_string())));
+            error!("Failed to load config for {}. Are you sure you have run `init` before? (Error was: {})", id, err);
+            return;
        }
    };

    let override_config_fields = OverrideConfig::from(args.clone());
    config = override_config(config, override_config_fields);

-    if config.get_base_mut().set_empty_fields_to_defaults() {
-        warn!("some of the core config options were left unset. the default values are going to get used instead.");
-    }
-
    if !version_check(&config) {
        error!("failed the local version check");
-        return Err(Box::new(ClientError::FailedLocalVersionCheck));
+        return;
    }

-    SocketClient::new(config).run_socket_forever().await
+    NymClient::new(config).run_forever().await;
 }
@@ -59,7 +59,7 @@ pub(crate) struct Upgrade {

 fn parse_config_version(config: &Config) -> Version {
    let version = Version::parse(config.get_base().get_version()).unwrap_or_else(|err| {
-        eprintln!("failed to parse client version! - {err}");
+        eprintln!("failed to parse client version! - {:?}", err);
        process::exit(1)
    });

@@ -103,15 +103,15 @@ fn minor_0_12_upgrade(
        Version::new(0, 12, 0)
    };

-    print_start_upgrade(config_version, &to_version);
+    print_start_upgrade(&config_version, &to_version);

    config
        .get_base_mut()
        .set_custom_version(to_version.to_string().as_ref());

    config.save_to_file(None).unwrap_or_else(|err| {
-        eprintln!("failed to overwrite config file! - {err}");
-        print_failed_upgrade(config_version, &to_version);
+        eprintln!("failed to overwrite config file! - {:?}", err);
+        print_failed_upgrade(&config_version, &to_version);
        process::exit(1);
    });

@@ -146,7 +146,7 @@ pub(crate) fn execute(args: &Upgrade) {
    let id = &args.id;

    let existing_config = Config::load_from_file(Some(id)).unwrap_or_else(|err| {
-        eprintln!("failed to load existing config file! - {err}");
+        eprintln!("failed to load existing config file! - {:?}", err);
        process::exit(1)
    });

@@ -1,20 +0,0 @@
-use client_core::client::replies::reply_storage::fs_backend;
-use client_core::error::ClientCoreError;
-
-#[derive(thiserror::Error, Debug)]
-pub enum ClientError {
-    #[error("I/O error: {0}")]
-    IoError(#[from] std::io::Error),
-
-    #[error("client-core error: {0}")]
-    ClientCoreError(#[from] ClientCoreError<fs_backend::Backend>),
-
-    #[error("Failed to load config for: {0}")]
-    FailedToLoadConfig(String),
-
-    #[error("Failed local version check, client and config mismatch")]
-    FailedLocalVersionCheck,
-
-    #[error("Attempted to start the client in invalid socket mode")]
-    InvalidSocketMode,
-}
@@ -2,5 +2,4 @@
 // SPDX-License-Identifier: Apache-2.0

 pub mod client;
-pub mod error;
 pub mod websocket;
@@ -1,25 +1,21 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use std::error::Error;
-
 use clap::{crate_version, Parser};
-use logging::setup_logging;
 use network_defaults::setup_env;

 pub mod client;
 pub mod commands;
-pub mod error;
 pub mod websocket;

 #[tokio::main]
-async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
+async fn main() {
    setup_logging();
    println!("{}", banner());

    let args = commands::Cli::parse();
    setup_env(args.config_env_file.clone());
-    commands::execute(&args).await
+    commands::execute(&args).await;
 }

 fn banner() -> String {
@@ -38,3 +34,25 @@ fn banner() -> String {
        crate_version!()
    )
 }
+
+fn setup_logging() {
+    let mut log_builder = pretty_env_logger::formatted_timed_builder();
+    if let Ok(s) = ::std::env::var("RUST_LOG") {
+        log_builder.parse_filters(&s);
+    } else {
+        // default to 'Info'
+        log_builder.filter(None, log::LevelFilter::Info);
+    }
+
+    log_builder
+        .filter_module("hyper", log::LevelFilter::Warn)
+        .filter_module("tokio_reactor", log::LevelFilter::Warn)
+        .filter_module("reqwest", log::LevelFilter::Warn)
+        .filter_module("mio", log::LevelFilter::Warn)
+        .filter_module("want", log::LevelFilter::Warn)
+        .filter_module("tungstenite", log::LevelFilter::Warn)
+        .filter_module("tokio_tungstenite", log::LevelFilter::Warn)
+        .filter_module("handlebars", log::LevelFilter::Warn)
+        .filter_module("sled", log::LevelFilter::Warn)
+        .init();
+}
@@ -1,10 +1,6 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use client_connections::{
-    ConnectionCommand, ConnectionCommandSender, ConnectionId, LaneQueueLengths, TransmissionLane,
-};
-use client_core::client::replies::reply_controller::requests::ReplyControllerSender;
 use client_core::client::{
    inbound_messages::{InputMessage, InputMessageSender},
    received_buffer::{
@@ -15,11 +11,9 @@ use futures::channel::mpsc;
 use futures::{SinkExt, StreamExt};
 use log::*;
 use nymsphinx::addressing::clients::Recipient;
-use nymsphinx::anonymous_replies::requests::AnonymousSenderTag;
+use nymsphinx::anonymous_replies::ReplySurb;
 use nymsphinx::receiver::ReconstructedMessage;
-use std::time::Duration;
 use tokio::net::TcpStream;
-use tokio::time::Instant;
 use tokio_tungstenite::{
    accept_async,
    tungstenite::{protocol::Message as WsMessage, Error as WsError},
@@ -38,250 +32,94 @@ impl Default for ReceivedResponseType {
    }
 }

-pub(crate) struct HandlerBuilder {
-    msg_input: InputMessageSender,
-    client_connection_tx: ConnectionCommandSender,
-    buffer_requester: ReceivedBufferRequestSender,
-    self_full_address: Recipient,
-    lane_queue_lengths: LaneQueueLengths,
-    reply_controller_sender: ReplyControllerSender,
-}
-
-impl HandlerBuilder {
-    pub(crate) fn new(
-        msg_input: InputMessageSender,
-        client_connection_tx: ConnectionCommandSender,
-        buffer_requester: ReceivedBufferRequestSender,
-        self_full_address: &Recipient,
-        lane_queue_lengths: LaneQueueLengths,
-        reply_controller_sender: ReplyControllerSender,
-    ) -> Self {
-        Self {
-            msg_input,
-            client_connection_tx,
-            buffer_requester,
-            self_full_address: *self_full_address,
-            lane_queue_lengths,
-            reply_controller_sender,
-        }
-    }
-
-    // TODO: make sure we only ever have one active handler
-    pub fn create_active_handler(&self) -> Handler {
-        Handler {
-            msg_input: self.msg_input.clone(),
-            client_connection_tx: self.client_connection_tx.clone(),
-            buffer_requester: self.buffer_requester.clone(),
-            self_full_address: self.self_full_address,
-            socket: None,
-            received_response_type: Default::default(),
-            lane_queue_lengths: self.lane_queue_lengths.clone(),
-            reply_controller_sender: self.reply_controller_sender.clone(),
-        }
-    }
-}
-
 pub(crate) struct Handler {
    msg_input: InputMessageSender,
-    client_connection_tx: ConnectionCommandSender,
    buffer_requester: ReceivedBufferRequestSender,
    self_full_address: Recipient,
    socket: Option<WebSocketStream<TcpStream>>,
    received_response_type: ReceivedResponseType,
-    lane_queue_lengths: LaneQueueLengths,
-    reply_controller_sender: ReplyControllerSender,
+}
+
+// clone is used to use handler on a new connection, which initially is `None`
+impl Clone for Handler {
+    fn clone(&self) -> Self {
+        Handler {
+            msg_input: self.msg_input.clone(),
+            buffer_requester: self.buffer_requester.clone(),
+            self_full_address: self.self_full_address,
+            socket: None,
+            received_response_type: Default::default(),
+        }
+    }
 }

 impl Drop for Handler {
    fn drop(&mut self) {
-        if self
-            .buffer_requester
+        self.buffer_requester
            .unbounded_send(ReceivedBufferMessage::ReceiverDisconnect)
-            .is_err()
-        {
-            error!("we failed to disconnect the receiver from the buffer! presumably the shutdown procedure has been initiated!")
-        }
+            .expect("the buffer request failed!")
    }
 }

 impl Handler {
-    async fn get_lane_queue_length(&self, connection_id: ConnectionId) -> Option<ServerResponse> {
-        let req_start = Instant::now();
-
-        // get the base queue length
-        // Note that this does _NOT_ take into account the packets that have been received but not
-        // yet reach `OutQueueControl`, so it might be a tad low.
-        let conn_lane = TransmissionLane::ConnectionId(connection_id);
-        let Ok(base_length) = self
-            .lane_queue_lengths
-            .lock()
-            .map(|guard| guard.get(&conn_lane).unwrap_or_default()) else {
-            // I'd argue we should panic here as this error it not recoverable
-            error!("The lane queue length lock is poisoned!!");
-            return None
-        };
-
-        // get the number of pending replies waiting for reply surbs
-        let reply_queue_length = self
-            .reply_controller_sender
-            .get_lane_queue_length(connection_id)
-            .await;
-
-        let queue_length = base_length + reply_queue_length;
-
-        let time_taken = req_start.elapsed();
-        let msg =
-            format!("it took {time_taken:?} to get lane length for connection {connection_id}. The length is: {queue_length} = {base_length} (already queued up) + {reply_queue_length} (waiting for reply SURBs)");
-
-        if time_taken > Duration::from_millis(1) {
-            info!("{msg}");
-        } else if time_taken > Duration::from_millis(10) {
-            warn!("{msg}");
-        } else if time_taken > Duration::from_millis(50) {
-            error!("{msg}");
+    pub(crate) fn new(
+        msg_input: InputMessageSender,
+        buffer_requester: ReceivedBufferRequestSender,
+        self_full_address: Recipient,
+    ) -> Self {
+        Handler {
+            msg_input,
+            buffer_requester,
+            self_full_address,
+            socket: None,
+            received_response_type: Default::default(),
        }
-
-        Some(ServerResponse::LaneQueueLength {
-            lane: connection_id,
-            queue_length,
-        })
    }

-    async fn handle_send(
+    fn handle_send(
        &mut self,
        recipient: Recipient,
        message: Vec<u8>,
-        connection_id: Option<u64>,
+        with_reply_surb: bool,
    ) -> Option<ServerResponse> {
-        info!(
-            "Attempting to send {:.2} kiB message to {recipient} on connection_id {connection_id:?}",
-            message.len() as f64 / 1024.0
-        );
-
-        // We map the absence of a connection id as going into the general lane.
-        let lane = connection_id.map_or(TransmissionLane::General, |id| {
-            TransmissionLane::ConnectionId(id)
-        });
-
        // the ack control is now responsible for chunking, etc.
-        let input_msg = InputMessage::new_regular(recipient, message, lane);
-        self.msg_input
-            .send(input_msg)
-            .await
-            .expect("InputMessageReceiver has stopped receiving!");
+        let input_msg = InputMessage::new_fresh(recipient, message, with_reply_surb);
+        self.msg_input.unbounded_send(input_msg).unwrap();

-        // Only reply back with a `LaneQueueLength` if the sender providided a connection id
-        let TransmissionLane::ConnectionId(connection_id) = lane else {
-          return None
-        };
-
-        self.get_lane_queue_length(connection_id).await
-    }
-
-    async fn handle_send_anonymous(
-        &mut self,
-        recipient: Recipient,
-        message: Vec<u8>,
-        reply_surbs: u32,
-        connection_id: Option<u64>,
-    ) -> Option<ServerResponse> {
-        info!(
-            "Attempting to anonymously send {:.2} kiB message to {recipient} on connection_id {connection_id:?} while attaching {reply_surbs} replySURBs.",
-            message.len() as f64 / 1024.0
-        );
-
-        // We map the absence of a connection id as going into the general lane.
-        let lane = connection_id.map_or(TransmissionLane::General, |id| {
-            TransmissionLane::ConnectionId(id)
-        });
-
-        let input_msg = InputMessage::new_anonymous(recipient, message, reply_surbs, lane);
-        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 {
-          return None
-        };
-
-        self.get_lane_queue_length(connection_id).await
-    }
-
-    async fn handle_reply(
-        &mut self,
-        recipient_tag: AnonymousSenderTag,
-        message: Vec<u8>,
-        connection_id: Option<u64>,
-    ) -> Option<ServerResponse> {
-        info!("Attempting to send {:.2} kiB reply message to {recipient_tag} on connection_id {connection_id:?}", message.len() as f64 / 1024.0);
-
-        // We map the absence of a connection id as going into the general lane.
-        let lane = connection_id.map_or(TransmissionLane::General, |id| {
-            TransmissionLane::ConnectionId(id)
-        });
-
-        let input_msg = InputMessage::new_reply(recipient_tag, message, lane);
-        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 {
-          return None
-        };
-
-        self.get_lane_queue_length(connection_id).await
-    }
-
-    fn handle_self_address(&self) -> ServerResponse {
-        ServerResponse::SelfAddress(Box::new(self.self_full_address))
-    }
-
-    fn handle_closed_connection(&self, connection_id: u64) -> Option<ServerResponse> {
-        self.client_connection_tx
-            .unbounded_send(ConnectionCommand::Close(connection_id))
-            .unwrap();
        None
    }

-    async fn handle_get_lane_queue_length(&self, connection_id: u64) -> Option<ServerResponse> {
-        self.get_lane_queue_length(connection_id).await
+    fn handle_reply(&mut self, reply_surb: ReplySurb, message: Vec<u8>) -> Option<ServerResponse> {
+        if message.len() > ReplySurb::max_msg_len(Default::default()) {
+            return Some(ServerResponse::new_error(format!("too long message to put inside a reply SURB. Received: {} bytes and maximum is {} bytes", message.len(), ReplySurb::max_msg_len(Default::default()))));
+        }
+
+        let input_msg = InputMessage::new_reply(reply_surb, message);
+        self.msg_input.unbounded_send(input_msg).unwrap();
+
+        None
    }

-    async fn handle_request(&mut self, request: ClientRequest) -> Option<ServerResponse> {
+    fn handle_self_address(&self) -> ServerResponse {
+        ServerResponse::SelfAddress(self.self_full_address)
+    }
+
+    fn handle_request(&mut self, request: ClientRequest) -> Option<ServerResponse> {
        match request {
            ClientRequest::Send {
                recipient,
                message,
-                connection_id,
-            } => self.handle_send(recipient, message, connection_id).await,
-
-            ClientRequest::SendAnonymous {
-                recipient,
-                message,
-                reply_surbs,
-                connection_id,
-            } => {
-                self.handle_send_anonymous(recipient, message, reply_surbs, connection_id)
-                    .await
-            }
-
+                with_reply_surb,
+            } => self.handle_send(recipient, message, with_reply_surb),
            ClientRequest::Reply {
                message,
-                sender_tag,
-                connection_id,
-            } => self.handle_reply(sender_tag, message, connection_id).await,
-
+                reply_surb,
+            } => self.handle_reply(reply_surb, message),
            ClientRequest::SelfAddress => Some(self.handle_self_address()),
-            ClientRequest::ClosedConnection(id) => self.handle_closed_connection(id),
-            ClientRequest::GetLaneQueueLength(id) => self.handle_get_lane_queue_length(id).await,
        }
    }

-    async fn handle_text_message(&mut self, msg: String) -> Option<WsMessage> {
+    fn handle_text_message(&mut self, msg: String) -> Option<WsMessage> {
        debug!("Handling text message request");
        trace!("Content: {:?}", msg);

@@ -290,13 +128,13 @@ impl Handler {

        let response = match client_request {
            Err(err) => Some(ServerResponse::Error(err)),
-            Ok(req) => self.handle_request(req).await,
+            Ok(req) => self.handle_request(req),
        };

        response.map(|resp| WsMessage::text(resp.into_text()))
    }

-    async fn handle_binary_message(&mut self, msg: &[u8]) -> Option<WsMessage> {
+    fn handle_binary_message(&mut self, msg: Vec<u8>) -> Option<WsMessage> {
        debug!("Handling binary message request");

        self.received_response_type = ReceivedResponseType::Binary;
@@ -304,23 +142,49 @@ impl Handler {

        let response = match client_request {
            Err(err) => Some(ServerResponse::Error(err)),
-            Ok(req) => self.handle_request(req).await,
+            Ok(req) => self.handle_request(req),
        };

        response.map(|resp| WsMessage::Binary(resp.into_binary()))
    }

-    async fn handle_ws_request(&mut self, raw_request: WsMessage) -> Option<WsMessage> {
+    fn handle_ws_request(&mut self, raw_request: WsMessage) -> Option<WsMessage> {
        // apparently tungstenite auto-handles ping/pong/close messages so for now let's ignore
        // them and let's test that claim. If that's not the case, just copy code from
        // old version of this file.
        match raw_request {
-            WsMessage::Text(text_message) => self.handle_text_message(text_message).await,
-            WsMessage::Binary(binary_message) => self.handle_binary_message(&binary_message).await,
+            WsMessage::Text(text_message) => self.handle_text_message(text_message),
+            WsMessage::Binary(binary_message) => self.handle_binary_message(binary_message),
            _ => None,
        }
    }

+    // I'm still not entirely sure why `send_all` requires `TryStream` rather than `Stream`, but
+    // let's just play along for now
+    fn prepare_reconstructed_binary(
+        &self,
+        reconstructed_messages: Vec<ReconstructedMessage>,
+    ) -> Vec<Result<WsMessage, WsError>> {
+        reconstructed_messages
+            .into_iter()
+            .map(ServerResponse::Received)
+            .map(|resp| Ok(WsMessage::Binary(resp.into_binary())))
+            .collect()
+    }
+
+    // I'm still not entirely sure why `send_all` requires `TryStream` rather than `Stream`, but
+    // let's just play along for now
+    fn prepare_reconstructed_text(
+        &self,
+        reconstructed_messages: Vec<ReconstructedMessage>,
+    ) -> Vec<Result<WsMessage, WsError>> {
+        reconstructed_messages
+            .into_iter()
+            .map(ServerResponse::Received)
+            .map(|resp| Ok(WsMessage::Text(resp.into_text())))
+            .collect()
+    }
+
    async fn push_websocket_received_plaintexts(
        &mut self,
        reconstructed_messages: Vec<ReconstructedMessage>,
@@ -329,8 +193,10 @@ impl Handler {
        // if it's text or binary, but for time being we use the naive assumption that if
        // client is sending Message::Text it expects text back. Same for Message::Binary
        let response_messages = match self.received_response_type {
-            ReceivedResponseType::Binary => prepare_reconstructed_binary(reconstructed_messages),
-            ReceivedResponseType::Text => prepare_reconstructed_text(reconstructed_messages),
+            ReceivedResponseType::Binary => {
+                self.prepare_reconstructed_binary(reconstructed_messages)
+            }
+            ReceivedResponseType::Text => self.prepare_reconstructed_text(reconstructed_messages),
        };

        let mut send_stream = futures::stream::iter(response_messages);
@@ -358,12 +224,8 @@ impl Handler {
        }
    }

-    async fn listen_for_requests(
-        &mut self,
-        mut msg_receiver: ReconstructedMessagesReceiver,
-        mut task_client: task::TaskClient,
-    ) {
-        while !task_client.is_shutdown() {
+    async fn listen_for_requests(&mut self, mut msg_receiver: ReconstructedMessagesReceiver) {
+        loop {
            tokio::select! {
                // we can either get a client request from the websocket
                socket_msg = self.next_websocket_request() => {
@@ -373,7 +235,7 @@ impl Handler {
                    let socket_msg = match socket_msg.unwrap() {
                        Ok(socket_msg) => socket_msg,
                        Err(err) => {
-                            warn!("failed to obtain message from websocket stream! stopping connection handler: {err}");
+                            warn!("failed to obtain message from websocket stream! stopping connection handler: {}", err);
                            break;
                        }
                    };
@@ -382,10 +244,11 @@ impl Handler {
                        break;
                    }

-                    if let Some(response) = self.handle_ws_request(socket_msg).await {
+                    if let Some(response) = self.handle_ws_request(socket_msg) {
                        if let Err(err) = self.send_websocket_response(response).await {
                            warn!(
-                                "Failed to send message over websocket: {err}. Assuming the connection is dead.",
+                                "Failed to send message over websocket: {}. Assuming the connection is dead.",
+                                err
                            );
                            break;
                        }
@@ -393,37 +256,24 @@ impl Handler {
                }
                // or a reconstructed mix message that we need to push back to the client
                mix_messages = msg_receiver.next() => {
-                    let Some(mix_messages) = mix_messages else {
-                        error!("mix messages sender was unexpectedly closed! this shouldn't have ever happened! (unless we're shutting down - TODO: implement proper graceful shutdown handler)");
-                        return
-                    };
-                    if let Err(err) = self.push_websocket_received_plaintexts(mix_messages).await {
-                        warn!("failed to send sphinx packets back to the client - {err}, assuming the connection is dead");
+                    let mix_messages = mix_messages.expect(
+                        "mix messages sender was unexpectedly closed! this shouldn't have ever happened!",
+                    );
+                    if let Err(e) = self.push_websocket_received_plaintexts(mix_messages).await {
+                        warn!("failed to send sphinx packets back to the client - {:?}, assuming the connection is dead", e);
                        break;
                    }
                }
-                _ = task_client.recv() => {
-                    log::trace!("Websocket handler: Received shutdown");
-                }
            }
        }
-        log::debug!("Websocket handler: Exiting");
    }

    // consume self to make sure `drop` is called after this is done
-    pub(crate) async fn handle_connection(
-        mut self,
-        socket: TcpStream,
-        mut task_client: task::TaskClient,
-    ) {
-        // We don't want a crash in the connection handler to trigger a shutdown of the whole
-        // process.
-        task_client.mark_as_success();
-
+    pub(crate) async fn handle_connection(mut self, socket: TcpStream) {
        let ws_stream = match accept_async(socket).await {
            Ok(ws_stream) => ws_stream,
            Err(err) => {
-                warn!("error while performing the websocket handshake - {err}");
+                warn!("error while performing the websocket handshake - {:?}", err);
                return;
            }
        };
@@ -438,31 +288,6 @@ impl Handler {
            ))
            .expect("the buffer request failed!");

-        self.listen_for_requests(reconstructed_receiver, task_client)
-            .await;
+        self.listen_for_requests(reconstructed_receiver).await;
    }
 }
-
-// I'm still not entirely sure why `send_all` requires `TryStream` rather than `Stream`, but
-// let's just play along for now
-fn prepare_reconstructed_binary(
-    reconstructed_messages: Vec<ReconstructedMessage>,
-) -> Vec<Result<WsMessage, WsError>> {
-    reconstructed_messages
-        .into_iter()
-        .map(ServerResponse::Received)
-        .map(|resp| Ok(WsMessage::Binary(resp.into_binary())))
-        .collect()
-}
-
-// I'm still not entirely sure why `send_all` requires `TryStream` rather than `Stream`, but
-// let's just play along for now
-fn prepare_reconstructed_text(
-    reconstructed_messages: Vec<ReconstructedMessage>,
-) -> Vec<Result<WsMessage, WsError>> {
-    reconstructed_messages
-        .into_iter()
-        .map(ServerResponse::Received)
-        .map(|resp| Ok(WsMessage::Text(resp.into_text())))
-        .collect()
-}
@@ -1,7 +1,7 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use super::handler::HandlerBuilder;
+use super::handler::Handler;
 use log::*;
 use std::{net::SocketAddr, process, sync::Arc};
 use tokio::io::AsyncWriteExt;
@@ -32,11 +32,11 @@ impl Listener {
        }
    }

-    pub(crate) async fn run(&mut self, handler: HandlerBuilder, mut task_client: task::TaskClient) {
+    pub(crate) async fn run(&mut self, handler: Handler) {
        let tcp_listener = match tokio::net::TcpListener::bind(self.address).await {
            Ok(listener) => listener,
            Err(err) => {
-                error!("Failed to bind to {} - {err}. Are you sure nothing else is running on the specified port and your user has sufficient permission to bind to the requested address?", self.address);
+                error!("Failed to bind to {} - {}. Are you sure nothing else is running on the specified port and your user has sufficient permission to bind to the requested address?", self.address, err);
                process::exit(1);
            }
        };
@@ -45,30 +45,18 @@ impl Listener {

        loop {
            tokio::select! {
-                // When the handler finishes we check if shutdown is signalled
                _ = notify.notified() => {
-                    if task_client.is_shutdown() {
-                        log::trace!("Websocket listener: detected shutdown after connection closed");
-                        break;
-                    }
                    // our connection terminated - we are open to a new one now!
                    self.state = State::AwaitingConnection;
                }
-                // ... but when there is no connected client at the time of shutdown being
-                // signalled, we handle it here.
-                _ = task_client.recv() => {
-                    if !self.state.is_connected() {
-                        log::trace!("Not connected: shutting down");
-                        break;
-                    }
-                }
                new_conn = tcp_listener.accept() => {
                    match new_conn {
                        Ok((mut socket, remote_addr)) => {
                            debug!("Received connection from {:?}", remote_addr);
                            if self.state.is_connected() {
-                                warn!("Tried to open a duplicate websocket connection. The request came from {}", remote_addr);
+                                warn!("tried to duplicate!");
                                // if we've already got a connection, don't allow another one
+                                debug!("but there was already a connection present!");
                                // while we only ever want to accept a single connection, we don't want
                                // to leave clients hanging (and also allow for reconnection if it somehow
                                // was dropped)
@@ -76,37 +64,31 @@ impl Listener {
                                    Ok(_) => trace!(
                                        "closed the connection between attempting websocket handshake"
                                    ),
-                                    Err(err) => warn!("failed to cleanly close the connection - {err}"),
+                                    Err(e) => warn!("failed to cleanly close the connection - {:?}", e),
                                };
                            } else {
                                // even though we're spawning a new task with the handler here, we will only ever spawn a single one.
                                // it's done so that any new connections to this listener could be rejected rather than left
                                // 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();
+                                let fresh_handler = handler.clone();
                                tokio::spawn(async move {
-                                    fresh_handler.handle_connection(socket, task_client_handler).await;
+                                    fresh_handler.handle_connection(socket).await;
                                    notify_clone.notify_one();
                                });
                                self.state = State::Connected;
                            }
                        }
-                        Err(err) => warn!("failed to get client: {err}"),
+                        Err(e) => warn!("failed to get client: {:?}", e),
                    }
                }
            }
        }
-        log::debug!("Websocket listener: Exiting");
    }

-    pub(crate) fn start(
-        mut self,
-        handler: HandlerBuilder,
-        shutdown: task::TaskClient,
-    ) -> JoinHandle<()> {
+    pub(crate) fn start(mut self, handler: Handler) -> JoinHandle<()> {
        info!("Running websocket on {:?}", self.address.to_string());

-        tokio::spawn(async move { self.run(handler, shutdown).await })
+        tokio::spawn(async move { self.run(handler).await })
    }
 }
@@ -1,7 +1,7 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-pub(crate) use handler::HandlerBuilder;
+pub(crate) use handler::Handler;
 pub(crate) use listener::Listener;

 pub(crate) mod handler;
@@ -24,11 +24,8 @@ impl fmt::Debug for Error {
 }

 impl Error {
-    pub fn new<S: Into<String>>(kind: ErrorKind, message: S) -> Self {
-        Error {
-            kind,
-            message: message.into(),
-        }
+    pub fn new(kind: ErrorKind, message: String) -> Self {
+        Error { kind, message }
    }
 }

@@ -65,31 +62,6 @@ pub enum ErrorKind {
    Other = 0xFF,
 }

-impl TryFrom<u8> for ErrorKind {
-    type Error = Error;
-
-    fn try_from(value: u8) -> Result<Self, Self::Error> {
-        match value {
-            _ if value == (ErrorKind::EmptyRequest as u8) => Ok(ErrorKind::EmptyRequest),
-            _ if value == (ErrorKind::TooShortRequest as u8) => Ok(ErrorKind::TooShortRequest),
-            _ if value == (ErrorKind::UnknownRequest as u8) => Ok(ErrorKind::UnknownRequest),
-            _ if value == (ErrorKind::MalformedRequest as u8) => Ok(ErrorKind::MalformedRequest),
-
-            _ if value == (ErrorKind::EmptyResponse as u8) => Ok(ErrorKind::EmptyResponse),
-            _ if value == (ErrorKind::TooShortResponse as u8) => Ok(ErrorKind::TooShortResponse),
-            _ if value == (ErrorKind::UnknownResponse as u8) => Ok(ErrorKind::UnknownResponse),
-            _ if value == (ErrorKind::MalformedResponse as u8) => Ok(ErrorKind::MalformedResponse),
-
-            _ if value == (ErrorKind::Other as u8) => Ok(ErrorKind::Other),
-
-            n => Err(Error::new(
-                ErrorKind::MalformedResponse,
-                format!("invalid error code {}", n),
-            )),
-        }
-    }
-}
-
 impl ErrorKind {
    pub(crate) fn as_str(&self) -> &'static str {
        match *self {
@@ -1,4 +1,4 @@
-// Copyright 2021-2022 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

 // all variable size data is always prefixed with u64 length
@@ -7,115 +7,53 @@
 use crate::error::{self, ErrorKind};
 use crate::text::ClientRequestText;
 use nymsphinx::addressing::clients::Recipient;
-use nymsphinx::anonymous_replies::requests::{AnonymousSenderTag, SENDER_TAG_SIZE};
+use nymsphinx::anonymous_replies::ReplySurb;
 use std::convert::{TryFrom, TryInto};
 use std::mem::size_of;

-#[repr(u8)]
-enum ClientRequestTag {
-    /// Value tag representing [`Send`] variant of the [`ClientRequest`]
-    Send = 0x00,
+/// Value tag representing [`Send`] variant of the [`ClientRequest`]
+pub const SEND_REQUEST_TAG: u8 = 0x00;

-    /// Value tag representing [`SendAnonymous`] variant of the [`ClientRequest`]
-    SendAnonymous = 0x01,
+/// Value tag representing [`Reply`] variant of the [`ClientRequest`]
+pub const REPLY_REQUEST_TAG: u8 = 0x01;

-    /// Value tag representing [`Reply`] variant of the [`ClientRequest`]
-    Reply = 0x02,
-
-    /// Value tag representing [`SelfAddress`] variant of the [`ClientRequest`]
-    SelfAddress = 0x03,
-
-    /// Value tag representing [`ClosedConnection`] variant of the [`ClientRequest`]
-    ClosedConnection = 0x04,
-
-    /// Value tag representing [`GetLaneQueueLength`] variant of the [`ClientRequest`]
-    GetLaneQueueLength = 0x05,
-}
-
-impl TryFrom<u8> for ClientRequestTag {
-    type Error = error::Error;
-
-    fn try_from(value: u8) -> Result<Self, Self::Error> {
-        match value {
-            _ if value == (Self::Send as u8) => Ok(Self::Send),
-            _ if value == (Self::SendAnonymous as u8) => Ok(Self::SendAnonymous),
-            _ if value == (Self::Reply as u8) => Ok(Self::Reply),
-            _ if value == (Self::SelfAddress as u8) => Ok(Self::SelfAddress),
-            _ if value == (Self::ClosedConnection as u8) => Ok(Self::ClosedConnection),
-            _ if value == (Self::GetLaneQueueLength as u8) => Ok(Self::GetLaneQueueLength),
-            n => Err(error::Error::new(
-                ErrorKind::UnknownRequest,
-                format!("{n} does not correspond to any valid request tag"),
-            )),
-        }
-    }
-}
+/// Value tag representing [`SelfAddress`] variant of the [`ClientRequest`]
+pub const SELF_ADDRESS_REQUEST_TAG: u8 = 0x02;

 #[allow(non_snake_case)]
 #[derive(Debug)]
 pub enum ClientRequest {
-    /// The simplest message variant where no additional information is attached.
-    /// You're simply sending your `data` to specified `recipient` without any tagging.
-    ///
-    /// Ends up with `NymMessage::Plain` variant
    Send {
        recipient: Recipient,
        message: Vec<u8>,
-        connection_id: Option<u64>,
+        // Perhaps we could change it to a number to indicate how many reply_SURBs we want to include?
+        with_reply_surb: bool,
    },
-
-    /// Create a message used for a duplex anonymous communication where the recipient
-    /// will never learn of our true identity. This is achieved by carefully sending `reply_surbs`.
-    ///
-    /// Note that if reply_surbs is set to zero then
-    /// this variant requires the client having sent some reply_surbs in the past
-    /// (and thus the recipient also knowing our sender tag).
-    ///
-    /// Ends up with `NymMessage::Repliable` variant
-    SendAnonymous {
-        recipient: Recipient,
-        message: Vec<u8>,
-        reply_surbs: u32,
-        connection_id: Option<u64>,
-    },
-
-    /// Attempt to use our internally received and stored `ReplySurb` to send the message back
-    /// to specified recipient whilst not knowing its full identity (or even gateway).
-    ///
-    /// Ends up with `NymMessage::Reply` variant
    Reply {
-        sender_tag: AnonymousSenderTag,
        message: Vec<u8>,
-        connection_id: Option<u64>,
+        reply_surb: ReplySurb,
    },
-
    SelfAddress,
-
-    ClosedConnection(u64),
-
-    GetLaneQueueLength(u64),
 }

 // we could have been parsing it directly TryFrom<WsMessage>, but we want to retain
 // information about whether it came from binary or text to send appropriate response back
 impl ClientRequest {
-    // SEND_REQUEST_TAG || recipient || conn_id || data_len || data
-    fn serialize_send(recipient: Recipient, data: Vec<u8>, connection_id: Option<u64>) -> Vec<u8> {
+    // SEND_REQUEST_TAG || with_surb || recipient || data_len || data
+    fn serialize_send(recipient: Recipient, data: Vec<u8>, with_reply_surb: bool) -> Vec<u8> {
        let data_len_bytes = (data.len() as u64).to_be_bytes();
-        let conn_id_bytes = connection_id.unwrap_or(0).to_be_bytes();
-
-        std::iter::once(ClientRequestTag::Send as u8)
-            .chain(recipient.to_bytes().into_iter()) // will not be length prefixed because the length is constant
-            .chain(conn_id_bytes.into_iter())
-            .chain(data_len_bytes.into_iter())
+        std::iter::once(SEND_REQUEST_TAG)
+            .chain(std::iter::once(with_reply_surb as u8))
+            .chain(recipient.to_bytes().iter().cloned()) // will not be length prefixed because the length is constant
+            .chain(data_len_bytes.iter().cloned())
            .chain(data.into_iter())
            .collect()
    }

-    // SEND_REQUEST_TAG || recipient || conn_id || data_len || data
+    // SEND_REQUEST_TAG || with_reply || recipient || data_len || data
    fn deserialize_send(b: &[u8]) -> Result<Self, error::Error> {
-        // we need to have at least 1 (tag) + Recipient::LEN + 2*sizeof<u64> bytes
-        if b.len() < 1 + Recipient::LEN + 2 * size_of::<u64>() {
+        // we need to have at least 1 (tag) + 1 (reply flag) + Recipient::LEN + sizeof<u64> bytes
+        if b.len() < 2 + Recipient::LEN + size_of::<u64>() {
            return Err(error::Error::new(
                ErrorKind::TooShortRequest,
                "not enough data provided to recover 'send'".to_string(),
@@ -123,34 +61,34 @@ impl ClientRequest {
        }

        // this MUST match because it was called by 'deserialize'
-        debug_assert_eq!(b[0], ClientRequestTag::Send as u8);
+        debug_assert_eq!(b[0], SEND_REQUEST_TAG);
+
+        let with_reply_surb = match b[1] {
+            0 => false,
+            1 => true,
+            n => {
+                return Err(error::Error::new(
+                    ErrorKind::MalformedRequest,
+                    format!("invalid reply surb flag {}", n),
+                ))
+            }
+        };

        let mut recipient_bytes = [0u8; Recipient::LEN];
-        recipient_bytes.copy_from_slice(&b[1..1 + Recipient::LEN]);
+        recipient_bytes.copy_from_slice(&b[2..2 + Recipient::LEN]);
        let recipient = match Recipient::try_from_bytes(recipient_bytes) {
            Ok(recipient) => recipient,
            Err(err) => {
                return Err(error::Error::new(
                    ErrorKind::MalformedRequest,
-                    format!("malformed recipient: {err}"),
+                    format!("malformed recipient: {:?}", err),
                ))
            }
        };

-        let mut connection_id_bytes = [0u8; size_of::<u64>()];
-        connection_id_bytes
-            .copy_from_slice(&b[1 + Recipient::LEN..1 + Recipient::LEN + size_of::<u64>()]);
-        let connection_id = u64::from_be_bytes(connection_id_bytes);
-        let connection_id = if connection_id == 0 {
-            None
-        } else {
-            Some(connection_id)
-        };
-
-        let data_len_bytes =
-            &b[1 + Recipient::LEN + size_of::<u64>()..1 + Recipient::LEN + 2 * size_of::<u64>()];
+        let data_len_bytes = &b[2 + Recipient::LEN..2 + Recipient::LEN + size_of::<u64>()];
        let data_len = u64::from_be_bytes(data_len_bytes.try_into().unwrap());
-        let data = &b[1 + Recipient::LEN + 2 * size_of::<u64>()..];
+        let data = &b[2 + Recipient::LEN + size_of::<u64>()..];
        if data.len() as u64 != data_len {
            return Err(error::Error::new(
                ErrorKind::MalformedRequest,
@@ -163,111 +101,32 @@ impl ClientRequest {
        }

        Ok(ClientRequest::Send {
+            with_reply_surb,
            recipient,
            message: data.to_vec(),
-            connection_id,
        })
    }

-    // SEND_ANONYMOUS_REQUEST_TAG || reply_surbs || recipient || conn_id || data_len || data
-    fn serialize_send_anonymous(
-        recipient: Recipient,
-        data: Vec<u8>,
-        reply_surbs: u32,
-        connection_id: Option<u64>,
-    ) -> Vec<u8> {
-        let data_len_bytes = (data.len() as u64).to_be_bytes();
-        let conn_id_bytes = connection_id.unwrap_or(0).to_be_bytes();
-
-        std::iter::once(ClientRequestTag::SendAnonymous as u8)
-            .chain(reply_surbs.to_be_bytes().into_iter())
-            .chain(recipient.to_bytes().into_iter()) // will not be length prefixed because the length is constant
-            .chain(conn_id_bytes.into_iter())
-            .chain(data_len_bytes.into_iter())
-            .chain(data.into_iter())
-            .collect()
-    }
-
-    // SEND_ANONYMOUS_REQUEST_TAG || reply_surbs || recipient || data_len || data
-    fn deserialize_send_anonymous(b: &[u8]) -> Result<Self, error::Error> {
-        // we need to have at least 1 (tag) + sizeof<u32> (num surbs) + Recipient::LEN + 2 *sizeof<u64> bytes
-        if b.len() < 1 + size_of::<u32>() + Recipient::LEN + 2 * size_of::<u64>() {
-            return Err(error::Error::new(
-                ErrorKind::TooShortRequest,
-                "not enough data provided to recover 'send_anonymous'".to_string(),
-            ));
-        }
-
-        // this MUST match because it was called by 'deserialize'
-        debug_assert_eq!(b[0], ClientRequestTag::SendAnonymous as u8);
-
-        let reply_surbs = u32::from_be_bytes([b[1], b[2], b[3], b[4]]);
-
-        let mut recipient_bytes = [0u8; Recipient::LEN];
-        recipient_bytes.copy_from_slice(&b[5..5 + Recipient::LEN]);
-        let recipient = match Recipient::try_from_bytes(recipient_bytes) {
-            Ok(recipient) => recipient,
-            Err(err) => {
-                return Err(error::Error::new(
-                    ErrorKind::MalformedRequest,
-                    format!("malformed recipient: {err}"),
-                ))
-            }
-        };
-
-        let mut connection_id_bytes = [0u8; size_of::<u64>()];
-        connection_id_bytes
-            .copy_from_slice(&b[5 + Recipient::LEN..5 + Recipient::LEN + size_of::<u64>()]);
-        let connection_id = u64::from_be_bytes(connection_id_bytes);
-        let connection_id = if connection_id == 0 {
-            None
-        } else {
-            Some(connection_id)
-        };
-
-        let data_len_bytes =
-            &b[5 + Recipient::LEN + size_of::<u64>()..5 + Recipient::LEN + 2 * size_of::<u64>()];
-        let data_len = u64::from_be_bytes(data_len_bytes.try_into().unwrap());
-        let data = &b[5 + Recipient::LEN + 2 * size_of::<u64>()..];
-        if data.len() as u64 != data_len {
-            return Err(error::Error::new(
-                ErrorKind::MalformedRequest,
-                format!(
-                    "data len has inconsistent length. specified: {} got: {}",
-                    data_len,
-                    data.len()
-                ),
-            ));
-        }
-
-        Ok(ClientRequest::SendAnonymous {
-            reply_surbs,
-            recipient,
-            message: data.to_vec(),
-            connection_id,
-        })
-    }
-
-    // REPLY_REQUEST_TAG || SENDER_TAG || conn_id || message_len || message
-    fn serialize_reply(
-        message: Vec<u8>,
-        sender_tag: AnonymousSenderTag,
-        connection_id: Option<u64>,
-    ) -> Vec<u8> {
+    // REPLY_REQUEST_TAG || surb_len || surb || message_len || message
+    fn serialize_reply(message: Vec<u8>, reply_surb: ReplySurb) -> Vec<u8> {
+        let reply_surb_bytes = reply_surb.to_bytes();
+        let surb_len_bytes = (reply_surb_bytes.len() as u64).to_be_bytes();
        let message_len_bytes = (message.len() as u64).to_be_bytes();
-        let conn_id_bytes = connection_id.unwrap_or(0).to_be_bytes();

-        std::iter::once(ClientRequestTag::Reply as u8)
-            .chain(sender_tag.to_bytes().into_iter())
-            .chain(conn_id_bytes.into_iter())
-            .chain(message_len_bytes.into_iter())
+        std::iter::once(REPLY_REQUEST_TAG)
+            .chain(surb_len_bytes.iter().cloned())
+            .chain(reply_surb_bytes.into_iter())
+            .chain(message_len_bytes.iter().cloned())
            .chain(message.into_iter())
            .collect()
    }

-    // REPLY_REQUEST_TAG || SENDER_TAG || conn_id || message_len || message
+    // REPLY_REQUEST_TAG || surb_len || surb || message_len || message
    fn deserialize_reply(b: &[u8]) -> Result<Self, error::Error> {
-        if b.len() < 1 + SENDER_TAG_SIZE + 2 * size_of::<u64>() {
+        // we need to have at the very least 2 * sizeof<u64> bytes (in case, for some peculiar reason
+        // message and reply surb were 0 len - the request would still be malformed, but would in theory
+        // be parse'able)
+        if b.len() < 1 + 2 * size_of::<u64>() {
            return Err(error::Error::new(
                ErrorKind::TooShortRequest,
                "not enough data provided to recover 'reply'".to_string(),
@@ -275,28 +134,42 @@ impl ClientRequest {
        }

        // this MUST match because it was called by 'deserialize'
-        debug_assert_eq!(b[0], ClientRequestTag::Reply as u8);
+        debug_assert_eq!(b[0], REPLY_REQUEST_TAG);

-        // the unwrap here is fine as we're definitely using exactly SENDER_TAG_SIZE bytes
-        let sender_tag =
-            AnonymousSenderTag::from_bytes(b[1..1 + SENDER_TAG_SIZE].try_into().unwrap());
+        let reply_surb_len =
+            u64::from_be_bytes(b[1..1 + size_of::<u64>()].as_ref().try_into().unwrap());

-        let mut connection_id_bytes = [0u8; size_of::<u64>()];
-        connection_id_bytes
-            .copy_from_slice(&b[1 + SENDER_TAG_SIZE..1 + SENDER_TAG_SIZE + size_of::<u64>()]);
-        let connection_id = u64::from_be_bytes(connection_id_bytes);
-        let connection_id = if connection_id == 0 {
-            None
-        } else {
-            Some(connection_id)
+        // make sure we won't go out of bounds here
+        if reply_surb_len > (b.len() - 1 + 2 * size_of::<u64>()) as u64 {
+            return Err(error::Error::new(
+                ErrorKind::MalformedRequest,
+                format!(
+                    "not enough data to recover reply surb with specified length {}",
+                    reply_surb_len
+                ),
+            ));
+        }
+
+        let surb_bound = 1 + size_of::<u64>() + reply_surb_len as usize;
+
+        let reply_surb_bytes = &b[1 + size_of::<u64>()..surb_bound];
+        let reply_surb = match ReplySurb::from_bytes(reply_surb_bytes) {
+            Ok(reply_surb) => reply_surb,
+            Err(err) => {
+                return Err(error::Error::new(
+                    ErrorKind::MalformedRequest,
+                    format!("malformed reply surb: {:?}", err),
+                ))
+            }
        };

        let message_len = u64::from_be_bytes(
-            b[1 + SENDER_TAG_SIZE + size_of::<u64>()..1 + SENDER_TAG_SIZE + 2 * size_of::<u64>()]
+            b[surb_bound..surb_bound + size_of::<u64>()]
+                .as_ref()
                .try_into()
                .unwrap(),
        );
-        let message = &b[1 + SENDER_TAG_SIZE + 2 * size_of::<u64>()..];
+        let message = &b[surb_bound + size_of::<u64>()..];
        if message.len() as u64 != message_len {
            return Err(error::Error::new(
                ErrorKind::MalformedRequest,
@@ -307,79 +180,26 @@ impl ClientRequest {
                ),
            ));
        }
+        // TODO: should this blow HERE, i.e. during deserialization that the data you're trying
+        // to send via reply is too long?

        Ok(ClientRequest::Reply {
+            reply_surb,
            message: message.to_vec(),
-            sender_tag,
-            connection_id,
        })
    }

    // SELF_ADDRESS_REQUEST_TAG
    fn serialize_self_address() -> Vec<u8> {
-        vec![ClientRequestTag::SelfAddress as u8]
+        std::iter::once(SELF_ADDRESS_REQUEST_TAG).collect()
    }

    // SELF_ADDRESS_REQUEST_TAG
-    fn deserialize_self_address(b: &[u8]) -> Result<Self, error::Error> {
+    fn deserialize_self_address(b: &[u8]) -> Self {
        // this MUST match because it was called by 'deserialize'
-        debug_assert_eq!(b[0], ClientRequestTag::SelfAddress as u8);
+        debug_assert_eq!(b[0], SELF_ADDRESS_REQUEST_TAG);

-        Ok(ClientRequest::SelfAddress)
-    }
-
-    // CLOSED_CONNECTION_REQUEST_TAG
-    fn serialize_closed_connection(connection_id: u64) -> Vec<u8> {
-        let conn_id_bytes = connection_id.to_be_bytes();
-        std::iter::once(ClientRequestTag::ClosedConnection as u8)
-            .chain(conn_id_bytes.into_iter())
-            .collect()
-    }
-
-    // CLOSED_CONNECTION_REQUEST_TAG
-    fn deserialize_closed_connection(b: &[u8]) -> Result<Self, error::Error> {
-        if b.len() != 1 + size_of::<u64>() {
-            return Err(error::Error::new(
-                ErrorKind::MalformedRequest,
-                "The received closed connection has invalid length",
-            ));
-        }
-
-        // this MUST match because it was called by 'deserialize'
-        debug_assert_eq!(b[0], ClientRequestTag::ClosedConnection as u8);
-
-        let mut connection_id_bytes = [0u8; size_of::<u64>()];
-        connection_id_bytes.copy_from_slice(&b[1..=size_of::<u64>()]);
-        let connection_id = u64::from_be_bytes(connection_id_bytes);
-
-        Ok(ClientRequest::ClosedConnection(connection_id))
-    }
-
-    // GET_LANE_QUEUE_LENGHT_TAG
-    fn serialize_get_lane_queue_lengths(connection_id: u64) -> Vec<u8> {
-        let conn_id_bytes = connection_id.to_be_bytes();
-        std::iter::once(ClientRequestTag::GetLaneQueueLength as u8)
-            .chain(conn_id_bytes.into_iter())
-            .collect()
-    }
-
-    // GET_LANE_QUEUE_LENGHT_TAG
-    fn deserialize_get_lane_queue_length(b: &[u8]) -> Result<Self, error::Error> {
-        if b.len() != 1 + size_of::<u64>() {
-            return Err(error::Error::new(
-                ErrorKind::MalformedRequest,
-                "The received get lane queue lengths has invalid length",
-            ));
-        }
-
-        // this MUST match because it was called by 'deserialize'
-        debug_assert_eq!(b[0], ClientRequestTag::GetLaneQueueLength as u8);
-
-        let mut connection_id_bytes = [0u8; size_of::<u64>()];
-        connection_id_bytes.copy_from_slice(&b[1..=size_of::<u64>()]);
-        let connection_id = u64::from_be_bytes(connection_id_bytes);
-
-        Ok(ClientRequest::GetLaneQueueLength(connection_id))
+        ClientRequest::SelfAddress
    }

    pub fn serialize(self) -> Vec<u8> {
@@ -387,27 +207,15 @@ impl ClientRequest {
            ClientRequest::Send {
                recipient,
                message,
-                connection_id,
-            } => Self::serialize_send(recipient, message, connection_id),
-
-            ClientRequest::SendAnonymous {
-                recipient,
-                message,
-                reply_surbs,
-                connection_id,
-            } => Self::serialize_send_anonymous(recipient, message, reply_surbs, connection_id),
+                with_reply_surb,
+            } => Self::serialize_send(recipient, message, with_reply_surb),

            ClientRequest::Reply {
                message,
-                sender_tag,
-                connection_id,
-            } => Self::serialize_reply(message, sender_tag, connection_id),
+                reply_surb,
+            } => Self::serialize_reply(message, reply_surb),

            ClientRequest::SelfAddress => Self::serialize_self_address(),
-
-            ClientRequest::ClosedConnection(id) => Self::serialize_closed_connection(id),
-
-            ClientRequest::GetLaneQueueLength(id) => Self::serialize_get_lane_queue_lengths(id),
        }
    }

@@ -421,21 +229,31 @@ impl ClientRequest {
            ));
        }

-        let request_tag = ClientRequestTag::try_from(b[0])?;
+        if b.len() < size_of::<u8>() {
+            return Err(error::Error::new(
+                ErrorKind::TooShortRequest,
+                format!(
+                    "not enough data provided to recover request tag. Provided only {} bytes",
+                    b.len()
+                ),
+            ));
+        }
+        let request_tag = b[0];

        // determine what kind of request that is and try to deserialize it
        match request_tag {
-            ClientRequestTag::Send => Self::deserialize_send(b),
-            ClientRequestTag::SendAnonymous => Self::deserialize_send_anonymous(b),
-            ClientRequestTag::Reply => Self::deserialize_reply(b),
-            ClientRequestTag::SelfAddress => Self::deserialize_self_address(b),
-            ClientRequestTag::ClosedConnection => Self::deserialize_closed_connection(b),
-            ClientRequestTag::GetLaneQueueLength => Self::deserialize_get_lane_queue_length(b),
+            SEND_REQUEST_TAG => Self::deserialize_send(b),
+            REPLY_REQUEST_TAG => Self::deserialize_reply(b),
+            SELF_ADDRESS_REQUEST_TAG => Ok(Self::deserialize_self_address(b)),
+            n => Err(error::Error::new(
+                ErrorKind::UnknownRequest,
+                format!("type {}", n),
+            )),
        }
    }

-    pub fn try_from_binary(raw_req: &[u8]) -> Result<Self, error::Error> {
-        Self::deserialize(raw_req)
+    pub fn try_from_binary(raw_req: Vec<u8>) -> Result<Self, error::Error> {
+        Self::deserialize(&raw_req)
    }

    pub fn try_from_text(raw_req: String) -> Result<Self, error::Error> {
@@ -458,52 +276,44 @@ mod tests {
        let recipient = Recipient::try_from_base58_string("CytBseW6yFXUMzz4SGAKdNLGR7q3sJLLYxyBGvutNEQV.4QXYyEVc5fUDjmmi8PrHN9tdUFV4PCvSJE1278cHyvoe@4sBbL1ngf1vtNqykydQKTFh26sQCw888GpUqvPvyNB4f").unwrap();
        let recipient_string = recipient.to_string();

-        let send_request = ClientRequest::Send {
+        let send_request_no_surb = ClientRequest::Send {
            recipient,
            message: b"foomp".to_vec(),
-            connection_id: Some(42),
+            with_reply_surb: false,
        };

-        let bytes = send_request.serialize();
+        let bytes = send_request_no_surb.serialize();
        let recovered = ClientRequest::deserialize(&bytes).unwrap();
        match recovered {
            ClientRequest::Send {
                recipient,
                message,
-                connection_id,
+                with_reply_surb,
            } => {
                assert_eq!(recipient.to_string(), recipient_string);
                assert_eq!(message, b"foomp".to_vec());
-                assert_eq!(connection_id, Some(42))
+                assert!(!with_reply_surb)
            }
            _ => unreachable!(),
        }
-    }

-    #[test]
-    fn send_anonymous_request_serialization_works() {
-        let original_recipient = Recipient::try_from_base58_string("CytBseW6yFXUMzz4SGAKdNLGR7q3sJLLYxyBGvutNEQV.4QXYyEVc5fUDjmmi8PrHN9tdUFV4PCvSJE1278cHyvoe@4sBbL1ngf1vtNqykydQKTFh26sQCw888GpUqvPvyNB4f").unwrap();
-
-        let send_anonymous_request = ClientRequest::SendAnonymous {
-            recipient: original_recipient,
+        let send_request_surb = ClientRequest::Send {
+            recipient,
            message: b"foomp".to_vec(),
-            reply_surbs: 666,
-            connection_id: Some(42),
+            with_reply_surb: true,
        };

-        let bytes = send_anonymous_request.serialize();
+        let bytes = send_request_surb.serialize();
        let recovered = ClientRequest::deserialize(&bytes).unwrap();
        match recovered {
-            ClientRequest::SendAnonymous {
+            ClientRequest::Send {
                recipient,
                message,
-                reply_surbs,
-                connection_id,
+                with_reply_surb,
            } => {
-                assert_eq!(recipient, original_recipient);
+                assert_eq!(recipient.to_string(), recipient_string);
                assert_eq!(message, b"foomp".to_vec());
-                assert_eq!(connection_id, Some(42));
-                assert_eq!(reply_surbs, 666)
+                assert!(with_reply_surb)
            }
            _ => unreachable!(),
        }
@@ -511,23 +321,22 @@ mod tests {

    #[test]
    fn reply_request_serialization_works() {
+        let reply_surb_string = "CjfVbHbfAjbC3W1BvNHGXmM8KNAnDNYGaHMLqVDxRYeo352csAihstup9bvqXam4dTWgfHak6KYwL9STaxWJ47E8XFZbSEvs7hEsfCkxr6K9WJuSBPK84GDDEvad8ZAuMCoaXsAd5S2Lj9a5eYyzG4SL1jHzhSMni55LyJwumxo1ZTGZNXggxw1RREosvyzNrW9Rsi3owyPqLCwXpiei2tHZty8w8midVvg8vDa7ZEJD842CLv8D4ohynSG7gDpqTrhkRaqYAuz7dzqNbMXLJRM7v823Jn16fA1L7YQxmcaUdUigyRSgTdb4i9ebiLGSyJ1iDe6Acz613PQZh6Ua3bZ2zVKq3dSycpDm9ngarRK4zJrAaUxRkdih8YzW3BY4nL9eqkfKA4N1TWCLaRU7zpSaf8yMEwrAZReU3d5zLV8c5KBfa2w8R5anhQeBojduZEGEad8kkHuKU52Zg93FeWHvH1qgZaEJMHH4nN7gKXz9mvWDhYwyF4vt3Uy2NhCHC3N5pL1gMme27YcoPcTEia1fxKZtnt6rtEozzTrAgCJGswigkFbkafiV5QaJwLKTUxtzhkZ57eEuLPte9UvJHzhhXUQ2CV7R2BUkJjYZy3Zsx6YYvdYWiAFFkWUwNEGA4QpShUHciBfsQVHQ7pN41YcyYUhbywQDFnTVgEmdUZ1XCBi3gyK5U3tDQmFzP1u9m3mWrUA8qB9mRDE7ptNDm5c3c1458L6uXLUth7sdMaa1Was5LCmCdmNDtvNpCDAEt1in6q6mrZFR85aCSU9b1baNGwZoCqPpPvydkVe63gXWoi8ebvdyxARrqACFrSB3ZdY3uJBw8CTMNkKK6MvcefMkSVVsbLd36TQAtYSCqrpiMc5dQuKcEu5QfciwvWYXYx8WFNAgKwP2mv49KCTvfozNDUCbjzDwSx92Zv5zjG8HbFpB13bY9UZGeyTPvv7gGxCzjGjJGbW6FRAheRQaaje5fUgCNM95Tv7wBmAMRHHFgWafeK1sdFH7dtCX9u898HucGTaboSKLsVh8J78gbbkHErwjMh7y9YRkceq5TTYS5da4kHnyNKYWSbxgZrmFg44XGKoeYcqoHB3XTZrdsf7F5fFeNwnihkmADvhAcaxXUmVqq4rQFZH84a1iC3WBWXYcqiZH2L7ujGWV7mMDT4HBEerDYjc8rNY4xGTPfivCrBCJW1i14aqW8xRdsdgTM88eTksvC3WPJLJ7iMzfKXeL7fMW1Ek6QGyQtLBW98vEESpdcDg6DeZ5rMz6VqjTGGqcCaFGfHoqtfxMDaBAEsyQ8h7XDX6dg1wq9wH6j4Tw7Tj1MEv1b8uj5NJkozZdzVdYA2QyE2Dp8vuurQG6uVdTDNww2d88RBQ8sVgjxN8gR45y4woJLhFAaNTAtrY6wDTxyXST13ni6oyqdYxjFVk9Am4v3DzH7Y2K8iRVSHfTk4FRbPULyaeK6wt2anvMJH1XdvVRgc14h67MnBxMgMD1UFk8AErN7CDj26fppe3c5G6KozJe4cSqQUGbBjVzBnrHCruqrfZBn5hNZHTV37bQiomqhRQXohxhuKEnNrGbAe1xNvJr9X";
+        let reply_surb = ReplySurb::from_base58_string(reply_surb_string).unwrap();
        let reply_request = ClientRequest::Reply {
-            sender_tag: [8u8; SENDER_TAG_SIZE].into(),
            message: b"foomp".to_vec(),
-            connection_id: Some(42),
+            reply_surb,
        };

        let bytes = reply_request.serialize();
        let recovered = ClientRequest::deserialize(&bytes).unwrap();
        match recovered {
            ClientRequest::Reply {
-                sender_tag,
+                reply_surb,
                message,
-                connection_id,
            } => {
-                assert_eq!(sender_tag, [8u8; SENDER_TAG_SIZE].into());
+                assert_eq!(reply_surb.to_base58_string(), reply_surb_string);
                assert_eq!(message, b"foomp".to_vec());
-                assert_eq!(connection_id, Some(42));
            }
            _ => unreachable!(),
        }
@@ -543,26 +352,4 @@ mod tests {
            _ => unreachable!(),
        }
    }
-
-    #[test]
-    fn close_connection_request_serialization_works() {
-        let close_connection_request = ClientRequest::ClosedConnection(42);
-        let bytes = close_connection_request.serialize();
-        let recovered = ClientRequest::deserialize(&bytes).unwrap();
-        match recovered {
-            ClientRequest::ClosedConnection(id) => assert_eq!(id, 42),
-            _ => unreachable!(),
-        }
-    }
-
-    #[test]
-    fn get_lane_queue_length_request_serialization_works() {
-        let close_connection_request = ClientRequest::GetLaneQueueLength(42);
-        let bytes = close_connection_request.serialize();
-        let recovered = ClientRequest::deserialize(&bytes).unwrap();
-        match recovered {
-            ClientRequest::GetLaneQueueLength(id) => assert_eq!(id, 42),
-            _ => unreachable!(),
-        }
-    }
 }
@@ -1,54 +1,32 @@
-// Copyright 2021-2022 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

 // all variable size data is always prefixed with u64 length
 // tags are u8

+#![allow(unknown_lints)] // due to using `clippy::branches_sharing_code` which does not exist on `stable` just yet
+
 use crate::error::{self, ErrorKind};
 use crate::text::ServerResponseText;
 use nymsphinx::addressing::clients::Recipient;
-use nymsphinx::anonymous_replies::requests::{AnonymousSenderTag, SENDER_TAG_SIZE};
+use nymsphinx::anonymous_replies::ReplySurb;
 use nymsphinx::receiver::ReconstructedMessage;
 use std::convert::TryInto;
 use std::mem::size_of;

-#[repr(u8)]
-enum ServerResponseTag {
-    /// Value tag representing [`Error`] variant of the [`ServerResponse`]
-    Error = 0x00,
+/// Value tag representing [`Error`] variant of the [`ServerResponse`]
+pub const ERROR_RESPONSE_TAG: u8 = 0x00;

-    /// Value tag representing [`Received`] variant of the [`ServerResponse`]
-    Received = 0x01,
+/// Value tag representing [`Received`] variant of the [`ServerResponse`]
+pub const RECEIVED_RESPONSE_TAG: u8 = 0x01;

-    /// Value tag representing [`SelfAddress`] variant of the [`ServerResponse`]
-    SelfAddress = 0x02,
-
-    /// Value tag representing [`LaneQueueLength`] variant of the [`ServerResponse`]
-    LaneQueueLength = 0x03,
-}
-
-impl TryFrom<u8> for ServerResponseTag {
-    type Error = error::Error;
-
-    fn try_from(value: u8) -> Result<Self, error::Error> {
-        match value {
-            _ if value == (Self::Error as u8) => Ok(Self::Error),
-            _ if value == (Self::Received as u8) => Ok(Self::Received),
-            _ if value == (Self::SelfAddress as u8) => Ok(Self::SelfAddress),
-            _ if value == (Self::LaneQueueLength as u8) => Ok(Self::LaneQueueLength),
-            n => Err(error::Error::new(
-                ErrorKind::UnknownResponse,
-                format!("{n} does not correspond to any valid response tag"),
-            )),
-        }
-    }
-}
+/// Value tag representing [`SelfAddress`] variant of the [`ServerResponse`]
+pub const SELF_ADDRESS_RESPONSE_TAG: u8 = 0x02;

 #[derive(Debug)]
 pub enum ServerResponse {
    Received(ReconstructedMessage),
-    SelfAddress(Box<Recipient>),
-    LaneQueueLength { lane: u64, queue_length: usize },
+    SelfAddress(Recipient),
    Error(error::Error),
 }

@@ -60,19 +38,24 @@ impl ServerResponse {
        })
    }

-    // RECEIVED_RESPONSE_TAG || 1 | 0 indicating sender_tag || Option<sender_tag> || msg_len || msg
+    // RECEIVED_RESPONSE_TAG || with_reply || (surb_len || surb) || msg_len || msg
    fn serialize_received(reconstructed_message: ReconstructedMessage) -> Vec<u8> {
        let message_len_bytes = (reconstructed_message.message.len() as u64).to_be_bytes();
+        if let Some(reply_surb) = reconstructed_message.reply_surb {
+            let reply_surb_bytes = reply_surb.to_bytes();
+            let surb_len_bytes = (reply_surb_bytes.len() as u64).to_be_bytes();

-        if let Some(sender_tag) = reconstructed_message.sender_tag {
-            std::iter::once(ServerResponseTag::Received as u8)
+            // with_reply || surb_len || surb || msg_len || msg
+            std::iter::once(RECEIVED_RESPONSE_TAG)
                .chain(std::iter::once(true as u8))
-                .chain(sender_tag.to_bytes().into_iter())
+                .chain(surb_len_bytes.iter().cloned())
+                .chain(reply_surb_bytes.iter().cloned())
                .chain(message_len_bytes.iter().cloned())
                .chain(reconstructed_message.message.into_iter())
                .collect()
        } else {
-            std::iter::once(ServerResponseTag::Received as u8)
+            // without_reply || msg_len || msg
+            std::iter::once(RECEIVED_RESPONSE_TAG)
                .chain(std::iter::once(false as u8))
                .chain(message_len_bytes.iter().cloned())
                .chain(reconstructed_message.message.into_iter())
@@ -80,9 +63,10 @@ impl ServerResponse {
        }
    }

-    // RECEIVED_RESPONSE_TAG || 1 | 0 indicating sender_tag || Option<sender_tag> || msg_len || msg
+    // RECEIVED_RESPONSE_TAG || with_reply || (surb_len || surb) || msg_len || msg
    fn deserialize_received(b: &[u8]) -> Result<Self, error::Error> {
        // this MUST match because it was called by 'deserialize'
+        debug_assert_eq!(b[0], RECEIVED_RESPONSE_TAG);

        // we must be able to read at the very least if it has a reply_surb and length of some field
        if b.len() < 2 + size_of::<u64>() {
@@ -91,70 +75,101 @@ impl ServerResponse {
                "not enough data provided to recover 'received'".to_string(),
            ));
        }
-        debug_assert_eq!(b[0], ServerResponseTag::Received as u8);

-        let has_sender_tag = match b[1] {
+        let with_reply_surb = match b[1] {
            0 => false,
            1 => true,
            n => {
                return Err(error::Error::new(
                    ErrorKind::MalformedResponse,
-                    format!("invalid sender tag flag {n}"),
+                    format!("invalid reply flag {}", n),
                ))
            }
        };

-        let mut i = 2;
-        let sender_tag = if has_sender_tag {
-            if b[2..].len() < SENDER_TAG_SIZE {
+        // this is a false positive as even though the code is the same, it refers to different things
+        #[allow(clippy::branches_sharing_code)]
+        if with_reply_surb {
+            let reply_surb_len =
+                u64::from_be_bytes(b[2..2 + size_of::<u64>()].as_ref().try_into().unwrap());
+
+            // make sure we won't go out of bounds here
+            if reply_surb_len > (b.len() - 2 + 2 * size_of::<u64>()) as u64 {
                return Err(error::Error::new(
-                    ErrorKind::TooShortResponse,
-                    "not enough data provided to recover 'received'".to_string(),
+                    ErrorKind::MalformedResponse,
+                    "not enough bytes to read reply_surb bytes!".to_string(),
                ));
            }
-            i += SENDER_TAG_SIZE;
-            Some(AnonymousSenderTag::from_bytes(
-                b[2..2 + SENDER_TAG_SIZE].try_into().unwrap(),
-            ))
+
+            let surb_bound = 2 + size_of::<u64>() + reply_surb_len as usize;
+
+            let reply_surb_bytes = &b[2 + size_of::<u64>()..surb_bound];
+            let reply_surb = match ReplySurb::from_bytes(reply_surb_bytes) {
+                Ok(reply_surb) => reply_surb,
+                Err(err) => {
+                    return Err(error::Error::new(
+                        ErrorKind::MalformedResponse,
+                        format!("malformed reply SURB: {:?}", err),
+                    ))
+                }
+            };
+
+            let message_len = u64::from_be_bytes(
+                b[surb_bound..surb_bound + size_of::<u64>()]
+                    .as_ref()
+                    .try_into()
+                    .unwrap(),
+            );
+            let message = &b[surb_bound + size_of::<u64>()..];
+            if message.len() as u64 != message_len {
+                return Err(error::Error::new(
+                    ErrorKind::MalformedResponse,
+                    format!(
+                        "message len has inconsistent length. specified: {} got: {}",
+                        message_len,
+                        message.len()
+                    ),
+                ));
+            }
+
+            Ok(ServerResponse::Received(ReconstructedMessage {
+                message: message.to_vec(),
+                reply_surb: Some(reply_surb),
+            }))
        } else {
-            None
-        };
+            let message_len =
+                u64::from_be_bytes(b[2..2 + size_of::<u64>()].as_ref().try_into().unwrap());
+            let message = &b[2 + size_of::<u64>()..];
+            if message.len() as u64 != message_len {
+                return Err(error::Error::new(
+                    ErrorKind::MalformedResponse,
+                    format!(
+                        "message len has inconsistent length. specified: {} got: {}",
+                        message_len,
+                        message.len()
+                    ),
+                ));
+            }

-        if b[i..].len() < size_of::<u64>() {
-            return Err(error::Error::new(
-                ErrorKind::TooShortResponse,
-                "not enough data provided to recover 'received'".to_string(),
-            ));
+            Ok(ServerResponse::Received(ReconstructedMessage {
+                message: message.to_vec(),
+                reply_surb: None,
+            }))
        }
-
-        let message_len = u64::from_be_bytes(b[i..i + size_of::<u64>()].try_into().unwrap());
-        let message = &b[i + size_of::<u64>()..];
-        if message.len() as u64 != message_len {
-            return Err(error::Error::new(
-                ErrorKind::MalformedResponse,
-                format!(
-                    "message len has inconsistent length. specified: {} got: {}",
-                    message_len,
-                    message.len()
-                ),
-            ));
-        }
-
-        Ok(ServerResponse::Received(ReconstructedMessage {
-            message: message.to_vec(),
-            sender_tag,
-        }))
    }

    // SELF_ADDRESS_RESPONSE_TAG || self_address
    fn serialize_self_address(address: Recipient) -> Vec<u8> {
-        std::iter::once(ServerResponseTag::SelfAddress as u8)
-            .chain(address.to_bytes().into_iter())
+        std::iter::once(SELF_ADDRESS_RESPONSE_TAG)
+            .chain(address.to_bytes().iter().cloned())
            .collect()
    }

    // SELF_ADDRESS_RESPONSE_TAG || self_address
    fn deserialize_self_address(b: &[u8]) -> Result<Self, error::Error> {
+        // this MUST match because it was called by 'deserialize'
+        debug_assert_eq!(b[0], SELF_ADDRESS_RESPONSE_TAG);
+
        if b.len() != 1 + Recipient::LEN {
            return Err(error::Error::new(
                ErrorKind::TooShortResponse,
@@ -162,9 +177,6 @@ impl ServerResponse {
            ));
        }

-        // this MUST match because it was called by 'deserialize'
-        debug_assert_eq!(b[0], ServerResponseTag::SelfAddress as u8);
-
        let mut recipient_bytes = [0u8; Recipient::LEN];
        recipient_bytes.copy_from_slice(&b[1..1 + Recipient::LEN]);

@@ -173,45 +185,20 @@ impl ServerResponse {
            Err(err) => {
                return Err(error::Error::new(
                    ErrorKind::MalformedResponse,
-                    format!("malformed Recipient: {err}"),
+                    format!("malformed Recipient: {:?}", err),
                ))
            }
        };

-        Ok(ServerResponse::SelfAddress(Box::new(recipient)))
-    }
-
-    // LANE_QUEUE_LENGTH_RESPONSE_TAG || lane || queue_length
-    fn serialize_lane_queue_length(lane: u64, queue_length: usize) -> Vec<u8> {
-        std::iter::once(ServerResponseTag::LaneQueueLength as u8)
-            .chain(lane.to_be_bytes().iter().cloned())
-            .chain(queue_length.to_be_bytes().iter().cloned())
-            .collect()
-    }
-
-    // LANE_QUEUE_LENGTH_RESPONSE_TAG || lane || queue_length
-    fn deserialize_lane_queue_length(b: &[u8]) -> Result<Self, error::Error> {
-        // this MUST match because it was called by 'deserialize'
-        debug_assert_eq!(b[0], ServerResponseTag::LaneQueueLength as u8);
-
-        let mut lane_bytes = [0u8; size_of::<u64>()];
-        lane_bytes.copy_from_slice(&b[1..=size_of::<u64>()]);
-        let lane = u64::from_be_bytes(lane_bytes);
-
-        let mut queue_length_bytes = [0u8; size_of::<usize>()];
-        queue_length_bytes
-            .copy_from_slice(&b[1 + size_of::<u64>()..1 + size_of::<u64>() + size_of::<usize>()]);
-        let queue_length = usize::from_be_bytes(queue_length_bytes);
-
-        Ok(ServerResponse::LaneQueueLength { lane, queue_length })
+        Ok(ServerResponse::SelfAddress(recipient))
    }

    // ERROR_RESPONSE_TAG || err_code || msg_len || msg
    fn serialize_error(error: error::Error) -> Vec<u8> {
        let message_len_bytes = (error.message.len() as u64).to_be_bytes();
-        std::iter::once(ServerResponseTag::Error as u8)
+        std::iter::once(ERROR_RESPONSE_TAG)
            .chain(std::iter::once(error.kind as u8))
-            .chain(message_len_bytes.into_iter())
+            .chain(message_len_bytes.iter().cloned())
            .chain(error.message.into_bytes().into_iter())
            .collect()
    }
@@ -219,7 +206,7 @@ impl ServerResponse {
    // ERROR_RESPONSE_TAG || err_code || msg_len || msg
    fn deserialize_error(b: &[u8]) -> Result<Self, error::Error> {
        // this MUST match because it was called by 'deserialize'
-        debug_assert_eq!(b[0], ServerResponseTag::Error as u8);
+        debug_assert_eq!(b[0], ERROR_RESPONSE_TAG);

        if b.len() < size_of::<u8>() + size_of::<u64>() {
            return Err(error::Error::new(
@@ -228,7 +215,26 @@ impl ServerResponse {
            ));
        }

-        let error_kind = ErrorKind::try_from(b[1])?;
+        let error_kind = match b[1] {
+            _ if b[1] == (ErrorKind::EmptyRequest as u8) => ErrorKind::EmptyRequest,
+            _ if b[1] == (ErrorKind::TooShortRequest as u8) => ErrorKind::TooShortRequest,
+            _ if b[1] == (ErrorKind::UnknownRequest as u8) => ErrorKind::UnknownRequest,
+            _ if b[1] == (ErrorKind::MalformedRequest as u8) => ErrorKind::MalformedRequest,
+
+            _ if b[1] == (ErrorKind::EmptyResponse as u8) => ErrorKind::EmptyResponse,
+            _ if b[1] == (ErrorKind::TooShortResponse as u8) => ErrorKind::TooShortResponse,
+            _ if b[1] == (ErrorKind::UnknownResponse as u8) => ErrorKind::UnknownResponse,
+            _ if b[1] == (ErrorKind::MalformedResponse as u8) => ErrorKind::MalformedResponse,
+
+            _ if b[1] == (ErrorKind::Other as u8) => ErrorKind::Other,
+
+            n => {
+                return Err(error::Error::new(
+                    ErrorKind::MalformedResponse,
+                    format!("invalid error code {}", n),
+                ))
+            }
+        };

        let message_len =
            u64::from_be_bytes(b[2..2 + size_of::<u64>()].as_ref().try_into().unwrap());
@@ -249,7 +255,7 @@ impl ServerResponse {
            Err(err) => {
                return Err(error::Error::new(
                    ErrorKind::MalformedResponse,
-                    format!("malformed error message: {err}"),
+                    format!("malformed error message: {:?}", err),
                ))
            }
        };
@@ -265,10 +271,7 @@ impl ServerResponse {
            ServerResponse::Received(reconstructed_message) => {
                Self::serialize_received(reconstructed_message)
            }
-            ServerResponse::SelfAddress(address) => Self::serialize_self_address(*address),
-            ServerResponse::LaneQueueLength { lane, queue_length } => {
-                Self::serialize_lane_queue_length(lane, queue_length)
-            }
+            ServerResponse::SelfAddress(address) => Self::serialize_self_address(address),
            ServerResponse::Error(err) => Self::serialize_error(err),
        }
    }
@@ -293,14 +296,17 @@ impl ServerResponse {
            ));
        }

-        let response_tag = ServerResponseTag::try_from(b[0])?;
+        let response_tag = b[0];

        // determine what kind of response that is and try to deserialize it
        match response_tag {
-            ServerResponseTag::Received => Self::deserialize_received(b),
-            ServerResponseTag::SelfAddress => Self::deserialize_self_address(b),
-            ServerResponseTag::LaneQueueLength => Self::deserialize_lane_queue_length(b),
-            ServerResponseTag::Error => Self::deserialize_error(b),
+            RECEIVED_RESPONSE_TAG => Self::deserialize_received(b),
+            SELF_ADDRESS_RESPONSE_TAG => Self::deserialize_self_address(b),
+            ERROR_RESPONSE_TAG => Self::deserialize_error(b),
+            n => Err(error::Error::new(
+                ErrorKind::UnknownResponse,
+                format!("type {}", n),
+            )),
        }
    }

@@ -322,33 +328,35 @@ mod tests {

    #[test]
    fn received_response_serialization_works() {
-        let received_with_sender_tag = ServerResponse::Received(ReconstructedMessage {
+        let reply_surb_string = "CjfVbHbfAjbC3W1BvNHGXmM8KNAnDNYGaHMLqVDxRYeo352csAihstup9bvqXam4dTWgfHak6KYwL9STaxWJ47E8XFZbSEvs7hEsfCkxr6K9WJuSBPK84GDDEvad8ZAuMCoaXsAd5S2Lj9a5eYyzG4SL1jHzhSMni55LyJwumxo1ZTGZNXggxw1RREosvyzNrW9Rsi3owyPqLCwXpiei2tHZty8w8midVvg8vDa7ZEJD842CLv8D4ohynSG7gDpqTrhkRaqYAuz7dzqNbMXLJRM7v823Jn16fA1L7YQxmcaUdUigyRSgTdb4i9ebiLGSyJ1iDe6Acz613PQZh6Ua3bZ2zVKq3dSycpDm9ngarRK4zJrAaUxRkdih8YzW3BY4nL9eqkfKA4N1TWCLaRU7zpSaf8yMEwrAZReU3d5zLV8c5KBfa2w8R5anhQeBojduZEGEad8kkHuKU52Zg93FeWHvH1qgZaEJMHH4nN7gKXz9mvWDhYwyF4vt3Uy2NhCHC3N5pL1gMme27YcoPcTEia1fxKZtnt6rtEozzTrAgCJGswigkFbkafiV5QaJwLKTUxtzhkZ57eEuLPte9UvJHzhhXUQ2CV7R2BUkJjYZy3Zsx6YYvdYWiAFFkWUwNEGA4QpShUHciBfsQVHQ7pN41YcyYUhbywQDFnTVgEmdUZ1XCBi3gyK5U3tDQmFzP1u9m3mWrUA8qB9mRDE7ptNDm5c3c1458L6uXLUth7sdMaa1Was5LCmCdmNDtvNpCDAEt1in6q6mrZFR85aCSU9b1baNGwZoCqPpPvydkVe63gXWoi8ebvdyxARrqACFrSB3ZdY3uJBw8CTMNkKK6MvcefMkSVVsbLd36TQAtYSCqrpiMc5dQuKcEu5QfciwvWYXYx8WFNAgKwP2mv49KCTvfozNDUCbjzDwSx92Zv5zjG8HbFpB13bY9UZGeyTPvv7gGxCzjGjJGbW6FRAheRQaaje5fUgCNM95Tv7wBmAMRHHFgWafeK1sdFH7dtCX9u898HucGTaboSKLsVh8J78gbbkHErwjMh7y9YRkceq5TTYS5da4kHnyNKYWSbxgZrmFg44XGKoeYcqoHB3XTZrdsf7F5fFeNwnihkmADvhAcaxXUmVqq4rQFZH84a1iC3WBWXYcqiZH2L7ujGWV7mMDT4HBEerDYjc8rNY4xGTPfivCrBCJW1i14aqW8xRdsdgTM88eTksvC3WPJLJ7iMzfKXeL7fMW1Ek6QGyQtLBW98vEESpdcDg6DeZ5rMz6VqjTGGqcCaFGfHoqtfxMDaBAEsyQ8h7XDX6dg1wq9wH6j4Tw7Tj1MEv1b8uj5NJkozZdzVdYA2QyE2Dp8vuurQG6uVdTDNww2d88RBQ8sVgjxN8gR45y4woJLhFAaNTAtrY6wDTxyXST13ni6oyqdYxjFVk9Am4v3DzH7Y2K8iRVSHfTk4FRbPULyaeK6wt2anvMJH1XdvVRgc14h67MnBxMgMD1UFk8AErN7CDj26fppe3c5G6KozJe4cSqQUGbBjVzBnrHCruqrfZBn5hNZHTV37bQiomqhRQXohxhuKEnNrGbAe1xNvJr9X";
+
+        let received_with_surb = ServerResponse::Received(ReconstructedMessage {
            message: b"foomp".to_vec(),
-            sender_tag: Some([42u8; SENDER_TAG_SIZE].into()),
+            reply_surb: Some(ReplySurb::from_base58_string(reply_surb_string).unwrap()),
        });
-        let bytes = received_with_sender_tag.serialize();
+        let bytes = received_with_surb.serialize();
        let recovered = ServerResponse::deserialize(&bytes).unwrap();
        match recovered {
            ServerResponse::Received(reconstructed) => {
                assert_eq!(reconstructed.message, b"foomp".to_vec());
                assert_eq!(
-                    reconstructed.sender_tag,
-                    Some([42u8; SENDER_TAG_SIZE].into())
+                    reconstructed.reply_surb.unwrap().to_base58_string(),
+                    reply_surb_string
                )
            }
            _ => unreachable!(),
        }

-        let received_without_sender_tag = ServerResponse::Received(ReconstructedMessage {
+        let received_without_surb = ServerResponse::Received(ReconstructedMessage {
            message: b"foomp".to_vec(),
-            sender_tag: None,
+            reply_surb: None,
        });
-        let bytes = received_without_sender_tag.serialize();
+        let bytes = received_without_surb.serialize();
        let recovered = ServerResponse::deserialize(&bytes).unwrap();
        match recovered {
            ServerResponse::Received(reconstructed) => {
                assert_eq!(reconstructed.message, b"foomp".to_vec());
-                assert!(reconstructed.sender_tag.is_none())
+                assert!(reconstructed.reply_surb.is_none())
            }
            _ => unreachable!(),
        }
@@ -359,7 +367,7 @@ mod tests {
        let recipient = Recipient::try_from_base58_string("CytBseW6yFXUMzz4SGAKdNLGR7q3sJLLYxyBGvutNEQV.4QXYyEVc5fUDjmmi8PrHN9tdUFV4PCvSJE1278cHyvoe@4sBbL1ngf1vtNqykydQKTFh26sQCw888GpUqvPvyNB4f").unwrap();
        let recipient_string = recipient.to_string();

-        let self_address_response = ServerResponse::SelfAddress(Box::new(recipient));
+        let self_address_response = ServerResponse::SelfAddress(recipient);
        let bytes = self_address_response.serialize();
        let recovered = ServerResponse::deserialize(&bytes).unwrap();
        match recovered {
@@ -370,23 +378,6 @@ mod tests {
        }
    }

-    #[test]
-    fn lane_queue_length_response_serialization_works() {
-        let lane_queue_length_response = ServerResponse::LaneQueueLength {
-            lane: 13,
-            queue_length: 42,
-        };
-        let bytes = lane_queue_length_response.serialize();
-        let recovered = ServerResponse::deserialize(&bytes).unwrap();
-        match recovered {
-            ServerResponse::LaneQueueLength { lane, queue_length } => {
-                assert_eq!(lane, 13);
-                assert_eq!(queue_length, 42)
-            }
-            _ => unreachable!(),
-        }
-    }
-
    #[test]
    fn error_response_serialization_works() {
        let dummy_error = error::Error::new(ErrorKind::UnknownRequest, "foomp message".to_string());
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Mark Sinclair	f9061f218c	Fix up webpack config so correct chunks get injected into entry points and remove inline CSS causing CSP issue	2022-09-14 19:32:12 +01:00
Jon Häggblad	739a4f4f1a	Since menu bar visible by default, change feature flag name	2022-09-14 14:49:33 +02:00
Jon Häggblad	f0fec05ccb	Remove redundant level from tauri log msg	2022-09-14 14:38:07 +02:00
Jon Häggblad	8c47afb21e	Add color to output, even if tauri hides it	2022-09-14 14:38:07 +02:00
Mark Sinclair	fccbe16b2a	Remove old code	2022-09-14 12:37:10 +01:00
Mark Sinclair	908bf42993	Improve log viewer	2022-09-14 12:25:32 +01:00
Mark Sinclair	77d3886a45	Remove old code	2022-09-14 12:25:21 +01:00
Mark Sinclair	6991f9cb11	Fix up imports	2022-09-14 11:21:44 +01:00
Jon Häggblad	32f4d6a7cb	Add changelog note	2022-09-14 11:43:29 +02:00
Jon Häggblad	aeecda31d7	rustfmt	2022-09-14 11:30:12 +02:00
Jon Häggblad	68097d4121	Remove unused deps	2022-09-14 11:24:07 +02:00
Jon Häggblad	c3e55bb03e	Put new menubar and log behind env variable flag	2022-09-14 11:19:07 +02:00
Jon Häggblad	af4c13e165	Fix format inside debug with ferm	2022-09-14 11:19:07 +02:00
Jon Häggblad	a7b133d72b	Proof of concept	2022-09-14 11:19:07 +02:00
Mark Sinclair	991c0392f9	wip	2022-09-14 11:19:05 +02:00
Mark Sinclair	71dd3cdddd	Upgrade tauri and use default tauri app menu for MacOS and add `Help` menu with `Show log` entry to show the logging window	2022-09-14 11:13:40 +02:00
Mark Sinclair	81d560cf91	LogViewer react component	2022-09-14 11:13:40 +02:00
Mark Sinclair	caef42067c	tauri operations to show a log window	2022-09-14 11:13:38 +02:00
Mark Sinclair	353c859e22	Add a second entry point to the webpack config for the logging window	2022-09-14 11:12:05 +02:00