Add gossip to mixnodes

2023-03-17 11:49:52 +01:00
1059 changed files with 45543 additions and 54100 deletions
@@ -11,25 +11,30 @@
 # In each subsection folders are ordered first by depth, then alphabetically.
 # This should make it easy to add new rules without breaking existing ones.

-# contracts
-/contracts/mixnet @durch @jstuczyn
-/contracts/vesting @durch @jstuczyn
-/contracts/service-provider-directory @octol
+# Something weird not covered by anything else
+* @futurechimp @mmsinclair

-# crypto code
-/common/crypto/ @jstuczyn
-/common/nymcoconut/ @jstuczyn
-/common/dkg/ @jstuczyn
-/common/nymsphinx/ @jstuczyn
+# Rust rules:
+*.rs @durch @futurechimp @jstuczyn @neacsu @octol
+Cargo.* @durch @futurechimp @jstuczyn @neacsu @octol

-# rust sdk
-/sdk/rust/ @octol
+# JS rules:
+*.js @mmsinclair @fmtabbara
+*.ts @mmsinclair @fmtabbara
+*.tsx @mmsinclair @fmtabbara
+*.jsx @mmsinclair @fmtabbara

-# nym-connect (rust)
-/nym-connect/desktop/src-tauri/ @octol
+# Something looking like possible documentation rules:
+*.md @mfahampshire

-# nym-wallet (rust)
-/nym-wallet/src-tauri/ @octol
+# our docker scripts
+/docker/ @neacsu

-# documentation
-/documentation @mfahampshire
+# if there are any changes in the core crypto, I feel like Ania should take a look:
+/common/crypto/ @aniampio
+/common/nymsphinx/ @aniampio
+
+# Explorer and wallet should probably get looked by the product team
+/explorer/ @nymtech/product 
+/nym-wallet/ @nymtech/product 
+/wallet-web/ @nymtech/product
@@ -1,16 +0,0 @@
-# To get started with Dependabot version updates, you'll need to specify which
-# package ecosystems to update and where the package manifests are located.
-# Please see the documentation for all configuration options:
-# https://help.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
-
-version: 2
-updates:
-  # Maintain dependencies for GitHub Actions
-  - package-ecosystem: "github-actions"
-    directory: "/"
-    schedule:
-      interval: "daily"
-    commit-message:
-        prefix: build
-        prefix-development: chore
-        include: scope
@@ -80,7 +80,7 @@ jobs:
          components: rustfmt, clippy

      - name: Install wasm-opt
-        run: cargo install --version 0.112.0 wasm-opt
+        run: cargo install wasm-opt

      - name: Build release contracts
        run: make wasm
@@ -98,15 +98,10 @@ jobs:
          cp target/release/nym-network-requester $OUTPUT_DIR
          cp target/release/nym-network-statistics $OUTPUT_DIR
          cp target/release/nym-cli $OUTPUT_DIR
-          cp target/release/nym-credential-client $OUTPUT_DIR
-          cp target/release/explorer-api $OUTPUT_DIR
+          cp target/release/credential $OUTPUT_DIR
          
          cp contracts/target/wasm32-unknown-unknown/release/mixnet_contract.wasm $OUTPUT_DIR
          cp contracts/target/wasm32-unknown-unknown/release/vesting_contract.wasm $OUTPUT_DIR
-          cp contracts/target/wasm32-unknown-unknown/release/nym_coconut_bandwidth.wasm $OUTPUT_DIR
-          cp contracts/target/wasm32-unknown-unknown/release/nym_coconut_dkg.wasm $OUTPUT_DIR
-          cp contracts/target/wasm32-unknown-unknown/release/cw3_flex_multisig.wasm $OUTPUT_DIR
-          cp contracts/target/wasm32-unknown-unknown/release/cw4_group.wasm $OUTPUT_DIR

      - name: Deploy branch to CI www
        continue-on-error: true
@@ -1,76 +0,0 @@
-name: CD dev-portal
-
-on:
-  push:
-    branches: master
-    paths:
-      - 'documentation/dev-portal/**'
-
-jobs:
-  build:
-    runs-on: custom-runner-linux
-    steps:
-      - uses: actions/checkout@v3
-      - name: Install rsync
-        run: sudo apt-get install rsync
-      - uses: rlespinasse/github-slug-action@v3.x
-      - uses: actions/setup-node@v3
-        with:
-          node-version: "16"
-      - name: Install Rust stable
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-      - name: Install mdbook
-        run: (test -x $HOME/.cargo/bin/mdbook || cargo install --vers "^0.4" mdbook)
-      - name: Install mdbook plugins
-        run: |
-          cargo install --vers "^0.2.0" mdbook-variables && cargo install \
-            --vers "^1.8.0" mdbook-admonish && cargo install --vers \
-            "^0.1.2" mdbook-last-changed && cargo install --vers "^0.1.2" \
-            mdbook-theme && cargo install --vers "^0.7.7" mdbook-linkcheck
-      - name: Clean website
-        run: cd documentation/dev-portal && mdbook clean
-      - name: Build website
-        run: cd documentation/dev-portal && mdbook build
-      - name: Deploy branch master to dev
-        continue-on-error: true
-        uses: easingthemes/ssh-deploy@main
-        env:
-          SSH_PRIVATE_KEY: ${{ secrets.CD_WWW_SSH_PRIVATE_KEY }}
-          ARGS: "-rltgoDzvO --delete"
-          SOURCE: "documentation/dev-portal/book/html/"
-          REMOTE_HOST: ${{ secrets.CD_WWW_REMOTE_HOST_DEV }}
-          REMOTE_USER: ${{ secrets.CD_WWW_REMOTE_USER }}
-          TARGET: ${{ secrets.CD_WWW_REMOTE_TARGET_DEVP }}/
-          EXCLUDE: "/dist/, /node_modules/"
-      - name: Deploy branch master to prod
-        uses: easingthemes/ssh-deploy@main
-        env:
-          SSH_PRIVATE_KEY: ${{ secrets.CD_WWW_SSH_PRIVATE_KEY }}
-          ARGS: "-rltgoDzvO --delete"
-          SOURCE: "documentation/dev-portal/book/html/"
-          REMOTE_HOST: ${{ secrets.CD_WWW_REMOTE_HOST_PROD }}
-          REMOTE_USER: ${{ secrets.CD_WWW_REMOTE_USER }}
-          TARGET: ${{ secrets.CD_WWW_REMOTE_TARGET_DEVP }}/
-          EXCLUDE: "/dist/, /node_modules/"
-      - name: Matrix - Node Install
-        run: npm install
-        working-directory: .github/workflows/support-files
-      - name: Matrix - Send Notification
-        env:
-          NYM_NOTIFICATION_KIND: cd-dev
-          NYM_PROJECT_NAME: "Dev portal CD"
-          NYM_CI_WWW_BASE: "${{ secrets.NYM_CD_WWW_BASE }}"
-          NYM_CI_WWW_LOCATION: "${{ env.GITHUB_REF_SLUG }}"
-          GIT_COMMIT_MESSAGE: "${{ github.event.head_commit.message }}"
-          GIT_BRANCH: "${GITHUB_REF##*/}"
-          MATRIX_SERVER: "${{ secrets.MATRIX_SERVER }}"
-          MATRIX_ROOM: "${{ secrets.MATRIX_ROOM_DEVP }}"
-          MATRIX_USER_ID: "${{ secrets.MATRIX_USER_ID }}"
-          MATRIX_TOKEN: "${{ secrets.MATRIX_TOKEN }}"
-          MATRIX_DEVICE_ID: "${{ secrets.MATRIX_DEVICE_ID }}"
-          IS_SUCCESS: "${{ job.status == 'success' }}"
-        uses: docker://keybaseio/client:stable-node
-        with:
-          args: .github/workflows/support-files/notifications/entry_point.sh
@@ -1,82 +0,0 @@
-name: CD docs
-
-on:
-  push:
-    branches: master
-    paths:
-      - 'documentation/docs/**'
-
-jobs:
-  build:
-    runs-on: custom-runner-linux
-    steps:
-      - uses: actions/checkout@v3
-      - name: Install rsync
-        run: sudo apt-get install rsync
-      - uses: rlespinasse/github-slug-action@v3.x
-      - uses: actions/setup-node@v3
-        with:
-          node-version: "16"
-      - name: Install Rust stable
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-      - name: Build all binaries
-        uses: actions-rs/cargo@v1
-        with:
-          command: build
-          args: --workspace --release --all
-      - name: Install mdbook
-        run: (test -x $HOME/.cargo/bin/mdbook || cargo install --vers "^0.4" mdbook)
-      - name: Install mdbook plugins
-        run: |
-          cargo install --vers "^0.2.0" mdbook-variables && cargo install \
-            --vers "^1.8.0" mdbook-admonish && cargo install --vers \
-            "^0.1.2" mdbook-last-changed && cargo install --vers "^0.1.2" \
-            mdbook-theme && cargo install --vers "^0.7.7" mdbook-linkcheck && \
-            cargo install --vers "^0.5.0" mdbook-cmdrun
-      - name: Clean website
-        run: cd documentation/docs && mdbook clean
-      - name: Build website
-        run: cd documentation/docs && mdbook build
-      - name: Deploy branch master to dev
-        continue-on-error: true
-        uses: easingthemes/ssh-deploy@main
-        env:
-          SSH_PRIVATE_KEY: ${{ secrets.CD_WWW_SSH_PRIVATE_KEY }}
-          ARGS: "-rltgoDzvO --delete"
-          SOURCE: "documentation/docs/book/"
-          REMOTE_HOST: ${{ secrets.CD_WWW_REMOTE_HOST_DEV }}
-          REMOTE_USER: ${{ secrets.CD_WWW_REMOTE_USER }}
-          TARGET: ${{ secrets.CD_WWW_REMOTE_TARGET }}/
-          EXCLUDE: "/dist/, /node_modules/"
-      - name: Deploy branch master to prod
-        uses: easingthemes/ssh-deploy@main
-        env:
-          SSH_PRIVATE_KEY: ${{ secrets.CD_WWW_SSH_PRIVATE_KEY }}
-          ARGS: "-rltgoDzvO --delete"
-          SOURCE: "documentation/docs/book/"
-          REMOTE_HOST: ${{ secrets.CD_WWW_REMOTE_HOST_PROD }}
-          REMOTE_USER: ${{ secrets.CD_WWW_REMOTE_USER }}
-          TARGET: ${{ secrets.CD_WWW_REMOTE_TARGET }}/
-          EXCLUDE: "/dist/, /node_modules/"
-      - name: Matrix - Node Install
-        run: npm install
-        working-directory: .github/workflows/support-files
-      - name: Matrix - Send Notification
-        env:
-          NYM_NOTIFICATION_KIND: cd-docs
-          NYM_PROJECT_NAME: "Docs CD"
-          NYM_CI_WWW_BASE: "${{ secrets.NYM_CD_WWW_BASE }}"
-          NYM_CI_WWW_LOCATION: "${{ env.GITHUB_REF_SLUG }}"
-          GIT_COMMIT_MESSAGE: "${{ github.event.head_commit.message }}"
-          GIT_BRANCH: "${GITHUB_REF##*/}"
-          MATRIX_SERVER: "${{ secrets.MATRIX_SERVER }}"
-          MATRIX_ROOM: "${{ secrets.MATRIX_ROOM_DOCS }}"
-          MATRIX_USER_ID: "${{ secrets.MATRIX_USER_ID }}"
-          MATRIX_TOKEN: "${{ secrets.MATRIX_TOKEN }}"
-          MATRIX_DEVICE_ID: "${{ secrets.MATRIX_DEVICE_ID }}"
-          IS_SUCCESS: "${{ job.status == 'success' }}"
-        uses: docker://keybaseio/client:stable-node
-        with:
-          args: .github/workflows/support-files/notifications/entry_point.sh
@@ -1,66 +0,0 @@
-name: CI dev-portal
-
-on:
-  push:
-    branches-ignore: master
-    paths:
-      - 'documentation/dev-portal/**'
-
-jobs:
-  build:
-    runs-on: custom-runner-linux
-    steps:
-      - uses: actions/checkout@v3
-      - name: Install rsync
-        run: sudo apt-get install rsync
-      - uses: rlespinasse/github-slug-action@v3.x
-      - uses: actions/setup-node@v3
-        with:
-          node-version: "16"
-      - name: Install Rust stable
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-      - name: Install mdbook
-        run: (test -x $HOME/.cargo/bin/mdbook || cargo install --vers "^0.4" mdbook)
-      - name: Install mdbook plugins
-        run: |
-          cargo install --vers "^0.2.0" mdbook-variables && cargo install \
-            --vers "^1.8.0" mdbook-admonish && cargo install --vers \
-            "^0.1.2" mdbook-last-changed && cargo install --vers "^0.1.2" mdbook-theme \
-            && cargo install --vers "^0.7.7" mdbook-linkcheck 
-      - name: Clean website
-        run: cd documentation/dev-portal && mdbook clean
-      - name: Build website
-        run: cd documentation/dev-portal && mdbook build
-      - name: Deploy branch to CI www
-        continue-on-error: true
-        uses: easingthemes/ssh-deploy@main
-        env:
-          SSH_PRIVATE_KEY: ${{ secrets.CI_WWW_SSH_PRIVATE_KEY }}
-          ARGS: "-rltgoDzvO --delete"
-          SOURCE: "documentation/dev-portal/book/html/"
-          REMOTE_HOST: ${{ secrets.CI_WWW_REMOTE_HOST }}
-          REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
-          TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/dev-portal-${{ env.GITHUB_REF_SLUG }}
-          EXCLUDE: "/dist/, /node_modules/"
-      - name: Matrix - Node Install
-        run: npm install
-        working-directory: .github/workflows/support-files
-      - name: Matrix - Send Notification
-        env:
-          NYM_NOTIFICATION_KIND: ci-dev
-          NYM_PROJECT_NAME: "Dev portal CI"
-          NYM_CI_WWW_BASE: "${{ secrets.NYM_CI_WWW_BASE }}"
-          NYM_CI_WWW_LOCATION: "dev-portal-${{ env.GITHUB_REF_SLUG }}"
-          GIT_COMMIT_MESSAGE: "${{ github.event.head_commit.message }}"
-          GIT_BRANCH: "${GITHUB_REF##*/}"
-          MATRIX_SERVER: "${{ secrets.MATRIX_SERVER }}"
-          MATRIX_ROOM: "${{ secrets.MATRIX_ROOM_DEVP }}"
-          MATRIX_USER_ID: "${{ secrets.MATRIX_USER_ID }}"
-          MATRIX_TOKEN: "${{ secrets.MATRIX_TOKEN }}"
-          MATRIX_DEVICE_ID: "${{ secrets.MATRIX_DEVICE_ID }}"
-          IS_SUCCESS: "${{ job.status == 'success' }}"
-        uses: docker://keybaseio/client:stable-node
-        with:
-          args: .github/workflows/support-files/notifications/entry_point.sh
@@ -1,72 +0,0 @@
-name: CI docs
-
-on:
-  push:
-    branches-ignore: master
-    paths:
-      - 'documentation/docs/**'
-
-jobs:
-  build:
-    runs-on: custom-runner-linux
-    steps:
-      - uses: actions/checkout@v3
-      - name: Install rsync
-        run: sudo apt-get install rsync
-      - uses: rlespinasse/github-slug-action@v3.x
-      - uses: actions/setup-node@v3
-        with:
-          node-version: "16"
-      - name: Install Rust stable
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-      - name: Build all binaries
-        uses: actions-rs/cargo@v1
-        with:
-          command: build
-          args: --workspace --release --all
-      - name: Install mdbook
-        run: (test -x $HOME/.cargo/bin/mdbook || cargo install --vers "^0.4" mdbook)
-      - name: Install mdbook plugins
-        run: |
-          cargo install --vers "^0.2.0" mdbook-variables && cargo install \
-            --vers "^1.8.0" mdbook-admonish && cargo install --vers \
-            "^0.1.2" mdbook-last-changed && cargo install --vers "^0.1.2" \
-            mdbook-theme && cargo install --vers "^0.7.7" mdbook-linkcheck && \
-            cargo install --vers "^0.5.0" mdbook-cmdrun
-      - name: Clean website
-        run: cd documentation/docs && mdbook clean
-      - name: Build website
-        run: cd documentation/docs && mdbook build
-      - name: Deploy branch to CI www
-        continue-on-error: true
-        uses: easingthemes/ssh-deploy@main
-        env:
-          SSH_PRIVATE_KEY: ${{ secrets.CI_WWW_SSH_PRIVATE_KEY }}
-          ARGS: "-rltgoDzvO --delete"
-          SOURCE: "documentation/docs/book/"
-          REMOTE_HOST: ${{ secrets.CI_WWW_REMOTE_HOST }}
-          REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
-          TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/docs-${{ env.GITHUB_REF_SLUG }}
-          EXCLUDE: "/dist/, /node_modules/"
-      - name: Matrix - Node Install
-        run: npm install
-        working-directory: .github/workflows/support-files
-      - name: Matrix - Send Notification
-        env:
-          NYM_NOTIFICATION_KIND: ci-docs
-          NYM_PROJECT_NAME: "Docs CI"
-          NYM_CI_WWW_BASE: "${{ secrets.NYM_CI_WWW_BASE }}"
-          NYM_CI_WWW_LOCATION: "docs-${{ env.GITHUB_REF_SLUG }}"
-          GIT_COMMIT_MESSAGE: "${{ github.event.head_commit.message }}"
-          GIT_BRANCH: "${GITHUB_REF##*/}"
-          MATRIX_SERVER: "${{ secrets.MATRIX_SERVER }}"
-          MATRIX_ROOM: "${{ secrets.MATRIX_ROOM_DOCS }}"
-          MATRIX_USER_ID: "${{ secrets.MATRIX_USER_ID }}"
-          MATRIX_TOKEN: "${{ secrets.MATRIX_TOKEN }}"
-          MATRIX_DEVICE_ID: "${{ secrets.MATRIX_DEVICE_ID }}"
-          IS_SUCCESS: "${{ job.status == 'success' }}"
-        uses: docker://keybaseio/client:stable-node
-        with:
-          args: .github/workflows/support-files/notifications/entry_point.sh
@@ -20,7 +20,7 @@ jobs:
          components: rustfmt, clippy

      - name: Install wasm-opt
-        run: cargo install --version 0.112.0 wasm-opt
+        run: cargo install wasm-opt

      - name: Build release contracts
        run: make wasm
@@ -30,7 +30,6 @@ jobs:
    continue-on-error: ${{ matrix.rust == 'nightly' }}
    needs: matrix_prep
    strategy:
-      fail-fast: false
      matrix: ${{fromJson(needs.matrix_prep.outputs.matrix)}}
    steps:
      - uses: actions/checkout@v2
@@ -64,4 +63,4 @@ jobs:
        if: ${{ matrix.rust != 'nightly' }}
        with:
          command: clippy
-          args: --manifest-path contracts/Cargo.toml --workspace --all-targets -- -D warnings
+          args: --manifest-path contracts/Cargo.toml --workspace -- -D warnings
@@ -1,13 +0,0 @@
-name: Greetings
-
-on: [pull_request_target, issues]
-
-jobs:
-  greeting:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/first-interaction@v1
-      with:
-        repo-token: ${{ secrets.GITHUB_TOKEN }}
-        issue-message: 'Thank you for raising this issue'
-        pr-message: 'Thank you for making this first PR'
@@ -6,7 +6,7 @@
  },

  {
-    "os":"windows10",
+    "os":"windows-latest",
    "rust":"stable",
    "runOnEvent":"schedule"
  },
@@ -22,7 +22,7 @@
    "runOnEvent":"schedule"
  },
  {
-    "os":"windows10",
+    "os":"windows-latest",
    "rust":"beta",
    "runOnEvent":"schedule"
  },
@@ -38,7 +38,7 @@
    "runOnEvent":"schedule"
  },
  {
-    "os":"windows10",
+    "os":"windows-latest",
    "rust":"nightly",
    "runOnEvent":"schedule"
  },
