Hide coconut runtime flags (#2990 )

Skip errors on blind sign within threshold (#2976 )
Feature/dkg reshare (#2936 )
2023-02-08 13:00:58 +02:00 · 2023-02-08 11:54:12 +02:00 · 2023-02-07 12:56:08 +02:00 · 2023-02-07 11:45:40 +01:00 · 2023-02-07 09:49:19 +00:00 · 2023-02-06 10:56:39 +01:00
1354 changed files with 17701 additions and 48490 deletions
@@ -39,16 +39,20 @@ jobs:
        uses: actions/setup-node@v3
        with:
          node-version: 16
-      - name: Matrix - Node Install
+      - name: Keybase - Node Install
        run: npm install
        working-directory: .github/workflows/support-files
-      - name: Matrix - Send Notification
+      - name: Keybase - Send Notification
        env:
          NYM_NOTIFICATION_KIND: security
          NYM_PROJECT_NAME: "Daily security report"
          GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
+          KEYBASE_NYMBOT_USERNAME: "${{ secrets.KEYBASE_NYMBOT_USERNAME }}"
+          KEYBASE_NYMBOT_PAPERKEY: "${{ secrets.KEYBASE_NYMBOT_PAPERKEY }}"
+          KEYBASE_NYMBOT_TEAM: "${{ secrets.KEYBASE_NYMBOT_TEAM }}"
+          KEYBASE_NYM_CHANNEL: "security"
          MATRIX_SERVER: "${{ secrets.MATRIX_SERVER }}"
-          MATRIX_ROOM: "${{ secrets.MATRIX_ROOM_AUDIT }}"
+          MATRIX_ROOM: "${{ secrets.MATRIX_ROOM }}"
          MATRIX_USER_ID: "${{ secrets.MATRIX_USER_ID }}"
          MATRIX_TOKEN: "${{ secrets.MATRIX_TOKEN }}"
          MATRIX_DEVICE_ID: "${{ secrets.MATRIX_DEVICE_ID }}"
@@ -34,7 +34,7 @@ on:
      - 'tools/ts-rs-cli/**'

 env:
-  NETWORK: mainnet
+  NETWORK: mainnet    

 jobs:
  publish-nym:
@@ -46,7 +46,7 @@ jobs:
    runs-on: ${{ matrix.platform }}
    steps:
      - uses: actions/checkout@v3
-
+      
      - name: Prepare build output directory
        shell: bash
        env:
@@ -69,7 +69,7 @@ jobs:
        uses: actions-rs/cargo@v1
        with:
          command: build
-          args: --workspace --release --all
+          args: --workspace --release

      - name: Install Rust stable
        uses: actions-rs/toolchain@v1
@@ -79,9 +79,6 @@ jobs:
          override: true
          components: rustfmt, clippy

-      - name: Install wasm-opt
-        run: cargo install --version 0.112.0 wasm-opt
-
      - name: Build release contracts
        run: make wasm

@@ -98,15 +95,9 @@ 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/credential $OUTPUT_DIR
-          cp target/release/explorer-api $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
@@ -119,3 +110,4 @@ jobs:
          REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
          TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/builds/
          EXCLUDE: "/dist/, /node_modules/"
+
@@ -43,10 +43,10 @@ jobs:
        REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
        TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/ts-${{ env.GITHUB_REF_SLUG }}-example
        EXCLUDE: "/dist/, /node_modules/"
-    - name: Matrix - Node Install
+    - name: Keybase - Node Install
      run: npm install
      working-directory: .github/workflows/support-files
-    - name: Matrix - Send Notification
+    - name: Keybase - Send Notification
      env:
        NYM_NOTIFICATION_KIND: ts-packages
        NYM_PROJECT_NAME: "ts-packages"
@@ -54,6 +54,10 @@ jobs:
        NYM_CI_WWW_LOCATION: "ts-${{ env.GITHUB_REF_SLUG }}"
        GIT_COMMIT_MESSAGE: "${{ github.event.head_commit.message }}"
        GIT_BRANCH: "${GITHUB_REF##*/}"
+        KEYBASE_NYMBOT_USERNAME: "${{ secrets.KEYBASE_NYMBOT_USERNAME }}"
+        KEYBASE_NYMBOT_PAPERKEY: "${{ secrets.KEYBASE_NYMBOT_PAPERKEY }}"
+        KEYBASE_NYMBOT_TEAM: "${{ secrets.KEYBASE_NYMBOT_TEAM }}"
+        KEYBASE_NYM_CHANNEL: "ci-ts-packages"
        IS_SUCCESS: "${{ job.status == 'success' }}"
        MATRIX_SERVER: "${{ secrets.MATRIX_SERVER }}"
        MATRIX_ROOM: "${{ secrets.MATRIX_ROOM }}"
@@ -1,61 +0,0 @@
-name: check-merge-conflicts
-
-# Check that the latest release branch merges into master and develop without
-# any conflicts that git is not able to resolve
-
-on:
-  workflow_dispatch:
-  schedule:
-    - cron: '5 6 * * *'
-
-jobs:
-  get_release:
-    runs-on: ubuntu-latest
-    outputs:
-      output1: ${{ steps.step2.outputs.latest_release }}
-    steps:
-      - name: Check out repository code
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-      - name: Set output variable to latest release branch
-        id: step2
-        run: echo "latest_release=$(git branch -r | grep -E 'release/v[0-9]+\.[0-9]+\.[0-9]+$' | sort -V | tail -n 1)" >> $GITHUB_OUTPUT
-
-  check-merge-release-into-master:
-    name: Check that the release branch merges into master
-    needs: get_release
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout repo
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-      - name: Setup git user
-        run: |
-          git config --global user.name "ci"
-          git config --global user.email "ci@localhost"
-      - name: Check merge release branch into master
-        run: |
-          ./.github/workflows/support-files/git-merge-check.sh origin/master $branch1
-        env:
-          branch1: ${{needs.get_release.outputs.output1}}
-
-  check-merge-release-into-develop:
-    name: Check that the release branch merges into develop
-    needs: get_release
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout repo
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-      - name: Setup git user
-        run: |
-          git config --global user.name "ci"
-          git config --global user.email "ci@localhost"
-      - name: Check merge release branch into develop
-        run: |
-          ./.github/workflows/support-files/git-merge-check.sh origin/develop $branch1
-        env:
-          branch1: ${{needs.get_release.outputs.output1}}
@@ -1,56 +0,0 @@
-name: Run config checks on all binaries
-
-on:
-  workflow_dispatch:
-  release:
-    types: [created]
-  push:
-    paths:
-      - 'clients/**'
-      - 'common/**'
-      - 'contracts/**'
-      - 'integrations/**'
-      - 'mixnode/**'
-      - 'sdk/rust/nym-sdk/**'
-      - 'service-providers/**'
-  pull_request:
-    paths:
-      - 'clients/**'
-      - 'common/**'
-      - 'gateway/**'
-      - 'integrations/**'
-      - 'mixnode/**'
-      - 'sdk/rust/nym-sdk/**'
-      - 'service-providers/**'
-
-env:
-  NETWORK: mainnet
-
-jobs:
-  publish-nym:
-    strategy:
-      fail-fast: false
-      matrix:
-        platform: [custom-runner-linux]
-         
-    runs-on: ${{ matrix.platform }}
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Install Dependencies (Linux)
-        run: sudo apt-get update && sudo apt-get -y install jq vim libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libudev-dev squashfs-tools
-        continue-on-error: true
-
-      - name: Install Rust stable
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-          
-      - name: Branch name
-        run: echo running on branch ${GITHUB_REF##*/}
-                    
-      - name: Run tests against binaries
-        run: ./build_and_run.sh ${{ github.head_ref || github.ref_name }}
-        working-directory: tests/
-        
-      
@@ -1,11 +1,9 @@
-name: Nym Connect - mobile (Rust)
+name: Nym Connect for Android (rust)

 on:
  push:
    paths:
-      - "nym-connect/mobile/src-tauri/**"
-      - "nym-connect/mobile/src-tauri/Cargo.toml"
-      - "!nym-connect/mobile/src-tauri/gen/**"
+      - "nym-connect-android/src-tauri/**"
      - "clients/client-core/**"
      - "clients/socks5/**"
      - "common/**"
@@ -14,9 +12,7 @@ on:
      - "nym-api/nym-api-requests/**"
  pull_request:
    paths:
-      - "nym-connect/mobile/src-tauri/**"
-      - "nym-connect/mobile/src-tauri/Cargo.toml"
-      - "!nym-connect/mobile/src-tauri/gen/**"
+      - "nym-connect-android/src-tauri/**"
      - "clients/client-core/**"
      - "clients/socks5/**"
      - "common/**"
@@ -32,9 +28,10 @@ jobs:
      #RUSTC_WRAPPER: /home/ubuntu/.cargo/bin/sccache
    #defaults:
      #run:
-        #working-directory: nym-connect/mobile/src-tauri/
+        #working-directory: nym-connect-android/src-tauri/
    steps:
      - name: Install Dependencies (Linux)
+        if: ${{ !env.ACT }}
        run: |
          sudo apt-get update
          sudo apt-get -y install \
@@ -49,6 +46,7 @@ jobs:
          librsvg2-dev \
          libsoup-3.0-dev \
          libjavascriptcoregtk-4.1-dev
+        #continue-on-error: true

      - name: Checkout
        uses: actions/checkout@v3
@@ -60,13 +58,13 @@ jobs:
          components: clippy, rustfmt

      - name: Check formatting
-        run: cargo fmt --manifest-path nym-connect/mobile/src-tauri/Cargo.toml -- --check
+        run: cargo fmt --manifest-path nym-connect-android/src-tauri/Cargo.toml -- --check

      - name: Build all binaries
-        run: cargo build --manifest-path nym-connect/mobile/src-tauri/Cargo.toml
+        run: cargo build --manifest-path nym-connect-android/src-tauri/Cargo.toml

      - name: Run all tests
-        run: cargo test  --manifest-path nym-connect/mobile/src-tauri/Cargo.toml
+        run: cargo test  --manifest-path nym-connect-android/src-tauri/Cargo.toml

      - name: Clippy
-        run: cargo clippy --manifest-path nym-connect/mobile/src-tauri/Cargo.toml --all-targets -- -D warnings
+        run: cargo clippy --manifest-path nym-connect-android/src-tauri/Cargo.toml --all-targets -- -D warnings
@@ -1,30 +1,28 @@
-name: Nym Connect - desktop (Rust)
+name: Nym Connect (rust)

 on:
  push:
    paths:
-      - "nym-connect/desktop/src-tauri/**"
-      - "nym-connect/desktop/src-tauri/Cargo.toml"
-      - "clients/client-core/**"
-      - "clients/socks5/**"
-      - "common/**"
-      - "gateway/gateway-requests/**"
-      - "contracts/vesting/**"
-      - "nym-api/nym-api-requests/**"
+      - 'nym-connect/**'
+      - 'clients/client-core/**'
+      - 'clients/socks5/**'
+      - 'common/**'
+      - 'gateway/gateway-requests/**'
+      - 'contracts/vesting/**'
+      - 'nym-api/nym-api-requests/**'
  pull_request:
    paths:
-      - "nym-connect/desktop/src-tauri/**"
-      - "nym-connect/desktop/src-tauri/Cargo.toml"
-      - "clients/client-core/**"
-      - "clients/socks5/**"
-      - "common/**"
-      - "gateway/gateway-requests/**"
-      - "contracts/vesting/**"
-      - "nym-api/nym-api-requests/**"
+      - 'nym-connect/**'
+      - 'clients/client-core/**'
+      - 'clients/socks5/**'
+      - 'common/**'
+      - 'gateway/gateway-requests/**'
+      - 'contracts/vesting/**'
+      - 'nym-api/nym-api-requests/**'

 jobs:
  build:
-    runs-on: [self-hosted, custom-linux]
+    runs-on: [ self-hosted, custom-linux ]
    env:
      RUSTC_WRAPPER: /home/ubuntu/.cargo/bin/sccache
    steps:
@@ -47,29 +45,29 @@ jobs:
        uses: actions-rs/cargo@v1
        with:
          command: build
-          args: --manifest-path nym-connect/desktop/Cargo.toml --workspace
+          args: --manifest-path nym-connect/Cargo.toml --workspace

      - name: Run all tests
        uses: actions-rs/cargo@v1
        with:
          command: test
-          args: --manifest-path nym-connect/desktop/Cargo.toml --workspace
+          args: --manifest-path nym-connect/Cargo.toml --workspace

      - name: Check formatting
        uses: actions-rs/cargo@v1
        with:
          command: fmt
-          args: --manifest-path nym-connect/desktop/Cargo.toml --all -- --check
+          args: --manifest-path nym-connect/Cargo.toml --all -- --check

      - uses: actions-rs/clippy-check@v1
        name: Clippy checks
        continue-on-error: true
        with:
          token: ${{ secrets.GITHUB_TOKEN }}
-          args: --manifest-path nym-connect/desktop/Cargo.toml --workspace --all-features
+          args: --manifest-path nym-connect/Cargo.toml --workspace --all-features

      - name: Run clippy
        uses: actions-rs/cargo@v1
        with:
          command: clippy
-          args: --manifest-path nym-connect/desktop/Cargo.toml --workspace --all-features -- -D warnings
+          args: --manifest-path nym-connect/Cargo.toml --workspace --all-features -- -D warnings
@@ -6,7 +6,7 @@ on:

 jobs:
  build:
-    if: ${{ (startsWith(github.ref, 'refs/tags/nym-contracts-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
+    if: ${{ startsWith(github.ref, 'refs/tags/nym-contracts-') && github.event_name == 'release' }}
    runs-on: [self-hosted, custom-runner-linux]
    steps:
      - uses: actions/checkout@v2
@@ -19,9 +19,6 @@ jobs:
          override: true
          components: rustfmt, clippy

-      - name: Install wasm-opt
-        run: cargo install --version 0.112.0 wasm-opt
-
      - name: Build release contracts
        run: make wasm

@@ -1,4 +1,4 @@
-name: Nym Connect - Android APK Build
+name: NC Android APK Release

 on:
  workflow_dispatch:
@@ -9,11 +9,11 @@ on:
 jobs:
  build:
    name: Build APK
-    runs-on: custom-runner-linux
+    runs-on: ubuntu-latest
    env:
      ANDROID_HOME: ${{ github.workspace }}/android-sdk
      NDK_VERSION: 25.1.8937393
-      NDK_HOME: ${{ github.workspace }}/android-sdk/ndk/25.1.8937393
+      NDK_HOME: ${{ env.ANDROID_HOME }}/ndk/${{ env.NDK_VERSION }}
      SDK_PLATFORM_VERSION: android-33
      SDK_BUILDTOOLS_VERSION: 33.0.1

@@ -23,17 +23,16 @@ jobs:
        run: |
          sudo apt-get update
          sudo apt-get -y install \
+          libwebkit2gtk-4.0-dev \
          build-essential \
-          unzip \
          curl \
          wget \
          libssl-dev \
+          libgtk-3-dev \
          squashfs-tools \
+          libayatana-appindicator3-dev \
          librsvg2-dev

-      - name: Checkout
-        uses: actions/checkout@v3
-
      - name: Install Java
        uses: actions/setup-java@v3
        with:
@@ -61,11 +60,6 @@ jobs:
      - name: Install Rust toolchain
        uses: dtolnay/rust-toolchain@stable

-      # TODO this step takes a considerable amount of time
-      # We could avoid to compile from source tauri-cli and use instead
-      # pre-compiled binary provided by the node package `@tauri-apps/cli`
-      # But when using the later the build fails for some reason
-      # so keep installing and using tauri-cli
      - name: Install tauri cli
        run: cargo install tauri-cli --version "^2.0.0-alpha.2"

@@ -86,53 +80,48 @@ jobs:
          npm i -g yarn
          yarn --version

+      - name: Checkout
+        uses: actions/checkout@v3
+
      - name: Build frontend code
        run: |
          yarn install --frozen-lockfile
          yarn build
-          yarn workspace @nym/nym-connect-mobile webpack:prod
+          yarn workspace @nym/nym-connect-android webpack:prod

      - name: Build APK
-        working-directory: nym-connect/mobile
+        working-directory: nym-connect-android
        env:
-          # NODE_TAURI_CLI=${{ github.workspace }}/nym-connect/mobile/node_modules/.bin/tauri
-          ANDROID_SDK_ROOT: ${{ env.ANDROID_HOME }}
-          WRY_ANDROID_PACKAGE: net.nymtech.nym_connect
-          WRY_ANDROID_LIBRARY: nym_connect
+          WRY_ANDROID_PACKAGE: net.nymtech.nym_connect_android
+          WRY_ANDROID_LIBRARY: nym_connect_android
        # TODO build with release profile (--release), it will requires
        # to sign the APK. For now build with debug profile to avoid that
-        # TODO build using `yarn tauri`, provide NODE_TAURI_CLI, see TODO notes above
-        run: cargo tauri android build --debug --apk --split-per-abi -t aarch64
+        run: cargo tauri android build --debug --apk

      # TODO add the version number to APK name
      - name: Rename APK artifact
        run: |
-          mkdir apk/
-          mv nym-connect/mobile/src-tauri/gen/android/nym_connect/app/build/outputs/apk/arm64/debug/app-arm64-debug.apk \
-            apk/nym-connect-arm64-debug.apk
-          mv nym-connect/mobile/src-tauri/gen/android/nym_connect/app/build/outputs/apk/x86_64/debug/app-x86_64-debug.apk \
-            apk/nym-connect-x86_64-debug.apk
+          mv nym-connect-android/src-tauri/gen/android/nym_connect_android/app/build/outputs/apk/universal/debug/app-universal-debug.apk \
+            nym-connect-debug.apk

      - name: Upload APK artifact
        uses: actions/upload-artifact@v3
        with:
          name: nc-apk-debug
-          path: |
-            apk/nym-connect-arm64-debug.apk
-            apk/nym-connect-x86_64-debug.apk
+          path: nym-connect-debug.apk

-  # publish:
-  #   name: Publish APK
-  #   needs: build
-  #   runs-on: ubuntu-latest
-  #   steps:
-  #     - name: Checkout
-  #       uses: actions/checkout@v3
-  #     - name: Download binary artifact
-  #       uses: actions/download-artifact@v3
-  #       with:
-  #         name: nc-apk-debug
-  #         path: apk
-  #     # TODO add a step to upload the APK somewhere
-  #     - name: Publish
-  #       uses: ???
+  publish:
+    name: Publish APK
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Download binary artifact
+        uses: actions/download-artifact@v3
+        with:
+          name: nc-apk-debug
+          path: apk
+      # TODO add a step to upload the APK somewhere
+      # - name: Publish
+      #   uses: ???
@@ -0,0 +1,57 @@
+name: CI for Network Explorer API
+
+on:
+  workflow_dispatch:
+  release:
+    types: [created]
+    
+env:
+  NETWORK: mainnet    
+
+jobs:
+  publish-nym:
+    if: ${{ startsWith(github.ref, 'refs/tags/nym-explorer-api-') && (github.event_name == 'release' || github.event_name == 'workflow_dispatch') }}
+    strategy:
+      fail-fast: false
+      matrix:
+        platform: [ubuntu-20.04]
+
+    runs-on: ${{ matrix.platform }}
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Install Dependencies (Linux)
+        run: sudo apt-get update && sudo apt-get -y install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libudev-dev squashfs-tools
+        continue-on-error: true
+
+      - name: Check the release tag starts with `nym-explorer-api-`
+        uses: actions/github-script@v3
+        with:
+          script: |
+            core.setFailed('Release tag did not start with nym-explorer-api-...')
+
+      - name: Install Rust stable
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+
+      - name: Build all explorer-api
+        uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: --manifest-path explorer-api/Cargo.toml --workspace --release
+
+      - name: Upload Artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: my-artifact
+          path: |
+            target/release/explorer-api
+          retention-days: 30
+
+      - name: Upload to release based on tag name
+        uses: softprops/action-gh-release@v1
+        if: github.event_name == 'release'
+        with:
+          files: |
+            target/release/explorer-api
@@ -57,10 +57,10 @@ jobs:
        REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
        TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/ne-sb-${{ env.GITHUB_REF_SLUG }}
        EXCLUDE: "/dist/, /node_modules/"
-    - name: Matrix - Node Install
+    - name: Keybase - Node Install
      run: npm install
      working-directory: .github/workflows/support-files
-    - name: Matrix - Send Notification
+    - name: Keybase - Send Notification
      env:
        NYM_NOTIFICATION_KIND: network-explorer
        NYM_PROJECT_NAME: "Network Explorer"
@@ -69,6 +69,10 @@ jobs:
        NYM_CI_WWW_LOCATION_STORYBOOK: "ne-sb-${{ env.GITHUB_REF_SLUG }}"
        GIT_COMMIT_MESSAGE: "${{ github.event.head_commit.message }}"
        GIT_BRANCH: "${GITHUB_REF##*/}"
+        KEYBASE_NYMBOT_USERNAME: "${{ secrets.KEYBASE_NYMBOT_USERNAME }}"
+        KEYBASE_NYMBOT_PAPERKEY: "${{ secrets.KEYBASE_NYMBOT_PAPERKEY }}"
+        KEYBASE_NYMBOT_TEAM: "${{ secrets.KEYBASE_NYMBOT_TEAM }}"
+        KEYBASE_NYM_CHANNEL: "ci-network-explorer"
        IS_SUCCESS: "${{ job.status == 'success' }}"
        MATRIX_SERVER: "${{ secrets.MATRIX_SERVER }}"
        MATRIX_ROOM: "${{ secrets.MATRIX_ROOM }}"
@@ -10,7 +10,7 @@ jobs:
      matrix: ${{ steps.set-matrix.outputs.matrix }}
    steps:
      # creates the matrix strategy from nightly_build_matrix_includes.json
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v2
      - id: set-matrix
        uses: JoshuaTheMiller/conditional-build-matrix@main
        with:
@@ -29,7 +29,7 @@ jobs:
        if: matrix.os == 'ubuntu-20.04'

      - name: Check out repository code
-        uses: actions/checkout@v3
+        uses: actions/checkout@v2

      - name: Install rust toolchain
        uses: actions-rs/toolchain@v1
@@ -51,9 +51,9 @@ jobs:
          command: build
          args: --workspace

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

@@ -63,9 +63,9 @@ jobs:
          command: build
          args: --workspace --examples

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

@@ -75,7 +75,7 @@ jobs:
          command: test
          args: --workspace

-      - name: Reclaim some disk space
+      - name: Reclaim some disk space (because Windows is being annoying)
        uses: actions-rs/cargo@v1
        if: ${{ matrix.os == 'windows-latest' || matrix.os == 'ubuntu-20.04' }}
        with:
@@ -88,9 +88,9 @@ jobs:
          command: test
          args: --workspace -- --ignored

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

@@ -147,17 +147,17 @@ jobs:
      - name: Collect jobs status
        uses: technote-space/workflow-conclusion-action@v2
      - name: Check out repository code
-        uses: actions/checkout@v3
+        uses: actions/checkout@v2
      - name: install npm
        uses: actions/setup-node@v3
        if: env.WORKFLOW_CONCLUSION == 'failure'
        with:
          node-version: 16
-      - name: Matrix - Node Install
+      - name: Keybase - Node Install
        if: env.WORKFLOW_CONCLUSION == 'failure'
        run: npm install
        working-directory: .github/workflows/support-files
-      - name: Matrix - Send Notification
+      - name: Keybase - Send Notification
        if: env.WORKFLOW_CONCLUSION == 'failure'
        env:
          NYM_NOTIFICATION_KIND: nightly
@@ -165,9 +165,13 @@ jobs:
          GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
          GIT_COMMIT_MESSAGE: "${{ github.event.head_commit.message }}"
          GIT_BRANCH: "${GITHUB_REF##*/}"
+          KEYBASE_NYMBOT_USERNAME: "${{ secrets.KEYBASE_NYMBOT_USERNAME }}"
+          KEYBASE_NYMBOT_PAPERKEY: "${{ secrets.KEYBASE_NYMBOT_PAPERKEY }}"
+          KEYBASE_NYMBOT_TEAM: "${{ secrets.KEYBASE_NYMBOT_TEAM }}"
+          KEYBASE_NYM_CHANNEL: "ci-nightly"
          IS_SUCCESS: "${{ env.WORKFLOW_CONCLUSION == 'success' }}"
          MATRIX_SERVER: "${{ secrets.MATRIX_SERVER }}"
-          MATRIX_ROOM: "${{ secrets.MATRIX_ROOM_NIGHTLY }}"
+          MATRIX_ROOM: "${{ secrets.MATRIX_ROOM }}"
          MATRIX_USER_ID: "${{ secrets.MATRIX_USER_ID }}"
          MATRIX_TOKEN: "${{ secrets.MATRIX_TOKEN }}"
          MATRIX_DEVICE_ID: "${{ secrets.MATRIX_DEVICE_ID }}"
@@ -28,7 +28,7 @@ jobs:
        run: git fetch --all
      - name: Set output variable to latest release branch
        id: step2
-        run: echo "latest_release=$(git branch -r | grep -E 'release/v[0-9]+\.[0-9]+\.[0-9]+$' | sort -V | tail -n 1 | sed 's/  origin\///')" >> $GITHUB_OUTPUT
+        run: echo "latest_release=$(git branch -r | grep -E 'release/v[0-9]+\.[0-9]+\.[0-9]+' | tail -n 1 | sed 's/  origin\///')" >> $GITHUB_OUTPUT
  build:
    needs: [get_release,matrix_prep]
    strategy:
@@ -54,33 +54,15 @@ jobs:
          override: true
          components: rustfmt, clippy

-      - name: Check formatting
-        uses: actions-rs/cargo@v1
-        with:
-          command: fmt
-          args: --all -- --check
-
      - name: Build all binaries
        uses: actions-rs/cargo@v1
        with:
          command: build
          args: --workspace

-      - name: Reclaim some disk space
+      - name: Reclaim some disk space (because Windows is being annoying)
        uses: actions-rs/cargo@v1
-        if: ${{ matrix.os == 'windows-latest' || matrix.os == 'ubuntu-20.04' }}
-        with:
-          command: clean
-
-      - name: Build all examples
-        uses: actions-rs/cargo@v1
-        with:
-          command: build
-          args: --workspace --examples
-
-      - name: Reclaim some disk space
-        uses: actions-rs/cargo@v1
-        if: ${{ matrix.os == 'windows-latest' || matrix.os == 'ubuntu-20.04' }}
+        if: ${{ matrix.os == 'windows-latest' }}
        with:
          command: clean

@@ -90,9 +72,9 @@ jobs:
          command: test
          args: --workspace

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

@@ -101,11 +83,17 @@ jobs:
        uses: actions-rs/cargo@v1
        with:
          command: test
-          args: --workspace -- --ignored
+          args: --workspace --all-features -- --ignored

-      - name: Reclaim some disk space
+      - name: Check formatting
        uses: actions-rs/cargo@v1
-        if: ${{ matrix.os == 'windows-latest' || matrix.os == 'ubuntu-20.04' }}
+        with:
+          command: fmt
+          args: --all -- --check
+
+      - name: Reclaim some disk space (because Windows is being annoying)
+        uses: actions-rs/cargo@v1
+        if: ${{ matrix.os == 'windows-latest' }}
        with:
          command: clean

@@ -114,7 +102,7 @@ jobs:
        continue-on-error: true
        with:
          token: ${{ secrets.GITHUB_TOKEN }}
-          args: --workspace
+          args: --all-features

      - name: Run clippy
        uses: actions-rs/cargo@v1
@@ -168,11 +156,11 @@ jobs:
        if: env.WORKFLOW_CONCLUSION == 'failure'
        with:
          node-version: 16
-      - name: Matrix - Node Install
+      - name: Keybase - Node Install
        if: env.WORKFLOW_CONCLUSION == 'failure'
        run: npm install
        working-directory: .github/workflows/support-files
-      - name: Matrix - Send Notification
+      - name: Keybase - Send Notification
        if: env.WORKFLOW_CONCLUSION == 'failure'
        env:
          NYM_NOTIFICATION_KIND: nightly
@@ -180,9 +168,13 @@ jobs:
          GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
          GIT_COMMIT_MESSAGE: "${{ github.event.head_commit.message }}"
          GIT_BRANCH_NAME: "${{needs.get_release.outputs.output1}}"
+          KEYBASE_NYMBOT_USERNAME: "${{ secrets.KEYBASE_NYMBOT_USERNAME }}"
+          KEYBASE_NYMBOT_PAPERKEY: "${{ secrets.KEYBASE_NYMBOT_PAPERKEY }}"
+          KEYBASE_NYMBOT_TEAM: "${{ secrets.KEYBASE_NYMBOT_TEAM }}"
+          KEYBASE_NYM_CHANNEL: "ci-nightly-release"
          IS_SUCCESS: "${{ env.WORKFLOW_CONCLUSION == 'success' }}"
          MATRIX_SERVER: "${{ secrets.MATRIX_SERVER }}"
-          MATRIX_ROOM: "${{ secrets.MATRIX_ROOM_NIGHTLY }}"
+          MATRIX_ROOM: "${{ secrets.MATRIX_ROOM }}"
          MATRIX_USER_ID: "${{ secrets.MATRIX_USER_ID }}"
          MATRIX_TOKEN: "${{ secrets.MATRIX_TOKEN }}"
          MATRIX_DEVICE_ID: "${{ secrets.MATRIX_DEVICE_ID }}"
@@ -28,7 +28,7 @@ jobs:
        run: git fetch --all
      - name: Set output variable to latest release branch
        id: step2
-        run: echo "latest_release=$(git branch -r | grep -E 'release/v[0-9]+\.[0-9]+\.[0-9]+$' | sort -V | tail -n 2 | head -n 1 | sed 's/  origin\///')" >> $GITHUB_OUTPUT
+        run: echo "latest_release=$(git branch -r | grep -E 'release/v[0-9]+\.[0-9]+\.[0-9]+' | tail -n 2 | head -n 1 | sed 's/  origin\///')" >> $GITHUB_OUTPUT
  build:
    needs: [get_release,matrix_prep]
    strategy:
@@ -54,12 +54,6 @@ jobs:
          override: true
          components: rustfmt, clippy

-      - name: Check formatting
-        uses: actions-rs/cargo@v1
-        with:
-          command: fmt
-          args: --all -- --check
-
      - name: Build all binaries
        uses: actions-rs/cargo@v1
        with:
@@ -72,18 +66,6 @@ jobs:
        with:
          command: clean

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

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

@@ -101,7 +83,13 @@ jobs:
        uses: actions-rs/cargo@v1
        with:
          command: test
-          args: --workspace -- --ignored
+          args: --workspace --all-features -- --ignored
+
+      - name: Check formatting
+        uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: --all -- --check

      - name: Reclaim some disk space (because Windows is being annoying)
        uses: actions-rs/cargo@v1
@@ -114,7 +102,7 @@ jobs:
        continue-on-error: true
        with:
          token: ${{ secrets.GITHUB_TOKEN }}
-          args: --workspace
+          args: --all-features

      - name: Run clippy
        uses: actions-rs/cargo@v1
@@ -168,11 +156,11 @@ jobs:
        if: env.WORKFLOW_CONCLUSION == 'failure'
        with:
          node-version: 16
-      - name: Matrix - Node Install
+      - name: Keybase - Node Install
        if: env.WORKFLOW_CONCLUSION == 'failure'
        run: npm install
        working-directory: .github/workflows/support-files
-      - name: Matrix - Send Notification
+      - name: Keybase - Send Notification
        if: env.WORKFLOW_CONCLUSION == 'failure'
        env:
          NYM_NOTIFICATION_KIND: nightly
@@ -180,9 +168,13 @@ jobs:
          GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
          GIT_COMMIT_MESSAGE: "${{ github.event.head_commit.message }}"
          GIT_BRANCH_NAME: "${{needs.get_release.outputs.output1}}"
+          KEYBASE_NYMBOT_USERNAME: "${{ secrets.KEYBASE_NYMBOT_USERNAME }}"
+          KEYBASE_NYMBOT_PAPERKEY: "${{ secrets.KEYBASE_NYMBOT_PAPERKEY }}"
+          KEYBASE_NYMBOT_TEAM: "${{ secrets.KEYBASE_NYMBOT_TEAM }}"
+          KEYBASE_NYM_CHANNEL: "ci-nightly-release"
          IS_SUCCESS: "${{ env.WORKFLOW_CONCLUSION == 'success' }}"
          MATRIX_SERVER: "${{ secrets.MATRIX_SERVER }}"
-          MATRIX_ROOM: "${{ secrets.MATRIX_ROOM_NIGHTLY }}"
+          MATRIX_ROOM: "${{ secrets.MATRIX_ROOM }}"
          MATRIX_USER_ID: "${{ secrets.MATRIX_USER_ID }}"
          MATRIX_TOKEN: "${{ secrets.MATRIX_TOKEN }}"
          MATRIX_DEVICE_ID: "${{ secrets.MATRIX_DEVICE_ID }}"
@@ -0,0 +1,50 @@
+name: Publish Nym CLI binaries
+
+on:
+  workflow_dispatch:
+  release:
+    types: [created]
+    
+env:
+  NETWORK: mainnet
+
+jobs:
+  publish-nym-cli:
+    if: ${{ startsWith(github.ref, 'refs/tags/nym-cli-') && (github.event_name == 'release' || github.event_name = 'workflow_dispatch') }}
+    strategy:
+      fail-fast: false
+      matrix:
+        platform: [ubuntu-20.04, windows-latest, macos-latest]
+
+    runs-on: ${{ matrix.platform }}
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Check the release tag starts with `nym-cli-`
+        uses: actions/github-script@v3
+        with:
+          script: |
+            core.setFailed('Release tag did not start with nym-cli-...')
+
+      - name: Install Rust stable
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+
+      - name: Build binary
+        run: make build-nym-cli
+
+      - name: Upload Artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: nym-cli-${{ matrix.platform }}
+          path: |
+            target/release/nym-cli*
+          retention-days: 30
+
+      - name: Upload to release based on tag name
+        uses: softprops/action-gh-release@v1
+        if: github.event_name == 'release'
+        with:
+          files: |
+            target/release/nym-cli
@@ -1,4 +1,4 @@
-name: Publish Nym Connect - desktop (MacOS)
+name: Publish Nym Connect (MacOS)
 on:
  workflow_dispatch:
  release:
@@ -6,11 +6,11 @@ on:

 defaults:
  run:
-    working-directory: nym-connect/desktop
+    working-directory: nym-connect

 jobs:
  publish-tauri:
-    if: ${{ (startsWith(github.ref, 'refs/tags/nym-connect-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
+    if: ${{ startsWith(github.ref, 'refs/tags/nym-connect-') && github.event_name == 'release' }}
    strategy:
      fail-fast: false
      matrix:
@@ -73,7 +73,7 @@ jobs:
        uses: actions/upload-artifact@v3
        with:
          name: nym-connect_1.0.0_x64.dmg
-          path: nym-connect/desktop/target/release/bundle/dmg/nym-connect_1.0.0_x64.dmg
+          path: nym-connect/target/release/bundle/dmg/nym-connect_1.0.0_x64.dmg
          retention-days: 30

      - name: Clean up keychain
@@ -86,5 +86,5 @@ jobs:
        if: github.event_name == 'release'
        with:
          files: |
-            nym-connect/desktop/target/release/bundle/dmg/*.dmg
-            nym-connect/desktop/target/release/bundle/macos/*.app.tar.gz*
+            nym-connect/target/release/bundle/dmg/*.dmg
+            nym-connect/target/release/bundle/macos/*.app.tar.gz*
@@ -1,4 +1,4 @@
-name: Publish Nym Connect - desktop (Ubuntu)
+name: Publish Nym Connect (Ubuntu)
 on:
  workflow_dispatch:
  release:
@@ -6,11 +6,11 @@ on:

 defaults:
  run:
-    working-directory: nym-connect/desktop
+    working-directory: nym-connect

 jobs:
  publish-tauri:
-    if: ${{ (startsWith(github.ref, 'refs/tags/nym-connect-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
+    if: ${{ startsWith(github.ref, 'refs/tags/nym-connect-') && github.event_name == 'release' }}
    strategy:
      fail-fast: false
      matrix:
@@ -53,7 +53,7 @@ jobs:
        uses: actions/upload-artifact@v3
        with:
          name: nym-connect.AppImage.tar.gz
-          path: nym-connect/desktop/target/release/bundle/appimage/nym-connect_1.0.0_amd64.AppImage
+          path: nym-connect/target/release/bundle/appimage/nym-connect_1.0.0_amd64.AppImage
          retention-days: 30

      - name: Upload to release based on tag name
@@ -61,5 +61,5 @@ jobs:
        if: github.event_name == 'release'
        with:
          files: |
-            nym-connect/desktop/target/release/bundle/appimage/*.AppImage
-            nym-connect/desktop/target/release/bundle/appimage/*.AppImage.tar.gz*
+            nym-connect/target/release/bundle/appimage/*.AppImage
+            nym-connect/target/release/bundle/appimage/*.AppImage.tar.gz*
@@ -1,4 +1,4 @@
-name: Publish Nym Connect - desktop (Windows 10)
+name: Publish Nym Connect (Windows 10)
 on:
  workflow_dispatch:
  release:
@@ -6,11 +6,11 @@ on:

 defaults:
  run:
-    working-directory: nym-connect/desktop
+    working-directory: nym-connect

 jobs:
  publish-tauri:
-    if: ${{ (startsWith(github.ref, 'refs/tags/nym-connect-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
+    if: ${{ startsWith(github.ref, 'refs/tags/nym-connect-') && github.event_name == 'release' }}
    strategy:
      fail-fast: false
      matrix:
@@ -56,7 +56,7 @@ jobs:
          encodedString: ${{ secrets.WALLET_ADMIN_ADDRESS }}

      - name: Install app dependencies
-        run: yarn --network-timeout 100000
+        run: yarn

      - name: Build and sign it
        env:
@@ -72,7 +72,7 @@ jobs:
        uses: actions/upload-artifact@v3
        with:
          name: nym-connect_1.0.0_x64_en-US.msi
-          path: nym-connect/desktop/target/release/bundle/msi/nym-connect_1.0.0_x64_en-US.msi
+          path: nym-connect/target/release/bundle/msi/nym-connect_1.0.0_x64_en-US.msi
          retention-days: 30

      - name: Upload to release based on tag name
@@ -80,5 +80,5 @@ jobs:
        if: github.event_name == 'release'
        with:
          files: |
-            nym-connect/desktop/target/release/bundle/msi/*.msi
-            nym-connect/desktop/target/release/bundle/msi/*.msi.zip*
+            nym-connect/target/release/bundle/msi/*.msi
+            nym-connect/target/release/bundle/msi/*.msi.zip*
@@ -1,13 +1,13 @@
-name: CI for nym-connect - Desktop
+name: CI for nym-connect

 on:
  push:
    paths:
-      - 'nym-connect/desktop/**'
+      - 'nym-connect/**'

 defaults:
  run:
-    working-directory: nym-connect/desktop
+    working-directory: nym-connect

 jobs:
  build:
@@ -34,15 +34,15 @@ jobs:
      env:
        SSH_PRIVATE_KEY: ${{ secrets.CI_WWW_SSH_PRIVATE_KEY }}
        ARGS: "-rltgoDzvO --delete"
-        SOURCE: "nym-connect/desktop/storybook-static/"
+        SOURCE: "nym-connect/storybook-static/"
        REMOTE_HOST: ${{ secrets.CI_WWW_REMOTE_HOST }}
        REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
        TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/nym-connect-${{ env.GITHUB_REF_SLUG }}
        EXCLUDE: "/dist/, /node_modules/"
-    - name: Matrix - Node Install
+    - name: Keybase - Node Install
      run: npm install
      working-directory: .github/workflows/support-files
-    - name: Matrix - Send Notification
+    - name: Keybase - Send Notification
      env:
        NYM_NOTIFICATION_KIND: nym-connect
        NYM_PROJECT_NAME: "nym-connect"
@@ -50,6 +50,10 @@ jobs:
        NYM_CI_WWW_LOCATION: "nym-connect-${{ env.GITHUB_REF_SLUG }}"
        GIT_COMMIT_MESSAGE: "${{ github.event.head_commit.message }}"
        GIT_BRANCH: "${GITHUB_REF##*/}"
+        KEYBASE_NYMBOT_USERNAME: "${{ secrets.KEYBASE_NYMBOT_USERNAME }}"
+        KEYBASE_NYMBOT_PAPERKEY: "${{ secrets.KEYBASE_NYMBOT_PAPERKEY }}"
+        KEYBASE_NYMBOT_TEAM: "${{ secrets.KEYBASE_NYMBOT_TEAM }}"
+        KEYBASE_NYM_CHANNEL: "ci-nym-connect"
        IS_SUCCESS: "${{ job.status == 'success' }}"
        MATRIX_SERVER: "${{ secrets.MATRIX_SERVER }}"
        MATRIX_ROOM: "${{ secrets.MATRIX_ROOM }}"
@@ -16,7 +16,7 @@ env:

 jobs:
  publish-nym:
-    if: ${{ (startsWith(github.ref, 'refs/tags/nym-binaries-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
+    if: ${{ startsWith(github.ref, 'refs/tags/nym-binaries-') && github.event_name == 'release' }}
    strategy:
      fail-fast: false
      matrix:
@@ -10,7 +10,7 @@ defaults:

 jobs:
  publish-tauri:
-    if: ${{ (startsWith(github.ref, 'refs/tags/nym-wallet-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
+    if: ${{ startsWith(github.ref, 'refs/tags/nym-wallet-') && github.event_name == 'release' }}
    strategy:
      fail-fast: false
      matrix:
@@ -9,7 +9,7 @@ defaults:

 jobs:
  publish-tauri:
-    if: ${{ (startsWith(github.ref, 'refs/tags/nym-wallet-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
+    if: ${{ startsWith(github.ref, 'refs/tags/nym-wallet-') && github.event_name == 'release' }}
    strategy:
      fail-fast: false
      matrix:
@@ -1,6 +1,5 @@
 name: Publish Nym Wallet (Windows 10)
 on:
-  workflow_dispatch:
  release:
    types: [created]

@@ -10,7 +9,7 @@ defaults:

 jobs:
  publish-tauri:
-    if: ${{ (startsWith(github.ref, 'refs/tags/nym-wallet-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
+    if: ${{ startsWith(github.ref, 'refs/tags/nym-wallet-') && github.event_name == 'release' }}
    strategy:
      fail-fast: false
      matrix:
@@ -56,7 +55,7 @@ jobs:
          encodedString: ${{ secrets.WALLET_ADMIN_ADDRESS }}

      - name: Install app dependencies
-        run: yarn --network-timeout 100000
+        run: yarn

      - name: Build and sign it
        env:
@@ -68,16 +67,8 @@ jobs:
          TAURI_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
        run: yarn build

-      - name: Upload Artifact
-        uses: actions/upload-artifact@v3
-        with:
-          name: nym-wallet_1.0.0_x64_en-US.msi
-          path: nym-wallet/target/release/bundle/msi/nym-wallet_1.*.msi
-          retention-days: 30
-
      - name: Upload to release based on tag name
        uses: softprops/action-gh-release@v1
-        if: github.event_name == 'release'
        with:
          files: |
            nym-wallet/target/release/bundle/msi/*.msi
@@ -35,10 +35,10 @@ jobs:
        REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
        TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/wallet-${{ env.GITHUB_REF_SLUG }}
        EXCLUDE: "/dist/, /node_modules/"
-    - name: Matrix - Node Install
+    - name: Keybase - Node Install
      run: npm install
      working-directory: .github/workflows/support-files
-    - name: Matrix - Send Notification
+    - name: Keybase - Send Notification
      env:
        NYM_NOTIFICATION_KIND: nym-wallet
        NYM_PROJECT_NAME: "nym-wallet"
@@ -46,6 +46,10 @@ jobs:
        NYM_CI_WWW_LOCATION: "wallet-${{ env.GITHUB_REF_SLUG }}"
        GIT_COMMIT_MESSAGE: "${{ github.event.head_commit.message }}"
        GIT_BRANCH: "${GITHUB_REF##*/}"
+        KEYBASE_NYMBOT_USERNAME: "${{ secrets.KEYBASE_NYMBOT_USERNAME }}"
+        KEYBASE_NYMBOT_PAPERKEY: "${{ secrets.KEYBASE_NYMBOT_PAPERKEY }}"
+        KEYBASE_NYMBOT_TEAM: "${{ secrets.KEYBASE_NYMBOT_TEAM }}"
+        KEYBASE_NYM_CHANNEL: "ci-nym-wallet"
        IS_SUCCESS: "${{ job.status == 'success' }}"
        MATRIX_SERVER: "${{ secrets.MATRIX_SERVER }}"
        MATRIX_ROOM: "${{ secrets.MATRIX_ROOM }}"
@@ -1,36 +0,0 @@
-name: CI for Nym API Tests
-
-on:
-  workflow_dispatch:
-  push:
-    paths:
-      - "nym-api/**"
-
-defaults:
-  run:
-    working-directory: nym-api/tests
-
-jobs:
-  test:
-    name: nym-api tests
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      
-      - name: Install npm
-        run: npm install
-        
-      - name: Node v18
-        uses: actions/setup-node@v3
-        with:
-          node-version: 18.1.0
-
-      - name: Install yarn
-        run: yarn install
-
-      - name: Run yarn
-        run: yarn
-
-      - name: Run tests
-        run: yarn test:qa
-        working-directory: nym-api/tests
@@ -1,3 +1,7 @@
+KEYBASE_NYM_CHANNEL=
+KEYBASE_NYMBOT_USERNAME=
+KEYBASE_NYMBOT_PAPERKEY=
+
 MATRIX_SERVER=
 MATRIX_ROOM=
 MATRIX_ROOM_OF_SHAME=
@@ -35,4 +39,4 @@ NYM_CI_WWW_BASE=example.com
 # Nightly builds
 WORKFLOW_CONCLUSION=success

-SHOW_DEBUG=true
+SHOW_DEBUG=true
@@ -4,7 +4,7 @@ This is a collection of scripts and files to support GitHub Actions.

 ## Sending Notifications

-These scripts send CI notifications to Matrix by creating messages from templates and env vars passed from GitHub Actions.
+These scripts send CI notifications to Keybase by creating messages from templates and env vars passed from GitHub Actions.

 ### Adding notifications to a GitHub Action

@@ -19,11 +19,10 @@ jobs:
      env:
        NYM_NOTIFICATION_KIND: "my-component"
        GIT_BRANCH: "${GITHUB_REF##*/}"
-        MATRIX_SERVER: "${{ secrets.MATRIX_SERVER }}"
-        MATRIX_ROOM: "${{ secrets.MATRIX_ROOM }}"
-        MATRIX_USER_ID: "${{ secrets.MATRIX_USER_ID }}"
-        MATRIX_TOKEN: "${{ secrets.MATRIX_TOKEN }}"
-        MATRIX_DEVICE_ID: "${{ secrets.MATRIX_DEVICE_ID }}"
+        KEYBASE_NYMBOT_USERNAME: "${{ secrets.KEYBASE_NYMBOT_USERNAME }}"
+        KEYBASE_NYMBOT_PAPERKEY: "${{ secrets.KEYBASE_NYMBOT_PAPERKEY }}"
+        KEYBASE_NYMBOT_TEAM: "${{ secrets.KEYBASE_NYMBOT_TEAM }}"
+        KEYBASE_NYM_CHANNEL: "ci-network-explorer"
        IS_SUCCESS: "${{ job.status == 'success' }}"
      uses: docker://keybaseio/client:stable-node
      with:
@@ -35,8 +34,8 @@ Notifications are run by adding the snippet above to a GitHub Action, and:
 1. Installing node packages needed at run time
 2. Set the env vars as required:
    - `NYM_NOTIFICATION_KIND` matches the directory in `.github/workflows/support-files/${NYM_NOTIFICATION_KIND}` to provide the templates and extra scripting in `index.js`
-    - Matrix credentials, room and other env vars for the status of the build and repo
-3. Replacing the default entry point shell script on the `keybaseio/client:stable-node` docker image to run `.github/workflows/support-files/notifications/entry_point.sh`
+    - Keybase credentials, channel and other env vars for the status of the build and repo
+3. Replacing the default entry point shell script on the `keybaseio/client:stable-node` docker image to run `.github/workflows/support-files/notifications/entry_point.sh` 

 ### Running locally

@@ -44,7 +43,7 @@ You will need:
 - Node 16 LTS
 - npm

-Copy `.github/workflows/support-files/.env.example` to `.github/workflows/support-files/.env` and valid Matrix credentials.
+Copy `.github/workflows/support-files/.env.example` to `.github/workflows/support-files/.env` and valid Keybase credentials.

 Then run `npm install` to get dependencies.

@@ -56,4 +55,4 @@ npm install
 cp .env.example .env
 vi .env
 npm run dev
-```
+```
@@ -1,62 +0,0 @@
-#!/usr/bin/env bash
-
-#
-# Basic usage:
-#   ./git-merge-check origin/develop origin/release/v1.1.9
-#
-
-set -x
-
-set -o nounset
-set -o pipefail
-
-# Start from branch ...
-branch1=$1
-
-# ... and try to merge in
-branch2=$2
-
-echo "Checking if $branch2 merges without conflicts into $branch1..."
-
-git checkout -q $branch1 || exit 1
-
-# There are two options here as far as I see on what we should check for. Either
-#
-#  (A) check for CONFLICT in any file except whitelist (such as .lock files)
-#  (B) check for "Automatic merge failed"
-#
-# Both of these options have drawbacks.
-#
-# The first (A) has the problem in that maybe we don't want to fail if the
-# changes can be automatically merged (duh), but at least we are not pestered
-# about constant lock file changes.
-# The second (B) has the problem that it's difficult to filter out automatic
-# merge fails for files we don't care about (.lock files).
-#
-# The ideal solution would be to check for automatic merge fails for files
-# except those on a whitelist (e.g. lock files).
-
-# For now I choose to use (B) here, because I hope it might be less noisy
-
-# Alternative A
-#output=$(git merge --no-commit --no-ff $branch2 | grep -v .lock)
-#merge_failed=$(echo $output | grep -v "CONFLICT")
-#return_code=$?
-
-# Alternative B
-output=$(git merge --no-commit --no-ff $branch2)
-merge_failed=$(echo $output | grep -v "Automatic merge failed")
-return_code=$?
-
-# Restore
-
-git merge --abort
-git checkout -q -
-
-if [ $return_code -eq 0 ]; then
-    echo "Merge check success"
-else
-    echo "Merge check failed"
-fi
-
-exit $return_code
@@ -1,14 +1,9 @@
 🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥
 > :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:
 ```
@@ -1,16 +1,10 @@
 🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩
 > :rocket: {{ env.NYM_PROJECT_NAME }}  ➡️➡️➡️➡️➡️ **View output:** https://{{ env.NYM_CI_WWW_LOCATION }}.{{ env.NYM_CI_WWW_BASE }}/
->
 > `storybook`: https://{{ env.NYM_CI_WWW_LOCATION_STORYBOOK }}.{{ 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 }}:
 ```
@@ -151,7 +151,7 @@ async function getMessageBody(context) {
      return `${icon} ${job.conclusion}: ${job.name} - ${job.html_url}`;
    })
    // and join with newlines for display in the template
-    .join('\n\n');
+    .join('\n');

  return template({ ...context, jobResults });
 }
@@ -1,15 +1,9 @@
 🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥
 > :rocket: {{ env.NYM_PROJECT_NAME }}
->
 > 🔴 **FAILURE** :cry:
->
 > `when` {{ timestamp }}
->
 > `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 }}
->

 {{ jobResults }}
@@ -1,15 +1,9 @@
 🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩
 > :rocket: {{ env.NYM_PROJECT_NAME }}
->
 > ✅ **SUCCESS**
->
 > `when` {{ timestamp }}
->
 > `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 }}
->

-{{ jobResults }}
+{{ jobResults }}
@@ -1,5 +1,6 @@
 require('dotenv').config();

+const Bot = require('keybase-bot');
 const { sendMatrixMessage } = require('./send_message_to_matrix');

 let context = {
@@ -23,6 +24,21 @@ function validateContext() {
      'Please set env var NYM_PROJECT_NAME with the project name for displaying in notification messages',
    );
  }
+  if (!context.env.KEYBASE_NYM_CHANNEL) {
+    throw new Error(
+      'Please set env var KEYBASE_NYM_CHANNEL with the channel name for the notification message',
+    );
+  }
+  if (!context.env.KEYBASE_NYMBOT_USERNAME) {
+    throw new Error(
+      'Username is not defined. Please set env var KEYBASE_NYMBOT_USERNAME',
+    );
+  }
+  if (!context.env.KEYBASE_NYMBOT_PAPERKEY) {
+    throw new Error(
+      'Paperkey is not defined. Please set env var KEYBASE_NYMBOT_PAPERKEY',
+    );
+  }
  if (context.env.MATRIX_ROOM) {
    if (!context.env.MATRIX_SERVER) {
      throw new Error(
@@ -68,6 +84,12 @@ function createTemplateContext() {

  context.kind = context.env.NYM_NOTIFICATION_KIND;

+  context.keybase = {
+    channel: context.env.KEYBASE_NYM_CHANNEL,
+    username: context.env.KEYBASE_NYMBOT_USERNAME,
+    paperkey: context.env.KEYBASE_NYMBOT_PAPERKEY,
+  };
+
  if (!context.env.GIT_BRANCH_NAME) {
    context.env.GIT_BRANCH_NAME = context.env.GITHUB_REF.split('/')
      .slice(2)
@@ -77,6 +99,40 @@ function createTemplateContext() {
  context.status = process.env.IS_SUCCESS === 'true' ? 'success' : 'failure';
 }

+async function sendKeybaseMessage(messageBody) {
+  const bot = new Bot();
+  try {
+    console.log(
+      `Initialising keybase with user "${
+        context.keybase.username
+      }" and key: "${'*'.repeat(context.keybase.paperkey.length)}"...`,
+    );
+    await bot.init(context.keybase.username, context.keybase.paperkey, {
+      verbose: false,
+    });
+
+    const channel = {
+      name: context.env.KEYBASE_NYMBOT_TEAM || 'nymtech_bot',
+      membersType: 'team',
+      topicName: context.keybase.channel,
+      topic_type: 'CHAT',
+    };
+    const message = {
+      body: messageBody,
+    };
+
+    console.log(`Sending to ${channel.name}#${channel.topicName}...`);
+    await bot.chat.send(channel, message);
+
+    console.log('Message sent!');
+  } catch (error) {
+    console.error(error);
+    process.exitCode = -1;
+  } finally {
+    await bot.deinit();
+  }
+}
+
 /**
 * Uses the `kind` set in the context to process the context and generate a notification message
 * @returns {Promise<string>} A string notification message body
@@ -113,6 +169,7 @@ async function main() {
    console.log(messageBody);
    console.log('-----------------------------------------');
  }
+  await sendKeybaseMessage(messageBody);
  if(context.env.MATRIX_ROOM) {
    await sendMatrixMessage(context, messageBody, context.env.MATRIX_ROOM)
  }
@@ -5,7 +5,12 @@ const localStorage = new LocalStorage('./scratch');
 const {
  LocalStorageCryptoStore,
 } = require('matrix-js-sdk/lib/crypto/store/localStorage-crypto-store');
-var showdown  = require('showdown');
+
+const vfile = require('to-vfile');
+const unified = require('unified');
+const remarkParse = require('remark-parse');
+const remarkHtml = require('remark-html');
+const emoji = require('remark-emoji');

 // hide all matrix client output
 console.error = (error) => console.log('❌ error: ', error);
@@ -54,9 +59,17 @@ function createClient(context, room, message) {
  return client;
 }

+async function markdownToHtml(messageAsMarkdown) {
+  const file = await unified()
+    .use(emoji)
+    .use(remarkParse)
+    .use(remarkHtml)
+    .process(await vfile({ path: 'test.md', contents: messageAsMarkdown}));
+  return String(file);
+}
+
 async function sendMatrixMessage(contextArg, messageAsMarkdown, roomId) {
-  const converter = new showdown.Converter();
-  const messageAsHtml = converter.makeHtml(messageAsMarkdown);
+  const messageAsHtml = await markdownToHtml(messageAsMarkdown);
  const client = createClient(contextArg, roomId, messageAsHtml);
  await client.initCrypto();
  await client.startClient({ initialSyncLimit: 1 });
@@ -1,14 +1,9 @@
 🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥
 > :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:
 ```
@@ -1,14 +1,9 @@
 🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩
 > :rocket: {{ env.NYM_PROJECT_NAME }}  ➡️➡️➡️➡️➡️ **View storybook:** 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 }}:
 ```
@@ -1,14 +1,9 @@
 🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥
 > :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:
 ```
@@ -1,18 +1,13 @@
 🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩
 > :rocket: {{ env.NYM_PROJECT_NAME }}
->
 > ✅ **SUCCESS**
->
+
 > ➡️➡️➡️➡️➡️ **View output:**
->
 > `storybook`: https://{{ env.NYM_CI_WWW_LOCATION }}.{{ env.NYM_CI_WWW_BASE }}
->
+
 > `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 }}:
 ```
@@ -1,6 +1,6 @@
 {
-  "name": "send-matrix-message",
-  "description": "Sends a notification message with the matrix sdk",
+  "name": "send-keybase-message",
+  "description": "Sends a notification message with the keybase package that fails when piped into the keybase CLI",
  "version": "1.0.0",
  "private": true,
  "scripts": {
@@ -10,6 +10,7 @@
  "dependencies": {
    "dotenv": "^16.0.0",
    "handlebars": "^4.7.7",
+    "keybase-bot": "^3.6.1",
    "matrix-js-sdk": "^9.3.0",
    "node-localstorage": "^2.1.6",
    "octokit": "^1.7.1",
@@ -17,7 +18,6 @@
    "remark-emoji": "^2.2.0",
    "remark-html": "^13.0.2",
    "remark-parse": "^9.0.0",
-    "showdown": "^2.1.0",
    "to-vfile": "^6.1.0",
    "unified": "^9.2.2"
  },
@@ -1,14 +1,9 @@
 🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥
 > :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:
 ```
@@ -1,20 +1,14 @@
 🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩
 > :rocket: {{ env.NYM_PROJECT_NAME }}
->
 > ✅ **SUCCESS**
->
+
 > ➡️➡️➡️➡️➡️ **View output:**
->
 > `storybook`: https://{{ env.NYM_CI_WWW_LOCATION }}.{{ env.NYM_CI_WWW_BASE }}
->
 > `example`: https://{{ env.NYM_CI_WWW_LOCATION }}-example.{{ env.NYM_CI_WWW_BASE }}
->
+
 > `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 }}:
 ```
@@ -1,46 +0,0 @@
-name: tag-and-release
-
-on:
-  workflow_dispatch:
-    inputs:  
-      nym_binaries_version:
-        description: 'Version of the nym-binaries tag'
-        required: false
-        type: string 
-      nym_wallet_version:
-        description: 'Version of the nym-wallet tag'
-        required: false
-        type: string 
-      nym_connect_version:
-        description: 'Version of the nym-connect tag'
-        required: false
-        type: string 
-
-jobs:
-  tag-components:
-    uses: nymtech/reusable-workflows/.github/workflows/tag-components.yml@master
-    with:
-      nym_binaries_version: ${{ input.nym_binaries_version }}
-      nym_wallet_version: ${{ input.nym_wallet_version }}
-      nym_connect_version: ${{ input.nym_connect_version }}
-
-  create-nym-binaries-release:
-    if: ${{ input.nym_binaries_version }}
-    uses: nymtech/reusable-workflows/.github/workflows/create-binaries-release.yml@master
-    with:
-      version: ${{ input.nym_binaries_version }}
-    needs: ["tag-components"]
-
-  create-nym-wallet-release:
-    if: ${{ input.nym_wallet_version }}
-    uses: nymtech/reusable-workflows/.github/workflows/create-wallet-release.yml@master
-    with:
-      version: ${{ input.nym_wallet_version }}
-    needs: ["tag-components"]
-
-  create-nym-connect-release:
-    if: ${{ input.nym_connect_version }}
-    uses: nymtech/reusable-workflows/.github/workflows/create-connect-release.yml@master
-    with:
-      version: ${{ input.nym_connect_version }}
-    needs: ["tag-components"]
@@ -5,22 +5,9 @@ on:
    paths:
      - 'ts-packages/**'
      - 'sdk/typescript/**'
-      - 'nym-connect/desktop/src/**'
-      - 'nym-connect/desktop/package.json'
-      - 'nym-connect/mobile/src/**'
-      - 'nym-connect/mobile/package.json'
-      - 'nym-wallet/src/**'
-      - 'nym-wallet/package.json'
-  pull_request:
-    paths:
-      - 'ts-packages/**'
-      - 'sdk/typescript/**'
-      - 'nym-connect/desktop/src/**'
-      - 'nym-connect/desktop/package.json'
-      - 'nym-connect/mobile/src/**'
-      - 'nym-connect/mobile/package.json'
-      - 'nym-wallet/src/**'
-      - 'nym-wallet/package.json'
+      - nym-connect
+      - nym-connect-android
+      - nym-wallet

 jobs:
  build:
@@ -36,16 +23,12 @@ jobs:
        node-version: 16
    - name: Setup yarn
      run: npm install -g yarn
-    - name: Install
-      run: yarn
-    - name: Build packages
-      run: yarn build
    - name: Lint
-      run: yarn lint && yarn tsc
-    - name: Matrix - Node Install
+      run: yarn && yarn lint && yarn tsc
+    - name: Keybase - Node Install
      run: npm install
      working-directory: .github/workflows/support-files
-    - name: Matrix - Send Notification
+    - name: Keybase - Send Notification
      env:
        NYM_NOTIFICATION_KIND: ts-packages
        NYM_PROJECT_NAME: "ts-packages"
@@ -53,6 +36,10 @@ jobs:
        NYM_CI_WWW_LOCATION: "ts-${{ env.GITHUB_REF_SLUG }}"
        GIT_COMMIT_MESSAGE: "${{ github.event.head_commit.message }}"
        GIT_BRANCH: "${GITHUB_REF##*/}"
+        KEYBASE_NYMBOT_USERNAME: "${{ secrets.KEYBASE_NYMBOT_USERNAME }}"
+        KEYBASE_NYMBOT_PAPERKEY: "${{ secrets.KEYBASE_NYMBOT_PAPERKEY }}"
+        KEYBASE_NYMBOT_TEAM: "${{ secrets.KEYBASE_NYMBOT_TEAM }}"
+        KEYBASE_NYM_CHANNEL: "ci-ts-packages"
        IS_SUCCESS: "${{ job.status == 'success' }}"
        MATRIX_SERVER: "${{ secrets.MATRIX_SERVER }}"
        MATRIX_ROOM: "${{ secrets.MATRIX_ROOM }}"
@@ -1,95 +0,0 @@
-name: update-versions-and-changelog
-
-on:
-  workflow_dispatch:
-    inputs:
-      release_version:
-        description: "Release version, usually the milestone title"
-        required: true
-        type: string
-      milestone_id:
-        description: "Milestone ID, check the URL when you're on the specific milestone page"
-        required: true
-        type: string
-
-env:
-  CI_BOT_AUTHOR: "Nym bot"
-  CI_BOT_EMAIL: "nym-bot@users.noreply.github.com"
-
-jobs:
-  update-versions:
-    runs-on: ubuntu-22.04
-    steps:
-      - name: checkout-source
-        uses: actions/checkout@v3
-        with:
-          ref: "release/${{ inputs.release_version }}"
-          path: "nym"
-
-      - name: checkout-ci-tools-repo
-        uses: actions/checkout@v3
-        with: 
-          repository: "nymtech/ci-tools"
-          ref: "master"
-          path: "ci-tools"
-          token: "${{ secrets.ACCESS_TOKEN_PRIVATE_REPOS }}"
-
-      - name: Install Rust stable
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-
-      - name: install-version-bumper
-        run: "cargo install --path ."
-        working-directory: "ci-tools/version-bumper"
-
-      - name: run-version-bumper
-        run: "version-bumper bump binaries --nym-repo-directory nym"
-
-      - name: push-changes-to-branch
-        run: |
-          git config --global user.name "${{ env.CI_BOT_AUTHOR }}"
-          git config --global user.email "${{ env.CI_BOT_EMAIL }}"
-          git checkout -b release/${{ inputs.release_version }}-preparation
-          git commit -am "chore: version bump in preparation for release"
-          git push -u origin release/${{ inputs.release_version }}-preparation
-        working-directory: "nym"
-
-  update-changelog:
-    runs-on: ubuntu-22.04
-    needs: [update-versions]
-    steps:
-      - name: checkout-source
-        uses: actions/checkout@v3
-        with:
-          ref: "release/${{ inputs.release_version }}"
-          path: "nym"
-
-      - name: checkout-ci-tools-repo
-        uses: actions/checkout@v3
-        with: 
-          repository: "nymtech/ci-tools"
-          ref: "master"
-          path: "ci-tools"
-          token: "${{ secrets.ACCESS_TOKEN_PRIVATE_REPOS }}"
-
-      - name: Install Rust stable
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-
-      - name: install-changelog-updater
-        run: "cargo install --path ."
-        working-directory: "ci-tools/changelog-updater"
-
-      - name: run-changelog-updater
-        run: "changelog-updater mix ${{ inputs.milestone_id }} release/${{ inputs.release_version }}"
-
-      - name: push-changes-to-branch
-        run: |
-          git config --global user.name "${{ env.CI_BOT_AUTHOR }}"
-          git config --global user.email "${{ env.CI_BOT_EMAIL }}"
-          git checkout release/${{ inputs.release_version }}-preparation
-          git commit -am "chore: update changelog preparation for release"
-          git push
-        working-directory: "nym"
@@ -39,5 +39,7 @@ validator-api-config.toml
 dist
 storybook-static
 envs/qwerty.env
+Cargo.lock
+nym-connect/Cargo.lock
 .parcel-cache
 **/.DS_Store
@@ -2,120 +2,19 @@

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

-## [Unreleased]
-
-## [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
-
-## [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])
- Fix contracts and nym-api audit findings ([#3026])
- 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
-[#3026]: https://github.com/nymtech/nym/issues/3026
-[#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])
- Introduce a way of injecting topology into the client ([#3044])
- Update mixnet TypeScript client methods #1 ([#2783])
- Update tooltips for routing and average score ([#3133])
- update selected service provider description style ([#3128])
-
-[#3093]: https://github.com/nymtech/nym/issues/3093
-[#3044]: https://github.com/nymtech/nym/issues/3044
-[#2783]: https://github.com/nymtech/nym/issues/2783
-[#3133]: https://github.com/nymtech/nym/pull/3133
-[#3128]: https://github.com/nymtech/nym/pull/3128
-
-## [v1.1.11] (2023-02-28)
-
- Fix empty dealer set loop ([#3105])
- The nym-api db.sqlite is broken when trying to run against it it in `enabled-credentials-mode true` there is an ordering issue with migrations when using the credential binary to purchase bandwidth ([#3100])
- Feature/latency based gateway selection ([#3081])
- Fix the credential binary to handle transactions to sleep when in non-inProgress epochs ([#3057])
- Publish mixnet contract to crates.io ([#1919])
- Publish vesting contract to crates.io ([#1920])
- Feature/update checker to use master ([#3097])
- Feature/improve binary checks ([#3094])
-
-[#3105]: https://github.com/nymtech/nym/issues/3105
-[#3100]: https://github.com/nymtech/nym/issues/3100
-[#3081]: https://github.com/nymtech/nym/pull/3081
-[#3057]: https://github.com/nymtech/nym/issues/3057
-[#1919]: https://github.com/nymtech/nym/issues/1919
-[#1920]: https://github.com/nymtech/nym/issues/1920
-[#3097]: https://github.com/nymtech/nym/pull/3097
-[#3094]: https://github.com/nymtech/nym/pull/3094
-
-## [v1.1.10] (2023-02-21)
-
- Verloc listener causing mixnode unexpected shutdown ([#3038])
- rust-sdk - update API following implementation experience with the network-requester ([#3001])
- Prevent coconut deposits in incompatible states ([#2991])
- Support unavailable signer within threshold ([#2987])
- Implement DKG re-sharing ([#2935])
- contracts: add nym prefix to mixnet and vesting contract packages ([#2855])
- Introduce common interface for all service providers to allow obtaining information such as whether they're online, what binary version they're running, etc. ([#2758])
- Add client functionality to nym-network-requester ([#1900])
- nym-api: uptime rework ([#3053])
- ci: update typescript-lint.yml ([#3035])
- contracts: add nym prefix to mixnet and vesting contract packages ([#2855])
-
-[#3038]: https://github.com/nymtech/nym/issues/3038
-[#3001]: https://github.com/nymtech/nym/issues/3001
-[#2991]: https://github.com/nymtech/nym/issues/2991
-[#2987]: https://github.com/nymtech/nym/issues/2987
-[#2935]: https://github.com/nymtech/nym/issues/2935
-[#2855]: https://github.com/nymtech/nym/pull/2855
-[#2758]: https://github.com/nymtech/nym/issues/2758
-[#1900]: https://github.com/nymtech/nym/issues/1900
-[#3053]: https://github.com/nymtech/nym/pull/3053
-[#3035]: https://github.com/nymtech/nym/pull/3035
-[#2855]: https://github.com/nymtech/nym/pull/2855
-
-## [v1.1.9] (2023-02-07)
+# [Unreleased]

 ### Added

- Remove Coconut feature flag ([#2793])
- Separate `nym-api` endpoints with values of "total-supply" and "circulating-supply" in `nym` ([#2964])
+- remove coconut feature and unify builds ([#2890])
+- native-client: is now capable of listening for requests on sockets different than `127.0.0.1` ([#2939]). This can be specified via `--host` flag during `init` or `run`. Alternatively a custom `host` can be set in `config.toml` file under `socket` section.
+- dkg resharing mode ([#2936])

-### Changed
+[#2890]: https://github.com/nymtech/nym/pull/2890
+[#2939]: https://github.com/nymtech/nym/pull/2939
+[#2936]: https://github.com/nymtech/nym/pull/2936

- native-client: is now capable of listening for requests on sockets different than `127.0.0.1` ([#2912]). This can be specified via `--host` flag during `init` or `run`. Alternatively a custom `host` can be set in `config.toml` file under `socket` section.
- mixnode, gateway: fix unexpected shutdown on corrupted connection ([#2963])
-
-[#2793]: https://github.com/nymtech/nym/issues/2793
-[#2912]: https://github.com/nymtech/nym/issues/2912
-[#2964]: https://github.com/nymtech/nym/issues/2964
-[#2963]: https://github.com/nymtech/nym/issues/3017
-
-## [v1.1.8] (2023-01-31)
+# [v1.1.8] (2023-01-31)

 ### Added

@@ -135,7 +34,7 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://
 [#2873]: https://github.com/nymtech/nym/issues/2873


-## [v1.1.7] (2023-01-24)
+# [v1.1.7] (2023-01-24)

 ### Added

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

 ### Added

+### Changed
+
+## [v1.1.5] (2023-01-10)
+
+### Added
+
 - socks5: send status message for service ready, and network-requester error response in https://github.com/nymtech/nym/pull/2715

 ### Changed
@@ -22,13 +22,15 @@ members = [
    "clients/native",
    "clients/native/websocket-requests",
    "clients/socks5",
-    "common/bin-common",
+    "common/bandwidth-claim-contract",
    "common/client-libs/gateway-client",
    "common/client-libs/mixnet-client",
    "common/client-libs/validator-client",
+    "common/client-connections",
    "common/coconut-interface",
    "common/commands",
    "common/config",
+    "common/build-information",
    "common/cosmwasm-smart-contracts/coconut-bandwidth-contract",
    "common/cosmwasm-smart-contracts/coconut-dkg",
    "common/cosmwasm-smart-contracts/contracts-common",
@@ -40,10 +42,11 @@ members = [
    "common/credential-storage",
    "common/credentials",
    "common/crypto",
-    "common/dkg",
+    "common/crypto/dkg",
    "common/execute",
    "common/inclusion-probability",
    "common/ledger",
+    "common/logging",
    "common/mixnode-common",
    "common/network-defaults",
    "common/nonexhaustive-delayqueue",
@@ -66,6 +69,7 @@ members = [
    "common/topology",
    "common/types",
    "common/wasm-utils",
+    "common/completions",
    "explorer-api",
    "gateway",
    "gateway/gateway-requests",
@@ -93,38 +97,18 @@ default-members = [
    "explorer-api",
 ]

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

 [workspace.package]
 authors = ["Nym Technologies SA"]
 repository = "https://github.com/nymtech/nym"
 homepage = "https://nymtech.net"
-documentation = "https://nymtech.net"
 edition = "2021"
-license = "Apache-2.0"

 [workspace.dependencies]
-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"
+async-trait = "0.1.63"
 log = "0.4"
-once_cell = "1.7.2"
-rand = "0.8.5"
+thiserror = "1.0.38"
 serde = "1.0.152"
 serde_json = "1.0.91"
-tap = "1.0.1"
-thiserror = "1.0.38"
 tokio = "1.24.1"
-url = "2.2"
@@ -1,90 +1,108 @@
-# Default target
-all: test
-
 test: clippy-all cargo-test wasm fmt
-
 test-all: test cargo-test-expensive
-
 no-clippy: build cargo-test wasm fmt
-
 happy: fmt clippy-happy test
+clippy-all: clippy-main clippy-all-contracts clippy-all-wallet clippy-all-connect clippy-all-wasm-client
+clippy-happy: clippy-happy-main clippy-happy-contracts clippy-happy-wallet clippy-happy-connect
+cargo-test: test-main test-contracts test-wallet test-connect
+cargo-test-expensive: test-main-expensive test-contracts-expensive test-wallet-expensive test-connect-expensive
+build: build-contracts build-wallet build-main build-connect build-wasm-client
+fmt: fmt-main fmt-contracts fmt-wallet fmt-connect fmt-wasm-client

-# -----------------------------------------------------------------------------
-# Define targets for a given workspace
-#  $(1): name
-#  $(2): path to workspace
-#  $(3): extra arguments to cargo
-# -----------------------------------------------------------------------------
-define add_cargo_workspace
+clippy-happy-main:
+	cargo clippy

-clippy-happy-$(1):
-	cargo clippy --manifest-path $(2)/Cargo.toml $(3)
+clippy-happy-contracts:
+	cargo clippy --manifest-path contracts/Cargo.toml --target wasm32-unknown-unknown

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

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

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

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

-build-$(1):
-	cargo build --manifest-path $(2)/Cargo.toml --workspace $(3)

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

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

-clippy-happy: clippy-happy-$(1)
-clippy-all: clippy-$(1) clippy-$(1)-examples
-cargo-test: test-$(1)
-cargo-test-expensive: test-$(1)-expensive
-build: build-$(1) build-$(1)-examples
-fmt: fmt-$(1)
+clippy-all-connect:
+	cargo clippy --workspace --manifest-path nym-connect/Cargo.toml --all-features -- -D warnings

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

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

-# Generate targets for the various cargo workspaces
+test-main-expensive:
+	cargo test --workspace -- --ignored

-$(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))
-ifndef NYM_NO_MOBILE
-$(eval $(call add_cargo_workspace,connect-mobile,nym-connect/mobile/src-tauri))
-endif
+test-contracts:
+	cargo test --manifest-path contracts/Cargo.toml --all-features

-# -----------------------------------------------------------------------------
-# Convenience targets for crates that are already part of the main workspace
-# -----------------------------------------------------------------------------
+test-contracts-expensive:
+	cargo test --manifest-path contracts/Cargo.toml --all-features -- --ignored
+
+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/Cargo.toml --all-features
+
+test-connect-expensive:
+	cargo test --manifest-path nym-connect/Cargo.toml --all-features -- --ignored
+
+build-main:
+	cargo build --workspace
+
+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/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

-# -----------------------------------------------------------------------------
-# Misc
-# -----------------------------------------------------------------------------
+fmt-main:
+	cargo fmt --all
+
+fmt-contracts:
+	cargo fmt --manifest-path contracts/Cargo.toml --all
+
+fmt-wallet:
+	cargo fmt --manifest-path nym-wallet/Cargo.toml --all
+
+fmt-connect:
+	cargo fmt --manifest-path nym-connect/Cargo.toml --all
+
+fmt-wasm-client:
+	cargo fmt --manifest-path clients/webassembly/Cargo.toml --all

 wasm:
 	RUSTFLAGS='-C link-arg=-s' cargo build --manifest-path contracts/Cargo.toml --release --target wasm32-unknown-unknown
-	wasm-opt --disable-sign-ext -Os contracts/target/wasm32-unknown-unknown/release/vesting_contract.wasm -o contracts/target/wasm32-unknown-unknown/release/vesting_contract.wasm
-	wasm-opt --disable-sign-ext -Os contracts/target/wasm32-unknown-unknown/release/mixnet_contract.wasm -o contracts/target/wasm32-unknown-unknown/release/mixnet_contract.wasm

-# NOTE: this seems deprecated an not needed anymore?
 mixnet-opt: wasm
 	cd contracts/mixnet && make opt

@@ -92,5 +110,5 @@ generate-typescript:
 	cd tools/ts-rs-cli && cargo run && cd ../..
 	yarn types:lint:fix

-run-api-tests:
-	cd nym-api/tests/functional_test && yarn test:qa
+run-validator-tests:
+	cd nym-api/tests/functional_test && yarn test:qa
@@ -16,7 +16,7 @@ The platform is composed of multiple Rust crates. Top-level executable binary cr
 * nym-wallet - a desktop wallet implemented using the [Tauri](https://tauri.studio/en/docs/about/intro) framework. 

 [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg?style=for-the-badge)](https://opensource.org/licenses/Apache-2.0)
-[![Build Status](https://img.shields.io/github/actions/workflow/status/nymtech/nym/build.yml?branch=develop&style=for-the-badge&logo=github-actions)](https://github.com/nymtech/nym/actions?query=branch%3Adevelop)
+[![Build Status](https://img.shields.io/github/workflow/status/nymtech/nym/Continuous%20integration/develop?style=for-the-badge&logo=github-actions)](https://github.com/nymtech/nym/actions?query=branch%3Adevelop)


 ### Building
@@ -1,6 +1,6 @@
 [package]
 name = "client-core"
-version = "1.1.14"
+version = "1.1.8"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
 edition = "2021"
 rust-version = "1.66"
@@ -8,7 +8,7 @@ rust-version = "1.66"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [dependencies]
-async-trait = { workspace = true }
+async-trait = { version = "0.1.58" }
 dirs = "4.0"
 dashmap = "5.4.0"
 futures = "0.3"
@@ -20,26 +20,22 @@ serde_json = "1.0.89"
 tap = "1.0.1"
 thiserror = "1.0.34"
 url = { version ="2.2", features = ["serde"] }
-tungstenite = { version = "0.13.0", default-features = false }
 tokio = { version = "1.24.1", features = ["macros"]}
 time = "0.3.17"

 # internal
-nym-config = { path = "../../common/config" }
-nym-crypto = { path = "../../common/crypto" }
+config = { path = "../../common/config" }
+client-connections = { path = "../../common/client-connections" }
+crypto = { path = "../../common/crypto" }
 gateway-client = { path = "../../common/client-libs/gateway-client" }
 #gateway-client = { path = "../../common/client-libs/gateway-client", default-features = false, features = ["wasm", "coconut"] }
 gateway-requests = { path = "../../gateway/gateway-requests" }
-nym-nonexhaustive-delayqueue = { path = "../../common/nonexhaustive-delayqueue" }
-nym-sphinx = { path = "../../common/nymsphinx" }
-nym-pemstore = { path = "../../common/pemstore" }
-nym-topology = { path = "../../common/topology" }
+nonexhaustive-delayqueue = { path = "../../common/nonexhaustive-delayqueue" }
+nymsphinx = { path = "../../common/nymsphinx" }
+pemstore = { path = "../../common/pemstore" }
+topology = { path = "../../common/topology" }
 validator-client = { path = "../../common/client-libs/validator-client", default-features = false }
-nym-task = { path = "../../common/task" }
-
-[target."cfg(not(target_arch = \"wasm32\"))".dependencies.validator-client]
-path = "../../common/client-libs/validator-client"
-features = ["nyxd-client"]
+task = { path = "../../common/task" }

 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio-stream]
 version = "0.1.11"
@@ -49,9 +45,6 @@ features = ["time"]
 version = "1.24.1"
 features = ["time"]

-[target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio-tungstenite]
-version = "0.14"
-
 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.sqlx]
 version = "0.6.2"
 features = ["runtime-tokio-rustls", "sqlite", "macros", "migrate"]
@@ -73,7 +66,6 @@ features = ["futures"]

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

 [target."cfg(target_arch = \"wasm32\")".dependencies.time]
 version = "0.3.17"
@@ -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,
    }
 }
@@ -15,13 +15,14 @@ use crate::client::replies::reply_controller::{ReplyControllerReceiver, ReplyCon
 use crate::client::replies::reply_storage::{
    CombinedReplyStorage, PersistentReplyStorage, ReplyStorageBackend, SentReplyKeys,
 };
-use crate::client::topology_control::nym_api_provider::NymApiTopologyProvider;
 use crate::client::topology_control::{
    TopologyAccessor, TopologyRefresher, TopologyRefresherConfig,
 };
 use crate::config::{Config, DebugConfig, GatewayEndpointConfig};
 use crate::error::ClientCoreError;
 use crate::spawn_future;
+use client_connections::{ConnectionCommandReceiver, ConnectionCommandSender, LaneQueueLengths};
+use crypto::asymmetric::{encryption, identity};
 use futures::channel::mpsc;
 use gateway_client::bandwidth::BandwidthController;
 #[cfg(target_arch = "wasm32")]
@@ -31,19 +32,15 @@ use gateway_client::{
    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_task::connections::{ConnectionCommandReceiver, ConnectionCommandSender, LaneQueueLengths};
-use nym_task::{TaskClient, TaskManager};
-use nym_topology::provider_trait::TopologyProvider;
+use nymsphinx::acknowledgements::AckKey;
+use nymsphinx::addressing::clients::Recipient;
+use nymsphinx::addressing::nodes::NodeIdentity;
+use nymsphinx::receiver::ReconstructedMessage;
 use std::sync::Arc;
 use std::time::Duration;
 use tap::TapFallible;
+use task::{TaskClient, TaskManager};
 use url::Url;
-
 #[cfg(not(target_arch = "wasm32"))]
 use validator_client::nyxd::CosmWasmClient;

@@ -54,22 +51,11 @@ pub mod non_wasm_helpers;

 pub mod helpers;

-#[derive(Clone)]
 pub struct ClientInput {
    pub connection_command_sender: ConnectionCommandSender,
    pub input_sender: InputMessageSender,
 }

-impl ClientInput {
-    pub async fn send(
-        &self,
-        message: InputMessage,
-    ) -> Result<(), tokio::sync::mpsc::error::SendError<InputMessage>> {
-        self.input_sender.send(message).await
-    }
-}
-
-#[derive(Clone)]
 pub struct ClientOutput {
    pub received_buffer_request_sender: ReceivedBufferRequestSender,
 }
@@ -93,7 +79,6 @@ impl ClientOutput {
 pub struct ClientState {
    pub shared_lane_queue_lengths: LaneQueueLengths,
    pub reply_controller_sender: ReplyControllerSender,
-    pub topology_accessor: TopologyAccessor,
 }

 pub enum ClientInputStatus {
@@ -158,7 +143,6 @@ pub struct BaseClientBuilder<'a, B, C: Clone> {
    nym_api_endpoints: Vec<Url>,
    reply_storage_backend: B,

-    custom_topology_provider: Option<Box<dyn TopologyProvider>>,
    bandwidth_controller: Option<BandwidthController<C>>,
    key_manager: KeyManager,
 }
@@ -182,7 +166,6 @@ where
            bandwidth_controller,
            reply_storage_backend,
            key_manager,
-            custom_topology_provider: None,
        }
    }

@@ -201,17 +184,11 @@ where
            disabled_credentials: credentials_toggle.is_disabled(),
            nym_api_endpoints,
            reply_storage_backend,
-            custom_topology_provider: None,
            bandwidth_controller,
            key_manager,
        }
    }

-    pub fn with_topology_provider(mut self, provider: Box<dyn TopologyProvider>) -> Self {
-        self.custom_topology_provider = Some(provider);
-        self
-    }
-
    pub fn as_mix_recipient(&self) -> Recipient {
        Recipient::new(
            *self.key_manager.identity_keypair().public_key(),
@@ -236,15 +213,15 @@ where

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

-        if let Some(size) = debug_config.traffic.use_extended_packet_size {
+        if let Some(size) = debug_config.use_extended_packet_size {
            log::debug!("Setting extended packet size: {:?}", size);
            stream.set_custom_packet_size(size.into());
        }
@@ -294,15 +271,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(
@@ -317,7 +293,7 @@ where
        }
        let gateway_address = self.gateway_config.gateway_listener.clone();
        if gateway_address.is_empty() {
-            return Err(ClientCoreError::GatewayAddressUnknown);
+            return Err(ClientCoreError::GatwayAddressUnknown);
        }

        let gateway_identity = identity::PublicKey::from_base58_string(gateway_id)
@@ -327,7 +303,6 @@ where
        let shared_key = if self.key_manager.is_gateway_key_set() {
            Some(self.key_manager.gateway_shared_key())
        } else {
-            log::info!("Gateway key not set! Will proceed anyway.");
            None
        };

@@ -338,9 +313,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,
        );
@@ -356,38 +329,25 @@ where
        Ok(gateway_client)
    }

-    fn setup_topology_provider(
-        custom_provider: Option<Box<dyn TopologyProvider>>,
-        nym_api_urls: Vec<Url>,
-    ) -> Box<dyn TopologyProvider> {
-        // if no custom provider was ... provided ..., create one using nym-api
-        custom_provider.unwrap_or_else(|| {
-            Box::new(NymApiTopologyProvider::new(
-                nym_api_urls,
-                env!("CARGO_PKG_VERSION").to_string(),
-            ))
-        })
-    }
-
    // future responsible for periodically polling directory server and updating
    // the current global view of topology
    async fn start_topology_refresher(
-        topology_provider: Box<dyn TopologyProvider>,
+        nym_api_urls: Vec<Url>,
        refresh_rate: Duration,
        topology_accessor: TopologyAccessor,
        shutdown: TaskClient,
    ) -> Result<(), ClientCoreError> {
-        let topology_refresher_config = TopologyRefresherConfig::new(refresh_rate);
-
-        let mut topology_refresher = TopologyRefresher::new(
-            topology_refresher_config,
-            topology_accessor,
-            topology_provider,
+        let topology_refresher_config = TopologyRefresherConfig::new(
+            nym_api_urls,
+            refresh_rate,
+            env!("CARGO_PKG_VERSION").to_string(),
        );
+        let mut topology_refresher =
+            TopologyRefresher::new(topology_refresher_config, topology_accessor);
        // before returning, block entire runtime to refresh the current network view so that any
        // components depending on topology would see a non-empty view
        info!("Obtaining initial network topology");
-        topology_refresher.try_refresh().await;
+        topology_refresher.refresh().await;

        if let Err(err) = topology_refresher.ensure_topology_is_routable().await {
            log::error!(
@@ -496,13 +456,9 @@ where
        )
        .await?;

-        let topology_provider = Self::setup_topology_provider(
-            self.custom_topology_provider.take(),
-            self.nym_api_endpoints,
-        );
        Self::start_topology_refresher(
-            topology_provider,
-            self.debug_config.topology.topology_refresh_rate,
+            self.nym_api_endpoints.clone(),
+            self.debug_config.topology_refresh_rate,
            shared_topology_accessor.clone(),
            task_manager.subscribe(),
        )
@@ -538,7 +494,7 @@ where
            self_address,
        );

-        if let Some(size) = self.debug_config.traffic.use_extended_packet_size {
+        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());
        }
@@ -557,16 +513,12 @@ 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(),
+                shared_topology_accessor,
                sphinx_message_sender,
                task_manager.subscribe(),
            );
@@ -590,7 +542,6 @@ where
            client_state: ClientState {
                shared_lane_queue_lengths,
                reply_controller_sender,
-                topology_accessor: shared_topology_accessor,
            },
            task_manager,
        })
@@ -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,
    )
 }

@@ -7,11 +7,11 @@ use crate::spawn_future;
 use futures::task::{Context, Poll};
 use futures::{Future, Stream, StreamExt};
 use log::*;
-use nym_sphinx::acknowledgements::AckKey;
-use nym_sphinx::addressing::clients::Recipient;
-use nym_sphinx::cover::generate_loop_cover_packet;
-use nym_sphinx::params::PacketSize;
-use nym_sphinx::utils::sample_poisson_duration;
+use nymsphinx::acknowledgements::AckKey;
+use nymsphinx::addressing::clients::Recipient;
+use nymsphinx::cover::generate_loop_cover_packet;
+use nymsphinx::params::PacketSize;
+use nymsphinx::utils::sample_poisson_duration;
 use rand::{rngs::OsRng, CryptoRng, Rng};
 use std::pin::Pin;
 use std::sync::Arc;
@@ -192,7 +192,7 @@ impl LoopCoverTrafficStream<OsRng> {
                    // 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");
+                    log::warn!("Failed to send sphinx packet - gateway or connection to gatway can't keep up");
                }
                TrySendError::Closed(_) => {
                    log::warn!("Failed to send cover message - channel closed");
@@ -213,7 +213,7 @@ impl LoopCoverTrafficStream<OsRng> {
        tokio::task::yield_now().await;
    }

-    pub fn start_with_shutdown(mut self, mut shutdown: nym_task::TaskClient) {
+    pub fn start_with_shutdown(mut self, mut shutdown: task::TaskClient) {
        // we should set initial delay only when we actually start the stream
        let sampled =
            sample_poisson_duration(&mut self.rng, self.average_cover_message_sending_delay);
@@ -1,6 +1,6 @@
-use nym_sphinx::addressing::clients::Recipient;
-use nym_sphinx::anonymous_replies::requests::AnonymousSenderTag;
-use nym_task::connections::TransmissionLane;
+use client_connections::TransmissionLane;
+use nymsphinx::addressing::clients::Recipient;
+use nymsphinx::anonymous_replies::requests::AnonymousSenderTag;

 pub type InputMessageSender = tokio::sync::mpsc::Sender<InputMessage>;
 pub type InputMessageReceiver = tokio::sync::mpsc::Receiver<InputMessage>;
@@ -77,12 +77,4 @@ impl InputMessage {
            lane,
        }
    }
-
-    pub fn lane(&self) -> &TransmissionLane {
-        match self {
-            InputMessage::Regular { lane, .. }
-            | InputMessage::Anonymous { lane, .. }
-            | InputMessage::Reply { lane, .. } => lane,
-        }
-    }
 }
@@ -2,10 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::config::persistence::key_pathfinder::ClientKeyPathfinder;
+use crypto::asymmetric::{encryption, identity};
 use gateway_requests::registration::handshake::SharedKeys;
 use log::*;
-use nym_crypto::asymmetric::{encryption, identity};
-use nym_sphinx::acknowledgements::AckKey;
+use nymsphinx::acknowledgements::AckKey;
 use rand::{CryptoRng, RngCore};
 use std::io;
 use std::sync::Arc;
@@ -72,17 +72,17 @@ impl KeyManager {
    /// Loads previously stored client keys from the disk.
    fn load_client_keys(client_pathfinder: &ClientKeyPathfinder) -> io::Result<Self> {
        let identity_keypair: identity::KeyPair =
-            nym_pemstore::load_keypair(&nym_pemstore::KeyPairPath::new(
+            pemstore::load_keypair(&pemstore::KeyPairPath::new(
                client_pathfinder.private_identity_key().to_owned(),
                client_pathfinder.public_identity_key().to_owned(),
            ))?;
        let encryption_keypair: encryption::KeyPair =
-            nym_pemstore::load_keypair(&nym_pemstore::KeyPairPath::new(
+            pemstore::load_keypair(&pemstore::KeyPairPath::new(
                client_pathfinder.private_encryption_key().to_owned(),
                client_pathfinder.public_encryption_key().to_owned(),
            ))?;

-        let ack_key: AckKey = nym_pemstore::load_key(client_pathfinder.ack_key())?;
+        let ack_key: AckKey = pemstore::load_key(client_pathfinder.ack_key())?;

        Ok(KeyManager {
            identity_keypair: Arc::new(identity_keypair),
@@ -98,7 +98,7 @@ impl KeyManager {
        let mut key_manager = Self::load_client_keys(client_pathfinder)?;

        let gateway_shared_key: SharedKeys =
-            nym_pemstore::load_key(client_pathfinder.gateway_shared_key())?;
+            pemstore::load_key(client_pathfinder.gateway_shared_key())?;

        key_manager.gateway_shared_key = Some(Arc::new(gateway_shared_key));

@@ -113,7 +113,7 @@ impl KeyManager {
        let mut key_manager = Self::load_client_keys(client_pathfinder)?;

        let gateway_shared_key: Result<SharedKeys, io::Error> =
-            nym_pemstore::load_key(client_pathfinder.gateway_shared_key());
+            pemstore::load_key(client_pathfinder.gateway_shared_key());

        // It's ok if the gateway key was not found
        let gateway_shared_key = match gateway_shared_key {
@@ -132,27 +132,27 @@ impl KeyManager {
    // it is done so for the consistency sake so that you wouldn't require an rng instance
    // during `load_keys` to generate the said key.
    pub fn store_keys(&self, client_pathfinder: &ClientKeyPathfinder) -> io::Result<()> {
-        nym_pemstore::store_keypair(
+        pemstore::store_keypair(
            self.identity_keypair.as_ref(),
-            &nym_pemstore::KeyPairPath::new(
+            &pemstore::KeyPairPath::new(
                client_pathfinder.private_identity_key().to_owned(),
                client_pathfinder.public_identity_key().to_owned(),
            ),
        )?;
-        nym_pemstore::store_keypair(
+        pemstore::store_keypair(
            self.encryption_keypair.as_ref(),
-            &nym_pemstore::KeyPairPath::new(
+            &pemstore::KeyPairPath::new(
                client_pathfinder.private_encryption_key().to_owned(),
                client_pathfinder.public_encryption_key().to_owned(),
            ),
        )?;

-        nym_pemstore::store_key(self.ack_key.as_ref(), client_pathfinder.ack_key())?;
+        pemstore::store_key(self.ack_key.as_ref(), client_pathfinder.ack_key())?;

        match self.gateway_shared_key.as_ref() {
            None => debug!("No gateway shared key available to store!"),
            Some(gate_key) => {
-                nym_pemstore::store_key(gate_key.as_ref(), client_pathfinder.gateway_shared_key())?
+                pemstore::store_key(gate_key.as_ref(), client_pathfinder.gateway_shared_key())?
            }
        }

@@ -168,7 +168,7 @@ impl KeyManager {
                ))
            }
            Some(gate_key) => {
-                nym_pemstore::store_key(gate_key.as_ref(), client_pathfinder.gateway_shared_key())?
+                pemstore::store_key(gate_key.as_ref(), client_pathfinder.gateway_shared_key())?
            }
        }

@@ -6,7 +6,7 @@ use crate::spawn_future;
 use gateway_client::wasm_mockups::CosmWasmClient;
 use gateway_client::GatewayClient;
 use log::*;
-use nym_sphinx::forwarding::packet::MixPacket;
+use nymsphinx::forwarding::packet::MixPacket;
 #[cfg(not(target_arch = "wasm32"))]
 use validator_client::nyxd::CosmWasmClient;

@@ -76,7 +76,7 @@ where
        }
    }

-    pub fn start_with_shutdown(mut self, mut shutdown: nym_task::TaskClient) {
+    pub fn start_with_shutdown(mut self, mut shutdown: task::TaskClient) {
        spawn_future(async move {
            debug!("Started MixTrafficController with graceful shutdown support");

@@ -5,7 +5,7 @@ use super::action_controller::{AckActionSender, Action};
 use futures::StreamExt;
 use gateway_client::AcknowledgementReceiver;
 use log::*;
-use nym_sphinx::{
+use nymsphinx::{
    acknowledgements::{identifier::recover_identifier, AckKey},
    chunking::fragment::{FragmentIdentifier, COVER_FRAG_ID},
 };
@@ -65,7 +65,7 @@ impl AcknowledgementListener {
        }
    }

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

        while !shutdown.is_shutdown() {
@@ -6,9 +6,9 @@ use crate::client::real_messages_control::acknowledgement_control::Retransmissio
 use futures::channel::mpsc;
 use futures::StreamExt;
 use log::*;
-use nym_nonexhaustive_delayqueue::{Expired, NonExhaustiveDelayQueue, QueueKey};
-use nym_sphinx::chunking::fragment::FragmentIdentifier;
-use nym_sphinx::Delay as SphinxDelay;
+use nonexhaustive_delayqueue::{Expired, NonExhaustiveDelayQueue, QueueKey};
+use nymsphinx::chunking::fragment::FragmentIdentifier;
+use nymsphinx::Delay as SphinxDelay;
 use std::collections::HashMap;
 use std::sync::Arc;
 use std::time::Duration;
@@ -216,7 +216,7 @@ impl ActionController {
    fn handle_expired_ack_timer(
        &mut self,
        expired_ack: Expired<FragmentIdentifier>,
-        task_client: &mut nym_task::TaskClient,
+        task_client: &mut task::TaskClient,
    ) {
        // I'm honestly not sure how to handle it, because getting it means other things in our
        // system are already misbehaving. If we ever see this panic, then I guess we should worry
@@ -260,7 +260,7 @@ impl ActionController {
        }
    }

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

        while !shutdown.is_shutdown() {
@@ -4,10 +4,10 @@
 use crate::client::inbound_messages::{InputMessage, InputMessageReceiver};
 use crate::client::real_messages_control::message_handler::MessageHandler;
 use crate::client::replies::reply_controller::ReplyControllerSender;
+use client_connections::TransmissionLane;
 use log::*;
-use nym_sphinx::addressing::clients::Recipient;
-use nym_sphinx::anonymous_replies::requests::AnonymousSenderTag;
-use nym_task::connections::TransmissionLane;
+use nymsphinx::addressing::clients::Recipient;
+use nymsphinx::anonymous_replies::requests::AnonymousSenderTag;
 use rand::{CryptoRng, Rng};

 /// Module responsible for dealing with the received messages: splitting them, creating acknowledgements,
@@ -109,7 +109,7 @@ where
        };
    }

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

        while !shutdown.is_shutdown() {
@@ -15,9 +15,9 @@ use action_controller::AckActionReceiver;
 use futures::channel::mpsc;
 use gateway_client::AcknowledgementReceiver;
 use log::*;
-use nym_sphinx::anonymous_replies::requests::AnonymousSenderTag;
-use nym_sphinx::params::PacketSize;
-use nym_sphinx::{
+use nymsphinx::anonymous_replies::requests::AnonymousSenderTag;
+use nymsphinx::params::PacketSize;
+use nymsphinx::{
    acknowledgements::AckKey,
    addressing::clients::Recipient,
    chunking::fragment::{Fragment, FragmentIdentifier},
@@ -249,7 +249,7 @@ where
        }
    }

-    pub(super) fn start_with_shutdown(self, shutdown: nym_task::TaskClient) {
+    pub(super) fn start_with_shutdown(self, shutdown: task::TaskClient) {
        let mut acknowledgement_listener = self.acknowledgement_listener;
        let mut input_message_listener = self.input_message_listener;
        let mut retransmission_request_listener = self.retransmission_request_listener;
@@ -9,12 +9,12 @@ use crate::client::real_messages_control::acknowledgement_control::PacketDestina
 use crate::client::real_messages_control::message_handler::{MessageHandler, PreparationError};
 use crate::client::real_messages_control::real_traffic_stream::RealMessage;
 use crate::client::replies::reply_controller::ReplyControllerSender;
+use client_connections::TransmissionLane;
 use futures::StreamExt;
 use log::*;
-use nym_sphinx::addressing::clients::Recipient;
-use nym_sphinx::chunking::fragment::Fragment;
-use nym_sphinx::preparer::PreparedFragment;
-use nym_task::connections::TransmissionLane;
+use nymsphinx::addressing::clients::Recipient;
+use nymsphinx::chunking::fragment::Fragment;
+use nymsphinx::preparer::PreparedFragment;
 use rand::{CryptoRng, Rng};
 use std::sync::{Arc, Weak};

@@ -137,7 +137,7 @@ where
            .await
    }

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

        while !shutdown.is_shutdown() {
@@ -5,7 +5,7 @@ use super::action_controller::{AckActionSender, Action};
 use super::SentPacketNotificationReceiver;
 use futures::StreamExt;
 use log::*;
-use nym_sphinx::chunking::fragment::{FragmentIdentifier, COVER_FRAG_ID};
+use nymsphinx::chunking::fragment::{FragmentIdentifier, COVER_FRAG_ID};

 /// Module responsible for starting up retransmission timers.
 /// It is required because when we send our packet to the `real traffic stream` controlled
@@ -37,7 +37,7 @@ impl SentNotificationListener {
            .unwrap();
    }

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

        while !shutdown.is_shutdown() {
@@ -8,23 +8,23 @@ use crate::client::real_messages_control::real_traffic_stream::{
 use crate::client::real_messages_control::{AckActionSender, Action};
 use crate::client::replies::reply_storage::{ReceivedReplySurbsMap, SentReplyKeys, UsedSenderTags};
 use crate::client::topology_control::{TopologyAccessor, TopologyReadPermit};
+use client_connections::TransmissionLane;
 use log::{debug, error, info, trace, warn};
-use nym_sphinx::acknowledgements::AckKey;
-use nym_sphinx::addressing::clients::Recipient;
-use nym_sphinx::anonymous_replies::requests::{AnonymousSenderTag, RepliableMessage, ReplyMessage};
-use nym_sphinx::anonymous_replies::{ReplySurb, SurbEncryptionKey};
-use nym_sphinx::chunking::fragment::{Fragment, FragmentIdentifier};
-use nym_sphinx::message::NymMessage;
-use nym_sphinx::params::{PacketSize, DEFAULT_NUM_MIX_HOPS};
-use nym_sphinx::preparer::{MessagePreparer, PreparedFragment};
-use nym_sphinx::Delay;
-use nym_task::connections::TransmissionLane;
-use nym_topology::{NymTopology, NymTopologyError};
+use nymsphinx::acknowledgements::AckKey;
+use nymsphinx::addressing::clients::Recipient;
+use nymsphinx::anonymous_replies::requests::{AnonymousSenderTag, RepliableMessage, ReplyMessage};
+use nymsphinx::anonymous_replies::{ReplySurb, SurbEncryptionKey};
+use nymsphinx::chunking::fragment::{Fragment, FragmentIdentifier};
+use nymsphinx::message::NymMessage;
+use nymsphinx::params::{PacketSize, DEFAULT_NUM_MIX_HOPS};
+use nymsphinx::preparer::{MessagePreparer, PreparedFragment};
+use nymsphinx::Delay;
 use rand::{CryptoRng, Rng};
 use std::collections::HashMap;
 use std::sync::Arc;
 use std::time::Duration;
 use thiserror::Error;
+use topology::{NymTopology, NymTopologyError};

 // TODO: move that error elsewhere since it seems to be contaminating different files
 #[derive(Debug, Clone, Error)]
@@ -21,13 +21,13 @@ use crate::{
    },
    spawn_future,
 };
+use client_connections::{ConnectionCommandReceiver, LaneQueueLengths};
 use futures::channel::mpsc;
 use gateway_client::AcknowledgementReceiver;
 use log::*;
-use nym_sphinx::acknowledgements::AckKey;
-use nym_sphinx::addressing::clients::Recipient;
-use nym_sphinx::params::PacketSize;
-use nym_task::connections::{ConnectionCommandReceiver, LaneQueueLengths};
+use nymsphinx::acknowledgements::AckKey;
+use nymsphinx::addressing::clients::Recipient;
+use nymsphinx::params::PacketSize;
 use rand::{rngs::OsRng, CryptoRng, Rng};
 use std::sync::Arc;
 use std::time::Duration;
@@ -153,35 +153,25 @@ impl Config {
            ack_key,
            self_recipient,
            packet_size: Default::default(),
-            ack_wait_addition: base_client_debug_config.acknowledgements.ack_wait_addition,
-            ack_wait_multiplier: base_client_debug_config
-                .acknowledgements
-                .ack_wait_multiplier,
-            average_message_sending_delay: base_client_debug_config
-                .traffic
-                .message_sending_average_delay,
-            average_packet_delay_duration: base_client_debug_config.traffic.average_packet_delay,
-            average_ack_delay_duration: base_client_debug_config.acknowledgements.average_ack_delay,
+            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
-                .traffic
                .disable_main_poisson_packet_distribution,
            minimum_reply_surb_request_size: base_client_debug_config
-                .reply_surbs
                .minimum_reply_surb_request_size,
            maximum_reply_surb_request_size: base_client_debug_config
-                .reply_surbs
                .maximum_reply_surb_request_size,
            maximum_allowed_reply_surb_request_size: base_client_debug_config
-                .reply_surbs
                .maximum_allowed_reply_surb_request_size,
            maximum_reply_surb_rerequest_waiting_period: base_client_debug_config
-                .reply_surbs
                .maximum_reply_surb_rerequest_waiting_period,
            maximum_reply_surb_drop_waiting_period: base_client_debug_config
-                .reply_surbs
                .maximum_reply_surb_drop_waiting_period,
-            maximum_reply_surb_age: base_client_debug_config.reply_surbs.maximum_reply_surb_age,
-            maximum_reply_key_age: base_client_debug_config.reply_surbs.maximum_reply_key_age,
+            maximum_reply_surb_age: base_client_debug_config.maximum_reply_surb_age,
+            maximum_reply_key_age: base_client_debug_config.maximum_reply_key_age,
        }
    }

@@ -280,7 +270,7 @@ impl RealMessagesController<OsRng> {
        }
    }

-    pub fn start_with_shutdown(self, shutdown: nym_task::TaskClient) {
+    pub fn start_with_shutdown(self, shutdown: task::TaskClient) {
        let mut out_queue_control = self.out_queue_control;
        let ack_control = self.ack_control;
        let mut reply_control = self.reply_control;
@@ -6,20 +6,20 @@ use crate::client::mix_traffic::BatchMixMessageSender;
 use crate::client::real_messages_control::acknowledgement_control::SentPacketNotificationSender;
 use crate::client::topology_control::TopologyAccessor;
 use crate::client::transmission_buffer::TransmissionBuffer;
+use client_connections::{
+    ConnectionCommand, ConnectionCommandReceiver, ConnectionId, LaneQueueLengths, TransmissionLane,
+};
 use futures::task::{Context, Poll};
 use futures::{Future, Stream, StreamExt};
 use log::*;
-use nym_sphinx::acknowledgements::AckKey;
-use nym_sphinx::addressing::clients::Recipient;
-use nym_sphinx::chunking::fragment::FragmentIdentifier;
-use nym_sphinx::cover::generate_loop_cover_packet;
-use nym_sphinx::forwarding::packet::MixPacket;
-use nym_sphinx::params::PacketSize;
-use nym_sphinx::preparer::PreparedFragment;
-use nym_sphinx::utils::sample_poisson_duration;
-use nym_task::connections::{
-    ConnectionCommand, ConnectionCommandReceiver, ConnectionId, LaneQueueLengths, TransmissionLane,
-};
+use nymsphinx::acknowledgements::AckKey;
+use nymsphinx::addressing::clients::Recipient;
+use nymsphinx::chunking::fragment::FragmentIdentifier;
+use nymsphinx::cover::generate_loop_cover_packet;
+use nymsphinx::forwarding::packet::MixPacket;
+use nymsphinx::params::PacketSize;
+use nymsphinx::preparer::PreparedFragment;
+use nymsphinx::utils::sample_poisson_duration;
 use rand::{CryptoRng, Rng};
 use std::pin::Pin;
 use std::sync::Arc;
@@ -342,6 +342,7 @@ where
        if let Poll::Ready(Some(id)) = Pin::new(&mut self.client_connection_rx).poll_next(cx) {
            match id {
                ConnectionCommand::Close(id) => self.on_close_connection(id),
+                ConnectionCommand::ActiveConnections(_) => panic!(),
            }
        }

@@ -420,6 +421,7 @@ where
        if let Poll::Ready(Some(id)) = Pin::new(&mut self.client_connection_rx).poll_next(cx) {
            match id {
                ConnectionCommand::Close(id) => self.on_close_connection(id),
+                ConnectionCommand::ActiveConnections(_) => panic!(),
            }
        }

@@ -460,7 +462,7 @@ where
    }

    #[cfg(not(target_arch = "wasm32"))]
-    fn log_status(&self, shutdown: &mut nym_task::TaskClient) {
+    fn log_status(&self, shutdown: &mut task::TaskClient) {
        use crate::error::ClientCoreStatusMessage;

        let packets = self.transmission_buffer.total_size();
@@ -501,7 +503,7 @@ where
        }
    }

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

        #[cfg(not(target_arch = "wasm32"))]
@@ -4,20 +4,20 @@
 use crate::client::replies::reply_controller::ReplyControllerSender;
 use crate::client::replies::reply_storage::SentReplyKeys;
 use crate::spawn_future;
+use crypto::asymmetric::encryption;
+use crypto::Digest;
 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_sphinx::anonymous_replies::requests::{
+use nymsphinx::anonymous_replies::requests::{
    RepliableMessage, RepliableMessageContent, ReplyMessage, ReplyMessageContent,
 };
-use nym_sphinx::anonymous_replies::{encryption_key::EncryptionKeyDigest, SurbEncryptionKey};
-use nym_sphinx::message::{NymMessage, PlainMessage};
-use nym_sphinx::params::ReplySurbKeyDigestAlgorithm;
-use nym_sphinx::receiver::{MessageReceiver, MessageRecoveryError, ReconstructedMessage};
+use nymsphinx::anonymous_replies::{encryption_key::EncryptionKeyDigest, SurbEncryptionKey};
+use nymsphinx::message::{NymMessage, PlainMessage};
+use nymsphinx::params::ReplySurbKeyDigestAlgorithm;
+use nymsphinx::receiver::{MessageReceiver, MessageRecoveryError, ReconstructedMessage};
 use std::collections::HashSet;
 use std::sync::Arc;

@@ -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,9 +45,9 @@ 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) {
+        if nymsphinx::cover::is_cover(fragment_data) {
            trace!("The message was a loop cover message! Skipping it");
            return None;
        }
@@ -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 {
@@ -403,7 +399,7 @@ impl<R: MessageReceiver> RequestReceiver<R> {
        }
    }

-    async fn run_with_shutdown(&mut self, mut shutdown: nym_task::TaskClient) {
+    async fn run_with_shutdown(&mut self, mut shutdown: task::TaskClient) {
        debug!("Started RequestReceiver with graceful shutdown support");
        while !shutdown.is_shutdown() {
            tokio::select! {
@@ -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: 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,
@@ -496,19 +488,15 @@ impl<R: MessageReceiver + Clone + Send + 'static> ReceivedMessagesBufferControll
        }
    }

-    pub fn start_with_shutdown(self, shutdown: nym_task::TaskClient) {
+    pub fn start_with_shutdown(self, shutdown: task::TaskClient) {
        let mut fragmented_message_receiver = self.fragmented_message_receiver;
        let mut request_receiver = self.request_receiver;

        let shutdown_handle = shutdown.clone();
        spawn_future(async move {
-            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;
@@ -4,14 +4,14 @@
 use crate::client::real_messages_control::acknowledgement_control::PendingAcknowledgement;
 use crate::client::real_messages_control::message_handler::{MessageHandler, PreparationError};
 use crate::client::replies::reply_storage::CombinedReplyStorage;
+use client_connections::{ConnectionId, TransmissionLane};
 use futures::channel::oneshot;
 use futures::StreamExt;
 use log::{debug, error, info, trace, warn};
-use nym_sphinx::addressing::clients::Recipient;
-use nym_sphinx::anonymous_replies::requests::AnonymousSenderTag;
-use nym_sphinx::anonymous_replies::ReplySurb;
-use nym_sphinx::chunking::fragment::{Fragment, FragmentIdentifier};
-use nym_task::connections::{ConnectionId, TransmissionLane};
+use nymsphinx::addressing::clients::Recipient;
+use nymsphinx::anonymous_replies::requests::AnonymousSenderTag;
+use nymsphinx::anonymous_replies::ReplySurb;
+use nymsphinx::chunking::fragment::{Fragment, FragmentIdentifier};
 use rand::{CryptoRng, Rng};
 use std::cmp::{max, min};
 use std::collections::btree_map::Entry;
@@ -835,7 +835,7 @@ where
    //     todo!()
    // }

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

        let polling_rate = Duration::from_secs(5);
@@ -2,12 +2,12 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::client::real_messages_control::acknowledgement_control::PendingAcknowledgement;
+use client_connections::{ConnectionId, TransmissionLane};
 use futures::channel::{mpsc, oneshot};
 use log::error;
-use nym_sphinx::addressing::clients::Recipient;
-use nym_sphinx::anonymous_replies::requests::AnonymousSenderTag;
-use nym_sphinx::anonymous_replies::ReplySurb;
-use nym_task::connections::{ConnectionId, TransmissionLane};
+use nymsphinx::addressing::clients::Recipient;
+use nymsphinx::anonymous_replies::requests::AnonymousSenderTag;
+use nymsphinx::anonymous_replies::ReplySurb;
 use std::sync::Weak;

 pub(crate) fn new_control_channels() -> (ReplyControllerSender, ReplyControllerReceiver) {
@@ -5,8 +5,6 @@ use crate::client::replies::reply_storage::backend::Empty;
 use crate::client::replies::reply_storage::{CombinedReplyStorage, ReplyStorageBackend};
 use async_trait::async_trait;

-use std::path::PathBuf;
-
 // well, right now we don't have the browser storage : (
 // so we keep everything in memory
 #[derive(Debug)]
@@ -29,22 +27,6 @@ impl Backend {
 impl ReplyStorageBackend for Backend {
    type StorageError = <Empty as ReplyStorageBackend>::StorageError;

-    async fn new(
-        debug_config: &crate::config::DebugConfig,
-        _db_path: Option<PathBuf>,
-    ) -> 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,
-            },
-        })
-    }
-
    async fn flush_surb_storage(
        &mut self,
        storage: &CombinedReplyStorage,
@@ -56,9 +56,4 @@ pub enum StorageError {
        details: String,
        // err: Option<Box<dyn std::error::Error>>
    },
-
-    #[error("failed to create storage")]
-    FailedToCreateStorage {
-        source: Box<dyn std::error::Error + Send + Sync>,
-    },
 }
@@ -1,7 +1,6 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::client::base_client::non_wasm_helpers;
 use crate::client::replies::reply_storage::backend::fs_backend::manager::StorageManager;
 use crate::client::replies::reply_storage::backend::fs_backend::models::{
    ReplySurbStorageMetadata, StoredReplyKey, StoredReplySurb, StoredSenderTag, StoredSurbSender,
@@ -12,7 +11,7 @@ use crate::client::replies::reply_storage::{
 };
 use async_trait::async_trait;
 use log::{error, info, warn};
-use nym_sphinx::anonymous_replies::requests::AnonymousSenderTag;
+use nymsphinx::anonymous_replies::requests::AnonymousSenderTag;
 use std::fs;
 use std::path::{Path, PathBuf};
 use time::OffsetDateTime;
@@ -155,21 +154,18 @@ impl Backend {
        // (assuming no key rotation has happened)
        // but the way it's currently coded, everyone will purge old data
        let since_last_flush = OffsetDateTime::now_utc() - last_flush;
-        let days = since_last_flush.whole_days();
-        let hours = since_last_flush.whole_hours() % 24;
-
-        if days > 0 {
-            info!("it's been over {days} days and {hours} hours since we last used our data store. our reply surbs are already outdated - we're going to purge them now.");
+        if since_last_flush.whole_days() > 0 {
+            info!("it's been over {} days and {} hours since we last used our data store. our reply surbs are already outdated - we're going to purge them now.", since_last_flush.whole_days(), since_last_flush.whole_hours());
            manager.delete_all_reply_surb_data().await?;
        }

-        if days > 1 {
-            info!("it's been over {days} days and {hours} hours since we last used our data store. our reply keys are already outdated - we're going to purge them now.");
+        if since_last_flush.whole_days() > 1 {
+            info!("it's been over {} days and {} hours since we last used our data store. our reply keys are already outdated - we're going to purge them now.", since_last_flush.whole_days(), since_last_flush.whole_hours());
            manager.delete_all_reply_keys().await?;
        }

-        if days > 2 {
-            info!("it's been over {days} days and {hours} hours since we last used our data store. our used sender tags are already outdated - we're going to purge them now.");
+        if since_last_flush.whole_days() > 2 {
+            info!("it's been over {} days and {} hours since we last used our data store. our used sender tags are already outdated - we're going to purge them now.", since_last_flush.whole_days(), since_last_flush.whole_hours());
            manager.delete_all_tags().await?;
        }

@@ -371,20 +367,6 @@ impl Backend {
 impl ReplyStorageBackend for Backend {
    type StorageError = error::StorageError;

-    async fn new(
-        debug_config: &crate::config::DebugConfig,
-        db_path: Option<PathBuf>,
-    ) -> Result<Self, Self::StorageError> {
-        non_wasm_helpers::setup_fs_reply_surb_backend(db_path, debug_config)
-            .await
-            .map_err(|err| {
-                log::error!("Failed to create storage: {err}");
-                Self::StorageError::FailedToCreateStorage {
-                    source: Box::new(err),
-                }
-            })
-    }
-
    fn is_active(&self) -> bool {
        self.manager.is_active()
    }
@@ -3,13 +3,13 @@

 use crate::client::replies::reply_storage::backend::fs_backend::error::StorageError;
 use crate::client::replies::reply_storage::key_storage::UsedReplyKey;
-use nym_crypto::generic_array::typenum::Unsigned;
-use nym_crypto::Digest;
-use nym_sphinx::addressing::clients::{Recipient, RecipientBytes};
-use nym_sphinx::anonymous_replies::encryption_key::EncryptionKeyDigest;
-use nym_sphinx::anonymous_replies::requests::{AnonymousSenderTag, SENDER_TAG_SIZE};
-use nym_sphinx::anonymous_replies::{ReplySurb, SurbEncryptionKey, SurbEncryptionKeySize};
-use nym_sphinx::params::ReplySurbKeyDigestAlgorithm;
+use crypto::generic_array::typenum::Unsigned;
+use crypto::Digest;
+use nymsphinx::addressing::clients::{Recipient, RecipientBytes};
+use nymsphinx::anonymous_replies::encryption_key::EncryptionKeyDigest;
+use nymsphinx::anonymous_replies::requests::{AnonymousSenderTag, SENDER_TAG_SIZE};
+use nymsphinx::anonymous_replies::{ReplySurb, SurbEncryptionKey, SurbEncryptionKeySize};
+use nymsphinx::params::ReplySurbKeyDigestAlgorithm;

 #[derive(Debug, Clone)]
 pub(crate) struct StoredSenderTag {
@@ -3,7 +3,7 @@

 use crate::client::replies::reply_storage::CombinedReplyStorage;
 use async_trait::async_trait;
-use std::{error::Error, path::PathBuf};
+use std::error::Error;
 use thiserror::Error;

 #[cfg(target_arch = "wasm32")]
@@ -30,20 +30,6 @@ pub struct Empty {
 impl ReplyStorageBackend for Empty {
    type StorageError = UndefinedError;

-    async fn new(
-        debug_config: &crate::config::DebugConfig,
-        _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,
-        })
-    }
-
    async fn flush_surb_storage(
        &mut self,
        _storage: &CombinedReplyStorage,
@@ -77,11 +63,6 @@ impl ReplyStorageBackend for Empty {
 pub trait ReplyStorageBackend: Sized {
    type StorageError: Error + 'static;

-    async fn new(
-        debug_config: &crate::config::DebugConfig,
-        db_path: Option<PathBuf>,
-    ) -> Result<Self, Self::StorageError>;
-
    fn is_active(&self) -> bool {
        true
    }
@@ -3,8 +3,8 @@

 use dashmap::iter::Iter;
 use dashmap::DashMap;
-use nym_sphinx::anonymous_replies::encryption_key::EncryptionKeyDigest;
-use nym_sphinx::anonymous_replies::SurbEncryptionKey;
+use nymsphinx::anonymous_replies::encryption_key::EncryptionKeyDigest;
+use nymsphinx::anonymous_replies::SurbEncryptionKey;
 use std::ops::Deref;
 use std::sync::Arc;
 use time::OffsetDateTime;
@@ -37,7 +37,7 @@ where
    pub async fn flush_on_shutdown(
        mut self,
        mem_state: CombinedReplyStorage,
-        mut shutdown: nym_task::TaskClient,
+        mut shutdown: task::TaskClient,
    ) {
        use log::{debug, error, info, warn};

@@ -4,8 +4,8 @@
 use dashmap::iter::Iter;
 use dashmap::DashMap;
 use log::trace;
-use nym_sphinx::anonymous_replies::requests::AnonymousSenderTag;
-use nym_sphinx::anonymous_replies::ReplySurb;
+use nymsphinx::anonymous_replies::requests::AnonymousSenderTag;
+use nymsphinx::anonymous_replies::ReplySurb;
 use std::collections::VecDeque;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::Arc;
@@ -2,8 +2,8 @@
 // SPDX-License-Identifier: Apache-2.0

 use dashmap::DashMap;
-use nym_sphinx::addressing::clients::{Recipient, RecipientBytes};
-use nym_sphinx::anonymous_replies::requests::AnonymousSenderTag;
+use nymsphinx::addressing::clients::{Recipient, RecipientBytes};
+use nymsphinx::anonymous_replies::requests::AnonymousSenderTag;
 use std::sync::Arc;

 #[cfg(all(not(target_arch = "wasm32"), feature = "fs-surb-storage"))]
@@ -0,0 +1,336 @@
+// Copyright 2021-2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::spawn_future;
+use futures::StreamExt;
+use log::*;
+use nymsphinx::addressing::clients::Recipient;
+use nymsphinx::params::DEFAULT_NUM_MIX_HOPS;
+use rand::seq::SliceRandom;
+use rand::thread_rng;
+use std::ops::Deref;
+use std::sync::Arc;
+use std::time::Duration;
+use tokio::sync::{RwLock, RwLockReadGuard};
+use topology::{nym_topology_from_detailed, NymTopology, NymTopologyError};
+use url::Url;
+
+// I'm extremely curious why compiler NEVER complained about lack of Debug here before
+#[derive(Debug)]
+pub struct TopologyAccessorInner(Option<NymTopology>);
+
+impl AsRef<Option<NymTopology>> for TopologyAccessorInner {
+    fn as_ref(&self) -> &Option<NymTopology> {
+        &self.0
+    }
+}
+
+impl TopologyAccessorInner {
+    fn new() -> Self {
+        TopologyAccessorInner(None)
+    }
+
+    fn update(&mut self, new: Option<NymTopology>) {
+        self.0 = new;
+    }
+}
+
+pub struct TopologyReadPermit<'a> {
+    permit: RwLockReadGuard<'a, TopologyAccessorInner>,
+}
+
+impl<'a> Deref for TopologyReadPermit<'a> {
+    type Target = TopologyAccessorInner;
+
+    fn deref(&self) -> &Self::Target {
+        &self.permit
+    }
+}
+
+impl<'a> TopologyReadPermit<'a> {
+    /// Using provided topology read permit, tries to get an immutable reference to the underlying
+    /// topology. For obvious reasons the lifetime of the topology reference is bound to the permit.
+    pub(super) fn try_get_valid_topology_ref(
+        &'a self,
+        ack_recipient: &Recipient,
+        packet_recipient: Option<&Recipient>,
+    ) -> Result<&'a NymTopology, NymTopologyError> {
+        // 1. Have we managed to get anything from the refresher, i.e. have the nym-api queries gone through?
+        let topology = self
+            .permit
+            .as_ref()
+            .as_ref()
+            .ok_or(NymTopologyError::EmptyNetworkTopology)?;
+
+        // 2. does it have any mixnode at all?
+        // 3. does it have any gateways at all?
+        // 4. does it have a mixnode on each layer?
+        topology.ensure_can_construct_path_through(DEFAULT_NUM_MIX_HOPS)?;
+
+        // 5. does it contain OUR gateway (so that we could create an ack packet)?
+        if !topology.gateway_exists(ack_recipient.gateway()) {
+            return Err(NymTopologyError::NonExistentGatewayError {
+                identity_key: ack_recipient.gateway().to_base58_string(),
+            });
+        }
+
+        // 6. for our target recipient, does it contain THEIR gateway (so that we could create
+        if let Some(recipient) = packet_recipient {
+            if !topology.gateway_exists(recipient.gateway()) {
+                return Err(NymTopologyError::NonExistentGatewayError {
+                    identity_key: recipient.gateway().to_base58_string(),
+                });
+            }
+        }
+
+        Ok(topology)
+    }
+}
+
+impl<'a> From<RwLockReadGuard<'a, TopologyAccessorInner>> for TopologyReadPermit<'a> {
+    fn from(read_permit: RwLockReadGuard<'a, TopologyAccessorInner>) -> Self {
+        TopologyReadPermit {
+            permit: read_permit,
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct TopologyAccessor {
+    // `RwLock` *seems to* be the better approach for this as write access is only requested every
+    // few seconds, while reads are needed every single packet generated.
+    // However, proper benchmarks will be needed to determine if `RwLock` is indeed a better
+    // approach than a `Mutex`
+    inner: Arc<RwLock<TopologyAccessorInner>>,
+}
+
+impl TopologyAccessor {
+    pub fn new() -> Self {
+        TopologyAccessor {
+            inner: Arc::new(RwLock::new(TopologyAccessorInner::new())),
+        }
+    }
+
+    pub async fn get_read_permit(&self) -> TopologyReadPermit<'_> {
+        self.inner.read().await.into()
+    }
+
+    async fn update_global_topology(&self, new_topology: Option<NymTopology>) {
+        self.inner.write().await.update(new_topology);
+    }
+
+    // only used by the client at startup to get a slightly more reasonable error message
+    // (currently displays as unused because health checker is disabled due to required changes)
+    pub async fn ensure_is_routable(&self) -> Result<(), NymTopologyError> {
+        match &self.inner.read().await.0 {
+            None => Err(NymTopologyError::EmptyNetworkTopology),
+            Some(ref topology) => topology.ensure_can_construct_path_through(DEFAULT_NUM_MIX_HOPS),
+        }
+    }
+}
+
+impl Default for TopologyAccessor {
+    fn default() -> Self {
+        TopologyAccessor::new()
+    }
+}
+
+pub struct TopologyRefresherConfig {
+    nym_api_urls: Vec<Url>,
+    refresh_rate: Duration,
+    client_version: String,
+}
+
+impl TopologyRefresherConfig {
+    pub fn new(nym_api_urls: Vec<Url>, refresh_rate: Duration, client_version: String) -> Self {
+        TopologyRefresherConfig {
+            nym_api_urls,
+            refresh_rate,
+            client_version,
+        }
+    }
+}
+
+pub struct TopologyRefresher {
+    validator_client: validator_client::client::NymApiClient,
+    client_version: String,
+
+    nym_api_urls: Vec<Url>,
+    topology_accessor: TopologyAccessor,
+    refresh_rate: Duration,
+
+    currently_used_api: usize,
+    was_latest_valid: bool,
+}
+
+impl TopologyRefresher {
+    pub fn new(mut cfg: TopologyRefresherConfig, topology_accessor: TopologyAccessor) -> Self {
+        cfg.nym_api_urls.shuffle(&mut thread_rng());
+
+        TopologyRefresher {
+            validator_client: validator_client::client::NymApiClient::new(
+                cfg.nym_api_urls[0].clone(),
+            ),
+            client_version: cfg.client_version,
+            nym_api_urls: cfg.nym_api_urls,
+            topology_accessor,
+            refresh_rate: cfg.refresh_rate,
+            currently_used_api: 0,
+            was_latest_valid: true,
+        }
+    }
+
+    fn use_next_nym_api(&mut self) {
+        if self.nym_api_urls.len() == 1 {
+            warn!("There's only a single nym API available - it won't be possible to use a different one");
+            return;
+        }
+
+        self.currently_used_api = (self.currently_used_api + 1) % self.nym_api_urls.len();
+        self.validator_client
+            .change_nym_api(self.nym_api_urls[self.currently_used_api].clone())
+    }
+
+    /// Verifies whether nodes a reasonably distributed among all mix layers.
+    ///
+    /// In ideal world we would have 33% nodes on layer 1, 33% on layer 2 and 33% on layer 3.
+    /// However, this is a rather unrealistic expectation, instead we check whether there exists
+    /// a layer with more than 66% of nodes or with fewer than 15% and if so, we trigger a failure.
+    ///
+    /// # Arguments
+    ///
+    /// * `topology`: active topology constructed from validator api data
+    fn check_layer_distribution(&self, active_topology: &NymTopology) -> bool {
+        let mixes = active_topology.mixes();
+        let mixnodes_count = active_topology.num_mixnodes();
+
+        if active_topology.gateways().is_empty() {
+            return false;
+        }
+
+        // trivial check to see if have at least a single node on each layer (regardless of active set size)
+        if mixes.get(&1).is_none() || mixes.get(&2).is_none() || mixes.get(&3).is_none() {
+            return false;
+        }
+
+        let upper_bound = (mixnodes_count as f32 * 0.66) as usize;
+        let lower_bound = (mixnodes_count as f32 * 0.15) as usize;
+
+        let layer1 = mixes.get(&1).unwrap().len();
+        let layer2 = mixes.get(&2).unwrap().len();
+        let layer3 = mixes.get(&3).unwrap().len();
+
+        if layer1 < lower_bound || layer1 > upper_bound {
+            warn!(
+                "nodes: {}, layer1: {}, layer2: {}, layer3: {}",
+                mixnodes_count, layer1, layer2, layer3
+            );
+            return false;
+        }
+
+        if layer2 < lower_bound || layer2 > upper_bound {
+            warn!(
+                "nodes: {}, layer1: {}, layer2: {}, layer3: {}",
+                mixnodes_count, layer1, layer2, layer3
+            );
+            return false;
+        }
+
+        if layer3 < lower_bound || layer3 > upper_bound {
+            warn!(
+                "nodes: {}, layer1: {}, layer2: {}, layer3: {}",
+                mixnodes_count, layer1, layer2, layer3
+            );
+            return false;
+        }
+
+        true
+    }
+
+    async fn get_current_compatible_topology(&self) -> Option<NymTopology> {
+        // TODO: optimization for the future:
+        // only refresh mixnodes on timer and refresh gateways only when
+        // we have to send to a new, unknown, gateway
+
+        let mixnodes = match self.validator_client.get_cached_active_mixnodes().await {
+            Err(err) => {
+                error!("failed to get network mixnodes - {err}");
+                return None;
+            }
+            Ok(mixes) => mixes,
+        };
+
+        let gateways = match self.validator_client.get_cached_gateways().await {
+            Err(err) => {
+                error!("failed to get network gateways - {err}");
+                return None;
+            }
+            Ok(gateways) => gateways,
+        };
+
+        let topology = nym_topology_from_detailed(mixnodes, gateways)
+            .filter_system_version(&self.client_version);
+
+        if !self.check_layer_distribution(&topology) {
+            warn!("The current filtered active topology has extremely skewed layer distribution. It cannot be used.");
+            None
+        } else {
+            Some(topology)
+        }
+    }
+
+    pub async fn refresh(&mut self) {
+        trace!("Refreshing the topology");
+        let new_topology = self.get_current_compatible_topology().await;
+
+        if new_topology.is_none() {
+            self.use_next_nym_api();
+        }
+
+        if new_topology.is_none() && self.was_latest_valid {
+            // if we failed to grab this topology, but the one before it was alright, let's assume
+            // validator had a tiny hiccup and use the old data
+            warn!("we're going to keep on using the old topology for this iteration");
+            self.was_latest_valid = false;
+            return;
+        } else if new_topology.is_some() {
+            self.was_latest_valid = true;
+        }
+
+        self.topology_accessor
+            .update_global_topology(new_topology)
+            .await;
+    }
+
+    pub async fn ensure_topology_is_routable(&self) -> Result<(), NymTopologyError> {
+        self.topology_accessor.ensure_is_routable().await
+    }
+
+    pub fn start_with_shutdown(mut self, mut shutdown: task::TaskClient) {
+        spawn_future(async move {
+            debug!("Started TopologyRefresher with graceful shutdown support");
+
+            #[cfg(not(target_arch = "wasm32"))]
+            let mut interval = tokio_stream::wrappers::IntervalStream::new(tokio::time::interval(
+                self.refresh_rate,
+            ));
+
+            #[cfg(target_arch = "wasm32")]
+            let mut interval =
+                gloo_timers::future::IntervalStream::new(self.refresh_rate.as_millis() as u32);
+
+            while !shutdown.is_shutdown() {
+                tokio::select! {
+                    _ = interval.next() => {
+                        self.refresh().await;
+                    },
+                    _ = shutdown.recv() => {
+                        log::trace!("TopologyRefresher: Received shutdown");
+                    },
+                }
+            }
+            shutdown.recv_timeout().await;
+            log::debug!("TopologyRefresher: Exiting");
+        })
+    }
+}
@@ -1,154 +0,0 @@
-// Copyright 2021-2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use nym_sphinx::addressing::clients::Recipient;
-use nym_sphinx::params::DEFAULT_NUM_MIX_HOPS;
-use nym_topology::{NymTopology, NymTopologyError};
-use std::ops::Deref;
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::Arc;
-use tokio::sync::{Notify, RwLock, RwLockReadGuard};
-
-#[derive(Debug)]
-pub struct TopologyAccessorInner {
-    controlled_manually: AtomicBool,
-    released_manual_control: Notify,
-    // `RwLock` *seems to* be the better approach for this as write access is only requested every
-    // few seconds, while reads are needed every single packet generated.
-    // However, proper benchmarks will be needed to determine if `RwLock` is indeed a better
-    // approach than a `Mutex`
-    topology: RwLock<Option<NymTopology>>,
-}
-
-impl TopologyAccessorInner {
-    fn new() -> Self {
-        TopologyAccessorInner {
-            controlled_manually: AtomicBool::new(false),
-            released_manual_control: Notify::new(),
-            topology: RwLock::new(None),
-        }
-    }
-
-    async fn update(&self, new: Option<NymTopology>) {
-        *self.topology.write().await = new;
-    }
-}
-
-pub struct TopologyReadPermit<'a> {
-    permit: RwLockReadGuard<'a, Option<NymTopology>>,
-}
-
-impl<'a> Deref for TopologyReadPermit<'a> {
-    type Target = Option<NymTopology>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.permit
-    }
-}
-
-impl<'a> TopologyReadPermit<'a> {
-    /// Using provided topology read permit, tries to get an immutable reference to the underlying
-    /// topology. For obvious reasons the lifetime of the topology reference is bound to the permit.
-    pub(crate) fn try_get_valid_topology_ref(
-        &'a self,
-        ack_recipient: &Recipient,
-        packet_recipient: Option<&Recipient>,
-    ) -> Result<&'a NymTopology, NymTopologyError> {
-        // 1. Have we managed to get anything from the refresher, i.e. have the nym-api queries gone through?
-        let topology = self
-            .permit
-            .as_ref()
-            .ok_or(NymTopologyError::EmptyNetworkTopology)?;
-
-        // 2. does it have any mixnode at all?
-        // 3. does it have any gateways at all?
-        // 4. does it have a mixnode on each layer?
-        topology.ensure_can_construct_path_through(DEFAULT_NUM_MIX_HOPS)?;
-
-        // 5. does it contain OUR gateway (so that we could create an ack packet)?
-        if !topology.gateway_exists(ack_recipient.gateway()) {
-            return Err(NymTopologyError::NonExistentGatewayError {
-                identity_key: ack_recipient.gateway().to_base58_string(),
-            });
-        }
-
-        // 6. for our target recipient, does it contain THEIR gateway (so that we could create
-        if let Some(recipient) = packet_recipient {
-            if !topology.gateway_exists(recipient.gateway()) {
-                return Err(NymTopologyError::NonExistentGatewayError {
-                    identity_key: recipient.gateway().to_base58_string(),
-                });
-            }
-        }
-
-        Ok(topology)
-    }
-}
-
-impl<'a> From<RwLockReadGuard<'a, Option<NymTopology>>> for TopologyReadPermit<'a> {
-    fn from(read_permit: RwLockReadGuard<'a, Option<NymTopology>>) -> Self {
-        TopologyReadPermit {
-            permit: read_permit,
-        }
-    }
-}
-
-#[derive(Clone, Debug)]
-pub struct TopologyAccessor {
-    inner: Arc<TopologyAccessorInner>,
-}
-
-impl TopologyAccessor {
-    pub fn new() -> Self {
-        TopologyAccessor {
-            inner: Arc::new(TopologyAccessorInner::new()),
-        }
-    }
-
-    pub fn controlled_manually(&self) -> bool {
-        self.inner.controlled_manually.load(Ordering::SeqCst)
-    }
-
-    pub async fn get_read_permit(&self) -> TopologyReadPermit<'_> {
-        self.inner.topology.read().await.into()
-    }
-
-    pub(crate) async fn update_global_topology(&self, new_topology: Option<NymTopology>) {
-        self.inner.update(new_topology).await;
-    }
-
-    pub(crate) async fn wait_for_released_manual_control(&self) {
-        self.inner.released_manual_control.notified().await
-    }
-
-    pub async fn current_topology(&self) -> Option<NymTopology> {
-        self.inner.topology.read().await.clone()
-    }
-
-    pub async fn manually_change_topology(&self, new_topology: NymTopology) {
-        self.inner.controlled_manually.store(true, Ordering::SeqCst);
-        self.inner.update(Some(new_topology)).await;
-    }
-
-    pub fn release_manual_control(&self) {
-        self.inner
-            .controlled_manually
-            .store(false, Ordering::SeqCst);
-        self.inner.released_manual_control.notify_waiters();
-    }
-
-    // only used by the client at startup to get a slightly more reasonable error message
-    // (currently displays as unused because health checker is disabled due to required changes)
-    pub async fn ensure_is_routable(&self) -> Result<(), NymTopologyError> {
-        match self.inner.topology.read().await.deref() {
-            None => Err(NymTopologyError::EmptyNetworkTopology),
-            Some(ref topology) => topology.ensure_can_construct_path_through(DEFAULT_NUM_MIX_HOPS),
-        }
-    }
-}
-
-impl Default for TopologyAccessor {
-    fn default() -> Self {
-        TopologyAccessor::new()
-    }
-}
@@ -1,115 +0,0 @@
-// Copyright 2021-2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::spawn_future;
-pub(crate) use accessor::{TopologyAccessor, TopologyReadPermit};
-use futures::StreamExt;
-use log::*;
-use nym_topology::provider_trait::TopologyProvider;
-use nym_topology::NymTopologyError;
-use std::time::Duration;
-
-mod accessor;
-pub(crate) mod nym_api_provider;
-
-// TODO: move it to config later
-const MAX_FAILURE_COUNT: usize = 10;
-
-pub struct TopologyRefresherConfig {
-    refresh_rate: Duration,
-}
-
-impl TopologyRefresherConfig {
-    pub fn new(refresh_rate: Duration) -> Self {
-        TopologyRefresherConfig { refresh_rate }
-    }
-}
-
-pub struct TopologyRefresher {
-    topology_provider: Box<dyn TopologyProvider>,
-    topology_accessor: TopologyAccessor,
-
-    refresh_rate: Duration,
-    consecutive_failure_count: usize,
-}
-
-impl TopologyRefresher {
-    pub fn new(
-        cfg: TopologyRefresherConfig,
-        topology_accessor: TopologyAccessor,
-        topology_provider: Box<dyn TopologyProvider>,
-    ) -> Self {
-        TopologyRefresher {
-            topology_provider,
-            topology_accessor,
-            refresh_rate: cfg.refresh_rate,
-            consecutive_failure_count: 0,
-        }
-    }
-
-    pub fn change_topology_provider(&mut self, provider: Box<dyn TopologyProvider>) {
-        self.topology_provider = provider;
-    }
-
-    pub async fn try_refresh(&mut self) {
-        trace!("Refreshing the topology");
-
-        if self.topology_accessor.controlled_manually() {
-            info!("topology is being controlled manually - we're going to wait until the control is released...");
-            self.topology_accessor
-                .wait_for_released_manual_control()
-                .await;
-        }
-
-        let new_topology = self.topology_provider.get_new_topology().await;
-        if new_topology.is_none() {
-            warn!("failed to obtain new network topology");
-        }
-
-        if new_topology.is_none() && self.consecutive_failure_count < MAX_FAILURE_COUNT {
-            // if we failed to grab this topology, but the one before it was alright, let's assume
-            // validator had a tiny hiccup and use the old data
-            warn!("we're going to keep on using the old topology for this iteration");
-            self.consecutive_failure_count += 1;
-            return;
-        } else if new_topology.is_some() {
-            self.consecutive_failure_count = 0;
-        }
-
-        self.topology_accessor
-            .update_global_topology(new_topology)
-            .await;
-    }
-
-    pub async fn ensure_topology_is_routable(&self) -> Result<(), NymTopologyError> {
-        self.topology_accessor.ensure_is_routable().await
-    }
-
-    pub fn start_with_shutdown(mut self, mut shutdown: nym_task::TaskClient) {
-        spawn_future(async move {
-            debug!("Started TopologyRefresher with graceful shutdown support");
-
-            #[cfg(not(target_arch = "wasm32"))]
-            let mut interval = tokio_stream::wrappers::IntervalStream::new(tokio::time::interval(
-                self.refresh_rate,
-            ));
-
-            #[cfg(target_arch = "wasm32")]
-            let mut interval =
-                gloo_timers::future::IntervalStream::new(self.refresh_rate.as_millis() as u32);
-
-            while !shutdown.is_shutdown() {
-                tokio::select! {
-                    _ = interval.next() => {
-                        self.try_refresh().await;
-                    },
-                    _ = shutdown.recv() => {
-                        log::trace!("TopologyRefresher: Received shutdown");
-                    },
-                }
-            }
-            shutdown.recv_timeout().await;
-            log::debug!("TopologyRefresher: Exiting");
-        })
-    }
-}
@@ -1,106 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use async_trait::async_trait;
-use log::{error, warn};
-use nym_topology::provider_trait::TopologyProvider;
-use nym_topology::{nym_topology_from_detailed, NymTopology, NymTopologyError};
-use rand::prelude::SliceRandom;
-use rand::thread_rng;
-use url::Url;
-
-pub(crate) struct NymApiTopologyProvider {
-    validator_client: validator_client::client::NymApiClient,
-    nym_api_urls: Vec<Url>,
-
-    client_version: String,
-    currently_used_api: usize,
-}
-
-impl NymApiTopologyProvider {
-    pub(crate) fn new(mut nym_api_urls: Vec<Url>, client_version: String) -> Self {
-        nym_api_urls.shuffle(&mut thread_rng());
-
-        NymApiTopologyProvider {
-            validator_client: validator_client::client::NymApiClient::new(nym_api_urls[0].clone()),
-            nym_api_urls,
-            client_version,
-            currently_used_api: 0,
-        }
-    }
-
-    fn use_next_nym_api(&mut self) {
-        if self.nym_api_urls.len() == 1 {
-            warn!("There's only a single nym API available - it won't be possible to use a different one");
-            return;
-        }
-
-        self.currently_used_api = (self.currently_used_api + 1) % self.nym_api_urls.len();
-        self.validator_client
-            .change_nym_api(self.nym_api_urls[self.currently_used_api].clone())
-    }
-
-    /// Verifies whether nodes a reasonably distributed among all mix layers.
-    ///
-    /// In ideal world we would have 33% nodes on layer 1, 33% on layer 2 and 33% on layer 3.
-    /// However, this is a rather unrealistic expectation, instead we check whether there exists
-    /// a layer with more than 66% of nodes or with fewer than 15% and if so, we trigger a failure.
-    ///
-    /// # Arguments
-    ///
-    /// * `topology`: active topology constructed from validator api data
-    fn check_layer_distribution(
-        &self,
-        active_topology: &NymTopology,
-    ) -> Result<(), NymTopologyError> {
-        let lower_threshold = 0.15;
-        let upper_threshold = 0.66;
-        active_topology.ensure_even_layer_distribution(lower_threshold, upper_threshold)
-    }
-
-    async fn get_current_compatible_topology(&mut self) -> Option<NymTopology> {
-        let mixnodes = match self.validator_client.get_cached_active_mixnodes().await {
-            Err(err) => {
-                error!("failed to get network mixnodes - {err}");
-                return None;
-            }
-            Ok(mixes) => mixes,
-        };
-
-        let gateways = match self.validator_client.get_cached_gateways().await {
-            Err(err) => {
-                error!("failed to get network gateways - {err}");
-                return None;
-            }
-            Ok(gateways) => gateways,
-        };
-
-        let topology = nym_topology_from_detailed(mixnodes, gateways)
-            .filter_system_version(&self.client_version);
-
-        if let Err(err) = self.check_layer_distribution(&topology) {
-            warn!("The current filtered active topology has extremely skewed layer distribution. It cannot be used: {err}");
-            self.use_next_nym_api();
-            None
-        } else {
-            Some(topology)
-        }
-    }
-}
-
-// hehe, wasm
-#[cfg(not(target_arch = "wasm32"))]
-#[async_trait]
-impl TopologyProvider for NymApiTopologyProvider {
-    async fn get_new_topology(&mut self) -> Option<NymTopology> {
-        self.get_current_compatible_topology().await
-    }
-}
-
-#[cfg(target_arch = "wasm32")]
-#[async_trait(?Send)]
-impl TopologyProvider for NymApiTopologyProvider {
-    async fn get_new_topology(&mut self) -> Option<NymTopology> {
-        self.get_current_compatible_topology().await
-    }
-}
@@ -3,8 +3,8 @@

 use crate::client::helpers::{get_time_now, Instant};
 use crate::client::real_messages_control::real_traffic_stream::RealMessage;
-use nym_sphinx::chunking::fragment::Fragment;
-use nym_task::connections::TransmissionLane;
+use client_connections::TransmissionLane;
+use nymsphinx::chunking::fragment::Fragment;
 use rand::{seq::SliceRandom, Rng};
 use std::{
    collections::{HashMap, HashSet, VecDeque},
@@ -1,9 +1,9 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use nym_config::defaults::NymNetworkDetails;
-use nym_config::{NymConfig, OptionalSet, CRED_DB_FILE_NAME};
-use nym_sphinx::params::PacketSize;
+use config::defaults::NymNetworkDetails;
+use config::{NymConfig, OptionalSet, DB_FILE_NAME};
+use nymsphinx::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";
@@ -211,12 +210,11 @@ impl<T> Config<T> {
    }

    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 {
@@ -227,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) {
@@ -313,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.traffic.use_extended_packet_size
+        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
+        self.debug.maximum_reply_key_age
    }
 }

@@ -443,8 +435,8 @@ impl GatewayEndpointConfig {
    }
 }

-impl From<nym_topology::gateway::Node> for GatewayEndpointConfig {
-    fn from(node: nym_topology::gateway::Node) -> GatewayEndpointConfig {
+impl From<topology::gateway::Node> for GatewayEndpointConfig {
+    fn from(node: topology::gateway::Node) -> GatewayEndpointConfig {
        let gateway_listener = node.clients_address();
        GatewayEndpointConfig {
            gateway_id: node.identity_key.to_base58_string(),
@@ -458,63 +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>,
+    super_struct: PhantomData<T>,
 }

 impl<T: NymConfig> Default for Client<T> {
@@ -587,7 +579,7 @@ impl<T: NymConfig> Client<T> {
    }

    fn default_database_path(id: &str) -> PathBuf {
-        T::default_data_directory(id).join(CRED_DB_FILE_NAME)
+        T::default_data_directory(id).join(DB_FILE_NAME)
    }
 }

@@ -595,9 +587,9 @@ impl<T: NymConfig> Client<T> {
 #[serde(deny_unknown_fields)]
 pub struct Logging {}

-#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
+#[derive(Debug, Clone, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct Traffic {
+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
@@ -605,74 +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,
-
-    /// Controls whether the sent sphinx packet use a NON-DEFAULT bigger size.
-    pub use_extended_packet_size: Option<ExtendedPacketSize>,
-}
-
-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,
-            use_extended_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,
-
-    /// 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,
-            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
@@ -690,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")]
@@ -715,20 +642,18 @@ pub struct Topology {
    /// did not reach its destination.
    #[serde(with = "humantime_serde")]
    pub topology_resolution_timeout: Duration,
-}

-impl Default for Topology {
-    fn default() -> Self {
-        Topology {
-            topology_refresh_rate: DEFAULT_TOPOLOGY_REFRESH_RATE,
-            topology_resolution_timeout: DEFAULT_TOPOLOGY_RESOLUTION_TIMEOUT,
-        }
-    }
-}
+    /// Controls whether the dedicated loop cover traffic stream should be enabled.
+    /// (and sending packets, on average, every [Self::loop_cover_traffic_average_delay])
+    pub disable_loop_cover_traffic_stream: bool,
+
+    /// Controls whether the main packet stream constantly produces packets according to the predefined
+    /// poisson distribution.
+    pub disable_main_poisson_packet_distribution: bool,
+
+    /// Controls whether the sent sphinx packet use a NON-DEFAULT bigger size.
+    pub use_extended_packet_size: Option<ExtendedPacketSize>,

-#[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,
@@ -766,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,
@@ -783,52 +728,6 @@ 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,
-}
-
-#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq, Eq)]
-#[serde(rename_all = "lowercase")]
-pub enum ExtendedPacketSize {
-    Extended8,
-    Extended16,
-    Extended32,
-}
-
-// 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 {
@@ -1,198 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::config::{
-    Acknowledgements, Client, Config, CoverTraffic, DebugConfig, ExtendedPacketSize,
-    GatewayConnection, Logging, ReplySurbs, Topology, Traffic, DEFAULT_ACK_WAIT_ADDITION,
-    DEFAULT_ACK_WAIT_MULTIPLIER, DEFAULT_AVERAGE_PACKET_DELAY, DEFAULT_GATEWAY_RESPONSE_TIMEOUT,
-    DEFAULT_LOOP_COVER_STREAM_AVERAGE_DELAY, DEFAULT_MAXIMUM_ALLOWED_SURB_REQUEST_SIZE,
-    DEFAULT_MAXIMUM_REPLY_KEY_AGE, DEFAULT_MAXIMUM_REPLY_SURB_AGE,
-    DEFAULT_MAXIMUM_REPLY_SURB_DROP_WAITING_PERIOD, DEFAULT_MAXIMUM_REPLY_SURB_REQUEST_SIZE,
-    DEFAULT_MAXIMUM_REPLY_SURB_REREQUEST_WAITING_PERIOD,
-    DEFAULT_MAXIMUM_REPLY_SURB_STORAGE_THRESHOLD, DEFAULT_MESSAGE_STREAM_AVERAGE_DELAY,
-    DEFAULT_MINIMUM_REPLY_SURB_REQUEST_SIZE, DEFAULT_MINIMUM_REPLY_SURB_STORAGE_THRESHOLD,
-    DEFAULT_TOPOLOGY_REFRESH_RATE, DEFAULT_TOPOLOGY_RESOLUTION_TIMEOUT,
-};
-use nym_config::NymConfig;
-use serde::{Deserialize, Serialize};
-use std::marker::PhantomData;
-use std::time::Duration;
-
-#[derive(Debug, Clone, Deserialize, PartialEq, Serialize)]
-#[serde(deny_unknown_fields)]
-pub struct OldConfigV1_1_13<T> {
-    pub client: Client<T>,
-
-    #[serde(default)]
-    logging: Logging,
-    #[serde(default)]
-    debug: OldDebugConfigV1_1_13,
-}
-
-impl<T: NymConfig> Default for OldConfigV1_1_13<T> {
-    fn default() -> Self {
-        OldConfigV1_1_13 {
-            client: Client::<T>::default(),
-            logging: Default::default(),
-            debug: Default::default(),
-        }
-    }
-}
-
-#[derive(Debug, Clone, Deserialize, PartialEq, Serialize)]
-#[serde(default, deny_unknown_fields)]
-pub struct OldDebugConfigV1_1_13 {
-    #[serde(with = "humantime_serde")]
-    pub average_packet_delay: Duration,
-
-    #[serde(with = "humantime_serde")]
-    pub average_ack_delay: Duration,
-
-    pub ack_wait_multiplier: f64,
-    #[serde(with = "humantime_serde")]
-    pub ack_wait_addition: Duration,
-
-    #[serde(with = "humantime_serde")]
-    pub loop_cover_traffic_average_delay: Duration,
-
-    #[serde(with = "humantime_serde")]
-    pub message_sending_average_delay: Duration,
-
-    #[serde(with = "humantime_serde")]
-    pub gateway_response_timeout: Duration,
-
-    #[serde(with = "humantime_serde")]
-    pub topology_refresh_rate: Duration,
-
-    #[serde(with = "humantime_serde")]
-    pub topology_resolution_timeout: Duration,
-
-    pub disable_loop_cover_traffic_stream: bool,
-
-    pub disable_main_poisson_packet_distribution: bool,
-
-    pub use_extended_packet_size: Option<ExtendedPacketSize>,
-
-    pub minimum_reply_surb_storage_threshold: usize,
-
-    pub maximum_reply_surb_storage_threshold: usize,
-
-    pub minimum_reply_surb_request_size: u32,
-
-    pub maximum_reply_surb_request_size: u32,
-
-    pub maximum_allowed_reply_surb_request_size: u32,
-
-    #[serde(with = "humantime_serde")]
-    pub maximum_reply_surb_rerequest_waiting_period: Duration,
-
-    #[serde(with = "humantime_serde")]
-    pub maximum_reply_surb_drop_waiting_period: Duration,
-
-    #[serde(with = "humantime_serde")]
-    pub maximum_reply_surb_age: Duration,
-
-    #[serde(with = "humantime_serde")]
-    pub maximum_reply_key_age: Duration,
-}
-
-impl From<OldDebugConfigV1_1_13> for DebugConfig {
-    fn from(value: OldDebugConfigV1_1_13) -> Self {
-        DebugConfig {
-            traffic: Traffic {
-                average_packet_delay: value.average_packet_delay,
-                message_sending_average_delay: value.message_sending_average_delay,
-                disable_main_poisson_packet_distribution: value
-                    .disable_main_poisson_packet_distribution,
-                use_extended_packet_size: value.use_extended_packet_size,
-            },
-            cover_traffic: CoverTraffic {
-                loop_cover_traffic_average_delay: value.loop_cover_traffic_average_delay,
-                disable_loop_cover_traffic_stream: value.disable_loop_cover_traffic_stream,
-            },
-            gateway_connection: GatewayConnection {
-                gateway_response_timeout: value.gateway_response_timeout,
-            },
-            acknowledgements: Acknowledgements {
-                average_ack_delay: value.average_ack_delay,
-                ack_wait_multiplier: value.ack_wait_multiplier,
-                ack_wait_addition: value.ack_wait_addition,
-            },
-            topology: Topology {
-                topology_refresh_rate: value.topology_refresh_rate,
-                topology_resolution_timeout: value.topology_resolution_timeout,
-            },
-            reply_surbs: ReplySurbs {
-                minimum_reply_surb_storage_threshold: value.minimum_reply_surb_storage_threshold,
-                maximum_reply_surb_storage_threshold: value.maximum_reply_surb_storage_threshold,
-                minimum_reply_surb_request_size: value.minimum_reply_surb_request_size,
-                maximum_reply_surb_request_size: value.maximum_reply_surb_request_size,
-                maximum_allowed_reply_surb_request_size: value
-                    .maximum_allowed_reply_surb_request_size,
-                maximum_reply_surb_rerequest_waiting_period: value
-                    .maximum_reply_surb_rerequest_waiting_period,
-                maximum_reply_surb_drop_waiting_period: value
-                    .maximum_reply_surb_drop_waiting_period,
-                maximum_reply_surb_age: value.maximum_reply_surb_age,
-                maximum_reply_key_age: value.maximum_reply_key_age,
-            },
-        }
-    }
-}
-
-impl Default for OldDebugConfigV1_1_13 {
-    fn default() -> Self {
-        OldDebugConfigV1_1_13 {
-            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,
-            maximum_reply_surb_request_size: DEFAULT_MAXIMUM_REPLY_SURB_REQUEST_SIZE,
-            maximum_allowed_reply_surb_request_size: DEFAULT_MAXIMUM_ALLOWED_SURB_REQUEST_SIZE,
-            maximum_reply_surb_rerequest_waiting_period:
-                DEFAULT_MAXIMUM_REPLY_SURB_REREQUEST_WAITING_PERIOD,
-            maximum_reply_surb_drop_waiting_period: DEFAULT_MAXIMUM_REPLY_SURB_DROP_WAITING_PERIOD,
-            maximum_reply_surb_age: DEFAULT_MAXIMUM_REPLY_SURB_AGE,
-            maximum_reply_key_age: DEFAULT_MAXIMUM_REPLY_KEY_AGE,
-        }
-    }
-}
-
-impl<T, U> From<OldConfigV1_1_13<T>> for Config<U> {
-    fn from(value: OldConfigV1_1_13<T>) -> Self {
-        Config {
-            client: Client {
-                version: value.client.version,
-                id: value.client.id,
-                disabled_credentials_mode: value.client.disabled_credentials_mode,
-                nyxd_urls: value.client.nyxd_urls,
-                nym_api_urls: value.client.nym_api_urls,
-                private_identity_key_file: value.client.private_identity_key_file,
-                public_identity_key_file: value.client.public_identity_key_file,
-                private_encryption_key_file: value.client.private_encryption_key_file,
-                public_encryption_key_file: value.client.public_encryption_key_file,
-                gateway_shared_key_file: value.client.gateway_shared_key_file,
-                ack_key_file: value.client.ack_key_file,
-                gateway_endpoint: value.client.gateway_endpoint,
-                database_path: value.client.database_path,
-                reply_surb_database_path: value.client.reply_surb_database_path,
-                nym_root_directory: value.client.nym_root_directory,
-
-                super_struct: PhantomData,
-            },
-            logging: value.logging,
-            debug: value.debug.into(),
-        }
-    }
-}
@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::config::Config;
-use nym_config::NymConfig;
+use config::NymConfig;
 use std::path::{Path, PathBuf};

 #[derive(Debug)]
@@ -1,10 +1,9 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

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

 #[derive(thiserror::Error, Debug)]
@@ -54,32 +53,7 @@ pub enum ClientCoreError {
    GatewayOwnerUnknown,

    #[error("The address of the gateway is unknown - did you run init?")]
-    GatewayAddressUnknown,
-
-    #[error("The gateway is malformed: {source}")]
-    MalformedGateway {
-        #[from]
-        source: GatewayConversionError,
-    },
-
-    #[error("failed to establish connection to gateway: {source}")]
-    GatewayConnectionFailure {
-        #[from]
-        source: tungstenite::Error,
-    },
-
-    #[cfg(target_arch = "wasm32")]
-    #[error("failed to establish gateway connection (wasm)")]
-    GatewayJsConnectionFailure,
-
-    #[error("Gateway connection was abruptly closed")]
-    GatewayConnectionAbruptlyClosed,
-
-    #[error("Timed out while trying to establish gateway connection")]
-    GatewayConnectionTimeout,
-
-    #[error("No ping measurements for the gateway ({identity}) performed")]
-    NoGatewayMeasurements { identity: String },
+    GatwayAddressUnknown,

    #[error("failed to register receiver for reconstructed mixnet messages")]
    FailedToRegisterReceiver,
@@ -6,223 +6,52 @@ use crate::{
    config::{persistence::key_pathfinder::ClientKeyPathfinder, Config},
    error::ClientCoreError,
 };
-use futures::{SinkExt, StreamExt};
+use config::NymConfig;
+use crypto::asymmetric::identity;
+#[cfg(target_arch = "wasm32")]
+use gateway_client::wasm_mockups::SigningNyxdClient;
 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_topology::{filter::VersionFilterable, gateway};
-use rand::{seq::SliceRandom, thread_rng, Rng};
+use rand::{seq::SliceRandom, thread_rng};
 use std::{sync::Arc, time::Duration};
 use tap::TapFallible;
-use tungstenite::Message;
+use topology::{filter::VersionFilterable, gateway};
 use url::Url;
-
-#[cfg(not(target_arch = "wasm32"))]
-use tokio::net::TcpStream;
-#[cfg(not(target_arch = "wasm32"))]
-use tokio::time::Instant;
-#[cfg(not(target_arch = "wasm32"))]
-use tokio_tungstenite::connect_async;
-#[cfg(not(target_arch = "wasm32"))]
-use tokio_tungstenite::{MaybeTlsStream, WebSocketStream};
 #[cfg(not(target_arch = "wasm32"))]
 use validator_client::nyxd::SigningNyxdClient;

-#[cfg(not(target_arch = "wasm32"))]
-type WsConn = WebSocketStream<MaybeTlsStream<TcpStream>>;
-
-#[cfg(target_arch = "wasm32")]
-use gateway_client::wasm_mockups::SigningNyxdClient;
-#[cfg(target_arch = "wasm32")]
-use wasm_timer::Instant;
-#[cfg(target_arch = "wasm32")]
-use wasm_utils::websocket::JSWebsocket;
-
-#[cfg(target_arch = "wasm32")]
-type WsConn = JSWebsocket;
-
-const MEASUREMENTS: usize = 3;
-
-#[cfg(not(target_arch = "wasm32"))]
-const CONN_TIMEOUT: Duration = Duration::from_millis(1500);
-const PING_TIMEOUT: Duration = Duration::from_millis(1000);
-
-struct GatewayWithLatency {
-    gateway: gateway::Node,
-    latency: Duration,
-}
-
-impl GatewayWithLatency {
-    fn new(gateway: gateway::Node, latency: Duration) -> Self {
-        GatewayWithLatency { gateway, latency }
-    }
-}
-
-async fn current_gateways<R: Rng>(
-    rng: &mut R,
-    nym_apis: Vec<Url>,
-) -> Result<Vec<gateway::Node>, ClientCoreError> {
-    let nym_api = nym_apis
-        .choose(rng)
+pub(super) async fn query_gateway_details(
+    validator_servers: Vec<Url>,
+    chosen_gateway_id: Option<identity::PublicKey>,
+) -> Result<gateway::Node, ClientCoreError> {
+    let nym_api = validator_servers
+        .choose(&mut thread_rng())
        .ok_or(ClientCoreError::ListOfNymApisIsEmpty)?;
-    let client = validator_client::client::NymApiClient::new(nym_api.clone());
+    let validator_client = validator_client::client::NymApiClient::new(nym_api.clone());

    log::trace!("Fetching list of gateways from: {}", nym_api);
-
-    let gateways = client.get_cached_gateways().await?;
+    let gateways = validator_client.get_cached_gateways().await?;
    let valid_gateways = gateways
        .into_iter()
        .filter_map(|gateway| gateway.try_into().ok())
        .collect::<Vec<gateway::Node>>();

-    // we were always filtering by version so I'm not removing that 'feature'
    let filtered_gateways = valid_gateways.filter_by_version(env!("CARGO_PKG_VERSION"));
-    Ok(filtered_gateways)
-}

-#[cfg(not(target_arch = "wasm32"))]
-async fn connect(endpoint: &str) -> Result<WsConn, ClientCoreError> {
-    match tokio::time::timeout(CONN_TIMEOUT, connect_async(endpoint)).await {
-        Err(_elapsed) => Err(ClientCoreError::GatewayConnectionTimeout),
-        Ok(Err(conn_failure)) => Err(conn_failure.into()),
-        Ok(Ok((stream, _))) => Ok(stream),
-    }
-}
-
-#[cfg(target_arch = "wasm32")]
-async fn connect(endpoint: &str) -> Result<WsConn, ClientCoreError> {
-    JSWebsocket::new(endpoint).map_err(|_| ClientCoreError::GatewayJsConnectionFailure)
-}
-
-async fn measure_latency(gateway: gateway::Node) -> Result<GatewayWithLatency, ClientCoreError> {
-    let addr = gateway.clients_address();
-    trace!(
-        "establishing connection to {} ({addr})...",
-        gateway.identity_key,
-    );
-    let mut stream = connect(&addr).await?;
-
-    let mut results = Vec::new();
-    for _ in 0..MEASUREMENTS {
-        let measurement_future = async {
-            let ping_content = vec![1, 2, 3];
-            let start = Instant::now();
-            stream.send(Message::Ping(ping_content.clone())).await?;
-
-            match stream.next().await {
-                Some(Ok(Message::Pong(content))) => {
-                    if content == ping_content {
-                        let elapsed = Instant::now().duration_since(start);
-                        trace!("current ping time: {elapsed:?}");
-                        results.push(elapsed);
-                    } else {
-                        warn!("received a pong message with different content? wtf.")
-                    }
-                }
-                Some(Ok(_)) => warn!("received a message that's not a pong!"),
-                Some(Err(err)) => return Err(err.into()),
-                None => return Err(ClientCoreError::GatewayConnectionAbruptlyClosed),
-            }
-
-            Ok::<(), ClientCoreError>(())
-        };
-
-        // thanks to wasm we can't use tokio::time::timeout : (
-        #[cfg(not(target_arch = "wasm32"))]
-        let timeout = tokio::time::sleep(PING_TIMEOUT);
-        #[cfg(not(target_arch = "wasm32"))]
-        tokio::pin!(timeout);
-
-        #[cfg(target_arch = "wasm32")]
-        let mut timeout = wasm_timer::Delay::new(PING_TIMEOUT);
-
-        tokio::select! {
-            _ = &mut timeout => {
-                warn!("timed out while trying to perform measurement...")
-            }
-            res = measurement_future => res?,
-        }
-    }
-
-    let count = results.len() as u64;
-    if count == 0 {
-        return Err(ClientCoreError::NoGatewayMeasurements {
-            identity: gateway.identity_key.to_base58_string(),
-        });
-    }
-
-    let sum: Duration = results.into_iter().sum();
-    let avg = Duration::from_nanos(sum.as_nanos() as u64 / count);
-
-    Ok(GatewayWithLatency::new(gateway, avg))
-}
-
-async fn choose_gateway_by_latency<R: Rng>(
-    rng: &mut R,
-    gateways: Vec<gateway::Node>,
-) -> Result<gateway::Node, ClientCoreError> {
-    info!("choosing gateway by latency...");
-
-    let mut gateways_with_latency = Vec::new();
-    for gateway in gateways {
-        let id = *gateway.identity();
-        trace!("measuring latency to {id}...");
-        let with_latency = match measure_latency(gateway).await {
-            Ok(res) => res,
-            Err(err) => {
-                warn!("failed to measure {id}: {err}");
-                continue;
-            }
-        };
-        debug!(
-            "{id} ({}): {:?}",
-            with_latency.gateway.location, with_latency.latency
-        );
-        gateways_with_latency.push(with_latency)
-    }
-
-    let chosen = gateways_with_latency
-        .choose_weighted(rng, |item| 1. / item.latency.as_secs_f32())
-        .expect("invalid selection weight!");
-
-    info!(
-        "chose gateway {} (located at {}) with average latency of {:?}",
-        chosen.gateway.identity_key, chosen.gateway.location, chosen.latency
-    );
-
-    Ok(chosen.gateway.clone())
-}
-
-fn uniformly_random_gateway<R: Rng>(
-    rng: &mut R,
-    gateways: Vec<gateway::Node>,
-) -> Result<gateway::Node, ClientCoreError> {
-    gateways
-        .choose(rng)
-        .ok_or(ClientCoreError::NoGatewaysOnNetwork)
-        .cloned()
-}
-
-pub(super) async fn query_gateway_details(
-    validator_servers: Vec<Url>,
-    chosen_gateway_id: Option<identity::PublicKey>,
-    by_latency: bool,
-) -> Result<gateway::Node, ClientCoreError> {
-    let mut rng = thread_rng();
-    let gateways = current_gateways(&mut rng, validator_servers).await?;
-
-    // if we set an explicit gateway, use that one and nothing else
-    if let Some(explicitly_chosen) = chosen_gateway_id {
-        gateways
-            .into_iter()
-            .find(|gateway| gateway.identity_key == explicitly_chosen)
-            .ok_or_else(|| ClientCoreError::NoGatewayWithId(explicitly_chosen.to_string()))
-    } else if by_latency {
-        choose_gateway_by_latency(&mut rng, gateways).await
+    // if we have chosen particular gateway - use it, otherwise choose a random one.
+    // (remember that in active topology all gateways have at least 100 reputation so should
+    // be working correctly)
+    if let Some(gateway_id) = chosen_gateway_id {
+        filtered_gateways
+            .iter()
+            .find(|gateway| gateway.identity_key == gateway_id)
+            .ok_or_else(|| ClientCoreError::NoGatewayWithId(gateway_id.to_string()))
+            .cloned()
    } else {
-        uniformly_random_gateway(&mut rng, gateways)
+        filtered_gateways
+            .choose(&mut rand::thread_rng())
+            .ok_or(ClientCoreError::NoGatewaysOnNetwork)
+            .cloned()
    }
 }

@@ -5,13 +5,13 @@

 use std::fmt::Display;

-use nym_sphinx::addressing::{clients::Recipient, nodes::NodeIdentity};
+use nymsphinx::addressing::{clients::Recipient, nodes::NodeIdentity};
 use rand::rngs::OsRng;
 use serde::Serialize;
 use tap::TapFallible;

-use nym_config::NymConfig;
-use nym_crypto::asymmetric::{encryption, identity};
+use config::NymConfig;
+use crypto::asymmetric::{encryption, identity};
 use url::Url;

 use crate::client::key_manager::KeyManager;
@@ -77,11 +77,9 @@ pub async fn register_with_gateway(
    key_manager: &mut KeyManager,
    nym_api_endpoints: Vec<Url>,
    chosen_gateway_id: Option<identity::PublicKey>,
-    by_latency: bool,
 ) -> Result<GatewayEndpointConfig, ClientCoreError> {
    // Get the gateway details of the gateway we will use
-    let gateway =
-        helpers::query_gateway_details(nym_api_endpoints, chosen_gateway_id, by_latency).await?;
+    let gateway = helpers::query_gateway_details(nym_api_endpoints, chosen_gateway_id).await?;
    log::debug!("Querying gateway gives: {}", gateway);

    let our_identity = key_manager.identity_keypair();
@@ -104,7 +102,6 @@ pub async fn setup_gateway_from_config<C, T>(
    register_gateway: bool,
    user_chosen_gateway_id: Option<identity::PublicKey>,
    config: &Config<T>,
-    by_latency: bool,
 ) -> Result<GatewayEndpointConfig, ClientCoreError>
 where
    C: NymConfig + ClientCoreConfigTrait,
@@ -112,20 +109,17 @@ where
 {
    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() {
        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
-    let gateway = helpers::query_gateway_details(
-        config.get_nym_api_endpoints(),
-        user_chosen_gateway_id,
-        by_latency,
-    )
-    .await?;
+    // Else, we preceed by querying the nym-api
+    let gateway =
+        helpers::query_gateway_details(config.get_nym_api_endpoints(), user_chosen_gateway_id)
+            .await?;
    log::debug!("Querying gateway gives: {}", gateway);

    // If we are not registering, just return this and assume the caller has the keys already and
@@ -188,13 +182,13 @@ pub fn get_client_address_from_stored_keys<T>(
    config: &Config<T>,
 ) -> Result<Recipient, ClientCoreError>
 where
-    T: nym_config::NymConfig,
+    T: config::NymConfig,
 {
    fn load_identity_keys(
        pathfinder: &ClientKeyPathfinder,
    ) -> Result<identity::KeyPair, ClientCoreError> {
        let identity_keypair: identity::KeyPair =
-            nym_pemstore::load_keypair(&nym_pemstore::KeyPairPath::new(
+            pemstore::load_keypair(&pemstore::KeyPairPath::new(
                pathfinder.private_identity_key().to_owned(),
                pathfinder.public_identity_key().to_owned(),
            ))
@@ -206,7 +200,7 @@ where
        pathfinder: &ClientKeyPathfinder,
    ) -> Result<encryption::KeyPair, ClientCoreError> {
        let sphinx_keypair: encryption::KeyPair =
-            nym_pemstore::load_keypair(&nym_pemstore::KeyPairPath::new(
+            pemstore::load_keypair(&pemstore::KeyPairPath::new(
                pathfinder.private_encryption_key().to_owned(),
                pathfinder.public_encryption_key().to_owned(),
            ))
@@ -6,22 +6,21 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [dependencies]
-bip39 = { workspace = true }
+bip39 = "1.0.1"
 clap = { version = "4.0", features = ["cargo", "derive"] }
-log = "0.4"
 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-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" }
+coconut-interface = { path = "../../common/coconut-interface" }
+config = { path = "../../common/config" }
+completions = { path = "../../common/completions" }
+credentials = { path = "../../common/credentials" }
+credential-storage = { path = "../../common/credential-storage" }
+crypto = { path = "../../common/crypto", features = ["rand", "asymmetric", "symmetric", "aes", "hashing"] }
+network-defaults = { path = "../../common/network-defaults" }
+pemstore = { path = "../../common/pemstore" }
 validator-client = { path = "../../common/client-libs/validator-client", features = ["nyxd-client"] }

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

 use crate::error::Result;
 use bip39::Mnemonic;
-use nym_network_defaults::{NymNetworkDetails, VOUCHER_INFO};
+use network_defaults::{NymNetworkDetails, VOUCHER_INFO};
 use std::str::FromStr;
 use url::Url;
 use validator_client::nyxd;
@@ -1,32 +1,29 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use clap::{ArgGroup, Args, Subcommand};
-use log::*;
-use nym_bin_common::completions::ArgShell;
+use clap::{Args, Subcommand};
+use completions::ArgShell;
 use rand::rngs::OsRng;
 use std::str::FromStr;

-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 coconut_interface::{Base58, Parameters};
+use credential_storage::storage::Storage;
+use credential_storage::PersistentStorage;
+use credentials::coconut::bandwidth::{BandwidthVoucher, TOTAL_ATTRIBUTES};
+use credentials::coconut::utils::obtain_aggregate_signature;
+use crypto::asymmetric::{encryption, identity};
+use network_defaults::{NymNetworkDetails, VOUCHER_INFO};
 use validator_client::nyxd::traits::DkgQueryClient;
 use validator_client::nyxd::tx::Hash;
-use validator_client::nyxd::CosmWasmClient;
-use validator_client::CoconutApiClient;
+use validator_client::{CoconutApiClient, Config};

 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 {
-    /// Run the binary to obtain a credential
+    /// Run the binary
    Run(Run),

    /// Generate shell completions
@@ -37,11 +34,6 @@ pub(crate) enum Command {
 }

 #[derive(Args)]
-#[clap(group(
-ArgGroup::new("recov")
-.required(true)
-.args(&["amount", "recovery_mode"]),
-))]
 pub(crate) struct Run {
    /// Home directory of the client that is supposed to use the credential.
    #[clap(long)]
@@ -55,25 +47,15 @@ pub(crate) struct Run {
    #[clap(long)]
    pub(crate) mnemonic: String,

-    /// The amount of utokens the credential will hold. If recovery mode is enabled, this value
-    /// is not needed
-    #[clap(long, default_value = "0")]
+    /// The amount of utokens the credential will hold
+    #[clap(long)]
    pub(crate) amount: u64,
-
-    /// Path to a directory used to store recovery files for unconsumed deposits
-    #[clap(long)]
-    pub(crate) recovery_dir: std::path::PathBuf,
-
-    /// Recovery mode, when enabled, tries to recover any deposit data dumped in recovery_dir
-    #[clap(long)]
-    pub(crate) recovery_mode: bool,
 }

 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
@@ -85,25 +67,20 @@ pub(crate) async fn deposit(nyxd_url: &str, mnemonic: &str, amount: u64) -> Resu
        )
        .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 };
+    let state = State {
+        amount,
+        tx_hash,
+        signing_keypair,
+        encryption_keypair,
+    };

    Ok(state)
 }

-pub(crate) async fn get_credential<C: Clone + CosmWasmClient + Send + Sync>(
-    state: &State,
-    client: validator_client::Client<C>,
-    shared_storage: PersistentStorage,
-) -> Result<()> {
+pub(crate) async fn get_credential(state: &State, shared_storage: PersistentStorage) -> Result<()> {
+    let network_details = NymNetworkDetails::new_from_env();
+    let config = Config::try_from_nym_network_details(&network_details)?;
+    let client = validator_client::Client::new_query(config)?;
    let epoch_id = client.nyxd.get_current_epoch().await?.epoch_id;
    let threshold = client
        .nyxd
@@ -112,20 +89,30 @@ pub(crate) async fn get_credential<C: Clone + CosmWasmClient + Send + Sync>(
        .ok_or(CredentialClientError::NoThreshold)?;
    let coconut_api_clients = CoconutApiClient::all_coconut_api_clients(&client, epoch_id).await?;

+    let params = Parameters::new(TOTAL_ATTRIBUTES).unwrap();
+    let bandwidth_credential_attributes = BandwidthVoucher::new(
+        &params,
+        state.amount.to_string(),
+        VOUCHER_INFO.to_string(),
+        Hash::from_str(&state.tx_hash).map_err(|_| CredentialClientError::InvalidTxHash)?,
+        identity::PrivateKey::from_base58_string(&state.signing_keypair.private_key)?,
+        encryption::PrivateKey::from_base58_string(&state.encryption_keypair.private_key)?,
+    );
+
    let signature = obtain_aggregate_signature(
-        &state.params,
-        &state.voucher,
+        &params,
+        &bandwidth_credential_attributes,
        &coconut_api_clients,
        threshold,
    )
    .await?;
-    info!("Signature: {:?}", signature.to_bs58());
+    println!("Signature: {:?}", signature.to_bs58());
    shared_storage
        .insert_coconut_credential(
-            state.voucher.get_voucher_value(),
+            state.amount.to_string(),
            VOUCHER_INFO.to_string(),
-            state.voucher.get_private_attributes()[0].to_bs58(),
-            state.voucher.get_private_attributes()[1].to_bs58(),
+            bandwidth_credential_attributes.get_private_attributes()[0].to_bs58(),
+            bandwidth_credential_attributes.get_private_attributes()[1].to_bs58(),
            signature.to_bs58(),
            epoch_id.to_string(),
        )
@@ -133,33 +120,3 @@ pub(crate) async fn get_credential<C: Clone + CosmWasmClient + Send + Sync>(

    Ok(())
 }
-
-pub(crate) async fn recover_credentials<C: Clone + CosmWasmClient + Send + Sync>(
-    client: validator_client::Client<C>,
-    recovery_storage: &RecoveryStorage,
-    shared_storage: PersistentStorage,
-) -> Result<()> {
-    for voucher in recovery_storage.unconsumed_vouchers()? {
-        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(),
-                e
-            )
-        } else {
-            info!(
-                "Converted deposit {} to a credential, removing recovery data for it",
-                state.voucher.tx_hash()
-            );
-            if let Err(e) = recovery_storage.remove_voucher(state.voucher.tx_hash().to_string()) {
-                warn!("Could not remove recovery data - {:?}", e);
-            }
-        }
-    }
-
-    Ok(())
-}
@@ -1,13 +1,12 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use std::time::SystemTimeError;
 use thiserror::Error;

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

@@ -15,9 +14,6 @@ pub type Result<T> = std::result::Result<T, CredentialClientError>;

 #[derive(Error, Debug)]
 pub enum CredentialClientError {
-    #[error("IO error: {0}")]
-    IOError(#[from] std::io::Error),
-
    #[error("Nyxd error: {0}")]
    Nyxd(#[from] NyxdError),

@@ -39,9 +35,6 @@ pub enum CredentialClientError {
    #[error("Could not use shared storage")]
    SharedStorageError(#[from] StorageError),

-    #[error("Could not get system time")]
-    SysTimeError(#[from] SystemTimeError),
-
    #[error("Threshold not set yet")]
    NoThreshold,
 }
@@ -4,25 +4,15 @@
 mod client;
 mod commands;
 mod error;
-mod recovery_storage;
 mod state;

 use commands::*;
+use completions::fig_generate;
+use config::{DATA_DIR, DB_FILE_NAME};
 use error::Result;
-use log::*;
-use nym_bin_common::completions::fig_generate;
-use nym_config::{CRED_DB_FILE_NAME, DATA_DIR};
-use nym_network_defaults::{setup_env, NymNetworkDetails};
-use std::process::exit;
-use std::time::{Duration, SystemTime};
+use network_defaults::setup_env;

 use clap::{CommandFactory, Parser};
-use nym_bin_common::logging::setup_logging;
-use validator_client::nyxd::traits::DkgQueryClient;
-use validator_client::nyxd::CosmWasmClient;
-use validator_client::Config;
-
-const SAFETY_BUFFER_SECS: u64 = 60; // 1 minute

 #[derive(Parser)]
 #[clap(author = "Nymtech", version, about)]
@@ -35,77 +25,19 @@ struct Cli {
    pub(crate) command: Command,
 }

-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?;
-        let current_timestamp_secs = SystemTime::now()
-            .duration_since(SystemTime::UNIX_EPOCH)?
-            .as_secs();
-        if epoch.state.is_final() {
-            if current_timestamp_secs + SAFETY_BUFFER_SECS >= epoch.finish_timestamp.seconds() {
-                info!("In the next {} minute(s), a transition will take place in the coconut system. Deposits should be halted in this time for safety reasons.", SAFETY_BUFFER_SECS / 60);
-                exit(0);
-            }
-
-            break;
-        } else {
-            // Use 1 additional second to not start the next iteration immediately and spam get_current_epoch queries
-            let secs_until_final = epoch
-                .final_timestamp_secs()
-                .saturating_sub(current_timestamp_secs)
-                + 1;
-            info!("Approximately {} seconds until coconut is available. Sleeping until then. You can safely kill the process at any moment.", secs_until_final);
-            std::thread::sleep(Duration::from_secs(secs_until_final));
-        }
-    }
-
-    Ok(())
-}
-
 #[tokio::main]
 async fn main() -> Result<()> {
    let args = Cli::parse();
-    setup_logging();
    setup_env(args.config_env_file.as_ref());
    let bin_name = "nym-credential-client";

    match args.command {
        Command::Run(r) => {
-            let db_path = r
-                .client_home_directory
-                .join(DATA_DIR)
-                .join(CRED_DB_FILE_NAME);
-            let shared_storage = nym_credential_storage::initialise_storage(db_path).await;
-            let recovery_storage = recovery_storage::RecoveryStorage::new(r.recovery_dir)?;
+            let db_path = r.client_home_directory.join(DATA_DIR).join(DB_FILE_NAME);
+            let shared_storage = credential_storage::initialise_storage(db_path).await;

-            let network_details = NymNetworkDetails::new_from_env();
-            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 = 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) {
-                        Ok(file_path) => {
-                            warn!("Dumped recovery data to {:?}. Try using recovery mode to convert it to a credential", file_path);
-                        }
-                        Err(e) => {
-                            error!("Could not dump recovery data to file system due to {:?}, the deposit will be lost!", e)
-                        }
-                    }
-                }
-            } else {
-                recover_credentials(client, &recovery_storage, shared_storage).await?;
-            }
+            let state = deposit(&r.nyxd_url, &r.mnemonic, r.amount).await?;
+            get_credential(&state, shared_storage).await?;
        }
        Command::Completions(c) => c.generate(&mut crate::Cli::command(), bin_name),
        Command::GenerateFigSpec => fig_generate(&mut crate::Cli::command(), bin_name),
@@ -1,56 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use nym_credentials::coconut::bandwidth::BandwidthVoucher;
-use std::fs::{create_dir_all, read_dir, File};
-use std::io::{Read, Write};
-use std::path::PathBuf;
-
-pub struct RecoveryStorage {
-    recovery_dir: PathBuf,
-}
-
-impl RecoveryStorage {
-    pub fn new(recovery_dir: PathBuf) -> std::io::Result<Self> {
-        create_dir_all(&recovery_dir)?;
-        Ok(Self { recovery_dir })
-    }
-
-    pub fn unconsumed_vouchers(&self) -> std::io::Result<impl Iterator<Item = BandwidthVoucher>> {
-        Ok(read_dir(&self.recovery_dir)?
-            .filter_map(|entry| entry.ok())
-            .filter_map(|entry| {
-                let path = entry.path();
-                if path.is_file() {
-                    Some(path)
-                } else {
-                    None
-                }
-            })
-            .filter_map(|path| File::open(path).ok())
-            .filter_map(|mut f| {
-                let mut buff = Vec::new();
-                if f.read_to_end(&mut buff).is_ok() {
-                    Some(buff)
-                } else {
-                    None
-                }
-            })
-            .filter_map(|buff| BandwidthVoucher::try_from_bytes(&buff).ok()))
-    }
-
-    pub fn insert_voucher(&self, voucher: &BandwidthVoucher) -> std::io::Result<PathBuf> {
-        let file_name = voucher.tx_hash().to_string();
-        let file_path = self.recovery_dir.join(file_name);
-        let mut file = File::create(&file_path)?;
-        let buff = voucher.to_bytes();
-        file.write_all(&buff)?;
-
-        Ok(file_path)
-    }
-
-    pub fn remove_voucher(&self, file_name: String) -> std::io::Result<()> {
-        let file_path = self.recovery_dir.join(file_name);
-        std::fs::remove_file(file_path)
-    }
-}
@@ -1,11 +1,11 @@
 // 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;
+use serde::{Deserialize, Serialize};

-use nym_crypto::asymmetric::{encryption, identity};
+use crypto::asymmetric::{encryption, identity};

+#[derive(Clone, Debug, Deserialize, Serialize)]
 pub(crate) struct KeyPair {
    pub public_key: String,
    pub private_key: String,
@@ -29,7 +29,10 @@ impl From<encryption::KeyPair> for KeyPair {
    }
 }

+#[derive(Clone, Debug, Deserialize, Serialize)]
 pub(crate) struct State {
-    pub voucher: BandwidthVoucher,
-    pub params: Parameters,
+    pub amount: u64,
+    pub tx_hash: String,
+    pub signing_keypair: KeyPair,
+    pub encryption_keypair: KeyPair,
 }
@@ -1,6 +1,6 @@
 [package]
 name = "nym-client"
-version = "1.1.14"
+version = "1.1.8"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>", "Jędrzej Stuczyński <andrew@nymtech.net>"]
 description = "Implementation of the Nym Client"
 edition = "2021"
@@ -34,21 +34,25 @@ tokio = { version = "1.24.1", features = ["rt-multi-thread", "net", "signal"] }
 tokio-tungstenite = "0.14" # websocket

 ## internal
-nym-bin-common = { path = "../../common/bin-common" }
+build-information = { path = "../../common/build-information" }
 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" }
+client-connections = { path = "../../common/client-connections" }
+coconut-interface = { path = "../../common/coconut-interface" }
+config = { path = "../../common/config" }
+completions = { path = "../../common/completions" }
+credential-storage = { path = "../../common/credential-storage" }
+credentials = { path = "../../common/credentials" }
+crypto = { path = "../../common/crypto" }
+logging = { path = "../../common/logging"}
 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" }
+network-defaults = { path = "../../common/network-defaults" }
+nymsphinx = { path = "../../common/nymsphinx" }
+pemstore = { path = "../../common/pemstore" }
+task = { path = "../../common/task" }
+topology = { path = "../../common/topology" }
 validator-client = { path = "../../common/client-libs/validator-client", features = ["nyxd-client"] }
+version-checker = { path = "../../common/version-checker" }
 websocket-requests = { path = "websocket-requests" }

 [dev-dependencies]
@@ -1,5 +1,5 @@
 use futures::{SinkExt, StreamExt};
-use nym_sphinx::addressing::clients::Recipient;
+use nymsphinx::addressing::clients::Recipient;
 use tokio::net::TcpStream;
 use tokio_tungstenite::{
    connect_async, tungstenite::protocol::Message, MaybeTlsStream, WebSocketStream,
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Bogdan-Ștefan Neacşu	b5213f3908	Hide coconut runtime flags (#2990 )	2023-02-08 13:00:58 +02:00
Bogdan-Ștefan Neacşu	590a4644e2	Skip errors on blind sign within threshold (#2976 )	2023-02-08 11:54:12 +02:00
Bogdan-Ștefan Neacşu	f8345e03c6	Feature/dkg reshare (#2936 ) * Add resharing parameter * Fix equality of dealers and members * Contract resharing handling * Dealer verification unit test * Dealing commit unit test * Epoch state unit tests * Fix clippy * Fmt * Query initial dealer data * Resharing nym-api changes * Implement the mockups for nym-api dkg tests * Dealing test * Vk unit test * Fix skipping vk submission * Fix clippy * Missing dealing for noninitial resharing dealer * Check master vk holds after resharing on nym-apis * Update changelog * Fix clippy	2023-02-07 12:56:08 +02:00
Jon Häggblad	6675ea0249	Remove all the .DS_Store files and add to gitignore (#2974 )	2023-02-07 11:45:40 +01:00
Jędrzej Stuczyński	56f48e6e41	Feature/service provider interface (#2934 ) * added additional workspace-wide dependencies * Added conditional serialization on 'BinaryBuildInformationOwned' * initial framework for service provider messages * updated request/response tags to account for existing variants of Socks5Message * handling legacy deserialization * another serialization revamp to account for legacy version * legacy client working with versioned network requester * socks5 client deserializing responses into updated structures * using new structures for sending in socks5 client * SendRequest wrapper for Request::Send variant * created named fields for all variants of 'ControllerCommand' * Versioning socks5 requests + moving to proper Socks5Request struct * Updated backwards compatible Socks5Response * unused imports * poc ServiceProvider trait * wip * implemented 'ServiceProvider' trait on the Network Requester * Socks5RequestError * added properly serialized ErrorResponse to ControlResponse * fixed version serialization + feature selection * handling of version control requests * improved SocksProxyError by providing more concrete variants and removing generic case * got rid of ServiceProviderClient trait and wrote simple example showing control requests * tests for serialisation backwards compatibility * post-merge fixes due to method renaming * enum boxing to make clippy happier * making sure to not drop buffer channel when starting `DirectClient` * Using nym-sdk in the example * Replaced printing version to stdout with proper log call	2023-02-07 09:49:19 +00:00
Pierre Dommerc	1733aaa4cc	NC Android - setup APK publish (#2967 ) * ci(nc-android): init workflow apk build & release * ci(nc-android): setup nc android project for APK publish * docs(nc-android): update readme * ci(nc-android): add note in the workflow	2023-02-06 10:56:39 +01:00
Mark Sinclair	78aa07360c	Update build-and-upload-binaries-ci.yml	2023-02-03 17:10:13 +00:00
Mark Sinclair	4e52478c7a	Update build-and-upload-binaries-ci.yml	2023-02-03 16:54:49 +00:00
Mark Sinclair	7c77665a37	Update build-and-upload-binaries-ci.yml	2023-02-03 16:36:44 +00:00
Mark Sinclair	72880b9764	Update build-and-upload-binaries-ci.yml	2023-02-03 16:14:29 +00:00
Mark Sinclair	fd1c0ae62b	Update build-and-upload-binaries-ci.yml	2023-02-03 12:03:13 +00:00
Mark Sinclair	bd7399091b	Update build-and-upload-binaries-ci.yml	2023-02-03 11:57:32 +00:00
Mark Sinclair	00fad44e2e	Update build-and-upload-binaries-ci.yml	2023-02-03 11:46:07 +00:00
Mark Sinclair	ea33c332ee	GitHub Actions: add action to build and upload binaries to CI server	2023-02-03 11:35:03 +00:00
Bogdan-Ștefan Neacșu	b39f8af8d0	Fix flaky dkg test	2023-02-03 12:29:21 +02:00
dependabot[bot]	a400463b7e	build(deps): bump ua-parser-js in /nym-wallet/webdriver (#2909 ) Bumps [ua-parser-js](https://github.com/faisalman/ua-parser-js) from 0.7.28 to 0.7.33. - [Release notes](https://github.com/faisalman/ua-parser-js/releases) - [Changelog](https://github.com/faisalman/ua-parser-js/blob/master/changelog.md) - [Commits](https://github.com/faisalman/ua-parser-js/compare/0.7.28...0.7.33) --- updated-dependencies: - dependency-name: ua-parser-js dependency-type: indirect ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2023-02-03 10:00:09 +00:00
dependabot[bot]	82928af64c	build(deps): bump http-cache-semantics in /nym-wallet/webdriver (#2960 ) Bumps [http-cache-semantics](https://github.com/kornelski/http-cache-semantics) from 4.1.0 to 4.1.1. - [Release notes](https://github.com/kornelski/http-cache-semantics/releases) - [Commits](https://github.com/kornelski/http-cache-semantics/commits) --- updated-dependencies: - dependency-name: http-cache-semantics dependency-type: indirect ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2023-02-03 09:59:08 +00:00
dependabot[bot]	c5891f546c	build(deps): bump http-cache-semantics from 4.1.0 to 4.1.1 (#2961 ) Bumps [http-cache-semantics](https://github.com/kornelski/http-cache-semantics) from 4.1.0 to 4.1.1. - [Release notes](https://github.com/kornelski/http-cache-semantics/releases) - [Commits](https://github.com/kornelski/http-cache-semantics/commits) --- updated-dependencies: - dependency-name: http-cache-semantics dependency-type: indirect ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2023-02-03 09:58:34 +00:00
Tommy Verrall	580b677489	Binary checker, introduction	2023-02-03 08:46:40 -01:00
Jędrzej Stuczyński	2093789c5c	Added an option to set custom 'host' for the native client (#2939 ) * Added an option to set custom 'host' for the native client * Changelog entry	2023-02-02 16:38:39 +00:00
Pierre Dommerc	d09864b99f	build(nc-android): prepare for apk release (#2943 ) * chore(nc-android): prepare for production build * refactor(nc-android): remove dead code * feat(nc-android): update native color theme * feat(nc-android): update native color theme * build(nc-android): fix rfd version issue * build(nc-android): fix dist dir no such file error * fix(nc-android): post rebase changes	2023-02-02 15:18:58 +01:00
Bogdan-Ștefan Neacşu	f6e8278592	Fix typo during merge back to develop (#2956 )	2023-02-02 13:55:58 +02:00
cgi-bin/	b085a8a636	typo: electrum (#2954 )	2023-02-02 09:34:08 +00:00
farbanas	e6ce531aeb	fix: formatting	2023-02-01 17:16:53 +01:00
farbanas	1a860eb3f5	fix: wrong parameter type for addresses in generator commands (should be AccountId instead of String)	2023-02-01 12:45:51 +01:00
Fran Arbanas	09cfd9ff05	Update CHANGELOG.md	2023-01-31 14:42:16 +00:00
Bogdan-Ștefan Neacșu	2c88ca137a	Resolve merge conflict	2023-01-31 16:19:34 +02:00
farbanas	ca3bfc859a	merge conflicts	2023-01-31 15:09:35 +01:00