@@ -1,29 +0,0 @@
-const Handlebars = require('handlebars');
-const fs = require('fs');
-const path = require('path');
-
-async function addToContextAndValidate(context) {
-  if (!context.env.NYM_CI_WWW_LOCATION) {
-    throw new Error('Please ensure the env var NYM_CI_WWW_LOCATION is set');
-  }
-  if (!context.env.NYM_CI_WWW_BASE) {
-    throw new Error('Please ensure the env var NYM_CI_WWW_BASE is set');
-  }
-}
-
-async function getMessageBody(context) {
-  const source = fs
-    .readFileSync(
-      context.env.IS_SUCCESS === 'true'
-        ? path.resolve(__dirname, 'templates', 'success')
-        : path.resolve(__dirname, 'templates', 'failure'),
-    )
-    .toString();
-  const template = Handlebars.compile(source);
-  return template(context);
-}
-
-module.exports = {
-  addToContextAndValidate,
-  getMessageBody,
-};
@@ -1,17 +0,0 @@
-🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥
-> :rocket: {{ env.NYM_PROJECT_NAME }}
->
-> 🔴 **FAILURE** :cry:
->
-> `branch` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/tree/{{ env.GIT_BRANCH_NAME }}
->
-> `commit` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/commit/{{ env.GITHUB_SHA }}
->
-> `build ` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/actions/runs/{{ env.GITHUB_RUN_ID }}
->
-
-Commit message:
-
-```
-{{ env.GIT_COMMIT_MESSAGE }}
-```
@@ -1,17 +0,0 @@
-🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩
-> :rocket: {{ env.NYM_PROJECT_NAME }}  ➡️➡️➡️➡️➡️ **View output:** https://{{ env.NYM_CI_WWW_BASE }}/developers/
->
-> ✅ **SUCCESS**
->
-> `branch` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/tree/{{ env.GIT_BRANCH_NAME }}
->
-> `commit` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/commit/{{ env.GITHUB_SHA }}
->
-> `build ` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/actions/runs/{{ env.GITHUB_RUN_ID }}
->
-
-Commit message by `{{ env.GITHUB_ACTOR }}` at {{ timestamp }}:
-
-```
-{{ env.GIT_COMMIT_MESSAGE }}
-```
@@ -1,29 +0,0 @@
-const Handlebars = require('handlebars');
-const fs = require('fs');
-const path = require('path');
-
-async function addToContextAndValidate(context) {
-  if (!context.env.NYM_CI_WWW_LOCATION) {
-    throw new Error('Please ensure the env var NYM_CI_WWW_LOCATION is set');
-  }
-  if (!context.env.NYM_CI_WWW_BASE) {
-    throw new Error('Please ensure the env var NYM_CI_WWW_BASE is set');
-  }
-}
-
-async function getMessageBody(context) {
-  const source = fs
-    .readFileSync(
-      context.env.IS_SUCCESS === 'true'
-        ? path.resolve(__dirname, 'templates', 'success')
-        : path.resolve(__dirname, 'templates', 'failure'),
-    )
-    .toString();
-  const template = Handlebars.compile(source);
-  return template(context);
-}
-
-module.exports = {
-  addToContextAndValidate,
-  getMessageBody,
-};
@@ -1,11 +0,0 @@
-🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥
-> :rocket: {{ env.NYM_PROJECT_NAME }}
-> 🔴 **FAILURE** :cry:
-> `branch` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/tree/{{ env.GIT_BRANCH_NAME }}
-> `commit` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/commit/{{ env.GITHUB_SHA }}
-> `build ` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/actions/runs/{{ env.GITHUB_RUN_ID }}
-
-Commit message:
-```
-{{ env.GIT_COMMIT_MESSAGE }}
-```
@@ -1,17 +0,0 @@
-🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩
-> :rocket: {{ env.NYM_PROJECT_NAME }}  ➡️➡️➡️➡️➡️ **View output:** https://{{ env.NYM_CI_WWW_BASE }}/docs/
->
-> ✅ **SUCCESS**
->
-> `branch` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/tree/{{ env.GIT_BRANCH_NAME }}
->
-> `commit` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/commit/{{ env.GITHUB_SHA }}
->
-> `build ` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/actions/runs/{{ env.GITHUB_RUN_ID }}
->
-
-Commit message by `{{ env.GITHUB_ACTOR }}` at {{ timestamp }}:
-
-```
-{{ env.GIT_COMMIT_MESSAGE }}
-```
@@ -1,29 +0,0 @@
-const Handlebars = require('handlebars');
-const fs = require('fs');
-const path = require('path');
-
-async function addToContextAndValidate(context) {
-  if (!context.env.NYM_CI_WWW_LOCATION) {
-    throw new Error('Please ensure the env var NYM_CI_WWW_LOCATION is set');
-  }
-  if (!context.env.NYM_CI_WWW_BASE) {
-    throw new Error('Please ensure the env var NYM_CI_WWW_BASE is set');
-  }
-}
-
-async function getMessageBody(context) {
-  const source = fs
-    .readFileSync(
-      context.env.IS_SUCCESS === 'true'
-        ? path.resolve(__dirname, 'templates', 'success')
-        : path.resolve(__dirname, 'templates', 'failure'),
-    )
-    .toString();
-  const template = Handlebars.compile(source);
-  return template(context);
-}
-
-module.exports = {
-  addToContextAndValidate,
-  getMessageBody,
-};
@@ -1,17 +0,0 @@
-🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥
-> :rocket: {{ env.NYM_PROJECT_NAME }}
->
-> 🔴 **FAILURE** :cry:
->
-> `branch` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/tree/{{ env.GIT_BRANCH_NAME }}
->
-> `commit` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/commit/{{ env.GITHUB_SHA }}
->
-> `build ` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/actions/runs/{{ env.GITHUB_RUN_ID }}
->
-
-Commit message:
-
-```
-{{ env.GIT_COMMIT_MESSAGE }}
-```
@@ -1,17 +0,0 @@
-🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩
-> :rocket: {{ env.NYM_PROJECT_NAME }}  ➡️➡️➡️➡️➡️ **View output:** https://{{ env.NYM_CI_WWW_LOCATION }}.{{ env.NYM_CI_WWW_BASE }}/
->
-> ✅ **SUCCESS**
->
-> `branch` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/tree/{{ env.GIT_BRANCH_NAME }}
->
-> `commit` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/commit/{{ env.GITHUB_SHA }}
->
-> `build ` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/actions/runs/{{ env.GITHUB_RUN_ID }}
->
-
-Commit message by `{{ env.GITHUB_ACTOR }}` at {{ timestamp }}:
-
-```
-{{ env.GIT_COMMIT_MESSAGE }}
-```
@@ -1,29 +0,0 @@
-const Handlebars = require('handlebars');
-const fs = require('fs');
-const path = require('path');
-
-async function addToContextAndValidate(context) {
-  if (!context.env.NYM_CI_WWW_LOCATION) {
-    throw new Error('Please ensure the env var NYM_CI_WWW_LOCATION is set');
-  }
-  if (!context.env.NYM_CI_WWW_BASE) {
-    throw new Error('Please ensure the env var NYM_CI_WWW_BASE is set');
-  }
-}
-
-async function getMessageBody(context) {
-  const source = fs
-    .readFileSync(
-      context.env.IS_SUCCESS === 'true'
-        ? path.resolve(__dirname, 'templates', 'success')
-        : path.resolve(__dirname, 'templates', 'failure'),
-    )
-    .toString();
-  const template = Handlebars.compile(source);
-  return template(context);
-}
-
-module.exports = {
-  addToContextAndValidate,
-  getMessageBody,
-};
@@ -1,17 +0,0 @@
-🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥
-> :rocket: {{ env.NYM_PROJECT_NAME }}
->
-> 🔴 **FAILURE** :cry:
->
-> `branch` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/tree/{{ env.GIT_BRANCH_NAME }}
->
-> `commit` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/commit/{{ env.GITHUB_SHA }}
->
-> `build ` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/actions/runs/{{ env.GITHUB_RUN_ID }}
->
-
-Commit message:
-
-```
-{{ env.GIT_COMMIT_MESSAGE }}
-```
@@ -1,17 +0,0 @@
-🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩
-> :rocket: {{ env.NYM_PROJECT_NAME }}  ➡️➡️➡️➡️➡️ **View output:** https://{{ env.NYM_CI_WWW_LOCATION }}.{{ env.NYM_CI_WWW_BASE }}/
->
-> ✅ **SUCCESS**
->
-> `branch` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/tree/{{ env.GIT_BRANCH_NAME }}
->
-> `commit` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/commit/{{ env.GITHUB_SHA }}
->
-> `build ` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/actions/runs/{{ env.GITHUB_RUN_ID }}
->
-
-Commit message by `{{ env.GITHUB_ACTOR }}` at {{ timestamp }}:
-
-```
-{{ env.GIT_COMMIT_MESSAGE }}
-```
@@ -3,7 +3,7 @@ require('dotenv').config();
 const { sendMatrixMessage } = require('./send_message_to_matrix');

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

 /**
@@ -22,6 +22,6 @@
    "unified": "^9.2.2"
  },
  "devDependencies": {
-    "prettier": "^2.8.7"
+    "prettier": "2.3.2"
  }
 }
@@ -64,4 +64,4 @@ jobs:
        uses: actions-rs/cargo@v1
        with:
          command: clippy
-          args: --manifest-path nym-wallet/Cargo.toml --workspace --all-features --all-targets -- -D warnings
+          args: --manifest-path nym-wallet/Cargo.toml --workspace --all-features -- -D warnings
@@ -39,7 +39,7 @@ validator-api-config.toml
 dist
 storybook-static
 envs/qwerty.env
+Cargo.lock
+nym-connect/Cargo.lock
 .parcel-cache
 **/.DS_Store
-cpu-cycles/libcpucycles/build
-foxyfox.env
@@ -4,87 +4,6 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://

 ## [Unreleased]

-## [v1.1.16] (2023-04-25)
-
- Explorer - Fix sorting function on Stake Saturation. It is currently working per page and not globally ([#3320])
- Poisson process gets stuck at too slow rate. Rework to more aggressively up-regulate ([#3309])
- decrease the logging level of warnings associated with clients dropping packets due to gateway being overloaded (I'd say reduce it to debug/trace) - there are few sources of those, e.g. in real and cover traffic streams ([#3299])
- Make the buffer size in `AvailableReader` depend on packet sizes the client is using + introduce read timeouts ([#3213])
- Rust SDK - Support coconut, credential storage etc ([#2755])
- version bump for next release ([#3349])
- added coconut credential generation example ([#3339])
- update mix-node setup docs with node description ([#3325])
- exposed missing gateway commands in nym-cli ([#3324])
- make sure to clear inner 'ack_map' in 'GatewaysReader' ([#3300])
-
-[#3320]: https://github.com/nymtech/nym/issues/3320
-[#3309]: https://github.com/nymtech/nym/issues/3309
-[#3299]: https://github.com/nymtech/nym/issues/3299
-[#3213]: https://github.com/nymtech/nym/issues/3213
-[#2755]: https://github.com/nymtech/nym/issues/2755
-[#3349]: https://github.com/nymtech/nym/pull/3349
-[#3339]: https://github.com/nymtech/nym/pull/3339
-[#3325]: https://github.com/nymtech/nym/pull/3325
-[#3324]: https://github.com/nymtech/nym/pull/3324
-[#3300]: https://github.com/nymtech/nym/pull/3300
-
-## [v1.1.15] (2023-04-18)
-
- Fix verloc being stuck waiting for shutdown signal ([#3250])
- Introduce `--output json` flag to `sign` command to allow to more easily capture the output ([#3249])
- Explorer - Dont fetch Service Provider list on Testnet ([#3245])
- When determining active set, rather than weighting the nodes by just the `stake`, use `stake * performance` ([#3234])
- Introduce dual packet sizes to our clients (as in use two packet sizes at the same time depending on message size) ([#3189])
- Experiment with offline signing in our validator client ([#3174])
- Modify network requester binary to reload `allowed.list` periodically to pull in any changes made upstream without having to restart the service ([#3149])
- Standardise all `--output json` on binary inits, we pass the output json at different points for different binaries. ([#3080])
- Service provider directory contract: initial version ([#2759])
- Fix issue where network-requester run failed on fresh init due to missing allow file ([#3316])
-
-[#3250]: https://github.com/nymtech/nym/issues/3250
-[#3249]: https://github.com/nymtech/nym/issues/3249
-[#3245]: https://github.com/nymtech/nym/issues/3245
-[#3234]: https://github.com/nymtech/nym/issues/3234
-[#3189]: https://github.com/nymtech/nym/issues/3189
-[#3174]: https://github.com/nymtech/nym/issues/3174
-[#3149]: https://github.com/nymtech/nym/issues/3149
-[#3080]: https://github.com/nymtech/nym/issues/3080
-[#2759]: https://github.com/nymtech/nym/issues/2759
-[#3316]: https://github.com/nymtech/nym/pull/3316
-
-## [v1.1.14] (2023-04-04)
-
- Investigate cause of qwerty validator being in invalid rewarding state ([#3224])
- Fix NR config due to changes in #3199 ([#3223])
- [Issue] Mixnodes and gateway do not close connections properly  ([#3187])
- disable sign-ext when using wasm-opt + update wasm-opt ([#3203])
- chore: tidy up client `Debug` config section ([#3199])
-
-[#3224]: https://github.com/nymtech/nym/issues/3224
-[#3223]: https://github.com/nymtech/nym/issues/3223
-[#3187]: https://github.com/nymtech/nym/issues/3187
-[#3203]: https://github.com/nymtech/nym/pull/3203
-[#3199]: https://github.com/nymtech/nym/pull/3199
->>>>>>> master
-
-## [v1.1.13] (2023-03-15)
-
- NE - instead of throwing a "Mixnode/Gateway not found" error for blacklisted nodes due to bad performance, show their history but tag them as "Having poor performance" ([#2979])
- NE - Upgrade Sandbox and make below changes:  ([#2332])
- Explorer - Updates ([#3168])
- Website v2 - deploy infrastructure for strapi and CI ([#2213])
- add blockstream green to sp list ([#3180])
- mock-nym-api: fix .storybook lint error ([#3178])
- Validating new interval config parameters to prevent division by zero ([#3153])
-
-[#2979]: https://github.com/nymtech/nym/issues/2979
-[#2332]: https://github.com/nymtech/nym/issues/2332
-[#3168]: https://github.com/nymtech/nym/issues/3168
-[#2213]: https://github.com/nymtech/nym/issues/2213
-[#3180]: https://github.com/nymtech/nym/pull/3180
-[#3178]: https://github.com/nymtech/nym/pull/3178
-[#3153]: https://github.com/nymtech/nym/pull/3153
-
 ## [v1.1.12] (2023-03-07)

 - Fix generated docs for mixnet and vesting contract on docs.rs ([#3093])
@@ -17,14 +17,12 @@ opt-level = 3

 resolver = "2"
 members = [
+    "clients/client-core",
    "clients/credential",
    "clients/native",
    "clients/native/websocket-requests",
    "clients/socks5",
-    "common/async-file-watcher",
-    "common/bandwidth-controller",
    "common/bin-common",
-    "common/client-core",
    "common/client-libs/gateway-client",
    "common/client-libs/mixnet-client",
    "common/client-libs/validator-client",
@@ -37,8 +35,8 @@ members = [
    "common/cosmwasm-smart-contracts/group-contract",
    "common/cosmwasm-smart-contracts/mixnet-contract",
    "common/cosmwasm-smart-contracts/multisig-contract",
-    "common/cosmwasm-smart-contracts/service-provider-directory",
    "common/cosmwasm-smart-contracts/vesting-contract",
+    "common/mobile-storage",
    "common/credential-storage",
    "common/credentials",
    "common/crypto",
@@ -48,7 +46,6 @@ members = [
    "common/ledger",
    "common/mixnode-common",
    "common/network-defaults",
-    "common/node-tester-utils",
    "common/nonexhaustive-delayqueue",
    "common/nymcoconut",
    "common/nymsphinx",
@@ -62,7 +59,6 @@ members = [
    "common/nymsphinx/params",
    "common/nymsphinx/types",
    "common/pemstore",
-    "common/socks5-client-core",
    "common/socks5/proxy-helpers",
    "common/socks5/requests",
    "common/statistics",
@@ -97,7 +93,7 @@ default-members = [
    "explorer-api",
 ]

-exclude = ["explorer", "contracts", "clients/webassembly", "nym-wallet", "nym-connect/mobile/src-tauri", "nym-connect/desktop", "cpu-cycles"]
+exclude = ["explorer", "contracts", "clients/webassembly", "nym-wallet", "nym-connect/mobile/src-tauri", "nym-connect/desktop"]

 [workspace.package]
 authors = ["Nym Technologies SA"]
@@ -111,16 +107,6 @@ license = "Apache-2.0"
 async-trait = "0.1.64"
 bip39 = { version = "2.0.0", features = ["zeroize"] }
 cfg-if = "1.0.0"
-cosmwasm-derive = "=1.0.0"
-cosmwasm-schema = "=1.0.0"
-cosmwasm-std = "=1.0.0"
-cosmwasm-storage = "=1.0.0"
-cw-utils = "=0.13.4"
-cw-storage-plus = "=0.13.4"
-cw2 = { version = "=0.13.4" }
-cw3 = { version = "=0.13.4" }
-cw3-fixed-multisig = { version = "=0.13.4" }
-cw4 = { version = "=0.13.4" }
 dotenvy = "0.15.6"
 lazy_static = "1.4.0"
 log = "0.4"
@@ -1,120 +1,143 @@
-# Default target
-all: test
-
 test: clippy-all cargo-test wasm fmt
-
+test-no-mobile: clippy-all-no-mobile cargo-test-no-mobile wasm fmt-no-mobile
 test-all: test cargo-test-expensive
-
+test-all-no-mobile: test-no-mobile cargo-test-expensive
 no-clippy: build cargo-test wasm fmt
-
+no-clippy-no-mobile: build-no-mobile cargo-test-no-mobile wasm fmt-no-mobile
 happy: fmt clippy-happy test
+happy-no-mobile: fmt-no-mobile clippy-happy-no-mobile test-no-mobile
+clippy-all: clippy-all-no-mobile clippy-all-connect-mobile
+clippy-all-no-mobile: clippy-main clippy-main-examples clippy-all-contracts clippy-all-wallet clippy-all-connect clippy-all-wasm-client
+clippy-happy: clippy-happy-no-mobile clippy-happy-connect-mobile
+clippy-happy-no-mobile: clippy-happy-main clippy-happy-contracts clippy-happy-wallet clippy-happy-connect
+cargo-test: cargo-test-no-mobile test-connect-mobile
+cargo-test-no-mobile: 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-no-mobile build-connect-mobile 
+build-no-mobile: build-contracts build-wallet build-main build-main-examples build-connect build-wasm-client 
+fmt: fmt-no-mobile fmt-connect-mobile
+fmt-no-mobile: fmt-main fmt-contracts fmt-wallet fmt-connect fmt-wasm-client

-# Building release binaries is a little manual as we can't just build --release
-# on all workspaces.
-build-release: build-release-main wasm
+clippy-happy-main:
+	cargo clippy

-# Deprecated
-# For backwards compatibility
-clippy-all: clippy
+clippy-happy-contracts:
+	cargo clippy --manifest-path contracts/Cargo.toml --target wasm32-unknown-unknown

-# -----------------------------------------------------------------------------
-# Define targets for a given workspace
-#  $(1): name
-#  $(2): path to workspace
-#  $(3): extra arguments to cargo
-# -----------------------------------------------------------------------------
-define add_cargo_workspace
+clippy-happy-wallet:
+	cargo clippy --manifest-path nym-wallet/Cargo.toml

-clippy-happy-$(1):
-	cargo clippy --manifest-path $(2)/Cargo.toml $(3)
+clippy-happy-connect:
+	cargo clippy --manifest-path nym-connect/desktop/Cargo.toml

-clippy-$(1):
-	cargo clippy --manifest-path $(2)/Cargo.toml --workspace $(3) -- -D warnings
+clippy-happy-connect-mobile:
+	cargo clippy --manifest-path nym-connect/mobile/src-tauri/Cargo.toml

-clippy-examples-$(1):
-	cargo clippy --manifest-path $(2)/Cargo.toml --workspace --examples -- -D warnings
+clippy-main:
+	cargo clippy --workspace -- -D warnings

-check-$(1):
-	cargo check --manifest-path $(2)/Cargo.toml --workspace $(3)
+clippy-main-examples:
+	cargo clippy --workspace --examples -- -D warnings

-test-$(1):
-	cargo test --manifest-path $(2)/Cargo.toml --workspace
+clippy-wasm:
+	cargo clippy --manifest-path clients/webassembly/Cargo.toml --target wasm32-unknown-unknown --workspace -- -D warnings

-test-expensive-$(1):
-	cargo test --manifest-path $(2)/Cargo.toml --workspace -- --ignored

-build-$(1):
-	cargo build --manifest-path $(2)/Cargo.toml --workspace $(3)
+clippy-all-contracts:
+	cargo clippy --workspace --manifest-path contracts/Cargo.toml --all-features --target wasm32-unknown-unknown -- -D warnings

-build-examples-$(1):
-	cargo build --manifest-path $(2)/Cargo.toml --workspace --examples
+clippy-all-wallet:
+	cargo clippy --workspace --manifest-path nym-wallet/Cargo.toml --all-features -- -D warnings

-build-release-$(1):
-	cargo build --manifest-path $(2)/Cargo.toml --workspace --release $(3)
+clippy-all-connect:
+	cargo clippy --workspace --manifest-path nym-connect/desktop/Cargo.toml --all-features -- -D warnings

-fmt-$(1):
-	cargo fmt --manifest-path $(2)/Cargo.toml --all
+clippy-all-connect-mobile:
+	cargo clippy --workspace --manifest-path nym-connect/mobile/src-tauri/Cargo.toml --all-features -- -D warnings

-clippy-happy: clippy-happy-$(1)
-clippy: clippy-$(1) clippy-examples-$(1)
-check: check-$(1)
-cargo-test: test-$(1)
-cargo-test-expensive: test-expensive-$(1)
-build: build-$(1) build-examples-$(1)
-build-release-all: build-release-$(1)
-fmt: fmt-$(1)
+clippy-all-wasm-client:
+	cargo clippy --workspace --manifest-path clients/webassembly/Cargo.toml --all-features --target wasm32-unknown-unknown -- -D warnings

-endef
+test-main:
+	cargo test --workspace

-# -----------------------------------------------------------------------------
-# Rust workspaces
-# -----------------------------------------------------------------------------
+test-main-expensive:
+	cargo test --workspace -- --ignored

-# Generate targets for the various cargo workspaces
+test-contracts:
+	cargo test --manifest-path contracts/Cargo.toml --all-features

-$(eval $(call add_cargo_workspace,main,.))
-$(eval $(call add_cargo_workspace,contracts,contracts,--target wasm32-unknown-unknown))
-$(eval $(call add_cargo_workspace,wasm-client,clients/webassembly,--target wasm32-unknown-unknown))
-$(eval $(call add_cargo_workspace,wallet,nym-wallet,))
-$(eval $(call add_cargo_workspace,connect,nym-connect/desktop))
-ifdef NYM_MOBILE
-$(eval $(call add_cargo_workspace,connect-mobile,nym-connect/mobile/src-tauri))
-endif
+test-contracts-expensive:
+	cargo test --manifest-path contracts/Cargo.toml --all-features -- --ignored

-# -----------------------------------------------------------------------------
-# Convenience targets for crates that are already part of the main workspace
-# -----------------------------------------------------------------------------
+test-wallet:
+	cargo test --manifest-path nym-wallet/Cargo.toml --all-features
+
+test-wallet-expensive:
+	cargo test --manifest-path nym-wallet/Cargo.toml --all-features -- --ignored
+
+test-connect:
+	cargo test --manifest-path nym-connect/desktop/Cargo.toml --all-features
+
+test-connect-expensive:
+	cargo test --manifest-path nym-connect/desktop/Cargo.toml --all-features -- --ignored
+
+test-connect-mobile:
+	cargo test --manifest-path nym-connect/mobile/src-tauri/Cargo.toml --all-features
+
+test-connect-mobile-expensive:
+	cargo test --manifest-path nym-connect/mobile/src-tauri/Cargo.toml --all-features -- --ignored
+
+build-main:
+	cargo build --workspace
+
+build-main-examples:
+	cargo build --workspace --examples
+
+build-contracts:
+	cargo build --manifest-path contracts/Cargo.toml --workspace
+
+build-wallet:
+	cargo build --manifest-path nym-wallet/Cargo.toml --workspace
+
+build-connect:
+	cargo build --manifest-path nym-connect/desktop/Cargo.toml --workspace
+
+build-connect-mobile:
+	cargo build --manifest-path nym-connect/mobile/src-tauri/Cargo.toml --workspace

 build-explorer-api:
-	cargo build -p 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 -p nym-cli --release
+	cargo build --release --manifest-path tools/nym-cli/Cargo.toml

-# -----------------------------------------------------------------------------
-# Build contracts ready for deploy
-# -----------------------------------------------------------------------------
+fmt-main:
+	cargo fmt --all

-CONTRACTS_OUT_DIR=contracts/target/wasm32-unknown-unknown/release
-VESTING_CONTRACT=$(CONTRACTS_OUT_DIR)/vesting_contract.wasm
-MIXNET_CONTRACT=$(CONTRACTS_OUT_DIR)/mixnet_contract.wasm
-SERVICE_PROVIDER_DIRECTORY_CONTRACT=$(CONTRACTS_OUT_DIR)/nym_service_provider_directory.wasm
+fmt-contracts:
+	cargo fmt --manifest-path contracts/Cargo.toml --all

-wasm: wasm-build wasm-opt
+fmt-wallet:
+	cargo fmt --manifest-path nym-wallet/Cargo.toml --all

-wasm-build:
+fmt-connect:
+	cargo fmt --manifest-path nym-connect/desktop/Cargo.toml --all
+
+fmt-connect-mobile:
+	cargo fmt --manifest-path nym-connect/mobile/src-tauri/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
+	wasm-opt -Os contracts/target/wasm32-unknown-unknown/release/vesting_contract.wasm -o contracts/target/wasm32-unknown-unknown/release/vesting_contract.wasm
+	wasm-opt -Os contracts/target/wasm32-unknown-unknown/release/mixnet_contract.wasm -o contracts/target/wasm32-unknown-unknown/release/mixnet_contract.wasm

-wasm-opt:
-	wasm-opt --disable-sign-ext -Os $(VESTING_CONTRACT) -o $(VESTING_CONTRACT)
-	wasm-opt --disable-sign-ext -Os $(MIXNET_CONTRACT) -o $(MIXNET_CONTRACT)
-	wasm-opt --disable-sign-ext -Os $(SERVICE_PROVIDER_DIRECTORY_CONTRACT) -o $(SERVICE_PROVIDER_DIRECTORY_CONTRACT)
-
-# -----------------------------------------------------------------------------
-# Misc
-# -----------------------------------------------------------------------------
-
-# NOTE: this seems deprecated an not needed anymore?
 mixnet-opt: wasm
 	cd contracts/mixnet && make opt

@@ -21,7 +21,7 @@ The platform is composed of multiple Rust crates. Top-level executable binary cr

 ### Building

-Platform build instructions are available on [our docs site](https://nymtech.net/docs/binaries/building-nym.html).
+Platform build instructions are available on [our docs site](https://nymtech.net/docs/stable/run-nym-nodes/build-nym).
 Wallet build instructions are also available on [our docs site](https://nymtech.net/docs/stable/nym-apps/wallet#for-developers).

 ### Developing
@@ -3,8 +3,8 @@ Critical bug or security issue 💥
 If you're here because you're trying to figure out how to notify us of a security issue, go to Discord, and alert the core engineers:

    Dave Hrycyszyn futurechimp#5430
+    Drazen Urch drazen#4873
    Jedrzej Stuczynski "Jedrzej | Nym#5666"
-    Fran Arbanas | franarbanas#0995
-    Mark Sinclair | marknym#8088 

-Please avoid opening public issues on GitHub that contain information about a potential security vulnerability as this makes it difficult to reduce the impact and harm of valid security issues.
+
+Please avoid opening public issues on GitHub that contain information about a potential security vulnerability as this makes it difficult to reduce the impact and harm of valid security issues.
@@ -1,6 +1,6 @@
 [package]
-name = "nym-client-core"
-version = "1.1.14"
+name = "client-core"
+version = "1.1.12"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
 edition = "2021"
 rust-version = "1.66"
@@ -15,8 +15,8 @@ futures = "0.3"
 humantime-serde = "1.0"
 log = { workspace = true }
 rand = { version = "0.7.3", features = ["wasm-bindgen"] }
-serde = { workspace = true, features = ["derive"] }
-serde_json = { workspace = true }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0.89"
 tap = "1.0.1"
 thiserror = "1.0.34"
 url = { version ="2.2", features = ["serde"] }
@@ -25,22 +25,20 @@ tokio = { version = "1.24.1", features = ["macros"]}
 time = "0.3.17"

 # internal
-nym-bandwidth-controller = { path = "../bandwidth-controller" }
-nym-config = { path = "../config" }
-nym-crypto = { path = "../crypto" }
-nym-gateway-client = { path = "../client-libs/gateway-client" }
+nym-config = { path = "../../common/config" }
+nym-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"] }
-nym-gateway-requests = { path = "../../gateway/gateway-requests" }
-nym-nonexhaustive-delayqueue = { path = "../nonexhaustive-delayqueue" }
-nym-sphinx = { path = "../nymsphinx" }
-nym-pemstore = { path = "../pemstore" }
-nym-topology = { path = "../topology" }
-nym-validator-client = { path = "../client-libs/validator-client", default-features = false }
-nym-task = { path = "../task" }
-nym-credential-storage = { path = "../credential-storage" }
+gateway-requests = { path = "../../gateway/gateway-requests" }
+nym-nonexhaustive-delayqueue = { path = "../../common/nonexhaustive-delayqueue" }
+nym-sphinx = { path = "../../common/nymsphinx" }
+nym-pemstore = { path = "../../common/pemstore" }
+nym-topology = { path = "../../common/topology" }
+validator-client = { path = "../../common/client-libs/validator-client", default-features = false }
+nym-task = { path = "../../common/task" }

-[target."cfg(not(target_arch = \"wasm32\"))".dependencies.nym-validator-client]
-path = "../client-libs/validator-client"
+[target."cfg(not(target_arch = \"wasm32\"))".dependencies.validator-client]
+path = "../../common/client-libs/validator-client"
 features = ["nyxd-client"]

 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio-stream]
@@ -74,7 +72,7 @@ version = "0.2.4"
 features = ["futures"]

 [target."cfg(target_arch = \"wasm32\")".dependencies.wasm-utils]
-path = "../wasm-utils"
+path = "../../common/wasm-utils"
 features = ["websocket"]

 [target."cfg(target_arch = \"wasm32\")".dependencies.time]
@@ -91,5 +89,5 @@ sqlx = { version = "0.6.2", features = ["runtime-tokio-rustls", "sqlite", "macro
 [features]
 default = []
 fs-surb-storage = ["sqlx"]
-wasm = ["nym-gateway-client/wasm"]
+wasm = ["gateway-client/wasm"]

@@ -5,11 +5,7 @@ use crate::{client::replies::reply_storage, config::DebugConfig};

 pub fn setup_empty_reply_surb_backend(debug_config: &DebugConfig) -> reply_storage::Empty {
    reply_storage::Empty {
-        min_surb_threshold: debug_config
-            .reply_surbs
-            .minimum_reply_surb_storage_threshold,
-        max_surb_threshold: debug_config
-            .reply_surbs
-            .maximum_reply_surb_storage_threshold,
+        min_surb_threshold: debug_config.minimum_reply_surb_storage_threshold,
+        max_surb_threshold: debug_config.maximum_reply_surb_storage_threshold,
    }
 }
@@ -1,7 +1,6 @@
-// Copyright 2022-2023 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use super::received_buffer::ReceivedBufferMessage;
 use crate::client::cover_traffic_stream::LoopCoverTrafficStream;
 use crate::client::inbound_messages::{InputMessage, InputMessageReceiver, InputMessageSender};
 use crate::client::key_manager::KeyManager;
@@ -22,32 +21,33 @@ use crate::client::topology_control::{
 };
 use crate::config::{Config, DebugConfig, GatewayEndpointConfig};
 use crate::error::ClientCoreError;
-use crate::{config, spawn_future};
+use crate::spawn_future;
 use futures::channel::mpsc;
-use log::{debug, info};
-use nym_bandwidth_controller::BandwidthController;
-use nym_crypto::asymmetric::{encryption, identity};
-use nym_gateway_client::{
+use gateway_client::bandwidth::BandwidthController;
+#[cfg(target_arch = "wasm32")]
+use gateway_client::wasm_mockups::CosmWasmClient;
+use gateway_client::{
    AcknowledgementReceiver, AcknowledgementSender, GatewayClient, MixnetMessageReceiver,
    MixnetMessageSender,
 };
+use log::{debug, info};
+use nym_crypto::asymmetric::{encryption, identity};
 use nym_sphinx::acknowledgements::AckKey;
 use nym_sphinx::addressing::clients::Recipient;
 use nym_sphinx::addressing::nodes::NodeIdentity;
-use nym_sphinx::receiver::{ReconstructedMessage, SphinxMessageReceiver};
+use nym_sphinx::receiver::ReconstructedMessage;
 use nym_task::connections::{ConnectionCommandReceiver, ConnectionCommandSender, LaneQueueLengths};
 use nym_task::{TaskClient, TaskManager};
 use nym_topology::provider_trait::TopologyProvider;
 use std::sync::Arc;
+use std::time::Duration;
 use tap::TapFallible;
 use url::Url;

-use nym_credential_storage::storage::Storage;
 #[cfg(not(target_arch = "wasm32"))]
-use nym_validator_client::nyxd::traits::DkgQueryClient;
+use validator_client::nyxd::CosmWasmClient;

-#[cfg(target_arch = "wasm32")]
-use nym_bandwidth_controller::wasm_mockups::DkgQueryClient;
+use super::received_buffer::ReceivedBufferMessage;

 #[cfg(all(not(target_arch = "wasm32"), feature = "fs-surb-storage"))]
 pub mod non_wasm_helpers;
@@ -90,7 +90,6 @@ impl ClientOutput {
    }
 }

-#[derive(Clone, Debug)]
 pub struct ClientState {
    pub shared_lane_queue_lengths: LaneQueueLengths,
    pub reply_controller_sender: ReplyControllerSender,
@@ -151,7 +150,7 @@ impl From<bool> for CredentialsToggle {
    }
 }

-pub struct BaseClientBuilder<'a, B, C, St: Storage> {
+pub struct BaseClientBuilder<'a, B, C: Clone> {
    // due to wasm limitations I had to split it like this : (
    gateway_config: &'a GatewayEndpointConfig,
    debug_config: &'a DebugConfig,
@@ -160,22 +159,21 @@ pub struct BaseClientBuilder<'a, B, C, St: Storage> {
    reply_storage_backend: B,

    custom_topology_provider: Option<Box<dyn TopologyProvider>>,
-    bandwidth_controller: Option<BandwidthController<C, St>>,
+    bandwidth_controller: Option<BandwidthController<C>>,
    key_manager: KeyManager,
 }

-impl<'a, B, C, St> BaseClientBuilder<'a, B, C, St>
+impl<'a, B, C> BaseClientBuilder<'a, B, C>
 where
    B: ReplyStorageBackend + Send + Sync + 'static,
-    C: DkgQueryClient + Sync + Send + 'static,
-    St: Storage + 'static,
+    C: CosmWasmClient + Sync + Send + Clone + 'static,
 {
    pub fn new_from_base_config<T>(
        base_config: &'a Config<T>,
        key_manager: KeyManager,
-        bandwidth_controller: Option<BandwidthController<C, St>>,
+        bandwidth_controller: Option<BandwidthController<C>>,
        reply_storage_backend: B,
-    ) -> BaseClientBuilder<'a, B, C, St> {
+    ) -> BaseClientBuilder<'a, B, C> {
        BaseClientBuilder {
            gateway_config: base_config.get_gateway_endpoint_config(),
            debug_config: base_config.get_debug_config(),
@@ -192,11 +190,11 @@ where
        gateway_config: &'a GatewayEndpointConfig,
        debug_config: &'a DebugConfig,
        key_manager: KeyManager,
-        bandwidth_controller: Option<BandwidthController<C, St>>,
+        bandwidth_controller: Option<BandwidthController<C>>,
        reply_storage_backend: B,
        credentials_toggle: CredentialsToggle,
        nym_api_endpoints: Vec<Url>,
-    ) -> BaseClientBuilder<'a, B, C, St> {
+    ) -> BaseClientBuilder<'a, B, C> {
        BaseClientBuilder {
            gateway_config,
            debug_config,
@@ -236,16 +234,21 @@ where
    ) {
        info!("Starting loop cover traffic stream...");

-        let stream = LoopCoverTrafficStream::new(
+        let mut stream = LoopCoverTrafficStream::new(
            ack_key,
-            debug_config.acknowledgements.average_ack_delay,
+            debug_config.average_ack_delay,
+            debug_config.average_packet_delay,
+            debug_config.loop_cover_traffic_average_delay,
            mix_tx,
            self_address,
            topology_accessor,
-            debug_config.traffic,
-            debug_config.cover_traffic,
        );

+        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);
    }

@@ -291,15 +294,14 @@ where
        shutdown: TaskClient,
    ) {
        info!("Starting received messages buffer controller...");
-        let controller: ReceivedMessagesBufferController<SphinxMessageReceiver> =
-            ReceivedMessagesBufferController::new(
-                local_encryption_keypair,
-                query_receiver,
-                mixnet_receiver,
-                reply_key_storage,
-                reply_controller_sender,
-            );
-        controller.start_with_shutdown(shutdown)
+        ReceivedMessagesBufferController::new(
+            local_encryption_keypair,
+            query_receiver,
+            mixnet_receiver,
+            reply_key_storage,
+            reply_controller_sender,
+        )
+        .start_with_shutdown(shutdown)
    }

    async fn start_gateway_client(
@@ -307,7 +309,7 @@ where
        mixnet_message_sender: MixnetMessageSender,
        ack_sender: AcknowledgementSender,
        shutdown: TaskClient,
-    ) -> Result<GatewayClient<C, St>, ClientCoreError> {
+    ) -> Result<GatewayClient<C>, ClientCoreError> {
        let gateway_id = self.gateway_config.gateway_id.clone();
        if gateway_id.is_empty() {
            return Err(ClientCoreError::GatewayIdUnknown);
@@ -335,9 +337,7 @@ where
            shared_key,
            mixnet_message_sender,
            ack_sender,
-            self.debug_config
-                .gateway_connection
-                .gateway_response_timeout,
+            self.debug_config.gateway_response_timeout,
            self.bandwidth_controller.take(),
            shutdown,
        );
@@ -370,12 +370,11 @@ where
    // the current global view of topology
    async fn start_topology_refresher(
        topology_provider: Box<dyn TopologyProvider>,
-        topology_config: config::Topology,
+        refresh_rate: Duration,
        topology_accessor: TopologyAccessor,
-        mut shutdown: TaskClient,
+        shutdown: TaskClient,
    ) -> Result<(), ClientCoreError> {
-        let topology_refresher_config =
-            TopologyRefresherConfig::new(topology_config.topology_refresh_rate);
+        let topology_refresher_config = TopologyRefresherConfig::new(refresh_rate);

        let mut topology_refresher = TopologyRefresher::new(
            topology_refresher_config,
@@ -395,26 +394,17 @@ where
            return Err(ClientCoreError::InsufficientNetworkTopology(err));
        }

-        if topology_config.disable_refreshing {
-            // if we're not spawning the refresher, don't cause shutdown immediately
-            info!("The topology refesher is not going to be started");
-            shutdown.mark_as_success();
-        } else {
-            // don't spawn the refresher if we don't want to be refreshing the topology.
-            // only use the initial values obtained
-            info!("Starting topology refresher...");
-            topology_refresher.start_with_shutdown(shutdown);
-        }
-
+        info!("Starting topology refresher...");
+        topology_refresher.start_with_shutdown(shutdown);
        Ok(())
    }

-    // controller for sending packets to mixnet (either real traffic or cover traffic)
+    // 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<C, St>,
+        gateway_client: GatewayClient<C>,
        shutdown: TaskClient,
    ) -> BatchMixMessageSender {
        info!("Starting mix traffic controller...");
@@ -509,7 +499,7 @@ where
        );
        Self::start_topology_refresher(
            topology_provider,
-            self.debug_config.topology,
+            self.debug_config.topology_refresh_rate,
            shared_topology_accessor.clone(),
            task_manager.subscribe(),
        )
@@ -524,11 +514,11 @@ where
            task_manager.subscribe(),
        );

-        // The message_sender is the transmitter for any component generating sphinx packets
+        // 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 message_sender =
+        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
@@ -539,18 +529,23 @@ where
        // primarily to throttle incoming connections (e.g socks5 for attached network-requesters)
        let shared_lane_queue_lengths = LaneQueueLengths::new();

-        let controller_config = real_messages_control::Config::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,
-            message_sender.clone(),
+            sphinx_message_sender.clone(),
            reply_storage,
            reply_controller_sender.clone(),
            reply_controller_receiver,
@@ -559,17 +554,13 @@ where
            task_manager.subscribe(),
        );

-        if !self
-            .debug_config
-            .cover_traffic
-            .disable_loop_cover_traffic_stream
-        {
+        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.clone(),
-                message_sender,
+                sphinx_message_sender,
                task_manager.subscribe(),
            );
        }
@@ -30,12 +30,8 @@ async fn setup_fresh_backend<P: AsRef<Path>>(
    // 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
-            .reply_surbs
-            .minimum_reply_surb_storage_threshold,
-        debug_config
-            .reply_surbs
-            .maximum_reply_surb_storage_threshold,
+        debug_config.minimum_reply_surb_storage_threshold,
+        debug_config.maximum_reply_surb_storage_threshold,
    );
    storage_backend
        .init_fresh(&mem_store)
@@ -50,12 +46,8 @@ async fn setup_fresh_backend<P: AsRef<Path>>(
 fn setup_inactive_backend(debug_config: &DebugConfig) -> fs_backend::Backend {
    info!("creating inactive surb database");
    fs_backend::Backend::new_inactive(
-        debug_config
-            .reply_surbs
-            .minimum_reply_surb_storage_threshold,
-        debug_config
-            .reply_surbs
-            .maximum_reply_surb_storage_threshold,
+        debug_config.minimum_reply_surb_storage_threshold,
+        debug_config.maximum_reply_surb_storage_threshold,
    )
 }

@@ -3,7 +3,7 @@

 use crate::client::mix_traffic::BatchMixMessageSender;
 use crate::client::topology_control::TopologyAccessor;
-use crate::{config, spawn_future};
+use crate::spawn_future;
 use futures::task::{Context, Poll};
 use futures::{Future, Stream, StreamExt};
 use log::*;
@@ -34,8 +34,11 @@ where
    /// Average delay an acknowledgement packet is going to get delay at a single mixnode.
    average_ack_delay: Duration,

-    /// Defines configuration options related to cover traffic.
-    cover_traffic: config::CoverTraffic,
+    /// Average delay a data packet is going to get delay at a single mixnode.
+    average_packet_delay: Duration,
+
+    /// Average delay between sending subsequent cover packets.
+    average_cover_message_sending_delay: Duration,

    /// Internal state, determined by `average_message_sending_delay`,
    /// used to keep track of when a next packet should be sent out.
@@ -45,7 +48,7 @@ where
    #[cfg(target_arch = "wasm32")]
    next_delay: Pin<Box<wasm_timer::Delay>>,

-    /// Channel used for sending prepared nym packets to `MixTrafficController` that sends them
+    /// Channel used for sending prepared sphinx packets to `MixTrafficController` that sends them
    /// out to the network without any further delays.
    mix_tx: BatchMixMessageSender,

@@ -58,11 +61,8 @@ where
    /// Accessor to the common instance of network topology.
    topology_access: TopologyAccessor,

-    /// Primary predefined packet size used for the loop cover messages.
-    primary_packet_size: PacketSize,
-
-    /// Optional secondary predefined packet size used for the loop cover messages.
-    secondary_packet_size: Option<PacketSize>,
+    /// Predefined packet size used for the loop cover messages.
+    packet_size: PacketSize,
 }

 impl<R> Stream for LoopCoverTrafficStream<R>
@@ -83,7 +83,7 @@ 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.cover_traffic.loop_cover_traffic_average_delay;
+        let avg_delay = self.average_cover_message_sending_delay;
        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
@@ -107,14 +107,15 @@ where
 // obviously when we finally make shared rng that is on 'higher' level, this should become
 // generic `R`
 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,
        mix_tx: BatchMixMessageSender,
        our_full_destination: Recipient,
        topology_access: TopologyAccessor,
-        traffic_config: config::Traffic,
-        cover_config: config::CoverTraffic,
    ) -> Self {
        let rng = OsRng;

@@ -127,17 +128,21 @@ impl LoopCoverTrafficStream<OsRng> {
        LoopCoverTrafficStream {
            ack_key,
            average_ack_delay,
-            cover_traffic: cover_config,
+            average_packet_delay,
+            average_cover_message_sending_delay,
            next_delay,
            mix_tx,
            our_full_destination,
            rng,
            topology_access,
-            primary_packet_size: traffic_config.primary_packet_size,
-            secondary_packet_size: traffic_config.secondary_packet_size,
+            packet_size: Default::default(),
        }
    }

+    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));
@@ -148,28 +153,9 @@ impl LoopCoverTrafficStream<OsRng> {
        self.next_delay = next_delay;
    }

-    fn loop_cover_message_size(&mut self) -> PacketSize {
-        let Some(secondary_packet_size) = self.secondary_packet_size else {
-            return self.primary_packet_size
-        };
-
-        let use_primary = self
-            .rng
-            .gen_bool(self.cover_traffic.cover_traffic_primary_size_ratio);
-
-        if use_primary {
-            self.primary_packet_size
-        } else {
-            secondary_packet_size
-        }
-    }
-
    async fn on_new_message(&mut self) {
        trace!("next cover message!");

-        let cover_traffic_packet_size = self.loop_cover_message_size();
-        trace!("the next loop cover message will be put in a {cover_traffic_packet_size} packet");
-
        // 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?
@@ -192,8 +178,8 @@ impl LoopCoverTrafficStream<OsRng> {
            &self.ack_key,
            &self.our_full_destination,
            self.average_ack_delay,
-            self.cover_traffic.loop_cover_traffic_average_delay,
-            cover_traffic_packet_size,
+            self.average_packet_delay,
+            self.packet_size,
        )
        .expect("Somehow failed to generate a loop cover message with a valid topology");

@@ -203,6 +189,10 @@ impl LoopCoverTrafficStream<OsRng> {
                    // 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 gateway can't keep up");
                }
                TrySendError::Closed(_) => {
                    log::warn!("Failed to send cover message - channel closed");
@@ -224,17 +214,9 @@ impl LoopCoverTrafficStream<OsRng> {
    }

    pub fn start_with_shutdown(mut self, mut shutdown: nym_task::TaskClient) {
-        if self.cover_traffic.disable_loop_cover_traffic_stream {
-            // we should have never got here in the first place - the task should have never been created to begin with
-            // so panic and review the code that lead to this branch
-            panic!("attempted to start LoopCoverTrafficStream while config explicitly disabled it.")
-        }
-
        // we should set initial delay only when we actually start the stream
-        let sampled = sample_poisson_duration(
-            &mut self.rng,
-            self.cover_traffic.loop_cover_traffic_average_delay,
-        );
+        let sampled =
+            sample_poisson_duration(&mut self.rng, self.average_cover_message_sending_delay);
        self.set_next_delay(sampled);

        spawn_future(async move {
@@ -1,10 +1,5 @@
-// Copyright 2020-2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
 use nym_sphinx::addressing::clients::Recipient;
 use nym_sphinx::anonymous_replies::requests::AnonymousSenderTag;
-use nym_sphinx::forwarding::packet::MixPacket;
-use nym_sphinx::params::PacketType;
 use nym_task::connections::TransmissionLane;

 pub type InputMessageSender = tokio::sync::mpsc::Sender<InputMessage>;
@@ -12,14 +7,6 @@ pub type InputMessageReceiver = tokio::sync::mpsc::Receiver<InputMessage>;

 #[derive(Debug)]
 pub enum InputMessage {
-    /// Fire an already prepared mix packets into the network.
-    /// No guarantees are made about it. For example no retransmssion
-    /// will be attempted if it gets dropped.
-    Premade {
-        msgs: Vec<MixPacket>,
-        lane: TransmissionLane,
-    },
-
    /// The simplest message variant where no additional information is attached.
    /// You're simply sending your `data` to specified `recipient` without any tagging.
    ///
@@ -54,49 +41,14 @@ pub enum InputMessage {
        data: Vec<u8>,
        lane: TransmissionLane,
    },
-
-    MessageWrapper {
-        message: Box<InputMessage>,
-        packet_type: PacketType,
-    },
 }

 impl InputMessage {
-    pub fn new_premade(
-        msgs: Vec<MixPacket>,
-        lane: TransmissionLane,
-        packet_type: PacketType,
-    ) -> Self {
-        let message = InputMessage::Premade { msgs, lane };
-        if packet_type == PacketType::Mix {
-            message
-        } else {
-            InputMessage::new_wrapper(message, packet_type)
-        }
-    }
-
-    pub fn new_wrapper(message: InputMessage, packet_type: PacketType) -> Self {
-        InputMessage::MessageWrapper {
-            message: Box::new(message),
-            packet_type,
-        }
-    }
-
-    pub fn new_regular(
-        recipient: Recipient,
-        data: Vec<u8>,
-        lane: TransmissionLane,
-        packet_type: Option<PacketType>,
-    ) -> Self {
-        let message = InputMessage::Regular {
+    pub fn new_regular(recipient: Recipient, data: Vec<u8>, lane: TransmissionLane) -> Self {
+        InputMessage::Regular {
            recipient,
            data,
            lane,
-        };
-        if let Some(packet_type) = packet_type {
-            InputMessage::new_wrapper(message, packet_type)
-        } else {
-            message
        }
    }

@@ -105,18 +57,12 @@ impl InputMessage {
        data: Vec<u8>,
        reply_surbs: u32,
        lane: TransmissionLane,
-        packet_type: Option<PacketType>,
    ) -> Self {
-        let message = InputMessage::Anonymous {
+        InputMessage::Anonymous {
            recipient,
            data,
            reply_surbs,
            lane,
-        };
-        if let Some(packet_type) = packet_type {
-            InputMessage::new_wrapper(message, packet_type)
-        } else {
-            message
        }
    }

@@ -124,17 +70,11 @@ impl InputMessage {
        recipient_tag: AnonymousSenderTag,
        data: Vec<u8>,
        lane: TransmissionLane,
-        packet_type: Option<PacketType>,
    ) -> Self {
-        let message = InputMessage::Reply {
+        InputMessage::Reply {
            recipient_tag,
            data,
            lane,
-        };
-        if let Some(packet_type) = packet_type {
-            InputMessage::new_wrapper(message, packet_type)
-        } else {
-            message
        }
    }

@@ -142,9 +82,7 @@ impl InputMessage {
        match self {
            InputMessage::Regular { lane, .. }
            | InputMessage::Anonymous { lane, .. }
-            | InputMessage::Reply { lane, .. }
-            | InputMessage::Premade { lane, .. } => lane,
-            InputMessage::MessageWrapper { message, .. } => message.lane(),
+            | InputMessage::Reply { lane, .. } => lane,
        }
    }
 }
@@ -2,9 +2,9 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::config::persistence::key_pathfinder::ClientKeyPathfinder;
+use gateway_requests::registration::handshake::SharedKeys;
 use log::*;
 use nym_crypto::asymmetric::{encryption, identity};
-use nym_gateway_requests::registration::handshake::SharedKeys;
 use nym_sphinx::acknowledgements::AckKey;
 use rand::{CryptoRng, RngCore};
 use std::io;
@@ -2,16 +2,13 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::spawn_future;
-use log::*;
-use nym_gateway_client::GatewayClient;
-use nym_sphinx::forwarding::packet::MixPacket;
-
-use nym_credential_storage::storage::Storage;
-#[cfg(not(target_arch = "wasm32"))]
-use nym_validator_client::nyxd::traits::DkgQueryClient;
-
 #[cfg(target_arch = "wasm32")]
-use nym_bandwidth_controller::wasm_mockups::DkgQueryClient;
+use gateway_client::wasm_mockups::CosmWasmClient;
+use gateway_client::GatewayClient;
+use log::*;
+use nym_sphinx::forwarding::packet::MixPacket;
+#[cfg(not(target_arch = "wasm32"))]
+use validator_client::nyxd::CosmWasmClient;

 pub type BatchMixMessageSender = tokio::sync::mpsc::Sender<Vec<MixPacket>>;
 pub type BatchMixMessageReceiver = tokio::sync::mpsc::Receiver<Vec<MixPacket>>;
@@ -20,10 +17,10 @@ pub type BatchMixMessageReceiver = tokio::sync::mpsc::Receiver<Vec<MixPacket>>;
 pub const MIX_MESSAGE_RECEIVER_BUFFER_SIZE: usize = 32;
 const MAX_FAILURE_COUNT: usize = 100;

-pub struct MixTrafficController<C, St: Storage> {
+pub struct MixTrafficController<C: Clone> {
    // TODO: most likely to be replaced by some higher level construct as
    // later on gateway_client will need to be accessible by other entities
-    gateway_client: GatewayClient<C, St>,
+    gateway_client: GatewayClient<C>,
    mix_rx: BatchMixMessageReceiver,

    // TODO: this is temporary work-around.
@@ -31,23 +28,22 @@ pub struct MixTrafficController<C, St: Storage> {
    consecutive_gateway_failure_count: usize,
 }

-impl<C, St> MixTrafficController<C, St>
+impl<C> MixTrafficController<C>
 where
-    C: DkgQueryClient + Sync + Send + 'static,
-    St: Storage + 'static,
+    C: CosmWasmClient + Sync + Send + Clone + 'static,
 {
    pub fn new(
-        gateway_client: GatewayClient<C, St>,
-    ) -> (MixTrafficController<C, St>, BatchMixMessageSender) {
-        let (message_sender, message_receiver) =
+        gateway_client: GatewayClient<C>,
+    ) -> (MixTrafficController<C>, BatchMixMessageSender) {
+        let (sphinx_message_sender, sphinx_message_receiver) =
            tokio::sync::mpsc::channel(MIX_MESSAGE_RECEIVER_BUFFER_SIZE);
        (
            MixTrafficController {
                gateway_client,
-                mix_rx: message_receiver,
+                mix_rx: sphinx_message_receiver,
                consecutive_gateway_failure_count: 0,
            },
-            message_sender,
+            sphinx_message_sender,
        )
    }

@@ -3,8 +3,8 @@

 use super::action_controller::{AckActionSender, Action};
 use futures::StreamExt;
+use gateway_client::AcknowledgementReceiver;
 use log::*;
-use nym_gateway_client::AcknowledgementReceiver;
 use nym_sphinx::{
    acknowledgements::{identifier::recover_identifier, AckKey},
    chunking::fragment::{FragmentIdentifier, COVER_FRAG_ID},
@@ -3,13 +3,10 @@

 use crate::client::inbound_messages::{InputMessage, InputMessageReceiver};
 use crate::client::real_messages_control::message_handler::MessageHandler;
-use crate::client::real_messages_control::real_traffic_stream::RealMessage;
 use crate::client::replies::reply_controller::ReplyControllerSender;
 use log::*;
 use nym_sphinx::addressing::clients::Recipient;
 use nym_sphinx::anonymous_replies::requests::AnonymousSenderTag;
-use nym_sphinx::forwarding::packet::MixPacket;
-use nym_sphinx::params::PacketType;
 use nym_task::connections::TransmissionLane;
 use rand::{CryptoRng, Rng};

@@ -44,18 +41,6 @@ where
        }
    }

-    async fn handle_premade_packets(&mut self, packets: Vec<MixPacket>, lane: TransmissionLane) {
-        self.message_handler
-            .send_premade_mix_packets(
-                packets
-                    .into_iter()
-                    .map(|p| RealMessage::new(p, None))
-                    .collect(),
-                lane,
-            )
-            .await
-    }
-
    async fn handle_reply(
        &mut self,
        recipient_tag: AnonymousSenderTag,
@@ -72,11 +57,10 @@ where
        recipient: Recipient,
        content: Vec<u8>,
        lane: TransmissionLane,
-        packet_type: PacketType,
    ) {
        if let Err(err) = self
            .message_handler
-            .try_send_plain_message(recipient, content, lane, packet_type)
+            .try_send_plain_message(recipient, content, lane)
            .await
        {
            warn!("failed to send a plain message - {err}")
@@ -89,11 +73,10 @@ where
        content: Vec<u8>,
        reply_surbs: u32,
        lane: TransmissionLane,
-        packet_type: PacketType,
    ) {
        if let Err(err) = self
            .message_handler
-            .try_send_message_with_reply_surbs(recipient, content, reply_surbs, lane, packet_type)
+            .try_send_message_with_reply_surbs(recipient, content, reply_surbs, lane)
            .await
        {
            warn!("failed to send a repliable message - {err}")
@@ -106,17 +89,14 @@ where
                recipient,
                data,
                lane,
-            } => {
-                self.handle_plain_message(recipient, data, lane, PacketType::Mix)
-                    .await
-            }
+            } => self.handle_plain_message(recipient, data, lane).await,
            InputMessage::Anonymous {
                recipient,
                data,
                reply_surbs,
                lane,
            } => {
-                self.handle_repliable_message(recipient, data, reply_surbs, lane, PacketType::Mix)
+                self.handle_repliable_message(recipient, data, reply_surbs, lane)
                    .await
            }
            InputMessage::Reply {
@@ -126,41 +106,6 @@ where
            } => {
                self.handle_reply(recipient_tag, data, lane).await;
            }
-            InputMessage::Premade { msgs, lane } => self.handle_premade_packets(msgs, lane).await,
-            InputMessage::MessageWrapper {
-                message,
-                packet_type,
-            } => match *message {
-                InputMessage::Regular {
-                    recipient,
-                    data,
-                    lane,
-                } => {
-                    self.handle_plain_message(recipient, data, lane, packet_type)
-                        .await
-                }
-                InputMessage::Anonymous {
-                    recipient,
-                    data,
-                    reply_surbs,
-                    lane,
-                } => {
-                    self.handle_repliable_message(recipient, data, reply_surbs, lane, packet_type)
-                        .await
-                }
-                InputMessage::Reply {
-                    recipient_tag,
-                    data,
-                    lane,
-                } => {
-                    self.handle_reply(recipient_tag, data, lane).await;
-                }
-                InputMessage::Premade { msgs, lane } => {
-                    self.handle_premade_packets(msgs, lane).await
-                }
-                // MessageWrappers can't be nested
-                InputMessage::MessageWrapper { .. } => unimplemented!(),
-            },
        };
    }

@@ -13,8 +13,8 @@ use crate::client::replies::reply_controller::ReplyControllerSender;
 use crate::spawn_future;
 use action_controller::AckActionReceiver;
 use futures::channel::mpsc;
+use gateway_client::AcknowledgementReceiver;
 use log::*;
-use nym_gateway_client::AcknowledgementReceiver;
 use nym_sphinx::anonymous_replies::requests::AnonymousSenderTag;
 use nym_sphinx::params::PacketSize;
 use nym_sphinx::{
@@ -11,9 +11,9 @@ use crate::client::real_messages_control::real_traffic_stream::RealMessage;
 use crate::client::replies::reply_controller::ReplyControllerSender;
 use futures::StreamExt;
 use log::*;
+use nym_sphinx::addressing::clients::Recipient;
 use nym_sphinx::chunking::fragment::Fragment;
 use nym_sphinx::preparer::PreparedFragment;
-use nym_sphinx::{addressing::clients::Recipient, params::PacketType};
 use nym_task::connections::TransmissionLane;
 use rand::{CryptoRng, Rng};
 use std::sync::{Arc, Weak};
@@ -51,10 +51,8 @@ where
    ) -> Result<PreparedFragment, PreparationError> {
        debug!("retransmitting normal packet...");

-        // TODO: Figure out retransmission packet type signaling
-
        self.message_handler
-            .try_prepare_single_chunk_for_sending(packet_recipient, chunk_data, PacketType::Mix)
+            .try_prepare_single_chunk_for_sending(packet_recipient, chunk_data)
            .await
    }

@@ -133,10 +131,7 @@ where
        // send to `OutQueueControl` to eventually send to the mix network
        self.message_handler
            .forward_messages(
-                vec![RealMessage::new(
-                    prepared_fragment.mix_packet,
-                    Some(frag_id),
-                )],
+                vec![RealMessage::new(prepared_fragment.mix_packet, frag_id)],
                TransmissionLane::Retransmission,
            )
            .await
@@ -15,7 +15,7 @@ use nym_sphinx::anonymous_replies::requests::{AnonymousSenderTag, RepliableMessa
 use nym_sphinx::anonymous_replies::{ReplySurb, SurbEncryptionKey};
 use nym_sphinx::chunking::fragment::{Fragment, FragmentIdentifier};
 use nym_sphinx::message::NymMessage;
-use nym_sphinx::params::{PacketSize, PacketType, DEFAULT_NUM_MIX_HOPS};
+use nym_sphinx::params::{PacketSize, DEFAULT_NUM_MIX_HOPS};
 use nym_sphinx::preparer::{MessagePreparer, PreparedFragment};
 use nym_sphinx::Delay;
 use nym_task::connections::TransmissionLane;
@@ -101,11 +101,8 @@ pub(crate) struct Config {
    /// Note that it does not include gateway hops.
    num_mix_hops: u8,

-    /// Primary predefined packet size used for the encapsulated messages.
-    primary_packet_size: PacketSize,
-
-    /// Optional secondary predefined packet size used for the encapsulated messages.
-    secondary_packet_size: Option<PacketSize>,
+    /// Predefined packet size used for the encapsulated messages.
+    packet_size: PacketSize,
 }

 impl Config {
@@ -121,8 +118,7 @@ impl Config {
            average_packet_delay,
            average_ack_delay,
            num_mix_hops: DEFAULT_NUM_MIX_HOPS,
-            primary_packet_size: PacketSize::default(),
-            secondary_packet_size: None,
+            packet_size: PacketSize::default(),
        }
    }

@@ -134,14 +130,8 @@ impl Config {
    }

    /// Allows setting non-default size of the sphinx packets sent out.
-    pub fn with_custom_primary_packet_size(mut self, packet_size: PacketSize) -> Self {
-        self.primary_packet_size = packet_size;
-        self
-    }
-
-    /// Allows setting non-default size of the sphinx packets sent out.
-    pub fn with_custom_secondary_packet_size(mut self, packet_size: Option<PacketSize>) -> Self {
-        self.secondary_packet_size = packet_size;
+    pub fn with_custom_packet_size(mut self, packet_size: PacketSize) -> Self {
+        self.packet_size = packet_size;
        self
    }
 }
@@ -180,6 +170,7 @@ where
            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 {
@@ -220,28 +211,6 @@ where
        }
    }

-    fn optimal_packet_size(&self, msg: &NymMessage) -> PacketSize {
-        // if secondary packet was never set, then it's obvious we have to use the primary packet
-        let Some(secondary_packet) = self.config.secondary_packet_size else {
-            trace!("only primary packet size is available");
-            return self.config.primary_packet_size
-        };
-
-        let primary_count =
-            msg.required_packets(self.config.primary_packet_size, self.config.num_mix_hops);
-        let secondary_count = msg.required_packets(secondary_packet, self.config.num_mix_hops);
-
-        trace!("This message would require: {primary_count} primary packets or {secondary_count} secondary packets...");
-        // if there would be no benefit in using the secondary packet - use the primary (duh)
-        if primary_count <= secondary_count {
-            trace!("so choosing primary for this message");
-            self.config.primary_packet_size
-        } else {
-            trace!("so choosing secondary for this message");
-            secondary_packet
-        }
-    }
-
    async fn generate_reply_surbs_with_keys(
        &mut self,
        amount: usize,
@@ -268,13 +237,9 @@ where
        reply_surb: ReplySurb,
        is_extra_surb_request: bool,
    ) -> Result<(), SurbWrappedPreparationError> {
-        let msg = NymMessage::new_reply(message);
-        let packet_size = self.optimal_packet_size(&msg);
-        debug!("Using {packet_size} packets for {msg}");
-
        let mut fragment = self
            .message_preparer
-            .pad_and_split_message(msg, packet_size);
+            .pad_and_split_message(NymMessage::new_reply(message));
        if fragment.len() > 1 {
            // well, it's not a single surb message
            return Err(SurbWrappedPreparationError {
@@ -291,10 +256,8 @@ where
            .try_prepare_single_reply_chunk_for_sending(reply_surb, chunk_clone)
            .await?;

-        let real_messages = RealMessage::new(
-            prepared_fragment.mix_packet,
-            Some(chunk.fragment_identifier()),
-        );
+        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);
@@ -326,12 +289,10 @@ where

    // // 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> {
-        let msg = NymMessage::new_reply(ReplyMessage::new_data_message(message));
-        let packet_size = self.optimal_packet_size(&msg);
-        debug!("Using {packet_size} packets for {msg}");
-
        self.message_preparer
-            .pad_and_split_message(msg, packet_size)
+            .pad_and_split_message(NymMessage::new_reply(ReplyMessage::new_data_message(
+                message,
+            )))
    }

    pub(crate) async fn send_retransmission_reply_chunks(
@@ -386,8 +347,7 @@ where
            let lane = raw.0;
            let fragment = raw.1;

-            let real_message =
-                RealMessage::new(prepared.mix_packet, Some(prepared.fragment_identifier));
+            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);

@@ -404,23 +364,14 @@ where
        Ok(())
    }

-    pub(crate) async fn send_premade_mix_packets(
-        &mut self,
-        msgs: Vec<RealMessage>,
-        lane: TransmissionLane,
-    ) {
-        self.forward_messages(msgs, lane).await;
-    }
-
    pub(crate) async fn try_send_plain_message(
        &mut self,
        recipient: Recipient,
        message: Vec<u8>,
        lane: TransmissionLane,
-        packet_type: PacketType,
    ) -> Result<(), PreparationError> {
        let message = NymMessage::new_plain(message);
-        self.try_split_and_send_non_reply_message(message, recipient, lane, packet_type)
+        self.try_split_and_send_non_reply_message(message, recipient, lane)
            .await
    }

@@ -429,7 +380,6 @@ where
        message: NymMessage,
        recipient: Recipient,
        lane: TransmissionLane,
-        packet_type: PacketType,
    ) -> Result<(), PreparationError> {
        // TODO: I really dislike existence of this assertion, it implies code has to be re-organised
        debug_assert!(!matches!(message, NymMessage::Reply(_)));
@@ -438,11 +388,7 @@ where
        let topology_permit = self.topology_access.get_read_permit().await;
        let topology = self.get_topology(&topology_permit)?;

-        let packet_size = self.optimal_packet_size(&message);
-        debug!("Using {packet_size} packets for {message}");
-        let fragments = self
-            .message_preparer
-            .pad_and_split_message(message, packet_size);
+        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());
@@ -455,13 +401,10 @@ where
                topology,
                &self.config.ack_key,
                &recipient,
-                &packet_type,
            )?;

-            let real_message = RealMessage::new(
-                prepared_fragment.mix_packet,
-                Some(fragment.fragment_identifier()),
-            );
+            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);

@@ -479,7 +422,6 @@ where
        &mut self,
        recipient: Recipient,
        amount: u32,
-        packet_type: PacketType,
    ) -> Result<(), PreparationError> {
        let sender_tag = self.get_or_create_sender_tag(&recipient);
        let (reply_surbs, reply_keys) =
@@ -494,7 +436,6 @@ where
            message,
            recipient,
            TransmissionLane::AdditionalReplySurbs,
-            packet_type,
        )
        .await?;

@@ -510,7 +451,6 @@ where
        message: Vec<u8>,
        num_reply_surbs: u32,
        lane: TransmissionLane,
-        packet_type: PacketType,
    ) -> Result<(), SurbWrappedPreparationError> {
        let sender_tag = self.get_or_create_sender_tag(&recipient);
        let (reply_surbs, reply_keys) = self
@@ -520,7 +460,7 @@ where
        let message =
            NymMessage::new_repliable(RepliableMessage::new_data(message, sender_tag, reply_surbs));

-        self.try_split_and_send_non_reply_message(message, recipient, lane, packet_type)
+        self.try_split_and_send_non_reply_message(message, recipient, lane)
            .await?;

        log::trace!("storing {} reply keys", reply_keys.len());
@@ -533,20 +473,13 @@ where
        &mut self,
        recipient: Recipient,
        chunk: Fragment,
-        packet_type: PacketType,
    ) -> 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,
-                &packet_type,
-            )
+            .prepare_chunk_for_sending(chunk, topology, &self.config.ack_key, &recipient)
            .unwrap();

        Ok(prepared_fragment)
@@ -582,7 +515,6 @@ where
                        topology,
                        &self.config.ack_key,
                        reply_surb,
-                        PacketType::Mix,
                    )
                    .unwrap()
            })
@@ -602,13 +534,7 @@ where

        let prepared_fragment = self
            .message_preparer
-            .prepare_reply_chunk_for_sending(
-                chunk,
-                topology,
-                &self.config.ack_key,
-                reply_surb,
-                PacketType::Mix,
-            )
+            .prepare_reply_chunk_for_sending(chunk, topology, &self.config.ack_key, reply_surb)
            .unwrap();

        Ok(prepared_fragment)
@@ -1,4 +1,4 @@
-// Copyright 2021-2023 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

 // INPUT: InputMessage from user
@@ -22,13 +22,15 @@ use crate::{
    spawn_future,
 };
 use futures::channel::mpsc;
+use gateway_client::AcknowledgementReceiver;
 use log::*;
-use nym_gateway_client::AcknowledgementReceiver;
 use nym_sphinx::acknowledgements::AckKey;
 use nym_sphinx::addressing::clients::Recipient;
+use nym_sphinx::params::PacketSize;
 use nym_task::connections::{ConnectionCommandReceiver, LaneQueueLengths};
 use rand::{rngs::OsRng, CryptoRng, Rng};
 use std::sync::Arc;
+use std::time::Duration;

 use crate::client::replies::reply_controller;
 use crate::config;
@@ -43,29 +45,61 @@ pub struct Config {
    /// Key used to decrypt contents of received SURBAcks
    ack_key: Arc<AckKey>,

+    /// Given ack timeout in the form a * BASE_DELAY + b, it specifies the additive part `b`
+    ack_wait_addition: Duration,
+
+    /// Given ack timeout in the form a * BASE_DELAY + b, it specifies the multiplier `a`
+    ack_wait_multiplier: f64,
+
    /// Address of `this` client.
    self_recipient: Recipient,

-    /// Specifies all traffic related configuration options.
-    traffic: config::Traffic,
+    /// Average delay between sending subsequent packets from this client.
+    average_message_sending_delay: Duration,

-    /// Specifies all cover traffic related configuration options.
-    cover_traffic: config::CoverTraffic,
+    /// Average delay a data packet is going to get delayed at a single mixnode.
+    average_packet_delay_duration: Duration,

-    /// Specifies all acknowledgements related configuration options.
-    acks: config::Acknowledgements,
+    /// Average delay an acknowledgement packet is going to get delayed at a single mixnode.
+    average_ack_delay_duration: Duration,

-    /// Specifies all reply SURBs related configuration options.
-    reply_surbs: config::ReplySurbs,
+    /// 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_rerequest_waiting_period: Duration,
+
+    /// Defines maximum amount of time the client is going to wait for reply surbs before
+    /// deciding it's never going to get them and would drop all pending messages
+    maximum_reply_surb_drop_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.acks.ack_wait_addition,
-            cfg.acks.ack_wait_multiplier,
-        )
-        .with_custom_packet_size(cfg.traffic.primary_packet_size)
+        acknowledgement_control::Config::new(cfg.ack_wait_addition, cfg.ack_wait_multiplier)
+            .with_custom_packet_size(cfg.packet_size)
    }
 }

@@ -74,16 +108,26 @@ impl<'a> From<&'a Config> for real_traffic_stream::Config {
        real_traffic_stream::Config::new(
            Arc::clone(&cfg.ack_key),
            cfg.self_recipient,
-            cfg.acks.average_ack_delay,
-            cfg.traffic,
-            cfg.cover_traffic.cover_traffic_primary_size_ratio,
+            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.reply_surbs)
+        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_rerequest_waiting_period,
+            cfg.maximum_reply_surb_drop_waiting_period,
+            cfg.maximum_reply_surb_age,
+            cfg.maximum_reply_key_age,
+        )
    }
 }

@@ -92,11 +136,10 @@ impl<'a> From<&'a Config> for message_handler::Config {
        message_handler::Config::new(
            Arc::clone(&cfg.ack_key),
            cfg.self_recipient,
-            cfg.traffic.average_packet_delay,
-            cfg.acks.average_ack_delay,
+            cfg.average_packet_delay_duration,
+            cfg.average_ack_delay_duration,
        )
-        .with_custom_primary_packet_size(cfg.traffic.primary_packet_size)
-        .with_custom_secondary_packet_size(cfg.traffic.secondary_packet_size)
+        .with_custom_packet_size(cfg.packet_size)
    }
 }

@@ -109,12 +152,32 @@ impl Config {
        Config {
            ack_key,
            self_recipient,
-            traffic: base_client_debug_config.traffic,
-            cover_traffic: base_client_debug_config.cover_traffic,
-            acks: base_client_debug_config.acknowledgements,
-            reply_surbs: base_client_debug_config.reply_surbs,
+            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_rerequest_waiting_period: base_client_debug_config
+                .maximum_reply_surb_rerequest_waiting_period,
+            maximum_reply_surb_drop_waiting_period: base_client_debug_config
+                .maximum_reply_surb_drop_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,
        }
    }
+
+    pub fn set_custom_packet_size(&mut self, packet_size: PacketSize) {
+        self.packet_size = packet_size;
+    }
 }

 pub(crate) struct RealMessagesController<R>
@@ -6,7 +6,6 @@ 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 crate::config;
 use futures::task::{Context, Poll};
 use futures::{Future, Stream, StreamExt};
 use log::*;
@@ -28,6 +27,7 @@ use std::time::Duration;

 #[cfg(not(target_arch = "wasm32"))]
 use tokio::time;
+
 #[cfg(target_arch = "wasm32")]
 use wasm_timer;

@@ -44,12 +44,18 @@ pub(crate) struct Config {
    /// Average delay an acknowledgement packet is going to get delay at a single mixnode.
    average_ack_delay: Duration,

-    /// Defines all configuration options related to this traffic stream.
-    traffic: config::Traffic,
+    /// Average delay a data packet is going to get delay at a single mixnode.
+    average_packet_delay: Duration,

-    /// Specifies the ratio of `primary_packet_size` to `secondary_packet_size` used in cover traffic.
-    /// Only applicable if `secondary_packet_size` is enabled.
-    cover_traffic_primary_size_ratio: f64,
+    /// 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 {
@@ -57,17 +63,25 @@ impl Config {
        ack_key: Arc<AckKey>,
        our_full_destination: Recipient,
        average_ack_delay: Duration,
-        traffic: config::Traffic,
-        cover_traffic_primary_size_ratio: f64,
+        average_packet_delay: Duration,
+        average_message_sending_delay: Duration,
+        disable_poisson_packet_distribution: bool,
    ) -> Self {
        Config {
            ack_key,
            our_full_destination,
            average_ack_delay,
-            traffic,
-            cover_traffic_primary_size_ratio,
+            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>
@@ -92,7 +106,7 @@ where
    // messages.
    sending_delay_controller: SendingDelayController,

-    /// Channel used for sending prepared packets to `MixTrafficController` that sends them
+    /// Channel used for sending prepared sphinx packets to `MixTrafficController` that sends them
    /// out to the network without any further delays.
    mix_tx: BatchMixMessageSender,

@@ -121,7 +135,7 @@ where
 #[derive(Debug)]
 pub(crate) struct RealMessage {
    mix_packet: MixPacket,
-    fragment_id: Option<FragmentIdentifier>,
+    fragment_id: FragmentIdentifier,
    // TODO: add info about it being constructed with reply-surb
 }

@@ -129,17 +143,17 @@ impl From<PreparedFragment> for RealMessage {
    fn from(fragment: PreparedFragment) -> Self {
        RealMessage {
            mix_packet: fragment.mix_packet,
-            fragment_id: Some(fragment.fragment_identifier),
+            fragment_id: fragment.fragment_identifier,
        }
    }
 }

 impl RealMessage {
    pub(crate) fn packet_size(&self) -> usize {
-        self.mix_packet.packet().len()
+        self.mix_packet.sphinx_packet().len()
    }

-    pub(crate) fn new(mix_packet: MixPacket, fragment_id: Option<FragmentIdentifier>) -> Self {
+    pub(crate) fn new(mix_packet: MixPacket, fragment_id: FragmentIdentifier) -> Self {
        RealMessage {
            mix_packet,
            fragment_id,
@@ -198,30 +212,11 @@ where
        self.sent_notifier.unbounded_send(frag_id).unwrap();
    }

-    fn loop_cover_message_size(&mut self) -> PacketSize {
-        let Some(secondary_packet_size) = self.config.traffic.secondary_packet_size else {
-            return self.config.traffic.primary_packet_size
-        };
-
-        let use_primary = self
-            .rng
-            .gen_bool(self.config.cover_traffic_primary_size_ratio);
-
-        if use_primary {
-            self.config.traffic.primary_packet_size
-        } else {
-            secondary_packet_size
-        }
-    }
-
    async fn on_message(&mut self, next_message: StreamMessage) {
        trace!("created new message");

        let (next_message, fragment_id) = match next_message {
            StreamMessage::Cover => {
-                let cover_traffic_packet_size = self.loop_cover_message_size();
-                trace!("the next loop cover message will be put in a {cover_traffic_packet_size} packet");
-
                // 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?
@@ -245,8 +240,8 @@ where
                        &self.config.ack_key,
                        &self.config.our_full_destination,
                        self.config.average_ack_delay,
-                        self.config.traffic.average_packet_delay,
-                        cover_traffic_packet_size,
+                        self.config.average_packet_delay,
+                        self.config.cover_packet_size,
                    )
                    .expect(
                        "Somehow failed to generate a loop cover message with a valid topology",
@@ -255,7 +250,7 @@ where
                )
            }
            StreamMessage::Real(real_message) => {
-                (real_message.mix_packet, real_message.fragment_id)
+                (real_message.mix_packet, Some(real_message.fragment_id))
            }
        };

@@ -291,7 +286,7 @@ where
    }

    fn current_average_message_sending_delay(&self) -> Duration {
-        self.config.traffic.message_sending_average_delay
+        self.config.average_message_sending_delay
            * self.sending_delay_controller.current_multiplier()
    }

@@ -302,34 +297,24 @@ where
            self.sending_delay_controller.current_multiplier()
        );

-        if self
-            .sending_delay_controller
-            .is_backpressure_currently_detected(used_slots)
-        {
+        // 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 by increasing the delay
-        // multiplier.
+        // 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();
        }

-        // If it looks like we are sending reliably, increase the sending rate by decreasing the
-        // sending delay multiplier.
-        if !self
-            .sending_delay_controller
-            .was_backpressure_detected_recently()
-            && self.sending_delay_controller.not_decreased_delay_recently()
-        {
+        // 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();
        }
-
-        // Keep track of multiplier changes, and log if necessary.
-        self.sending_delay_controller.record_delay_multiplier();
    }

    fn pop_next_message(&mut self) -> Option<RealMessage> {
@@ -386,7 +371,7 @@ where

            // 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 packets from multiple
+            // 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
@@ -415,10 +400,8 @@ where
            // 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.traffic.message_sending_average_delay,
-            );
+            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));
@@ -469,7 +452,7 @@ where
        mut self: Pin<&mut Self>,
        cx: &mut Context<'_>,
    ) -> Poll<Option<StreamMessage>> {
-        if self.config.traffic.disable_main_poisson_packet_distribution {
+        if self.config.disable_poisson_packet_distribution {
            self.poll_immediate(cx)
        } else {
            self.poll_poisson(cx)
@@ -485,7 +468,7 @@ where
        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.traffic.disable_main_poisson_packet_distribution {
+        let status_str = if self.config.disable_poisson_packet_distribution {
            format!("Status: {lanes} lanes, backlog: {backlog:.2} kiB ({packets}), no delay")
        } else {
            format!(
@@ -508,12 +491,23 @@ where
        }
    }

+    #[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: nym_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! {
@@ -524,6 +518,9 @@ where
                    _ = 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 {
                        self.on_message(next_message).await;
                    } else {
@@ -11,20 +11,15 @@ 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 = 2;
-// The queue length that is required for us to register that backpressure occured. If there are
-// more than this many packets waiting to be sent, we consider the channel to be under
-// backpressure.
-const BACKPRESSURE_THRESHOLD: usize = 10;
+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.
-const ACCEPTABLE_TIME_WITHOUT_BACKPRESSURE_SECS: u64 = 2;
+// 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;
-// If the multipler increases we log it, but we don't want to log about it too often.
-const INTERVAL_BETWEEN_WARNING_ABOUT_ELEVATED_MULTIPLIER_SECS: u64 = 60;

 pub(crate) struct SendingDelayController {
    /// Multiply the average sending delay.
@@ -38,14 +33,6 @@ pub(crate) struct SendingDelayController {
    /// Minimum delay multiplier
    lower_bound: u32,

-    /// We counter the number of times the multiplier has been elevated. If it is elevated for long
-    /// enough we need to log about it.
-    multiplier_elevated_counter: u32,
-
-    /// We can't log about the elevated multiplier too often, so we keep track of the last time we
-    /// did,
-    time_when_logged_about_elevated_multiplier: Instant,
-
    /// To make sure we don't change the multiplier to fast, we limit a change to some duration
    time_when_changed: Instant,

@@ -68,9 +55,6 @@ impl SendingDelayController {
            current_multiplier: MIN_DELAY_MULTIPLIER,
            upper_bound,
            lower_bound,
-            multiplier_elevated_counter: 0,
-            time_when_logged_about_elevated_multiplier: now
-                - Duration::from_secs(INTERVAL_BETWEEN_WARNING_ABOUT_ELEVATED_MULTIPLIER_SECS),
            time_when_changed: now,
            time_when_backpressure_detected: now,
        }
@@ -95,7 +79,7 @@ impl SendingDelayController {
            self.current_multiplier =
                (self.current_multiplier + 1).clamp(self.lower_bound, self.upper_bound);
            self.time_when_changed = get_time_now();
-            log::debug!(
+            log::warn!(
                "Increasing sending delay multiplier to: {}",
                self.current_multiplier
            );
@@ -116,58 +100,22 @@ impl SendingDelayController {
        }
    }

+    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 not_decreased_delay_recently(&self) -> bool {
-        get_time_now()
-            > self.time_when_changed + Duration::from_secs(DECREASE_DELAY_MIN_CHANGE_INTERVAL_SECS)
-    }
-
-    pub(crate) fn is_backpressure_currently_detected(&self, queue_length: usize) -> bool {
-        queue_length > BACKPRESSURE_THRESHOLD
-    }
-
-    pub(crate) fn record_backpressure_detected(&mut self) {
-        self.time_when_backpressure_detected = get_time_now();
-    }
-
-    pub(crate) fn was_backpressure_detected_recently(&self) -> bool {
-        get_time_now()
-            < self.time_when_backpressure_detected
-                + Duration::from_secs(ACCEPTABLE_TIME_WITHOUT_BACKPRESSURE_SECS)
-    }
-
-    pub(crate) fn record_delay_multiplier(&mut self) {
-        // Count the number of times the multiplier has been elevated.
-        let multiplier_elevated = self.current_multiplier - self.lower_bound;
-        if multiplier_elevated == 0 {
-            self.multiplier_elevated_counter = 0;
-        } else {
-            self.multiplier_elevated_counter += 1;
-        }
-
-        // If needed, log about the elevated multiplier.
+    pub(crate) fn is_sending_reliable(&self) -> bool {
        let now = get_time_now();
-        if self.multiplier_elevated_counter > 20
-            && now
-                > self.time_when_logged_about_elevated_multiplier
-                    + Duration::from_secs(INTERVAL_BETWEEN_WARNING_ABOUT_ELEVATED_MULTIPLIER_SECS)
-        {
-            let status_str = format!(
-                "Poisson delay currently scaled by: {}",
-                self.current_multiplier()
-            );
-            if self.current_multiplier() > 0 {
-                log::debug!("{}", status_str);
-            } else if self.current_multiplier() > 1 {
-                log::info!("{}", status_str);
-            } else if self.current_multiplier() > 2 {
-                log::warn!("{}", status_str);
-            }
-            self.time_when_logged_about_elevated_multiplier = 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
    }
 }
@@ -7,10 +7,10 @@ use crate::spawn_future;
 use futures::channel::mpsc;
 use futures::lock::Mutex;
 use futures::StreamExt;
+use gateway_client::MixnetMessageReceiver;
 use log::*;
 use nym_crypto::asymmetric::encryption;
 use nym_crypto::Digest;
-use nym_gateway_client::MixnetMessageReceiver;
 use nym_sphinx::anonymous_replies::requests::{
    RepliableMessage, RepliableMessageContent, ReplyMessage, ReplyMessageContent,
 };
@@ -30,13 +30,13 @@ pub type ReceivedBufferRequestReceiver = mpsc::UnboundedReceiver<ReceivedBufferM
 pub type ReconstructedMessagesSender = mpsc::UnboundedSender<Vec<ReconstructedMessage>>;
 pub type ReconstructedMessagesReceiver = mpsc::UnboundedReceiver<Vec<ReconstructedMessage>>;

-struct ReceivedMessagesBufferInner<R: MessageReceiver> {
+struct ReceivedMessagesBufferInner {
    messages: Vec<ReconstructedMessage>,
    local_encryption_keypair: Arc<encryption::KeyPair>,

    // TODO: looking how it 'looks' here, perhaps `MessageReceiver` should be renamed to something
    // else instead.
-    message_receiver: R,
+    message_receiver: MessageReceiver,
    message_sender: Option<ReconstructedMessagesSender>,

    // TODO: this will get cleared upon re-running the client
@@ -45,7 +45,7 @@ struct ReceivedMessagesBufferInner<R: MessageReceiver> {
    recently_reconstructed: HashSet<i32>,
 }

-impl<R: MessageReceiver> ReceivedMessagesBufferInner<R> {
+impl ReceivedMessagesBufferInner {
    fn recover_from_fragment(&mut self, fragment_data: &[u8]) -> Option<NymMessage> {
        if nym_sphinx::cover::is_cover(fragment_data) {
            trace!("The message was a loop cover message! Skipping it");
@@ -102,13 +102,13 @@ impl<R: MessageReceiver> ReceivedMessagesBufferInner<R> {
        &mut self,
        reply_ciphertext: &mut [u8],
        reply_key: SurbEncryptionKey,
-    ) -> Result<Option<NymMessage>, MessageRecoveryError> {
+    ) -> Option<NymMessage> {
        // note: this performs decryption IN PLACE without extra allocation
        self.message_receiver
-            .recover_plaintext_from_reply(reply_ciphertext, reply_key)?;
+            .recover_plaintext_from_reply(reply_ciphertext, reply_key);
        let fragment_data = reply_ciphertext;

-        Ok(self.recover_from_fragment(fragment_data))
+        self.recover_from_fragment(fragment_data)
    }

    fn process_received_regular_packet(&mut self, mut raw_fragment: Vec<u8>) -> Option<NymMessage> {
@@ -130,13 +130,13 @@ impl<R: MessageReceiver> ReceivedMessagesBufferInner<R> {
 #[derive(Debug, Clone)]
 // Note: you should NEVER create more than a single instance of this using 'new()'.
 // You should always use .clone() to create additional instances
-struct ReceivedMessagesBuffer<R: MessageReceiver> {
-    inner: Arc<Mutex<ReceivedMessagesBufferInner<R>>>,
+struct ReceivedMessagesBuffer {
+    inner: Arc<Mutex<ReceivedMessagesBufferInner>>,
    reply_key_storage: SentReplyKeys,
    reply_controller_sender: ReplyControllerSender,
 }

-impl<R: MessageReceiver> ReceivedMessagesBuffer<R> {
+impl ReceivedMessagesBuffer {
    fn new(
        local_encryption_keypair: Arc<encryption::KeyPair>,
        reply_key_storage: SentReplyKeys,
@@ -146,7 +146,7 @@ impl<R: MessageReceiver> ReceivedMessagesBuffer<R> {
            inner: Arc::new(Mutex::new(ReceivedMessagesBufferInner {
                messages: Vec::new(),
                local_encryption_keypair,
-                message_receiver: R::new(),
+                message_receiver: MessageReceiver::new(),
                message_sender: None,
                recently_reconstructed: HashSet::new(),
            })),
@@ -328,10 +328,7 @@ impl<R: MessageReceiver> ReceivedMessagesBuffer<R> {
            })
    }

-    async fn handle_new_received(
-        &mut self,
-        msgs: Vec<Vec<u8>>,
-    ) -> Result<(), MessageRecoveryError> {
+    async fn handle_new_received(&mut self, msgs: Vec<Vec<u8>>) {
        trace!(
            "Processing {:?} new message that might get added to the buffer!",
            msgs.len()
@@ -347,7 +344,7 @@ impl<R: MessageReceiver> ReceivedMessagesBuffer<R> {
            // 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)?
+                    inner_guard.process_received_reply(reply_message, reply_key)
                } else {
                    inner_guard.process_received_regular_packet(msg)
                };
@@ -363,7 +360,6 @@ impl<R: MessageReceiver> ReceivedMessagesBuffer<R> {
        if !completed_messages.is_empty() {
            self.handle_reconstructed_messages(completed_messages).await
        }
-        Ok(())
    }
 }

@@ -376,14 +372,14 @@ pub enum ReceivedBufferMessage {
    ReceiverDisconnect,
 }

-struct RequestReceiver<R: MessageReceiver> {
-    received_buffer: ReceivedMessagesBuffer<R>,
+struct RequestReceiver {
+    received_buffer: ReceivedMessagesBuffer,
    query_receiver: ReceivedBufferRequestReceiver,
 }

-impl<R: MessageReceiver> RequestReceiver<R> {
+impl RequestReceiver {
    fn new(
-        received_buffer: ReceivedMessagesBuffer<R>,
+        received_buffer: ReceivedMessagesBuffer,
        query_receiver: ReceivedBufferRequestReceiver,
    ) -> Self {
        RequestReceiver {
@@ -426,14 +422,14 @@ impl<R: MessageReceiver> RequestReceiver<R> {
    }
 }

-struct FragmentedMessageReceiver<R: MessageReceiver> {
-    received_buffer: ReceivedMessagesBuffer<R>,
+struct FragmentedMessageReceiver {
+    received_buffer: ReceivedMessagesBuffer,
    mixnet_packet_receiver: MixnetMessageReceiver,
 }

-impl<R: MessageReceiver> FragmentedMessageReceiver<R> {
+impl FragmentedMessageReceiver {
    fn new(
-        received_buffer: ReceivedMessagesBuffer<R>,
+        received_buffer: ReceivedMessagesBuffer,
        mixnet_packet_receiver: MixnetMessageReceiver,
    ) -> Self {
        FragmentedMessageReceiver {
@@ -442,16 +438,13 @@ impl<R: MessageReceiver> FragmentedMessageReceiver<R> {
        }
    }

-    async fn run_with_shutdown(
-        &mut self,
-        mut shutdown: nym_task::TaskClient,
-    ) -> Result<(), MessageRecoveryError> {
+    async fn run_with_shutdown(&mut self, mut shutdown: nym_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?;
+                        self.received_buffer.handle_new_received(new_messages).await;
                    } else {
                        log::trace!("FragmentedMessageReceiver: Stopping since channel closed");
                        break;
@@ -464,16 +457,15 @@ impl<R: MessageReceiver> FragmentedMessageReceiver<R> {
        }
        shutdown.recv_timeout().await;
        log::debug!("FragmentedMessageReceiver: Exiting");
-        Ok(())
    }
 }

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

-impl<R: MessageReceiver + Clone + Send + 'static> ReceivedMessagesBufferController<R> {
+impl ReceivedMessagesBufferController {
    pub(crate) fn new(
        local_encryption_keypair: Arc<encryption::KeyPair>,
        query_receiver: ReceivedBufferRequestReceiver,
@@ -502,13 +494,9 @@ impl<R: MessageReceiver + Clone + Send + 'static> ReceivedMessagesBufferControll

        let shutdown_handle = shutdown.clone();
        spawn_future(async move {
-            match fragmented_message_receiver
+            fragmented_message_receiver
                .run_with_shutdown(shutdown_handle)
-                .await
-            {
-                Ok(_) => {}
-                Err(e) => error!("{e}"),
-            }
+                .await;
        });
        spawn_future(async move {
            request_receiver.run_with_shutdown(shutdown).await;
@@ -22,21 +22,38 @@ use time::OffsetDateTime;

 use crate::client::helpers::new_interval_stream;
 use crate::client::transmission_buffer::TransmissionBuffer;
-use crate::config;
 pub(crate) use requests::{ReplyControllerMessage, ReplyControllerReceiver, ReplyControllerSender};

 pub mod requests;

-// this is still left as a separate config so I wouldn't need to replace it everywhere
-// plus its not unreasonable to think that we might need something outside config::ReplySurbs struct
 pub struct Config {
-    reply_surbs: config::ReplySurbs,
+    min_surb_request_size: u32,
+    max_surb_request_size: u32,
+    maximum_allowed_reply_surb_request_size: u32,
+    max_surb_rerequest_waiting_period: Duration,
+    max_surb_drop_waiting_period: Duration,
+    max_reply_surb_age: Duration,
+    max_reply_key_age: Duration,
 }

 impl Config {
-    pub(crate) fn new(reply_surbs_cfg: config::ReplySurbs) -> Self {
+    pub(crate) fn new(
+        min_surb_request_size: u32,
+        max_surb_request_size: u32,
+        maximum_allowed_reply_surb_request_size: u32,
+        max_surb_rerequest_waiting_period: Duration,
+        max_surb_drop_waiting_period: Duration,
+        max_reply_surb_age: Duration,
+        max_reply_key_age: Duration,
+    ) -> Self {
        Self {
-            reply_surbs: reply_surbs_cfg,
+            min_surb_request_size,
+            max_surb_request_size,
+            maximum_allowed_reply_surb_request_size,
+            max_surb_rerequest_waiting_period,
+            max_surb_drop_waiting_period,
+            max_reply_surb_age,
+            max_reply_key_age,
        }
    }
 }
@@ -492,17 +509,9 @@ where
        }

        // 2. check whether the requested amount is within sane range
-        if amount
-            > self
-                .config
-                .reply_surbs
-                .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.reply_surbs.maximum_allowed_reply_surb_request_size);
-            amount = self
-                .config
-                .reply_surbs
-                .maximum_allowed_reply_surb_request_size;
+        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
@@ -512,11 +521,7 @@ where
            let to_send = min(remaining, 100);
            if let Err(err) = self
                .message_handler
-                .try_send_additional_reply_surbs(
-                    recipient,
-                    to_send,
-                    nym_sphinx::params::PacketType::Mix,
-                )
+                .try_send_additional_reply_surbs(recipient, to_send)
                .await
            {
                warn!("failed to send additional surbs to {recipient} - {err}");
@@ -702,11 +707,8 @@ where
        }

        let request_size = min(
-            self.config.reply_surbs.maximum_reply_surb_request_size,
-            max(
-                total_queue,
-                self.config.reply_surbs.minimum_reply_surb_request_size,
-            ),
+            self.config.max_surb_request_size,
+            max(total_queue, self.config.min_surb_request_size),
        );

        if let Err(err) = self
@@ -742,17 +744,9 @@ where
            };

            let diff = now - last_received_time;
-            let max_rerequest_wait = self
-                .config
-                .reply_surbs
-                .maximum_reply_surb_rerequest_waiting_period;
-            let max_drop_wait = self
-                .config
-                .reply_surbs
-                .maximum_reply_surb_drop_waiting_period;

-            if diff > max_rerequest_wait {
-                if diff > max_drop_wait {
+            if diff > self.config.max_surb_rerequest_waiting_period {
+                if diff > self.config.max_surb_drop_waiting_period {
                    to_remove.push(*pending_reply_target)
                } else {
                    debug!("We haven't received any surbs in {:?} from {pending_reply_target}. Going to explicitly ask for more", diff);
@@ -799,7 +793,7 @@ where
            };
            let diff = now - last_received_time;

-            if diff > self.config.reply_surbs.maximum_reply_surb_age {
+            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);
@@ -819,7 +813,7 @@ where

            let diff = now - sent_at;

-            if diff > self.config.reply_surbs.maximum_reply_key_age {
+            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);
            }
@@ -848,8 +842,7 @@ where
        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.reply_surbs.maximum_reply_surb_age.as_secs() / 10);
+        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() {
@@ -35,12 +35,8 @@ impl ReplyStorageBackend for Backend {
    ) -> Result<Self, Self::StorageError> {
        Ok(Backend {
            empty: Empty {
-                min_surb_threshold: debug_config
-                    .reply_surbs
-                    .minimum_reply_surb_storage_threshold,
-                max_surb_threshold: debug_config
-                    .reply_surbs
-                    .maximum_reply_surb_storage_threshold,
+                min_surb_threshold: debug_config.minimum_reply_surb_storage_threshold,
+                max_surb_threshold: debug_config.maximum_reply_surb_storage_threshold,
            },
        })
    }
@@ -35,12 +35,8 @@ impl ReplyStorageBackend for Empty {
        _db_path: Option<PathBuf>,
    ) -> Result<Self, Self::StorageError> {
        Ok(Self {
-            min_surb_threshold: debug_config
-                .reply_surbs
-                .minimum_reply_surb_storage_threshold,
-            max_surb_threshold: debug_config
-                .reply_surbs
-                .maximum_reply_surb_storage_threshold,
+            min_surb_threshold: debug_config.minimum_reply_surb_storage_threshold,
+            max_surb_threshold: debug_config.maximum_reply_surb_storage_threshold,
        })
    }

@@ -10,7 +10,7 @@ use rand::thread_rng;
 use url::Url;

 pub(crate) struct NymApiTopologyProvider {
-    validator_client: nym_validator_client::client::NymApiClient,
+    validator_client: validator_client::client::NymApiClient,
    nym_api_urls: Vec<Url>,

    client_version: String,
@@ -22,9 +22,7 @@ impl NymApiTopologyProvider {
        nym_api_urls.shuffle(&mut thread_rng());

        NymApiTopologyProvider {
-            validator_client: nym_validator_client::client::NymApiClient::new(
-                nym_api_urls[0].clone(),
-            ),
+            validator_client: validator_client::client::NymApiClient::new(nym_api_urls[0].clone()),
            nym_api_urls,
            client_version,
            currently_used_api: 0,
@@ -28,7 +28,7 @@ impl SizedData for RealMessage {

 impl SizedData for Fragment {
    fn data_size(&self) -> usize {
-        // note that raw `Fragment` is smaller than packet payload
+        // 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()
    }
@@ -171,6 +171,8 @@ impl<T> TransmissionBuffer<T> {
        &mut self,
        n: usize,
    ) -> Option<Vec<(TransmissionLane, T)>> {
+        // let start = Instant::now();
+
        if self.buffer.is_empty() {
            return None;
        }
@@ -185,6 +187,8 @@ impl<T> TransmissionBuffer<T> {
            items.push(next)
        }

+        // todo!("time time taken");
+
        Some(items)
    }

@@ -3,7 +3,7 @@

 use nym_config::defaults::NymNetworkDetails;
 use nym_config::{NymConfig, OptionalSet, CRED_DB_FILE_NAME};
-use nym_sphinx::params::{PacketSize, PacketType};
+use nym_sphinx::params::PacketSize;
 use serde::{Deserialize, Serialize};
 use std::marker::PhantomData;
 use std::path::PathBuf;
@@ -13,7 +13,6 @@ use url::Url;
 #[cfg(target_arch = "wasm32")]
 use wasm_bindgen::prelude::*;

-pub mod old_config_v1_1_13;
 pub mod persistence;

 pub const MISSING_VALUE: &str = "MISSING VALUE";
@@ -32,8 +31,6 @@ 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);

-const DEFAULT_COVER_TRAFFIC_PRIMARY_SIZE_RATIO: f64 = 0.70;
-
 // reply-surbs related:

 // define when to request
@@ -92,11 +89,6 @@ impl<T> Config<T> {
        Config::default().with_id(id)
    }

-    pub fn validate(&self) -> bool {
-        // no other sections have explicit requirements (yet)
-        self.debug.validate()
-    }
-
    #[must_use]
    pub fn with_id<S: Into<String>>(mut self, id: S) -> Self
    where
@@ -217,18 +209,12 @@ impl<T> Config<T> {
        self
    }

-    pub fn with_packet_type(mut self, packet_type: PacketType) -> Self {
-        self.client.packet_type = Some(packet_type);
-        self
-    }
-
    pub fn set_high_default_traffic_volume(&mut self) {
-        self.debug.traffic.average_packet_delay = Duration::from_millis(10);
+        self.debug.average_packet_delay = Duration::from_millis(10);
        // basically don't really send cover messages
-        self.debug.cover_traffic.loop_cover_traffic_average_delay =
-            Duration::from_millis(2_000_000);
+        self.debug.loop_cover_traffic_average_delay = Duration::from_millis(2_000_000);
        // 250 "real" messages / s
-        self.debug.traffic.message_sending_average_delay = Duration::from_millis(4);
+        self.debug.message_sending_average_delay = Duration::from_millis(4);
    }

    pub fn with_disabled_cover_traffic(mut self, disabled: bool) -> Self {
@@ -239,8 +225,8 @@ impl<T> Config<T> {
    }

    pub fn set_no_cover_traffic(&mut self) {
-        self.debug.cover_traffic.disable_loop_cover_traffic_stream = true;
-        self.debug.traffic.disable_main_poisson_packet_distribution = true;
+        self.debug.disable_loop_cover_traffic_stream = true;
+        self.debug.disable_main_poisson_packet_distribution = true;
    }

    pub fn set_custom_version(&mut self, version: &str) {
@@ -325,93 +311,87 @@ impl<T> Config<T> {
    }

    pub fn get_average_packet_delay(&self) -> Duration {
-        self.debug.traffic.average_packet_delay
+        self.debug.average_packet_delay
    }

    pub fn get_average_ack_delay(&self) -> Duration {
-        self.debug.acknowledgements.average_ack_delay
+        self.debug.average_ack_delay
    }

    pub fn get_ack_wait_multiplier(&self) -> f64 {
-        self.debug.acknowledgements.ack_wait_multiplier
+        self.debug.ack_wait_multiplier
    }

    pub fn get_ack_wait_addition(&self) -> Duration {
-        self.debug.acknowledgements.ack_wait_addition
+        self.debug.ack_wait_addition
    }

    pub fn get_loop_cover_traffic_average_delay(&self) -> Duration {
-        self.debug.cover_traffic.loop_cover_traffic_average_delay
+        self.debug.loop_cover_traffic_average_delay
    }

    pub fn get_message_sending_average_delay(&self) -> Duration {
-        self.debug.traffic.message_sending_average_delay
+        self.debug.message_sending_average_delay
    }

    pub fn get_gateway_response_timeout(&self) -> Duration {
-        self.debug.gateway_connection.gateway_response_timeout
+        self.debug.gateway_response_timeout
    }

    pub fn get_topology_refresh_rate(&self) -> Duration {
-        self.debug.topology.topology_refresh_rate
+        self.debug.topology_refresh_rate
    }

    pub fn get_topology_resolution_timeout(&self) -> Duration {
-        self.debug.topology.topology_resolution_timeout
+        self.debug.topology_resolution_timeout
    }

    pub fn get_disabled_loop_cover_traffic_stream(&self) -> bool {
-        self.debug.cover_traffic.disable_loop_cover_traffic_stream
+        self.debug.disable_loop_cover_traffic_stream
    }

    pub fn get_disabled_main_poisson_packet_distribution(&self) -> bool {
-        self.debug.traffic.disable_main_poisson_packet_distribution
+        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.reply_surbs.minimum_reply_surb_storage_threshold
+        self.debug.minimum_reply_surb_storage_threshold
    }

    pub fn get_maximum_reply_surb_storage_threshold(&self) -> usize {
-        self.debug.reply_surbs.maximum_reply_surb_storage_threshold
+        self.debug.maximum_reply_surb_storage_threshold
    }

    pub fn get_minimum_reply_surb_request_size(&self) -> u32 {
-        self.debug.reply_surbs.minimum_reply_surb_request_size
+        self.debug.minimum_reply_surb_request_size
    }

    pub fn get_maximum_reply_surb_request_size(&self) -> u32 {
-        self.debug.reply_surbs.maximum_reply_surb_request_size
+        self.debug.maximum_reply_surb_request_size
    }

    pub fn get_maximum_allowed_reply_surb_request_size(&self) -> u32 {
-        self.debug
-            .reply_surbs
-            .maximum_allowed_reply_surb_request_size
+        self.debug.maximum_allowed_reply_surb_request_size
    }

    pub fn get_maximum_reply_surb_rerequest_waiting_period(&self) -> Duration {
-        self.debug
-            .reply_surbs
-            .maximum_reply_surb_rerequest_waiting_period
+        self.debug.maximum_reply_surb_rerequest_waiting_period
    }

    pub fn get_maximum_reply_surb_drop_waiting_period(&self) -> Duration {
-        self.debug
-            .reply_surbs
-            .maximum_reply_surb_drop_waiting_period
+        self.debug.maximum_reply_surb_drop_waiting_period
    }

    pub fn get_maximum_reply_surb_age(&self) -> Duration {
-        self.debug.reply_surbs.maximum_reply_surb_age
+        self.debug.maximum_reply_surb_age
    }

    pub fn get_maximum_reply_key_age(&self) -> Duration {
-        self.debug.reply_surbs.maximum_reply_key_age
-    }
-
-    pub fn get_packet_type(&self) -> PacketType {
-        self.client.packet_type.unwrap_or(PacketType::Mix)
+        self.debug.maximum_reply_key_age
    }
 }

@@ -470,65 +450,63 @@ impl From<nym_topology::gateway::Node> for GatewayEndpointConfig {
 pub struct Client<T> {
    /// Version of the client for which this configuration was created.
    #[serde(default = "missing_string_value")]
-    pub version: String,
+    version: String,

    /// ID specifies the human readable ID of this particular client.
-    pub id: String,
+    id: String,

    /// Indicates whether this client is running in a disabled credentials mode, thus attempting
    /// to claim bandwidth without presenting bandwidth credentials.
    #[serde(default)]
-    pub disabled_credentials_mode: bool,
+    disabled_credentials_mode: bool,

    /// Addresses to nyxd validators via which the client can communicate with the chain.
    #[serde(alias = "validator_urls")]
-    pub nyxd_urls: Vec<Url>,
+    nyxd_urls: Vec<Url>,

    /// Addresses to APIs running on validator from which the client gets the view of the network.
    #[serde(alias = "validator_api_urls")]
-    pub nym_api_urls: Vec<Url>,
+    nym_api_urls: Vec<Url>,

    /// Path to file containing private identity key.
-    pub private_identity_key_file: PathBuf,
+    private_identity_key_file: PathBuf,

    /// Path to file containing public identity key.
-    pub public_identity_key_file: PathBuf,
+    public_identity_key_file: PathBuf,

    /// Path to file containing private encryption key.
-    pub private_encryption_key_file: PathBuf,
+    private_encryption_key_file: PathBuf,

    /// Path to file containing public encryption key.
-    pub public_encryption_key_file: PathBuf,
+    public_encryption_key_file: PathBuf,

    /// Path to file containing shared key derived with the specified gateway that is used
    /// for all communication with it.
-    pub gateway_shared_key_file: PathBuf,
+    gateway_shared_key_file: PathBuf,

    /// Path to file containing key used for encrypting and decrypting the content of an
    /// acknowledgement so that nobody besides the client knows which packet it refers to.
-    pub ack_key_file: PathBuf,
+    ack_key_file: PathBuf,

    /// Information regarding how the client should send data to gateway.
-    pub gateway_endpoint: GatewayEndpointConfig,
+    gateway_endpoint: GatewayEndpointConfig,

    /// Path to the database containing bandwidth credentials of this client.
-    pub database_path: PathBuf,
+    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)]
-    pub reply_surb_database_path: PathBuf,
+    reply_surb_database_path: PathBuf,

    /// 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.
-    pub nym_root_directory: PathBuf,
+    nym_root_directory: PathBuf,

    #[serde(skip)]
-    pub super_struct: PhantomData<T>,
-
-    pub packet_type: Option<PacketType>,
+    super_struct: PhantomData<T>,
 }

 impl<T: NymConfig> Default for Client<T> {
@@ -567,7 +545,6 @@ impl<T: NymConfig> Default for Client<T> {
            reply_surb_database_path: Default::default(),
            nym_root_directory: T::default_root_directory(),
            super_struct: Default::default(),
-            packet_type: Default::default(),
        }
    }
 }
@@ -610,9 +587,9 @@ impl<T: NymConfig> Client<T> {
 #[serde(deny_unknown_fields)]
 pub struct Logging {}

-#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
-#[serde(default)]
-pub struct Traffic {
+#[derive(Debug, Clone, Deserialize, PartialEq, Serialize)]
+#[serde(default, deny_unknown_fields)]
+pub struct DebugConfig {
    /// 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
@@ -620,99 +597,6 @@ pub struct Traffic {
    #[serde(with = "humantime_serde")]
    pub average_packet_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,
-
-    /// Controls whether the main packet stream constantly produces packets according to the predefined
-    /// poisson distribution.
-    pub disable_main_poisson_packet_distribution: bool,
-
-    /// Specifies the packet size used for sent messages.
-    /// Do not override it unless you understand the consequences of that change.
-    pub primary_packet_size: PacketSize,
-
-    /// Specifies the optional auxiliary packet size for optimizing message streams.
-    /// Note that its use decreases overall anonymity.
-    /// Do not set it it unless you understand the consequences of that change.
-    pub secondary_packet_size: Option<PacketSize>,
-}
-
-impl Traffic {
-    pub fn validate(&self) -> bool {
-        if let Some(secondary_packet_size) = self.secondary_packet_size {
-            if secondary_packet_size == PacketSize::AckPacket
-                || secondary_packet_size == self.primary_packet_size
-            {
-                return false;
-            }
-        }
-        true
-    }
-}
-
-impl Default for Traffic {
-    fn default() -> Self {
-        Traffic {
-            average_packet_delay: DEFAULT_AVERAGE_PACKET_DELAY,
-            message_sending_average_delay: DEFAULT_MESSAGE_STREAM_AVERAGE_DELAY,
-            disable_main_poisson_packet_distribution: false,
-            primary_packet_size: PacketSize::RegularPacket,
-            secondary_packet_size: None,
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
-#[serde(default, deny_unknown_fields)]
-pub struct CoverTraffic {
-    /// 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,
-
-    /// Specifies the ratio of `primary_packet_size` to `secondary_packet_size` used in cover traffic.
-    /// Only applicable if `secondary_packet_size` is enabled.
-    pub cover_traffic_primary_size_ratio: f64,
-
-    /// 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,
-}
-
-impl Default for CoverTraffic {
-    fn default() -> Self {
-        CoverTraffic {
-            loop_cover_traffic_average_delay: DEFAULT_LOOP_COVER_STREAM_AVERAGE_DELAY,
-            cover_traffic_primary_size_ratio: DEFAULT_COVER_TRAFFIC_PRIMARY_SIZE_RATIO,
-            disable_loop_cover_traffic_stream: false,
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
-#[serde(default, deny_unknown_fields)]
-pub struct GatewayConnection {
-    /// 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,
-}
-
-impl Default for GatewayConnection {
-    fn default() -> Self {
-        GatewayConnection {
-            gateway_response_timeout: DEFAULT_GATEWAY_RESPONSE_TIMEOUT,
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
-#[serde(default, deny_unknown_fields)]
-pub struct Acknowledgements {
    /// 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
@@ -730,21 +614,24 @@ pub struct Acknowledgements {
    /// In an ideal network with 0 latency, this value would have been 0.
    #[serde(with = "humantime_serde")]
    pub ack_wait_addition: Duration,
-}

-impl Default for Acknowledgements {
-    fn default() -> Self {
-        Acknowledgements {
-            average_ack_delay: DEFAULT_AVERAGE_PACKET_DELAY,
-            ack_wait_multiplier: DEFAULT_ACK_WAIT_MULTIPLIER,
-            ack_wait_addition: DEFAULT_ACK_WAIT_ADDITION,
-        }
-    }
-}
+    /// 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,
+
+    /// 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,
+
+    /// 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,

-#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
-#[serde(default, deny_unknown_fields)]
-pub struct Topology {
    /// The uniform delay every which clients are querying the directory server
    /// to try to obtain a compatible network topology to send sphinx packets through.
    #[serde(with = "humantime_serde")]
@@ -756,25 +643,17 @@ pub struct Topology {
    #[serde(with = "humantime_serde")]
    pub topology_resolution_timeout: Duration,

-    /// Specifies whether the client should not refresh the network topology after obtaining
-    /// the first valid instance.
-    /// Supersedes `topology_refresh_rate_ms`.
-    pub disable_refreshing: bool,
-}
+    /// 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,

-impl Default for Topology {
-    fn default() -> Self {
-        Topology {
-            topology_refresh_rate: DEFAULT_TOPOLOGY_REFRESH_RATE,
-            topology_resolution_timeout: DEFAULT_TOPOLOGY_RESOLUTION_TIMEOUT,
-            disable_refreshing: false,
-        }
-    }
-}
+    /// 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>,

-#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
-#[serde(default, deny_unknown_fields)]
-pub struct ReplySurbs {
    /// 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,
@@ -812,9 +691,29 @@ pub struct ReplySurbs {
    pub maximum_reply_key_age: Duration,
 }

-impl Default for ReplySurbs {
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "lowercase")]
+pub enum ExtendedPacketSize {
+    Extended8,
+    Extended16,
+    Extended32,
+}
+
+impl Default for DebugConfig {
    fn default() -> Self {
-        ReplySurbs {
+        DebugConfig {
+            average_packet_delay: DEFAULT_AVERAGE_PACKET_DELAY,
+            average_ack_delay: DEFAULT_AVERAGE_PACKET_DELAY,
+            ack_wait_multiplier: DEFAULT_ACK_WAIT_MULTIPLIER,
+            ack_wait_addition: DEFAULT_ACK_WAIT_ADDITION,
+            loop_cover_traffic_average_delay: DEFAULT_LOOP_COVER_STREAM_AVERAGE_DELAY,
+            message_sending_average_delay: DEFAULT_MESSAGE_STREAM_AVERAGE_DELAY,
+            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,
@@ -829,47 +728,12 @@ impl Default for ReplySurbs {
    }
 }

-#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
-#[serde(default, deny_unknown_fields)]
-pub struct DebugConfig {
-    /// Defines all configuration options related to traffic streams.
-    pub traffic: Traffic,
-
-    /// Defines all configuration options related to cover traffic stream(s).
-    pub cover_traffic: CoverTraffic,
-
-    /// Defines all configuration options related to the gateway connection.
-    pub gateway_connection: GatewayConnection,
-
-    /// Defines all configuration options related to acknowledgements, such as delays or wait timeouts.
-    pub acknowledgements: Acknowledgements,
-
-    /// Defines all configuration options related topology, such as refresh rates or timeouts.
-    pub topology: Topology,
-
-    /// Defines all configuration options related to reply SURBs.
-    pub reply_surbs: ReplySurbs,
-}
-
-impl DebugConfig {
-    pub fn validate(&self) -> bool {
-        // no other sections have explicit requirements (yet)
-        self.traffic.validate()
-    }
-}
-
-// it could be derived, sure, but I'd rather have an explicit implementation in case we had to change
-// something manually at some point
-#[allow(clippy::derivable_impls)]
-impl Default for DebugConfig {
-    fn default() -> Self {
-        DebugConfig {
-            traffic: Default::default(),
-            cover_traffic: Default::default(),
-            gateway_connection: Default::default(),
-            acknowledgements: Default::default(),
-            topology: Default::default(),
-            reply_surbs: Default::default(),
+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,11 +1,11 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

+use gateway_client::error::GatewayClientError;
 use nym_crypto::asymmetric::identity::Ed25519RecoveryError;
-use nym_gateway_client::error::GatewayClientError;
 use nym_topology::gateway::GatewayConversionError;
 use nym_topology::NymTopologyError;
-use nym_validator_client::ValidatorClientError;
+use validator_client::ValidatorClientError;

 #[derive(thiserror::Error, Debug)]
 pub enum ClientCoreError {
@@ -7,11 +7,11 @@ use crate::{
    error::ClientCoreError,
 };
 use futures::{SinkExt, StreamExt};
+use gateway_client::GatewayClient;
+use gateway_requests::registration::handshake::SharedKeys;
 use log::{debug, info, trace, warn};
 use nym_config::NymConfig;
 use nym_crypto::asymmetric::identity;
-use nym_gateway_client::GatewayClient;
-use nym_gateway_requests::registration::handshake::SharedKeys;
 use nym_topology::{filter::VersionFilterable, gateway};
 use rand::{seq::SliceRandom, thread_rng, Rng};
 use std::{sync::Arc, time::Duration};
@@ -19,8 +19,6 @@ use tap::TapFallible;
 use tungstenite::Message;
 use url::Url;

-#[cfg(not(target_arch = "wasm32"))]
-use nym_validator_client::nyxd::DirectSigningNyxdClient;
 #[cfg(not(target_arch = "wasm32"))]
 use tokio::net::TcpStream;
 #[cfg(not(target_arch = "wasm32"))]
@@ -29,13 +27,14 @@ use tokio::time::Instant;
 use tokio_tungstenite::connect_async;
 #[cfg(not(target_arch = "wasm32"))]
 use tokio_tungstenite::{MaybeTlsStream, WebSocketStream};
+#[cfg(not(target_arch = "wasm32"))]
+use validator_client::nyxd::SigningNyxdClient;

 #[cfg(not(target_arch = "wasm32"))]
 type WsConn = WebSocketStream<MaybeTlsStream<TcpStream>>;
-use nym_credential_storage::storage::Storage;

 #[cfg(target_arch = "wasm32")]
-use nym_bandwidth_controller::wasm_mockups::DirectSigningNyxdClient;
+use gateway_client::wasm_mockups::SigningNyxdClient;
 #[cfg(target_arch = "wasm32")]
 use wasm_timer::Instant;
 #[cfg(target_arch = "wasm32")]
@@ -68,7 +67,7 @@ async fn current_gateways<R: Rng>(
    let nym_api = nym_apis
        .choose(rng)
        .ok_or(ClientCoreError::ListOfNymApisIsEmpty)?;
-    let client = nym_validator_client::client::NymApiClient::new(nym_api.clone());
+    let client = validator_client::client::NymApiClient::new(nym_api.clone());

    log::trace!("Fetching list of gateways from: {}", nym_api);

@@ -177,7 +176,10 @@ async fn choose_gateway_by_latency<R: Rng>(
                continue;
            }
        };
-        debug!("{id}: {:?}", with_latency.latency);
+        debug!(
+            "{id} ({}): {:?}",
+            with_latency.gateway.location, with_latency.latency
+        );
        gateways_with_latency.push(with_latency)
    }

@@ -186,8 +188,8 @@ async fn choose_gateway_by_latency<R: Rng>(
        .expect("invalid selection weight!");

    info!(
-        "chose gateway {} with average latency of {:?}",
-        chosen.gateway.identity_key, chosen.latency
+        "chose gateway {} (located at {}) with average latency of {:?}",
+        chosen.gateway.identity_key, chosen.gateway.location, chosen.latency
    );

    Ok(chosen.gateway.clone())
@@ -224,12 +226,12 @@ pub(super) async fn query_gateway_details(
    }
 }

-pub(super) async fn register_with_gateway<St: Storage>(
+pub(super) 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<DirectSigningNyxdClient, St> = GatewayClient::new_init(
+    let mut gateway_client: GatewayClient<SigningNyxdClient> = GatewayClient::new_init(
        gateway.clients_address(),
        gateway.identity_key,
        our_identity.clone(),
@@ -11,7 +11,6 @@ use serde::Serialize;
 use tap::TapFallible;

 use nym_config::NymConfig;
-use nym_credential_storage::storage::Storage;
 use nym_crypto::asymmetric::{encryption, identity};
 use url::Url;

@@ -74,7 +73,7 @@ pub fn new_client_keys() -> KeyManager {
 /// Either pick one at random by querying the available gateways from the nym-api, or use the
 /// chosen one if it's among the available ones.
 /// The shared key is added to the supplied `KeyManager` and the endpoint details are returned.
-pub async fn register_with_gateway<St: Storage>(
+pub async fn register_with_gateway(
    key_manager: &mut KeyManager,
    nym_api_endpoints: Vec<Url>,
    chosen_gateway_id: Option<identity::PublicKey>,
@@ -88,7 +87,7 @@ pub async fn register_with_gateway<St: Storage>(
    let our_identity = key_manager.identity_keypair();

    // Establish connection, authenticate and generate keys for talking with the gateway
-    let shared_keys = helpers::register_with_gateway::<St>(&gateway, our_identity).await?;
+    let shared_keys = helpers::register_with_gateway(&gateway, our_identity).await?;
    key_manager.insert_gateway_shared_key(shared_keys);

    Ok(gateway.into())
@@ -101,7 +100,7 @@ pub async fn register_with_gateway<St: Storage>(
 /// b. Create a new gateway configuration but keep existing keys. This assumes that the caller
 ///    knows what they are doing and that the keys match the requested gateway.
 /// c. Create a new gateway configuration with a newly registered gateway and keys.
-pub async fn setup_gateway_from_config<C, T, St>(
+pub async fn setup_gateway_from_config<C, T>(
    register_gateway: bool,
    user_chosen_gateway_id: Option<identity::PublicKey>,
    config: &Config<T>,
@@ -110,18 +109,17 @@ pub async fn setup_gateway_from_config<C, T, St>(
 where
    C: NymConfig + ClientCoreConfigTrait,
    T: NymConfig,
-    St: Storage,
 {
    let id = config.get_id();

-    // If we are not going to register gateway, and an explicitly chosen gateway is not passed in,
+    // If we are not going to register gateway, and an explicitly chosed gateway is not passed in,
    // load the existing configuration file
    if !register_gateway && user_chosen_gateway_id.is_none() {
-        eprintln!("Not registering gateway, will reuse existing config and keys");
+        println!("Not registering gateway, will reuse existing config and keys");
        return load_existing_gateway_config::<C>(&id);
    }

-    // Else, we proceed by querying the nym-api
+    // Else, we preceed by querying the nym-api
    let gateway = helpers::query_gateway_details(
        config.get_nym_api_endpoints(),
        user_chosen_gateway_id,
@@ -133,7 +131,7 @@ where
    // If we are not registering, just return this and assume the caller has the keys already and
    // wants to keep the,
    if !register_gateway && user_chosen_gateway_id.is_some() {
-        eprintln!("Using gateway provided by user, keeping existing keys");
+        println!("Using gateway provided by user, keeping existing keys");
        return Ok(gateway.into());
    }

@@ -142,8 +140,8 @@ where
    let our_identity = key_manager.identity_keypair();

    // Establish connection, authenticate and generate keys for talking with the gateway
-    eprintln!("Registering with new gateway");
-    let shared_keys = helpers::register_with_gateway::<St>(&gateway, our_identity).await?;
+    println!("Registering with new gateway");
+    let shared_keys = helpers::register_with_gateway(&gateway, our_identity).await?;
    key_manager.insert_gateway_shared_key(shared_keys);

    // Write all keys to storage and just return the gateway endpoint config. It is assumed that we
@@ -1,23 +1,27 @@
 [package]
-name = "nym-credential-client"
+name = "credential"
 version = "0.1.0"
 edition = "2021"

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

 [dependencies]
+bip39 = { workspace = true }
 clap = { version = "4.0", features = ["cargo", "derive"] }
 log = "0.4"
-serde = { workspace = true, features = ["derive"] }
+rand = "0.7.3"
+serde = { version = "1.0", features = ["derive"] }
 thiserror = "1.0"
+url = "2.2"
 tokio = { version = "1.24.1", features = ["rt-multi-thread", "net", "signal", "macros"] } # async runtime

-nym-bandwidth-controller = { path = "../../common/bandwidth-controller" }
+nym-coconut-interface = { path = "../../common/coconut-interface" }
 nym-config = { path = "../../common/config" }
 nym-credentials = { path = "../../common/credentials" }
 nym-credential-storage = { path = "../../common/credential-storage" }
+nym-crypto = { path = "../../common/crypto", features = ["rand", "asymmetric", "symmetric", "aes", "hashing"] }
 nym-bin-common = { path = "../../common/bin-common"}
 nym-network-defaults = { path = "../../common/network-defaults" }
 nym-pemstore = { path = "../../common/pemstore" }
-nym-validator-client = { path = "../../common/client-libs/validator-client", features = ["nyxd-client"] }
+validator-client = { path = "../../common/client-libs/validator-client", features = ["nyxd-client"] }

@@ -1,32 +0,0 @@
-<!--
-Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-SPDX-License-Identifier: Apache-2.0
-->
-
-## Credential binary
-
-The credential binary is used to acquire coconut bandwidth credentials in exchange for nym tokens. Those credentials are stored in the client's `data` directory, so that they can be used as the client sees fit.
-
-### Warning
-
-The credential binary is still experimental software. The infrastructure for using it is not yet deployed to mainnet and it's still in the process of being deployed to sandbox.
-
-### Building
-
-From the project's root directory, run:
-```
-cargo build -p credential
-```
-which generates the `credential` binary in `target/debug/credential`.
-
-
-### Running
-
-For example, you can get a credential worth 3 nym (3000000 unym) in a socks5 client that was already initialized like so:
-
-```
-./target/debug/credential --config-env-file envs/sandbox.env --client-home-directory  ~/.nym/socks5-clients/cred_client  --nyxd-url  https://sandbox-validator1.nymtech.net --mnemonic $MNEMONIC  --recovery-dir /tmp/recovery --amount 3000000
-```
-
-More information regarding how to run the binary can be found by running it with the `--help` argument.
-
@@ -4,14 +4,14 @@
 use crate::error::Result;
 use bip39::Mnemonic;
 use nym_network_defaults::{NymNetworkDetails, VOUCHER_INFO};
-use nym_validator_client::nyxd;
-use nym_validator_client::nyxd::traits::CoconutBandwidthSigningClient;
-use nym_validator_client::nyxd::{Coin, DirectSigningNyxdClient, Fee, NyxdClient};
 use std::str::FromStr;
 use url::Url;
+use validator_client::nyxd;
+use validator_client::nyxd::traits::CoconutBandwidthSigningClient;
+use validator_client::nyxd::{Coin, Fee, NyxdClient, SigningNyxdClient};

 pub(crate) struct Client {
-    nyxd_client: NyxdClient<DirectSigningNyxdClient>,
+    nyxd_client: NyxdClient<SigningNyxdClient>,
    mix_denom_base: String,
 }

@@ -3,13 +3,26 @@

 use clap::{ArgGroup, Args, Subcommand};
 use log::*;
-use nym_bandwidth_controller::acquire::state::State;
 use nym_bin_common::completions::ArgShell;
-use nym_credential_storage::persistent_storage::PersistentStorage;
-use nym_validator_client::nyxd::traits::DkgQueryClient;
+use rand::rngs::OsRng;
+use std::str::FromStr;

-use crate::error::Result;
+use nym_coconut_interface::{Base58, Parameters};
+use nym_credential_storage::storage::Storage;
+use nym_credential_storage::PersistentStorage;
+use nym_credentials::coconut::bandwidth::{BandwidthVoucher, TOTAL_ATTRIBUTES};
+use nym_credentials::coconut::utils::obtain_aggregate_signature;
+use nym_crypto::asymmetric::{encryption, identity};
+use nym_network_defaults::VOUCHER_INFO;
+use validator_client::nyxd::traits::DkgQueryClient;
+use validator_client::nyxd::tx::Hash;
+use validator_client::nyxd::CosmWasmClient;
+use validator_client::CoconutApiClient;
+
+use crate::client::Client;
+use crate::error::{CredentialClientError, Result};
 use crate::recovery_storage::RecoveryStorage;
+use crate::state::{KeyPair, State};

 #[derive(Subcommand)]
 pub(crate) enum Command {
@@ -34,6 +47,10 @@ pub(crate) struct Run {
    #[clap(long)]
    pub(crate) client_home_directory: std::path::PathBuf,

+    /// The nyxd URL that should be used
+    #[clap(long)]
+    pub(crate) nyxd_url: String,
+
    /// A mnemonic for the account that buys the credential
    #[clap(long)]
    pub(crate) mnemonic: String,
@@ -52,16 +69,82 @@ pub(crate) struct Run {
    pub(crate) recovery_mode: bool,
 }

-pub(crate) async fn recover_credentials<C: DkgQueryClient + Send + Sync>(
-    client: &C,
+pub(crate) async fn deposit(nyxd_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));
+    let params = Parameters::new(TOTAL_ATTRIBUTES).unwrap();
+
+    let client = Client::new(nyxd_url, mnemonic);
+    let tx_hash = client
+        .deposit(
+            amount,
+            signing_keypair.public_key.clone(),
+            encryption_keypair.public_key.clone(),
+            None,
+        )
+        .await?;
+
+    let voucher = BandwidthVoucher::new(
+        &params,
+        amount.to_string(),
+        VOUCHER_INFO.to_string(),
+        Hash::from_str(&tx_hash).map_err(|_| CredentialClientError::InvalidTxHash)?,
+        identity::PrivateKey::from_base58_string(&signing_keypair.private_key)?,
+        encryption::PrivateKey::from_base58_string(&encryption_keypair.private_key)?,
+    );
+
+    let state = State { voucher, params };
+
+    Ok(state)
+}
+
+pub(crate) async fn get_credential<C: Clone + CosmWasmClient + Send + Sync>(
+    state: &State,
+    client: validator_client::Client<C>,
+    shared_storage: PersistentStorage,
+) -> Result<()> {
+    let epoch_id = client.nyxd.get_current_epoch().await?.epoch_id;
+    let threshold = client
+        .nyxd
+        .get_current_epoch_threshold()
+        .await?
+        .ok_or(CredentialClientError::NoThreshold)?;
+    let coconut_api_clients = CoconutApiClient::all_coconut_api_clients(&client, epoch_id).await?;
+
+    let signature = obtain_aggregate_signature(
+        &state.params,
+        &state.voucher,
+        &coconut_api_clients,
+        threshold,
+    )
+    .await?;
+    info!("Signature: {:?}", signature.to_bs58());
+    shared_storage
+        .insert_coconut_credential(
+            state.voucher.get_voucher_value(),
+            VOUCHER_INFO.to_string(),
+            state.voucher.get_private_attributes()[0].to_bs58(),
+            state.voucher.get_private_attributes()[1].to_bs58(),
+            signature.to_bs58(),
+            epoch_id.to_string(),
+        )
+        .await?;
+
+    Ok(())
+}
+
+pub(crate) async fn recover_credentials<C: Clone + CosmWasmClient + Send + Sync>(
+    client: validator_client::Client<C>,
    recovery_storage: &RecoveryStorage,
-    shared_storage: &PersistentStorage,
+    shared_storage: PersistentStorage,
 ) -> Result<()> {
    for voucher in recovery_storage.unconsumed_vouchers()? {
-        let state = State::new(voucher);
-        if let Err(e) =
-            nym_bandwidth_controller::acquire::get_credential(&state, client, shared_storage).await
-        {
+        let state = State {
+            voucher,
+            params: Parameters::new(TOTAL_ATTRIBUTES).unwrap(),
+        };
+        if let Err(e) = get_credential(&state, client.clone(), shared_storage.clone()).await {
            error!(
                "Could not recover deposit {} due to {:?}, try again later",
                state.voucher.tx_hash(),
@@ -6,8 +6,10 @@ use thiserror::Error;

 use nym_credential_storage::error::StorageError;
 use nym_credentials::error::Error as CredentialError;
-use nym_validator_client::nyxd::error::NyxdError;
-use nym_validator_client::ValidatorClientError;
+use nym_crypto::asymmetric::encryption::KeyRecoveryError;
+use nym_crypto::asymmetric::identity::Ed25519RecoveryError;
+use validator_client::nyxd::error::NyxdError;
+use validator_client::ValidatorClientError;

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

@@ -16,9 +18,6 @@ pub enum CredentialClientError {
    #[error("IO error: {0}")]
    IOError(#[from] std::io::Error),

-    #[error("Bandwidth controller error: {0}")]
-    BandwidthControllerError(#[from] nym_bandwidth_controller::error::BandwidthControllerError),
-
    #[error("Nyxd error: {0}")]
    Nyxd(#[from] NyxdError),

@@ -28,9 +27,21 @@ pub enum CredentialClientError {
    #[error("Credential error: {0}")]
    Credential(#[from] CredentialError),

+    #[error("The tx hash provided is not valid")]
+    InvalidTxHash,
+
+    #[error("Could not parse Ed25519 data")]
+    Ed25519ParseError(#[from] Ed25519RecoveryError),
+
+    #[error("Could not parse X25519 data")]
+    X25519ParseError(#[from] KeyRecoveryError),
+
    #[error("Could not use shared storage")]
    SharedStorageError(#[from] StorageError),

    #[error("Could not get system time")]
    SysTimeError(#[from] SystemTimeError),
+
+    #[error("Threshold not set yet")]
+    NoThreshold,
 }
@@ -1,9 +1,11 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

+mod client;
 mod commands;
 mod error;
 mod recovery_storage;
+mod state;

 use commands::*;
 use error::Result;
@@ -16,9 +18,9 @@ use std::time::{Duration, SystemTime};

 use clap::{CommandFactory, Parser};
 use nym_bin_common::logging::setup_logging;
-use nym_validator_client::nyxd::traits::DkgQueryClient;
-use nym_validator_client::nyxd::{Coin, CosmWasmClient};
-use nym_validator_client::Config;
+use validator_client::nyxd::traits::DkgQueryClient;
+use validator_client::nyxd::CosmWasmClient;
+use validator_client::Config;

 const SAFETY_BUFFER_SECS: u64 = 60; // 1 minute

@@ -33,8 +35,8 @@ struct Cli {
    pub(crate) command: Command,
 }

-async fn block_until_coconut_is_available<C: CosmWasmClient + Send + Sync>(
-    client: &nym_validator_client::Client<C>,
+async fn block_until_coconut_is_available<C: Clone + CosmWasmClient + Send + Sync>(
+    client: &validator_client::Client<C>,
 ) -> Result<()> {
    loop {
        let epoch = client.nyxd.get_current_epoch().await?;
@@ -75,34 +77,21 @@ async fn main() -> Result<()> {
                .client_home_directory
                .join(DATA_DIR)
                .join(CRED_DB_FILE_NAME);
-            let shared_storage =
-                nym_credential_storage::initialise_persistent_storage(db_path).await;
+            let shared_storage = nym_credential_storage::initialise_storage(db_path).await;
            let recovery_storage = recovery_storage::RecoveryStorage::new(r.recovery_dir)?;

            let network_details = NymNetworkDetails::new_from_env();
-            let config = Config::try_from_nym_network_details(&network_details).expect(
-                "failed to construct valid validator client config with the provided network",
-            );
-            let amount = Coin::new(
-                r.amount as u128,
-                network_details.chain_details.mix_denom.base,
-            );
-            let client =
-                nym_validator_client::Client::new_signing(config, r.mnemonic.parse().unwrap())?;
+            let config = Config::try_from_nym_network_details(&network_details)?;
+            let client = validator_client::Client::new_query(config)?;

            block_until_coconut_is_available(&client).await?;
            info!("Starting depositing funds, don't kill the process");

            if !r.recovery_mode {
-                let state =
-                    nym_bandwidth_controller::acquire::deposit(&client.nyxd, amount).await?;
-                if nym_bandwidth_controller::acquire::get_credential(
-                    &state,
-                    &client,
-                    &shared_storage,
-                )
-                .await
-                .is_err()
+                let state = deposit(&r.nyxd_url, &r.mnemonic, r.amount).await?;
+                if get_credential(&state, client, shared_storage)
+                    .await
+                    .is_err()
                {
                    warn!("Failed to obtain credential. Dumping recovery data.",);
                    match recovery_storage.insert_voucher(&state.voucher) {
@@ -115,11 +104,11 @@ async fn main() -> Result<()> {
                    }
                }
            } else {
-                recover_credentials(&client.nyxd, &recovery_storage, &shared_storage).await?;
+                recover_credentials(client, &recovery_storage, shared_storage).await?;
            }
        }
-        Command::Completions(c) => c.generate(&mut Cli::command(), bin_name),
-        Command::GenerateFigSpec => fig_generate(&mut Cli::command(), bin_name),
+        Command::Completions(c) => c.generate(&mut crate::Cli::command(), bin_name),
+        Command::GenerateFigSpec => fig_generate(&mut crate::Cli::command(), bin_name),
    }

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

 use nym_coconut_interface::Parameters;
-use nym_credentials::coconut::bandwidth::{BandwidthVoucher, TOTAL_ATTRIBUTES};
+use nym_credentials::coconut::bandwidth::BandwidthVoucher;

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

@@ -29,16 +29,7 @@ impl From<encryption::KeyPair> for KeyPair {
    }
 }

-pub struct State {
+pub(crate) struct State {
    pub voucher: BandwidthVoucher,
    pub params: Parameters,
 }
-
-impl State {
-    pub fn new(voucher: BandwidthVoucher) -> Self {
-        State {
-            voucher,
-            params: Parameters::new(TOTAL_ATTRIBUTES).unwrap(),
-        }
-    }
-}
@@ -1,6 +1,6 @@
 [package]
 name = "nym-client"
-version = "1.1.16"
+version = "1.1.12"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>", "Jędrzej Stuczyński <andrew@nymtech.net>"]
 description = "Implementation of the Nym Client"
 edition = "2021"
@@ -26,29 +26,30 @@ lazy_static = "1.4.0"
 log = { workspace = true } # 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 = { workspace = true, features = ["derive"] } # for config serialization/deserialization
-serde_json = { workspace = true }
+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.24.1", features = ["rt-multi-thread", "net", "signal"] } # async runtime
 tokio-tungstenite = "0.14" # websocket

 ## internal
-nym-bandwidth-controller = { path = "../../common/bandwidth-controller" }
-nym-bin-common = { path = "../../common/bin-common", features = ["output_format"] }
-nym-client-core = { path = "../../common/client-core", features = ["fs-surb-storage"] }
+nym-bin-common = { path = "../../common/bin-common" }
+client-core = { path = "../client-core", features = ["fs-surb-storage"] }
 nym-coconut-interface = { path = "../../common/coconut-interface" }
 nym-config = { path = "../../common/config" }
 nym-credential-storage = { path = "../../common/credential-storage" }
 nym-credentials = { path = "../../common/credentials" }
 nym-crypto = { path = "../../common/crypto" }
-nym-gateway-requests = { path = "../../gateway/gateway-requests" }
+gateway-client = { path = "../../common/client-libs/gateway-client" }
+gateway-requests = { path = "../../gateway/gateway-requests" }
 nym-network-defaults = { path = "../../common/network-defaults" }
 nym-sphinx = { path = "../../common/nymsphinx" }
 nym-pemstore = { path = "../../common/pemstore" }
 nym-task = { path = "../../common/task" }
 nym-topology = { path = "../../common/topology" }
-nym-validator-client = { path = "../../common/client-libs/validator-client", features = ["nyxd-client"] }
-nym-client-websocket-requests = { path = "websocket-requests" }
+validator-client = { path = "../../common/client-libs/validator-client", features = ["nyxd-client"] }
+websocket-requests = { path = "websocket-requests" }

 [dev-dependencies]
+serde_json = "1.0" # for the "textsend" example
@@ -13,7 +13,7 @@
      },
      "devDependencies": {
        "clean-webpack-plugin": "^4.0.0",
-        "webpack": "^5.76.0",
+        "webpack": "^5.70.0",
        "webpack-cli": "^4.9.2",
        "webpack-dev-server": "^4.7.4"
      }
@@ -490,9 +490,9 @@
      }
    },
    "node_modules/acorn": {
-      "version": "8.8.2",
-      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.8.2.tgz",
-      "integrity": "sha512-xjIYgE8HBrkpd/sJqOGNspf8uHG+NOHGOw6a/Urj8taM2EXfdNAH2oFcPeIFfsv3+kz/mJrS5VuMqbNLjCa2vw==",
+      "version": "8.7.0",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.7.0.tgz",
+      "integrity": "sha512-V/LGr1APy+PXIwKebEWrkZPwoeoF+w1jiOBUmuxuiUIaOHtob8Qc9BTrYo7VuI5fR8tqsy+buA2WFooR5olqvQ==",
      "bin": {
        "acorn": "bin/acorn"
      },
@@ -1327,9 +1327,9 @@
      }
    },
    "node_modules/enhanced-resolve": {
-      "version": "5.12.0",
-      "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.12.0.tgz",
-      "integrity": "sha512-QHTXI/sZQmko1cbDoNAa3mJ5qhWUUNAq3vR0/YiD379fWQrcfuoX1+HW2S0MTt7XmoPLapdaDKUtelUSPic7hQ==",
+      "version": "5.9.2",
+      "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.9.2.tgz",
+      "integrity": "sha512-GIm3fQfwLJ8YZx2smuHpBKkXC1yOk+OBEmKckVyL0i/ea8mqDEykK3ld5dgH1QYPNyT/lIllxV2LULnxCHaHkA==",
      "dependencies": {
        "graceful-fs": "^4.2.4",
        "tapable": "^2.2.0"
@@ -2380,10 +2380,10 @@
        "node": ">= 10.13.0"
      }
    },
-    "node_modules/json-parse-even-better-errors": {
-      "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz",
-      "integrity": "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w=="
+    "node_modules/json-parse-better-errors": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/json-parse-better-errors/-/json-parse-better-errors-1.0.2.tgz",
+      "integrity": "sha512-mrqyZKfX5EhL7hvqcV6WG1yYjnjeuYDzDhhcAAUrq8Po85NBQBJP+ZDUT75qZQ98IkUoBqdkExkukOU7Ts2wrw=="
    },
    "node_modules/json-schema-traverse": {
      "version": "0.4.1",
@@ -3824,9 +3824,9 @@
      }
    },
    "node_modules/watchpack": {
-      "version": "2.4.0",
-      "resolved": "https://registry.npmjs.org/watchpack/-/watchpack-2.4.0.tgz",
-      "integrity": "sha512-Lcvm7MGST/4fup+ifyKi2hjyIAwcdI4HRgtvTpIUxBRhB+RFtUh8XtDOxUfctVCnhVi+QQj49i91OyvzkJl6cg==",
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/watchpack/-/watchpack-2.3.1.tgz",
+      "integrity": "sha512-x0t0JuydIo8qCNctdDrn1OzH/qDzk2+rdCOC3YzumZ42fiMqmQ7T3xQurykYMhYfHaPHTp4ZxAx2NfUo1K6QaA==",
      "dependencies": {
        "glob-to-regexp": "^0.4.1",
        "graceful-fs": "^4.1.2"
@@ -3845,33 +3845,33 @@
      }
    },
    "node_modules/webpack": {
-      "version": "5.76.0",
-      "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.76.0.tgz",
-      "integrity": "sha512-l5sOdYBDunyf72HW8dF23rFtWq/7Zgvt/9ftMof71E/yUb1YLOBmTgA2K4vQthB3kotMrSj609txVE0dnr2fjA==",
+      "version": "5.70.0",
+      "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.70.0.tgz",
+      "integrity": "sha512-ZMWWy8CeuTTjCxbeaQI21xSswseF2oNOwc70QSKNePvmxE7XW36i7vpBMYZFAUHPwQiEbNGCEYIOOlyRbdGmxw==",
      "dependencies": {
        "@types/eslint-scope": "^3.7.3",
        "@types/estree": "^0.0.51",
        "@webassemblyjs/ast": "1.11.1",
        "@webassemblyjs/wasm-edit": "1.11.1",
        "@webassemblyjs/wasm-parser": "1.11.1",
-        "acorn": "^8.7.1",
+        "acorn": "^8.4.1",
        "acorn-import-assertions": "^1.7.6",
        "browserslist": "^4.14.5",
        "chrome-trace-event": "^1.0.2",
-        "enhanced-resolve": "^5.10.0",
+        "enhanced-resolve": "^5.9.2",
        "es-module-lexer": "^0.9.0",
        "eslint-scope": "5.1.1",
        "events": "^3.2.0",
        "glob-to-regexp": "^0.4.1",
        "graceful-fs": "^4.2.9",
-        "json-parse-even-better-errors": "^2.3.1",
+        "json-parse-better-errors": "^1.0.2",
        "loader-runner": "^4.2.0",
        "mime-types": "^2.1.27",
        "neo-async": "^2.6.2",
        "schema-utils": "^3.1.0",
        "tapable": "^2.1.1",
        "terser-webpack-plugin": "^5.1.3",
-        "watchpack": "^2.4.0",
+        "watchpack": "^2.3.1",
        "webpack-sources": "^3.2.3"
      },
      "bin": {
@@ -4894,9 +4894,9 @@
      }
    },
    "acorn": {
-      "version": "8.8.2",
-      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.8.2.tgz",
-      "integrity": "sha512-xjIYgE8HBrkpd/sJqOGNspf8uHG+NOHGOw6a/Urj8taM2EXfdNAH2oFcPeIFfsv3+kz/mJrS5VuMqbNLjCa2vw=="
+      "version": "8.7.0",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.7.0.tgz",
+      "integrity": "sha512-V/LGr1APy+PXIwKebEWrkZPwoeoF+w1jiOBUmuxuiUIaOHtob8Qc9BTrYo7VuI5fR8tqsy+buA2WFooR5olqvQ=="
    },
    "acorn-import-assertions": {
      "version": "1.8.0",
@@ -5527,9 +5527,9 @@
      "dev": true
    },
    "enhanced-resolve": {
-      "version": "5.12.0",
-      "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.12.0.tgz",
-      "integrity": "sha512-QHTXI/sZQmko1cbDoNAa3mJ5qhWUUNAq3vR0/YiD379fWQrcfuoX1+HW2S0MTt7XmoPLapdaDKUtelUSPic7hQ==",
+      "version": "5.9.2",
+      "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.9.2.tgz",
+      "integrity": "sha512-GIm3fQfwLJ8YZx2smuHpBKkXC1yOk+OBEmKckVyL0i/ea8mqDEykK3ld5dgH1QYPNyT/lIllxV2LULnxCHaHkA==",
      "requires": {
        "graceful-fs": "^4.2.4",
        "tapable": "^2.2.0"
@@ -6305,10 +6305,10 @@
        "supports-color": "^8.0.0"
      }
    },
-    "json-parse-even-better-errors": {
-      "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz",
-      "integrity": "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w=="
+    "json-parse-better-errors": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/json-parse-better-errors/-/json-parse-better-errors-1.0.2.tgz",
+      "integrity": "sha512-mrqyZKfX5EhL7hvqcV6WG1yYjnjeuYDzDhhcAAUrq8Po85NBQBJP+ZDUT75qZQ98IkUoBqdkExkukOU7Ts2wrw=="
    },
    "json-schema-traverse": {
      "version": "0.4.1",
@@ -7396,9 +7396,9 @@
      "dev": true
    },
    "watchpack": {
-      "version": "2.4.0",
-      "resolved": "https://registry.npmjs.org/watchpack/-/watchpack-2.4.0.tgz",
-      "integrity": "sha512-Lcvm7MGST/4fup+ifyKi2hjyIAwcdI4HRgtvTpIUxBRhB+RFtUh8XtDOxUfctVCnhVi+QQj49i91OyvzkJl6cg==",
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/watchpack/-/watchpack-2.3.1.tgz",
+      "integrity": "sha512-x0t0JuydIo8qCNctdDrn1OzH/qDzk2+rdCOC3YzumZ42fiMqmQ7T3xQurykYMhYfHaPHTp4ZxAx2NfUo1K6QaA==",
      "requires": {
        "glob-to-regexp": "^0.4.1",
        "graceful-fs": "^4.1.2"
@@ -7414,33 +7414,33 @@
      }
    },
    "webpack": {
-      "version": "5.76.0",
-      "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.76.0.tgz",
-      "integrity": "sha512-l5sOdYBDunyf72HW8dF23rFtWq/7Zgvt/9ftMof71E/yUb1YLOBmTgA2K4vQthB3kotMrSj609txVE0dnr2fjA==",
+      "version": "5.70.0",
+      "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.70.0.tgz",
+      "integrity": "sha512-ZMWWy8CeuTTjCxbeaQI21xSswseF2oNOwc70QSKNePvmxE7XW36i7vpBMYZFAUHPwQiEbNGCEYIOOlyRbdGmxw==",
      "requires": {
        "@types/eslint-scope": "^3.7.3",
        "@types/estree": "^0.0.51",
        "@webassemblyjs/ast": "1.11.1",
        "@webassemblyjs/wasm-edit": "1.11.1",
        "@webassemblyjs/wasm-parser": "1.11.1",
-        "acorn": "^8.7.1",
+        "acorn": "^8.4.1",
        "acorn-import-assertions": "^1.7.6",
        "browserslist": "^4.14.5",
        "chrome-trace-event": "^1.0.2",
-        "enhanced-resolve": "^5.10.0",
+        "enhanced-resolve": "^5.9.2",
        "es-module-lexer": "^0.9.0",
        "eslint-scope": "5.1.1",
        "events": "^3.2.0",
        "glob-to-regexp": "^0.4.1",
        "graceful-fs": "^4.2.9",
-        "json-parse-even-better-errors": "^2.3.1",
+        "json-parse-better-errors": "^1.0.2",
        "loader-runner": "^4.2.0",
        "mime-types": "^2.1.27",
        "neo-async": "^2.6.2",
        "schema-utils": "^3.1.0",
        "tapable": "^2.1.1",
        "terser-webpack-plugin": "^5.1.3",
-        "watchpack": "^2.4.0",
+        "watchpack": "^2.3.1",
        "webpack-sources": "^3.2.3"
      }
    },
@@ -19,7 +19,7 @@
  "license": "Apache-2.0",
  "devDependencies": {
    "clean-webpack-plugin": "^4.0.0",
-    "webpack": "^5.76.0",
+    "webpack": "^5.70.0",
    "webpack-cli": "^4.9.2",
    "webpack-dev-server": "^4.7.4"
  },
@@ -1,10 +1,10 @@
 use futures::{SinkExt, StreamExt};
-use nym_client_websocket_requests::{requests::ClientRequest, responses::ServerResponse};
 use nym_sphinx::addressing::clients::Recipient;
 use tokio::net::TcpStream;
 use tokio_tungstenite::{
    connect_async, tungstenite::protocol::Message, MaybeTlsStream, WebSocketStream,
 };
+use websocket_requests::{requests::ClientRequest, responses::ServerResponse};

 // just helpers functions that work in this very particular context because we are sending to ourselves
 // and hence will always get a response back (i.e. the message we sent)
@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::client::config::template::config_template;
-use nym_client_core::config::ClientCoreConfigTrait;
+use client_core::config::ClientCoreConfigTrait;
 use nym_config::defaults::DEFAULT_WEBSOCKET_LISTENING_PORT;
 use nym_config::{NymConfig, OptionalSet};
 use serde::{Deserialize, Serialize};
@@ -11,11 +11,10 @@ use std::net::{IpAddr, Ipv4Addr};
 use std::path::PathBuf;
 use std::str::FromStr;

-pub use nym_client_core::config::Config as BaseConfig;
-pub use nym_client_core::config::MISSING_VALUE;
-pub use nym_client_core::config::{DebugConfig, GatewayEndpointConfig};
+pub use client_core::config::Config as BaseConfig;
+pub use client_core::config::MISSING_VALUE;
+pub use client_core::config::{DebugConfig, GatewayEndpointConfig};

-pub mod old_config_v1_1_13;
 mod template;

 #[derive(Debug, Deserialize, PartialEq, Eq, Serialize, Clone, Copy)]
@@ -81,7 +80,7 @@ impl NymConfig for Config {
 }

 impl ClientCoreConfigTrait for Config {
-    fn get_gateway_endpoint(&self) -> &nym_client_core::config::GatewayEndpointConfig {
+    fn get_gateway_endpoint(&self) -> &client_core::config::GatewayEndpointConfig {
        self.base.get_gateway_endpoint()
    }
 }
@@ -94,11 +93,6 @@ impl Config {
        }
    }

-    pub fn validate(&self) -> bool {
-        // no other sections have explicit requirements (yet)
-        self.base.validate()
-    }
-
    pub fn with_socket(mut self, socket_type: SocketType) -> Self {
        self.socket.socket_type = socket_type;
        self
@@ -1,60 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::client::config::{Config, Socket};
-use nym_client_core::config::old_config_v1_1_13::OldConfigV1_1_13 as OldBaseConfigV1_1_13;
-use nym_config::NymConfig;
-use serde::{Deserialize, Serialize};
-use std::path::PathBuf;
-
-#[derive(Debug, Default, Deserialize, PartialEq, Serialize)]
-#[serde(deny_unknown_fields)]
-pub struct OldConfigV1_1_13 {
-    #[serde(flatten)]
-    base: OldBaseConfigV1_1_13<OldConfigV1_1_13>,
-
-    socket: Socket,
-}
-
-impl NymConfig for OldConfigV1_1_13 {
-    fn template() -> &'static str {
-        // not intended to be used
-        unimplemented!()
-    }
-
-    fn default_root_directory() -> PathBuf {
-        dirs::home_dir()
-            .expect("Failed to evaluate $HOME value")
-            .join(".nym")
-            .join("clients")
-    }
-
-    fn try_default_root_directory() -> Option<PathBuf> {
-        dirs::home_dir().map(|path| path.join(".nym").join("clients"))
-    }
-
-    fn root_directory(&self) -> PathBuf {
-        self.base.client.nym_root_directory.clone()
-    }
-
-    fn config_directory(&self) -> PathBuf {
-        self.root_directory()
-            .join(&self.base.client.id)
-            .join("config")
-    }
-
-    fn data_directory(&self) -> PathBuf {
-        self.root_directory()
-            .join(&self.base.client.id)
-            .join("data")
-    }
-}
-
-impl From<OldConfigV1_1_13> for Config {
-    fn from(value: OldConfigV1_1_13) -> Self {
-        Config {
-            base: value.base.into(),
-            socket: value.socket,
-        }
-    }
-}
@@ -110,15 +110,10 @@ host = '{{ socket.host }}'

 [debug]

-[debug.traffic]
-average_packet_delay = '{{ debug.traffic.average_packet_delay }}'
-message_sending_average_delay = '{{ debug.traffic.message_sending_average_delay }}'
-
-[debug.acknowledgements]
-average_ack_delay = '{{ debug.acknowledgements.average_ack_delay }}'
-
-[debug.cover_traffic]
-loop_cover_traffic_average_delay = '{{ debug.cover_traffic.loop_cover_traffic_average_delay }}'
+average_packet_delay = '{{ debug.average_packet_delay }}'
+average_ack_delay = '{{ debug.average_ack_delay }}'
+loop_cover_traffic_average_delay = '{{ debug.loop_cover_traffic_average_delay }}'
+message_sending_average_delay = '{{ debug.message_sending_average_delay }}'

 "#
 }
@@ -1,34 +1,31 @@
 // Copyright 2021-2022 - 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 futures::channel::mpsc;
-use log::*;
-use nym_bandwidth_controller::BandwidthController;
-use nym_client_core::client::base_client::{
+use client_core::client::base_client::{
    non_wasm_helpers, BaseClientBuilder, ClientInput, ClientOutput, ClientState,
 };
-use nym_client_core::client::inbound_messages::InputMessage;
-use nym_client_core::client::received_buffer::{
+use client_core::client::inbound_messages::InputMessage;
+use client_core::client::received_buffer::{
    ReceivedBufferMessage, ReceivedBufferRequestSender, ReconstructedMessagesReceiver,
 };
-use nym_client_core::config::persistence::key_pathfinder::ClientKeyPathfinder;
+use client_core::config::persistence::key_pathfinder::ClientKeyPathfinder;
+use futures::channel::mpsc;
+use gateway_client::bandwidth::BandwidthController;
+use log::*;
 use nym_sphinx::anonymous_replies::requests::AnonymousSenderTag;
-use nym_sphinx::params::PacketType;
 use nym_task::connections::TransmissionLane;
 use nym_task::TaskManager;
-use nym_validator_client::nyxd::QueryNyxdClient;
-use std::error::Error;
 use tokio::sync::watch::error::SendError;
+use validator_client::nyxd::QueryNyxdClient;

-pub use nym_client_core::client::key_manager::KeyManager;
-use nym_credential_storage::persistent_storage::PersistentStorage;
+pub use client_core::client::key_manager::KeyManager;
 pub use nym_sphinx::addressing::clients::Recipient;
 pub use nym_sphinx::receiver::ReconstructedMessage;
-use nym_validator_client::Client;
-
 pub mod config;

 pub struct SocketClient {
@@ -58,13 +55,10 @@ impl SocketClient {
        }
    }

-    async fn create_bandwidth_controller(
-        config: &Config,
-    ) -> BandwidthController<Client<QueryNyxdClient>, PersistentStorage> {
+    async fn create_bandwidth_controller(config: &Config) -> BandwidthController<QueryNyxdClient> {
        let details = nym_network_defaults::NymNetworkDetails::new_from_env();
-        let mut client_config =
-            nym_validator_client::Config::try_from_nym_network_details(&details)
-                .expect("failed to construct validator client config");
+        let mut client_config = validator_client::Config::try_from_nym_network_details(&details)
+            .expect("failed to construct validator client config");
        let nyxd_url = config
            .get_base()
            .get_validator_endpoints()
@@ -77,13 +71,10 @@ impl SocketClient {
            .expect("No validator api endpoint provided");
        // overwrite env configuration with config URLs
        client_config = client_config.with_urls(nyxd_url, api_url);
-        let client = nym_validator_client::Client::new_query(client_config)
+        let client = validator_client::Client::new_query(client_config)
            .expect("Could not construct query client");
        BandwidthController::new(
-            nym_credential_storage::initialise_persistent_storage(
-                config.get_base().get_database_path(),
-            )
-            .await,
+            nym_credential_storage::initialise_storage(config.get_base().get_database_path()).await,
            client,
        )
    }
@@ -120,7 +111,6 @@ impl SocketClient {
            self_address,
            shared_lane_queue_lengths,
            reply_controller_sender,
-            None,
        );

        websocket::Listener::new(config.get_listening_ip(), config.get_listening_port())
@@ -180,10 +170,7 @@ impl SocketClient {
        Ok(started_client.task_manager)
    }

-    pub async fn start_direct(
-        self,
-        packet_type: Option<PacketType>,
-    ) -> Result<DirectClient, ClientError> {
+    pub async fn start_direct(self) -> Result<DirectClient, ClientError> {
        if self.config.get_socket_type().is_websocket() {
            return Err(ClientError::InvalidSocketMode);
        }
@@ -229,7 +216,6 @@ impl SocketClient {
            reconstructed_receiver,
            address,
            shutdown_notifier: started_client.task_manager,
-            packet_type,
        })
    }
 }
@@ -243,7 +229,6 @@ pub struct DirectClient {

    // we need to keep reference to this guy otherwise things will start dropping
    shutdown_notifier: TaskManager,
-    packet_type: Option<PacketType>,
 }

 impl DirectClient {
@@ -264,7 +249,7 @@ impl DirectClient {
    /// 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.packet_type);
+        let input_msg = InputMessage::new_regular(recipient, message, lane);

        self.client_input
            .input_sender
@@ -283,8 +268,7 @@ impl DirectClient {
        reply_surbs: u32,
    ) {
        let lane = TransmissionLane::General;
-        let input_msg =
-            InputMessage::new_anonymous(recipient, message, reply_surbs, lane, self.packet_type);
+        let input_msg = InputMessage::new_anonymous(recipient, message, reply_surbs, lane);

        self.client_input
            .input_sender
@@ -298,7 +282,7 @@ impl DirectClient {
    /// 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, self.packet_type);
+        let input_msg = InputMessage::new_reply(recipient_tag, message, lane);

        self.client_input
            .input_sender
@@ -1,16 +1,13 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::commands::try_upgrade_v1_1_13_config;
 use crate::{
    client::config::Config,
    commands::{override_config, OverrideConfig},
    error::ClientError,
 };
 use clap::Args;
-use nym_bin_common::output_format::OutputFormat;
 use nym_config::NymConfig;
-use nym_credential_storage::persistent_storage::PersistentStorage;
 use nym_crypto::asymmetric::identity;
 use nym_sphinx::addressing::clients::Recipient;
 use serde::Serialize;
@@ -73,8 +70,9 @@ pub(crate) struct Init {
    #[clap(long, hide = true)]
    enabled_credentials_mode: Option<bool>,

-    #[clap(short, long, default_value_t = OutputFormat::default())]
-    output: OutputFormat,
+    /// Save a summary of the initialization to a json file
+    #[clap(long)]
+    output_json: bool,
 }

 impl From<Init> for OverrideConfig {
@@ -96,17 +94,15 @@ impl From<Init> for OverrideConfig {
 #[derive(Debug, Serialize)]
 pub struct InitResults {
    #[serde(flatten)]
-    client_core: nym_client_core::init::InitResults,
+    client_core: client_core::init::InitResults,
    client_listening_port: String,
-    client_address: String,
 }

 impl InitResults {
    fn new(config: &Config, address: &Recipient) -> Self {
        Self {
-            client_core: nym_client_core::init::InitResults::new(config.get_base(), address),
+            client_core: client_core::init::InitResults::new(config.get_base(), address),
            client_listening_port: config.get_listening_port().to_string(),
-            client_address: address.to_string(),
        }
    }
 }
@@ -114,29 +110,25 @@ impl InitResults {
 impl Display for InitResults {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        writeln!(f, "{}", self.client_core)?;
-        writeln!(f, "Client listening port: {}", self.client_listening_port)?;
-        write!(f, "Address of this client: {}", self.client_address)
+        write!(f, "Client listening port: {}", self.client_listening_port)
    }
 }

 pub(crate) async fn execute(args: &Init) -> Result<(), ClientError> {
-    eprintln!("Initialising client...");
+    println!("Initialising client...");

    let id = &args.id;

    let already_init = Config::default_config_file_path(id).exists();
    if already_init {
-        // in case we're using old config, try to upgrade it
-        // (if we're using the current version, it's a no-op)
-        try_upgrade_v1_1_13_config(id)?;
-        eprintln!("Client \"{id}\" was already initialised before");
+        println!("Client \"{id}\" was already initialised before");
    }

    // Usually you only register with the gateway on the first init, however you can force
    // re-registering if wanted.
    let user_wants_force_register = args.force_register_gateway;
    if user_wants_force_register {
-        eprintln!("Instructed to force registering gateway. This might overwrite keys!");
+        println!("Instructed to force registering gateway. This might overwrite keys!");
    }

    // If the client was already initialized, don't generate new keys and don't re-register with
@@ -152,7 +144,7 @@ pub(crate) async fn execute(args: &Init) -> Result<(), ClientError> {

    // 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 = nym_client_core::init::setup_gateway_from_config::<Config, _, PersistentStorage>(
+    let gateway = client_core::init::setup_gateway_from_config::<Config, _>(
        register_gateway,
        user_chosen_gateway_id,
        config.get_base(),
@@ -169,22 +161,28 @@ pub(crate) async fn execute(args: &Init) -> Result<(), ClientError> {

    print_saved_config(&config);

-    let address = nym_client_core::init::get_client_address_from_stored_keys(config.get_base())?;
+    let address = client_core::init::get_client_address_from_stored_keys(config.get_base())?;
    let init_results = InitResults::new(&config, &address);
-    println!("{}", args.output.format(&init_results));
+    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: {address}\n");
    Ok(())
 }

 fn print_saved_config(config: &Config) {
    let config_save_location = config.get_config_file_save_location();
-    eprintln!("Saved configuration file to {config_save_location:?}");
-    eprintln!("Using gateway: {}", config.get_base().get_gateway_id());
+    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());
    log::debug!("Gateway owner: {}", config.get_base().get_gateway_owner());
    log::debug!(
        "Gateway listener: {}",
        config.get_base().get_gateway_listener()
    );
-    eprintln!("Client configuration completed.\n");
+    println!("Client configuration completed.\n");
 }
@@ -1,15 +1,13 @@
 // Copyright 2021-2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::client::config::old_config_v1_1_13::OldConfigV1_1_13;
 use crate::client::config::{BaseConfig, Config};
 use clap::CommandFactory;
 use clap::{Parser, Subcommand};
 use lazy_static::lazy_static;
-use log::info;
 use nym_bin_common::build_information::BinaryBuildInformation;
 use nym_bin_common::completions::{fig_generate, ArgShell};
-use nym_config::{NymConfig, OptionalSet};
+use nym_config::OptionalSet;
 use std::error::Error;
 use std::net::IpAddr;

@@ -104,20 +102,6 @@ pub(crate) fn override_config(config: Config, args: OverrideConfig) -> Config {
        )
 }

-fn try_upgrade_v1_1_13_config(id: &str) -> std::io::Result<()> {
-    // explicitly load it as v1.1.13 (which is incompatible with the current, i.e. 1.1.14+)
-    let Ok(old_config) = OldConfigV1_1_13::load_from_file(id) else {
-        // if we failed to load it, there might have been nothing to upgrade
-        // or maybe it was an even older file. in either way. just ignore it and carry on with our day
-        return Ok(());
-    };
-    info!("It seems the client is using <= v1.1.13 config template.");
-    info!("It is going to get updated to the current specification.");
-
-    let updated: Config = old_config.into();
-    updated.save_to_file(None)
-}
-
 #[cfg(test)]
 mod tests {
    use super::*;
--- a/Show More
+++ b/Show More