display loading modal for initial loading of values

run cargo fmt fix clippy error minor fixes
set active set to be always true
2022-12-19 09:38:00 +00:00 · 2022-12-19 09:38:00 +00:00 · 2022-12-19 09:38:00 +00:00 · 2022-12-19 09:38:00 +00:00 · 2022-12-19 09:38:00 +00:00 · 2022-12-19 09:38:00 +00:00
1496 changed files with 36494 additions and 61057 deletions
@@ -14,7 +14,7 @@ GEOIPUPDATE_LICENSE_KEY=xxx
 # List of space-separated database edition IDs. Edition IDs may
 # consist of letters, digits, and dashes. For example, GeoIP2-City
 # would download the GeoIP2 City database (GeoIP2-City).
-GEOIPUPDATE_EDITION_IDS=GeoLite2-City
+GEOIPUPDATE_EDITION_IDS=GeoLite2-Country
 # The number of hours between geoipupdate runs. If this is not set
 # or is set to 0, geoipupdate will run once and exit.
 GEOIPUPDATE_FREQUENCY=72
@@ -26,7 +26,7 @@ jobs:
          path: .github/workflows/support-files/notifications/deny.message
  notification:
    needs: cargo-deny
-    runs-on: custom-runner-linux
+    runs-on: ubuntu-20.04
    steps:
      - name: Check out repository code
        uses: actions/checkout@v2
@@ -35,23 +35,18 @@ jobs:
        with:
          name: report
          path: .github/workflows/support-files/notifications
-      - name: install npm
-        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 }}"
-          MATRIX_SERVER: "${{ secrets.MATRIX_SERVER }}"
-          MATRIX_ROOM: "${{ secrets.MATRIX_ROOM_AUDIT }}"
-          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: "security"
        uses: docker://keybaseio/client:stable-node
        with:
          args: .github/workflows/support-files/notifications/entry_point.sh
@@ -1,113 +0,0 @@
-name: Build and upload binaries to CI
-
-on:
-  workflow_dispatch:
-  push:
-    paths:
-      - 'clients/**'
-      - 'common/**'
-      - 'contracts/**'
-      - 'explorer-api/**'
-      - 'gateway/**'
-      - 'integrations/**'
-      - 'mixnode/**'
-      - 'sdk/rust/nym-sdk/**'
-      - 'service-providers/**'
-      - 'nym-api/**'
-      - 'nym-outfox/**'
-      - 'tools/nym-cli/**'
-      - 'tools/ts-rs-cli/**'
-  pull_request:
-    paths:
-      - 'clients/**'
-      - 'common/**'
-      - 'contracts/**'
-      - 'explorer-api/**'
-      - 'gateway/**'
-      - 'integrations/**'
-      - 'mixnode/**'
-      - 'sdk/rust/nym-sdk/**'
-      - 'service-providers/**'
-      - 'nym-api/**'
-      - 'nym-outfox/**'
-      - 'tools/nym-cli/**'
-      - 'tools/ts-rs-cli/**'
-
-env:
-  NETWORK: mainnet
-
-jobs:
-  publish-nym:
-    strategy:
-      fail-fast: false
-      matrix:
-        platform: [ubuntu-20.04]
-
-    runs-on: ${{ matrix.platform }}
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Prepare build output directory
-        shell: bash
-        env:
-          OUTPUT_DIR: ci-builds/${{ github.ref_name }}
-        run: |
-          rm -rf ci-builds || true
-          mkdir -p $OUTPUT_DIR
-          echo $OUTPUT_DIR
-
-      - 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: Install Rust stable
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-
-      - name: Build all binaries
-        uses: actions-rs/cargo@v1
-        with:
-          command: build
-          args: --workspace --release --all
-
-      - name: Install Rust stable
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-          target: wasm32-unknown-unknown
-          override: true
-          components: rustfmt, clippy
-
-      - name: Build release contracts
-        run: make wasm
-
-      - name: Prepare build output
-        shell: bash
-        env:
-          OUTPUT_DIR: ci-builds/${{ github.ref_name }}
-        run: |
-          cp target/release/nym-client $OUTPUT_DIR
-          cp target/release/nym-gateway $OUTPUT_DIR
-          cp target/release/nym-mixnode $OUTPUT_DIR
-          cp target/release/nym-socks5-client $OUTPUT_DIR
-          cp target/release/nym-api $OUTPUT_DIR
-          cp target/release/nym-network-requester $OUTPUT_DIR
-          cp target/release/nym-network-statistics $OUTPUT_DIR
-          cp target/release/nym-cli $OUTPUT_DIR
-          cp target/release/credential $OUTPUT_DIR
-          
-          cp contracts/target/wasm32-unknown-unknown/release/mixnet_contract.wasm $OUTPUT_DIR
-          cp contracts/target/wasm32-unknown-unknown/release/vesting_contract.wasm $OUTPUT_DIR
-
-      - name: Deploy branch to CI www
-        continue-on-error: true
-        uses: easingthemes/ssh-deploy@main
-        env:
-          SSH_PRIVATE_KEY: ${{ secrets.CI_WWW_SSH_PRIVATE_KEY }}
-          ARGS: "-avzr"
-          SOURCE: "ci-builds/"
-          REMOTE_HOST: ${{ secrets.CI_WWW_REMOTE_HOST }}
-          REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
-          TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/builds/
-          EXCLUDE: "/dist/, /node_modules/"
@@ -1,59 +0,0 @@
-name: Build and upload binaries to artifact storage
-
-on:
-  workflow_dispatch:
-    inputs:  
-      add_tokio_unstable:
-        description: 'True to add RUSTFLAGS="--cfg tokio_unstable"'
-        required: true
-        default: false
-        type: boolean 
-    
-env:
-  NETWORK: mainnet    
-
-jobs:
-  publish-nym:
-    strategy:
-      fail-fast: false
-      matrix:
-        platform: [ubuntu-20.04]
-
-    runs-on: ${{ matrix.platform }}
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Install Dependencies (Linux)
-        run: sudo apt-get update && sudo apt-get -y install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libudev-dev squashfs-tools
-        continue-on-error: true
-
-      - name: Sets env vars for tokio if set in manual dispatch inputs
-        run: |
-          echo 'RUSTFLAGS="--cfg tokio_unstable"' >> $GITHUB_ENV
-        if: github.event_name == 'workflow_dispatch' && inputs.add_tokio_unstable == true
-
-      - name: Install Rust stable
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-
-      - name: Build all binaries
-        uses: actions-rs/cargo@v1
-        with:
-          command: build
-          args: --workspace --release
-
-      - name: Upload Artifact
-        uses: actions/upload-artifact@v3
-        with:
-          name: nym-binaries-artifacts
-          path: |
-            target/release/nym-client
-            target/release/nym-gateway
-            target/release/nym-mixnode
-            target/release/nym-socks5-client
-            target/release/nym-api
-            target/release/nym-network-requester
-            target/release/nym-network-statistics
-            target/release/nym-cli
-          retention-days: 30
@@ -12,7 +12,6 @@ jobs:
    - uses: actions/checkout@v2
    - name: Install rsync
      run: sudo apt-get install rsync
-      continue-on-error: true
    - uses: rlespinasse/github-slug-action@v3.x
    - uses: actions/setup-node@v3
      with:
@@ -43,10 +42,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,12 +53,11 @@ 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 }}"
-        MATRIX_USER_ID: "${{ secrets.MATRIX_USER_ID }}"
-        MATRIX_TOKEN: "${{ secrets.MATRIX_TOKEN }}"
-        MATRIX_DEVICE_ID: "${{ secrets.MATRIX_DEVICE_ID }}"
      uses: docker://keybaseio/client:stable-node
      with:
        args: .github/workflows/support-files/notifications/entry_point.sh
@@ -2,44 +2,21 @@ name: Continuous integration

 on:
  push:
-    paths:
-      - 'clients/**'
-      - 'common/**'
-      - 'explorer-api/**'
-      - 'gateway/**'
-      - 'integrations/**'
-      - 'mixnode/**'
-      - 'sdk/rust/nym-sdk/**'
-      - 'service-providers/**'
-      - 'nym-api/**'
-      - 'nym-outfox/**'
-      - 'tools/nym-cli/**'
-      - 'tools/ts-rs-cli/**'
+    paths-ignore:
+      - 'explorer/**'
  pull_request:
-    paths:
-      - 'clients/**'
-      - 'common/**'
-      - 'explorer-api/**'
-      - 'gateway/**'
-      - 'integrations/**'
-      - 'mixnode/**'
-      - 'sdk/rust/nym-sdk/**'
-      - 'service-providers/**'
-      - 'nym-api/**'
-      - 'nym-outfox/**'
-      - 'tools/nym-cli/**'
-      - 'tools/ts-rs-cli/**'
+    paths-ignore:
+      - 'explorer/**'

 jobs:
  build:
    runs-on: [ self-hosted, custom-linux ]
-    # Enable sccache via environment variable
+    # Enable sccache via environment variable
    env:
      RUSTC_WRAPPER: /home/ubuntu/.cargo/bin/sccache
    steps:
      - name: Install Dependencies (Linux)
        run: sudo apt-get update && sudo apt-get -y install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libudev-dev squashfs-tools
-        continue-on-error: true

      - name: Check out repository code
        uses: actions/checkout@v2
@@ -64,34 +41,47 @@ jobs:
          command: build
          args: --workspace

-      - name: Build all examples
-        uses: actions-rs/cargo@v1
-        with:
-          command: build
-          args: --workspace --examples
-
      - name: Run all tests
        uses: actions-rs/cargo@v1
        with:
          command: test
-          args: --workspace
+          args: --workspace --all-features

      - name: Run expensive tests
        if: github.ref == 'refs/heads/develop' || github.event.pull_request.base.ref == 'develop' || github.event.pull_request.base.ref == 'master'
        uses: actions-rs/cargo@v1
        with:
          command: test
-          args: --workspace -- --ignored
+          args: --workspace --all-features -- --ignored

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

      - name: Run clippy
        uses: actions-rs/cargo@v1
        with:
          command: clippy
-          args: --workspace --all-targets -- -D warnings
+          args: --workspace -- -D warnings
+
+      # COCONUT stuff
+
+      - name: Build all binaries with coconut enabled
+        uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: --workspace --features=coconut
+
+      - name: Run all tests with coconut enabled
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --workspace --features=coconut
+
+      - name: Run clippy with coconut enabled
+        uses: actions-rs/cargo@v1
+        with:
+          command: clippy
+          args: --all-targets --features=coconut -- -D warnings
@@ -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,138 +0,0 @@
-name: Nym Connect - Android APK Build
-
-on:
-  workflow_dispatch:
-  push:
-    branches:
-      - "release/nc-android-v[0-9].[0-9].[0-9]*"
-
-jobs:
-  build:
-    name: Build APK
-    runs-on: custom-runner-linux
-    env:
-      ANDROID_HOME: ${{ github.workspace }}/android-sdk
-      NDK_VERSION: 25.1.8937393
-      NDK_HOME: ${{ github.workspace }}/android-sdk/ndk/25.1.8937393
-      SDK_PLATFORM_VERSION: android-33
-      SDK_BUILDTOOLS_VERSION: 33.0.1
-
-    steps:
-      - name: Install Dependencies (Linux)
-        # https://next--tauri.netlify.app/next/guides/getting-started/prerequisites/linux/#1-system-dependencies
-        run: |
-          sudo apt-get update
-          sudo apt-get -y install \
-          build-essential \
-          unzip \
-          curl \
-          wget \
-          libssl-dev \
-          squashfs-tools \
-          librsvg2-dev
-
-      - name: Checkout
-        uses: actions/checkout@v3
-
-      - name: Install Java
-        uses: actions/setup-java@v3
-        with:
-          distribution: "temurin"
-          java-version: "17"
-
-      - name: Install Android SDK manager
-        # https://developer.android.com/studio/command-line/sdkmanager
-        run: |
-          curl -sS https://dl.google.com/android/repository/commandlinetools-linux-9477386_latest.zip -o cmdline-tools.zip
-          unzip cmdline-tools.zip
-          mkdir -p $ANDROID_HOME/cmdline-tools/latest
-          mv cmdline-tools/* $ANDROID_HOME/cmdline-tools/latest
-          rm -rf cmdline-tools
-
-      - name: Install Android S/NDK
-        run: |
-          echo y | $ANDROID_HOME/cmdline-tools/latest/bin/sdkmanager --licenses
-          echo y | $ANDROID_HOME/cmdline-tools/latest/bin/sdkmanager \
-            "platforms;$SDK_PLATFORM_VERSION" \
-            "platform-tools" \
-            "ndk;$NDK_VERSION" \
-            "build-tools;$SDK_BUILDTOOLS_VERSION"
-
-      - 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"
-
-      - name: Install rust android targets
-        run: |
-          rustup target add aarch64-linux-android \
-            armv7-linux-androideabi \
-            i686-linux-android \
-            x86_64-linux-android
-
-      - name: Setup Nodejs
-        uses: actions/setup-node@v3
-        with:
-          node-version: 18
-
-      - name: Install yarn
-        run: |
-          npm i -g yarn
-          yarn --version
-
-      - name: Build frontend code
-        run: |
-          yarn install --frozen-lockfile
-          yarn build
-          yarn workspace @nym/nym-connect-mobile webpack:prod
-
-      - name: Build APK
-        working-directory: nym-connect/mobile
-        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
-        # 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
-
-      # 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
-
-      - 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
-
-  # 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: ???
@@ -1,75 +0,0 @@
-name: Nym Connect - desktop (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/**"
-  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/**"
-
-jobs:
-  build:
-    runs-on: [self-hosted, custom-linux]
-    env:
-      RUSTC_WRAPPER: /home/ubuntu/.cargo/bin/sccache
-    steps:
-      - name: Install Dependencies (Linux)
-        run: sudo apt-get update && sudo apt-get -y install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev squashfs-tools libayatana-appindicator3-dev
-        continue-on-error: true
-
-      - name: Check out repository code
-        uses: actions/checkout@v2
-
-      - name: Install rust toolchain
-        uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: stable
-          override: true
-          components: rustfmt, clippy
-
-      - name: Build all binaries
-        uses: actions-rs/cargo@v1
-        with:
-          command: build
-          args: --manifest-path nym-connect/desktop/Cargo.toml --workspace
-
-      - name: Run all tests
-        uses: actions-rs/cargo@v1
-        with:
-          command: test
-          args: --manifest-path nym-connect/desktop/Cargo.toml --workspace
-
-      - name: Check formatting
-        uses: actions-rs/cargo@v1
-        with:
-          command: fmt
-          args: --manifest-path nym-connect/desktop/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
-
-      - name: Run clippy
-        uses: actions-rs/cargo@v1
-        with:
-          command: clippy
-          args: --manifest-path nym-connect/desktop/Cargo.toml --workspace --all-features -- -D warnings
@@ -1,72 +0,0 @@
-name: Nym Connect - mobile (Rust)
-
-on:
-  push:
-    paths:
-      - "nym-connect/mobile/src-tauri/**"
-      - "nym-connect/mobile/src-tauri/Cargo.toml"
-      - "!nym-connect/mobile/src-tauri/gen/**"
-      - "clients/client-core/**"
-      - "clients/socks5/**"
-      - "common/**"
-      - "gateway/gateway-requests/**"
-      - "contracts/vesting/**"
-      - "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/**"
-      - "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: ubuntu-22.04
-    #env:
-      #RUSTC_WRAPPER: /home/ubuntu/.cargo/bin/sccache
-    #defaults:
-      #run:
-        #working-directory: nym-connect/mobile/src-tauri/
-    steps:
-      - name: Install Dependencies (Linux)
-        run: |
-          sudo apt-get update
-          sudo apt-get -y install \
-          libwebkit2gtk-4.1-dev \
-          build-essential \
-          curl \
-          wget \
-          libssl-dev \
-          libgtk-3-dev \
-          squashfs-tools \
-          libayatana-appindicator3-dev \
-          librsvg2-dev \
-          libsoup-3.0-dev \
-          libjavascriptcoregtk-4.1-dev
-
-      - name: Checkout
-        uses: actions/checkout@v3
-
-      - name: Install Rust toolchain
-        uses: dtolnay/rust-toolchain@master
-        with:
-          toolchain: stable
-          components: clippy, rustfmt
-
-      - name: Check formatting
-        run: cargo fmt --manifest-path nym-connect/mobile/src-tauri/Cargo.toml -- --check
-
-      - name: Build all binaries
-        run: cargo build --manifest-path nym-connect/mobile/src-tauri/Cargo.toml
-
-      - name: Run all tests
-        run: cargo test  --manifest-path nym-connect/mobile/src-tauri/Cargo.toml
-
-      - name: Clippy
-        run: cargo clippy --manifest-path nym-connect/mobile/src-tauri/Cargo.toml --all-targets -- -D warnings
@@ -0,0 +1,56 @@
+name: Nym Connect (rust)
+
+on:
+  push:
+    paths-ignore:
+      - 'explorer/**'
+
+jobs:
+  build:
+    runs-on: [ self-hosted, custom-linux ]
+    env:
+      RUSTC_WRAPPER: /home/ubuntu/.cargo/bin/sccache
+    steps:
+      - name: Install Dependencies (Linux)
+        run: sudo apt-get update && sudo apt-get -y install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev squashfs-tools libayatana-appindicator3-dev
+
+      - name: Check out repository code
+        uses: actions/checkout@v2
+
+      - name: Install rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: stable
+          override: true
+          components: rustfmt, clippy
+
+      - name: Build all binaries
+        uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: --manifest-path nym-connect/Cargo.toml --workspace
+
+      - name: Run all tests
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --manifest-path nym-connect/Cargo.toml --workspace
+
+      - name: Check formatting
+        uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: --manifest-path nym-connect/Cargo.toml --all -- --check
+
+      - uses: actions-rs/clippy-check@v1
+        name: Clippy checks
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          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/Cargo.toml --workspace --all-features -- -D warnings
@@ -6,11 +6,17 @@ on:

 jobs:
  build:
-    if: ${{ startsWith(github.ref, 'refs/tags/nym-contracts-') && github.event_name == 'release' }}
-    runs-on: [self-hosted, custom-runner-linux]
+    runs-on: ubuntu-20.04
    steps:
      - uses: actions/checkout@v2
      
+      - name: Check the release tag starts with `nym-contracts-`
+        if: startsWith(github.ref, 'refs/tags/nym-contracts-') == false && github.event_name != 'workflow_dispatch'
+        uses: actions/github-script@v3
+        with:
+          script: |
+            core.setFailed('Release tag did not start with nym-contracts-...')      
+
      - name: Install Rust stable
        uses: actions-rs/toolchain@v1
        with:
@@ -2,13 +2,11 @@ name: Contracts

 on:
  push:
-    paths:
-      - 'contracts/**'
-      - 'common/**'
+    paths-ignore:
+      - 'explorer/**'
  pull_request:
    paths-ignore:
-      - 'contracts/**'
-      - 'common/**'
+      - 'explorer/**'

 jobs:
  matrix_prep:
@@ -10,7 +10,6 @@ env:

 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:
@@ -22,9 +21,9 @@ jobs:

      - 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-`
+        if: startsWith(github.ref, 'refs/tags/nym-explorer-api-') == false && github.event_name != 'workflow_dispatch'
        uses: actions/github-script@v3
        with:
          script: |
@@ -17,7 +17,6 @@ jobs:
    - uses: actions/checkout@v2
    - name: Install rsync
      run: sudo apt-get install rsync
-      continue-on-error: true
    - uses: rlespinasse/github-slug-action@v3.x
    - uses: actions/setup-node@v3
      with:
@@ -57,10 +56,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,12 +68,11 @@ 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 }}"
-        MATRIX_USER_ID: "${{ secrets.MATRIX_USER_ID }}"
-        MATRIX_TOKEN: "${{ secrets.MATRIX_TOKEN }}"
-        MATRIX_DEVICE_ID: "${{ secrets.MATRIX_DEVICE_ID }}"
      uses: docker://keybaseio/client:stable-node
      with:
        args: .github/workflows/support-files/notifications/entry_point.sh
@@ -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:
@@ -25,11 +25,10 @@ jobs:
    steps:
      - name: Install Dependencies (Linux)
        run: sudo apt-get update && sudo apt-get install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libudev-dev squashfs-tools
-        continue-on-error: true
        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
@@ -39,33 +38,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

@@ -75,9 +56,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

@@ -86,20 +67,25 @@ 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

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

      - name: Run clippy
        uses: actions-rs/cargo@v1
@@ -114,6 +100,38 @@ jobs:
        with:
          command: clean

+      # COCONUT stuff
+      - name: Build all binaries with coconut enabled
+        uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: --workspace --features=coconut
+
+      - name: Reclaim some disk space (because Windows is being annoying)
+        uses: actions-rs/cargo@v1
+        if: ${{ matrix.os == 'windows-latest' }}
+        with:
+          command: clean
+
+      - name: Run all tests with coconut enabled
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --workspace --features=coconut
+
+      - name: Reclaim some disk space (because Windows is being annoying)
+        uses: actions-rs/cargo@v1
+        if: ${{ matrix.os == 'windows-latest' }}
+        with:
+          command: clean
+
+      - name: Run clippy with coconut enabled
+        uses: actions-rs/cargo@v1
+        if: ${{ matrix.rust != 'nightly' }}
+        with:
+          command: clippy
+          args: --workspace --all-targets --features=coconut -- -D warnings
+
      # nym-wallet (the rust part)
      - name: Build nym-wallet rust code
        uses: actions-rs/cargo@v1
@@ -142,22 +160,17 @@ jobs:

  notification:
    needs: build
-    runs-on: custom-runner-linux
+    runs-on: ubuntu-20.04
    steps:
      - name: Collect jobs status
        uses: technote-space/workflow-conclusion-action@v2
      - name: Check out repository code
-        uses: actions/checkout@v3
-      - name: install npm
-        uses: actions/setup-node@v3
-        if: env.WORKFLOW_CONCLUSION == 'failure'
-        with:
-          node-version: 16
-      - name: Matrix - Node Install
+        uses: actions/checkout@v2
+      - 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,12 +178,11 @@ 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_USER_ID: "${{ secrets.MATRIX_USER_ID }}"
-          MATRIX_TOKEN: "${{ secrets.MATRIX_TOKEN }}"
-          MATRIX_DEVICE_ID: "${{ secrets.MATRIX_DEVICE_ID }}"
        uses: docker://keybaseio/client:stable-node
        with:
          args: .github/workflows/support-files/notifications/entry_point.sh
@@ -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:
@@ -38,7 +38,6 @@ jobs:
    steps:
      - name: Install Dependencies (Linux)
        run: sudo apt-get update && sudo apt-get install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libudev-dev squashfs-tools
-        continue-on-error: true
        if: matrix.os == 'ubuntu-20.04'

      - name: Check out latest release branch
@@ -54,33 +53,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 +71,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,20 +82,25 @@ 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

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

      - name: Run clippy
        uses: actions-rs/cargo@v1
@@ -129,6 +115,38 @@ jobs:
        with:
          command: clean

+      # COCONUT stuff
+      - name: Build all binaries with coconut enabled
+        uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: --workspace --features=coconut
+
+      - name: Reclaim some disk space (because Windows is being annoying)
+        uses: actions-rs/cargo@v1
+        if: ${{ matrix.os == 'windows-latest' }}
+        with:
+          command: clean
+
+      - name: Run all tests with coconut enabled
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --workspace --features=coconut
+
+      - name: Reclaim some disk space (because Windows is being annoying)
+        uses: actions-rs/cargo@v1
+        if: ${{ matrix.os == 'windows-latest' }}
+        with:
+          command: clean
+
+      - name: Run clippy with coconut enabled
+        uses: actions-rs/cargo@v1
+        if: ${{ matrix.rust != 'nightly' }}
+        with:
+          command: clippy
+          args: --workspace --all-targets --features=coconut -- -D warnings
+
      # nym-wallet (the rust part)
      - name: Build nym-wallet rust code
        uses: actions-rs/cargo@v1
@@ -157,22 +175,17 @@ jobs:

  notification:
    needs: [build,get_release]
-    runs-on: custom-runner-linux
+    runs-on: ubuntu-20.04
    steps:
      - name: Collect jobs status
        uses: technote-space/workflow-conclusion-action@v2
      - name: Check out repository code
        uses: actions/checkout@v3
-      - name: 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
@@ -180,12 +193,11 @@ 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_USER_ID: "${{ secrets.MATRIX_USER_ID }}"
-          MATRIX_TOKEN: "${{ secrets.MATRIX_TOKEN }}"
-          MATRIX_DEVICE_ID: "${{ secrets.MATRIX_DEVICE_ID }}"
        uses: docker://keybaseio/client:stable-node
        with:
          args: .github/workflows/support-files/notifications/entry_point.sh
@@ -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:
@@ -38,7 +38,6 @@ jobs:
    steps:
      - name: Install Dependencies (Linux)
        run: sudo apt-get update && sudo apt-get install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libudev-dev squashfs-tools
-        continue-on-error: true
        if: matrix.os == 'ubuntu-20.04'

      - name: Check out latest release branch
@@ -54,12 +53,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 +65,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 +73,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 +82,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
@@ -111,10 +98,9 @@ jobs:

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

      - name: Run clippy
        uses: actions-rs/cargo@v1
@@ -129,6 +115,38 @@ jobs:
        with:
          command: clean

+      # COCONUT stuff
+      - name: Build all binaries with coconut enabled
+        uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: --workspace --features=coconut
+
+      - name: Reclaim some disk space (because Windows is being annoying)
+        uses: actions-rs/cargo@v1
+        if: ${{ matrix.os == 'windows-latest' }}
+        with:
+          command: clean
+
+      - name: Run all tests with coconut enabled
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --workspace --features=coconut
+
+      - name: Reclaim some disk space (because Windows is being annoying)
+        uses: actions-rs/cargo@v1
+        if: ${{ matrix.os == 'windows-latest' }}
+        with:
+          command: clean
+
+      - name: Run clippy with coconut enabled
+        uses: actions-rs/cargo@v1
+        if: ${{ matrix.rust != 'nightly' }}
+        with:
+          command: clippy
+          args: --workspace --all-targets --features=coconut -- -D warnings
+
      # nym-wallet (the rust part)
      - name: Build nym-wallet rust code
        uses: actions-rs/cargo@v1
@@ -157,22 +175,17 @@ jobs:

  notification:
    needs: [build,get_release]
-    runs-on: custom-runner-linux
+    runs-on: ubuntu-20.04
    steps:
      - name: Collect jobs status
        uses: technote-space/workflow-conclusion-action@v2
      - name: Check out repository code
        uses: actions/checkout@v3
-      - name: 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
@@ -180,12 +193,11 @@ 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_USER_ID: "${{ secrets.MATRIX_USER_ID }}"
-          MATRIX_TOKEN: "${{ secrets.MATRIX_TOKEN }}"
-          MATRIX_DEVICE_ID: "${{ secrets.MATRIX_DEVICE_ID }}"
        uses: docker://keybaseio/client:stable-node
        with:
          args: .github/workflows/support-files/notifications/entry_point.sh
@@ -10,7 +10,6 @@ env:

 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:
@@ -21,6 +20,7 @@ jobs:
      - uses: actions/checkout@v3

      - name: Check the release tag starts with `nym-cli-`
+        if: startsWith(github.ref, 'refs/tags/nym-cli-') == false && github.event_name != 'workflow_dispatch'
        uses: actions/github-script@v3
        with:
          script: |
@@ -1,4 +1,4 @@
-name: Publish Nym Connect - desktop (MacOS)
+name: Publish Nym Connect (MacOS)
 on:
  workflow_dispatch:
  release:
@@ -6,33 +6,34 @@ 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' }}
    strategy:
      fail-fast: false
      matrix:
-        platform: [custom-runner-mac-m1]
+        platform: [macos-latest]

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

+      - name: Check the release tag starts with `nym-connect-`
+        if: startsWith(github.ref, 'refs/tags/nym-connect-') == false && github.event_name != 'workflow_dispatch'
+        uses: actions/github-script@v3
+        with:
+          script: |
+            core.setFailed('Release tag did not start with nym-connect-...')
+
      - name: Node v16
        uses: actions/setup-node@v3
        with:
          node-version: 16
-
-      - name: Setup yarn
-        run: npm install -g yarn
-
      - name: Install Rust stable
        uses: actions-rs/toolchain@v1
        with:
          toolchain: stable
-
      - name: Install the Apple developer certificate for code signing
        env:
          APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
@@ -44,7 +45,7 @@ jobs:
          KEYCHAIN_PATH=$RUNNER_TEMP/app-signing.keychain-db

          # import certificate and provisioning profile from secrets
-          echo -n "$APPLE_CERTIFICATE" | base64 --decode --output=$CERTIFICATE_PATH
+          echo -n "$APPLE_CERTIFICATE" | base64 --decode --output $CERTIFICATE_PATH

          # create temporary keychain
          security create-keychain -p "$KEYCHAIN_PASSWORD" $KEYCHAIN_PATH
@@ -78,7 +79,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
@@ -91,5 +92,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,15 +6,14 @@ 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' }}
    strategy:
      fail-fast: false
      matrix:
-        platform: [custom-runner-linux]
+        platform: [ubuntu-20.04]

    runs-on: ${{ matrix.platform }}
    steps:
@@ -24,13 +23,17 @@ jobs:
        run: >
          sudo apt-get update &&
          sudo apt-get install -y webkit2gtk-4.0 libayatana-appindicator3-dev
-        continue-on-error: true
+      - name: Check the release tag starts with `nym-connect-`
+        if: startsWith(github.ref, 'refs/tags/nym-connect-') == false && github.event_name != 'workflow_dispatch'
+        uses: actions/github-script@v3
+        with:
+          script: |
+            core.setFailed('Release tag did not start with nym-connect-...')

      - name: Node v16
        uses: actions/setup-node@v3
        with:
          node-version: 16
-
      - name: Install Rust stable
        uses: actions-rs/toolchain@v1
        with:
@@ -53,7 +56,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 +64,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,10 @@ 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' }}
    strategy:
      fail-fast: false
      matrix:
@@ -28,6 +27,13 @@ jobs:

      - uses: actions/checkout@v3

+      - name: Check the release tag starts with `nym-connect-`
+        if: startsWith(github.ref, 'refs/tags/nym-connect-') == false && github.event_name != 'workflow_dispatch'
+        uses: actions/github-script@v3
+        with:
+          script: |
+            core.setFailed('Release tag did not start with nym-connect-...')
+
      - name: Import signing certificate
        env:
          WINDOWS_CERTIFICATE: ${{ secrets.WINDOWS_CERTIFICATE }}
@@ -56,7 +62,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 +78,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 +86,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:
@@ -16,7 +16,6 @@ jobs:
    - uses: actions/checkout@v2
    - name: Install rsync
      run: sudo apt-get install rsync
-      continue-on-error: true
    - uses: rlespinasse/github-slug-action@v3.x
    - uses: actions/setup-node@v3
      with:
@@ -34,15 +33,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,12 +49,11 @@ 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 }}"
-        MATRIX_USER_ID: "${{ secrets.MATRIX_USER_ID }}"
-        MATRIX_TOKEN: "${{ secrets.MATRIX_TOKEN }}"
-        MATRIX_DEVICE_ID: "${{ secrets.MATRIX_DEVICE_ID }}"
      uses: docker://keybaseio/client:stable-node
      with:
        args: .github/workflows/support-files/notifications/entry_point.sh
@@ -16,11 +16,10 @@ env:

 jobs:
  publish-nym:
-    if: ${{ startsWith(github.ref, 'refs/tags/nym-binaries-') && github.event_name == 'release' }}
    strategy:
      fail-fast: false
      matrix:
-        platform: [custom-runner-linux]
+        platform: [ubuntu-20.04]

    runs-on: ${{ matrix.platform }}
    steps:
@@ -28,7 +27,13 @@ jobs:

      - 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-binaries-`
+        if: startsWith(github.ref, 'refs/tags/nym-binaries-') == false && github.event_name != 'workflow_dispatch'
+        uses: actions/github-script@v3
+        with:
+          script: |
+            core.setFailed('Release tag did not start with nym-binaries-...')
            
      - name: Sets env vars for tokio if set in manual dispatch inputs
        run: |
@@ -51,12 +56,11 @@ jobs:
        with:
          name: my-artifact
          path: |
-            target/release/explorer-api
            target/release/nym-client
            target/release/nym-gateway
            target/release/nym-mixnode
            target/release/nym-socks5-client
-            target/release/nym-api
+            target/release/nym-validator-api
            target/release/nym-network-requester
            target/release/nym-network-statistics
            target/release/nym-cli
@@ -67,12 +71,11 @@ jobs:
        if: github.event_name == 'release'
        with:
          files: |
-            target/release/explorer-api
            target/release/nym-client
            target/release/nym-gateway
            target/release/nym-mixnode
            target/release/nym-socks5-client
-            target/release/nym-api
+            target/release/nym-validator-api
            target/release/nym-network-requester
            target/release/nym-network-statistics
            target/release/nym-cli
@@ -10,7 +10,6 @@ defaults:

 jobs:
  publish-tauri:
-    if: ${{ startsWith(github.ref, 'refs/tags/nym-wallet-') && github.event_name == 'release' }}
    strategy:
      fail-fast: false
      matrix:
@@ -20,6 +19,13 @@ jobs:
    steps:
      - uses: actions/checkout@v2

+      - name: Check the release tag starts with `nym-wallet-`
+        if: startsWith(github.ref, 'refs/tags/nym-wallet-') == false && github.event_name != 'workflow_dispatch'
+        uses: actions/github-script@v3
+        with:
+          script: |
+            core.setFailed('Release tag did not start with nym-wallet-...')
+
      - name: Node v16
        uses: actions/setup-node@v3
        with:
@@ -9,11 +9,10 @@ defaults:

 jobs:
  publish-tauri:
-    if: ${{ startsWith(github.ref, 'refs/tags/nym-wallet-') && github.event_name == 'release' }}
    strategy:
      fail-fast: false
      matrix:
-        platform: [custom-runner-linux]
+        platform: [ubuntu-20.04]

    runs-on: ${{ matrix.platform }}
    steps:
@@ -23,13 +22,17 @@ jobs:
        run: >
          sudo apt-get update &&
          sudo apt-get install -y webkit2gtk-4.0
-        continue-on-error: true
+      - name: Check the release tag starts with `nym-wallet-`
+        if: startsWith(github.ref, 'refs/tags/nym-wallet-') == false
+        uses: actions/github-script@v3
+        with:
+          script: |
+            core.setFailed('Release tag did not start with nym-wallet-...')

      - name: Node v16
        uses: actions/setup-node@v3
        with:
          node-version: 16
-
      - name: Install Rust stable
        uses: actions-rs/toolchain@v1
        with:
@@ -1,6 +1,5 @@
 name: Publish Nym Wallet (Windows 10)
 on:
-  workflow_dispatch:
  release:
    types: [created]

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

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

      - uses: actions/checkout@v3

+      - name: Check the release tag starts with `nym-wallet-`
+        if: startsWith(github.ref, 'refs/tags/nym-wallet-') == false
+        uses: actions/github-script@v3
+        with:
+          script: |
+            core.setFailed('Release tag did not start with nym-wallet-...')
+
      - name: Import signing certificate
        env:
          WINDOWS_CERTIFICATE: ${{ secrets.WINDOWS_CERTIFICATE }}
@@ -56,7 +61,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 +73,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
@@ -12,7 +12,6 @@ jobs:
    - uses: actions/checkout@v2
    - name: Install rsync
      run: sudo apt-get install rsync
-      continue-on-error: true
    - uses: rlespinasse/github-slug-action@v3.x
    - uses: actions/setup-node@v3
      with:
@@ -35,10 +34,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,12 +45,11 @@ 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 }}"
-        MATRIX_USER_ID: "${{ secrets.MATRIX_USER_ID }}"
-        MATRIX_TOKEN: "${{ secrets.MATRIX_TOKEN }}"
-        MATRIX_DEVICE_ID: "${{ secrets.MATRIX_DEVICE_ID }}"
      uses: docker://keybaseio/client:stable-node
      with:
        args: .github/workflows/support-files/notifications/entry_point.sh
@@ -26,7 +26,6 @@ jobs:
          libappindicator3-dev
          webkit2gtk-driver
          xvfb
-        continue-on-error: true

      - name: Install minimal stable
        uses: actions-rs/toolchain@v1
@@ -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,9 +1,6 @@
-MATRIX_SERVER=
-MATRIX_ROOM=
-MATRIX_ROOM_OF_SHAME=
-MATRIX_USER_ID=
-MATRIX_TOKEN=
-MATRIX_DEVICE_ID=
+KEYBASE_NYM_CHANNEL=
+KEYBASE_NYMBOT_USERNAME=
+KEYBASE_NYMBOT_PAPERKEY=

 NYM_NOTIFICATION_KIND=nightly
 NYM_PROJECT_NAME=Nightly Build
@@ -35,4 +32,4 @@ NYM_CI_WWW_BASE=example.com
 # Nightly builds
 WORKFLOW_CONCLUSION=success

-SHOW_DEBUG=true
+SHOW_DEBUG=true
@@ -2,6 +2,4 @@ node_modules
 .idea

 # don't commit the lock file to avoid cross-platform issues
-package-lock.json
-
-scratch
+package-lock.json
@@ -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,6 +1,6 @@
 require('dotenv').config();

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

 let context = {
  kinds: ['nym-wallet', 'ts-packages', 'network-explorer', 'nightly', 'nym-connect','security'],
@@ -23,27 +23,20 @@ function validateContext() {
      'Please set env var NYM_PROJECT_NAME with the project name for displaying in notification messages',
    );
  }
-  if (context.env.MATRIX_ROOM) {
-    if (!context.env.MATRIX_SERVER) {
-      throw new Error(
-        'Matrix server is not defined. Please set env var MATRIX_SERVER',
-      );
-    }
-    if (!context.env.MATRIX_USER_ID) {
-      throw new Error(
-        'Matrix user id is not defined. Please set env var MATRIX_USER_ID',
-      );
-    }
-    if (!context.env.MATRIX_TOKEN) {
-      throw new Error(
-        'Matrix token is not defined. Please set env var MATRIX_TOKEN',
-      );
-    }
-    if (!context.env.MATRIX_DEVICE_ID) {
-      throw new Error(
-        'Matrix device id is not defined. Please set env var MATRIX_DEVICE_ID',
-      );
-    }
+  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',
+    );
  }
 }

@@ -68,6 +61,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 +76,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,13 +146,7 @@ async function main() {
    console.log(messageBody);
    console.log('-----------------------------------------');
  }
-  if(context.env.MATRIX_ROOM) {
-    await sendMatrixMessage(context, messageBody, context.env.MATRIX_ROOM)
-  }
-  if(context.env.MATRIX_ROOM_OF_SHAME && context.env.IS_SUCCESS !== 'true') {
-    // when a job fails
-    await sendMatrixMessage(context, messageBody, context.env.MATRIX_ROOM_OF_SHAME)
-  }
+  await sendKeybaseMessage(messageBody);
 }

 // call main function and let NodeJS handle the promise
@@ -1,67 +0,0 @@
-const sdk = require('matrix-js-sdk');
-global.Olm = require('olm');
-const { LocalStorage } = require('node-localstorage');
-const localStorage = new LocalStorage('./scratch');
-const {
-  LocalStorageCryptoStore,
-} = require('matrix-js-sdk/lib/crypto/store/localStorage-crypto-store');
-var showdown  = require('showdown');
-
-// hide all matrix client output
-console.error = (error) => console.log('❌ error: ', error);
-process.stderr.write = () => {};
-process.stdout.write = () => {};
-
-
-function createClient(context, room, message) {
-  const server = context.env.MATRIX_SERVER;
-  const token = context.env.MATRIX_TOKEN;
-  const deviceId = context.env.MATRIX_DEVICE_ID;
-  const userId = context.env.MATRIX_USER_ID;
-
-  const client = sdk.createClient({
-    baseUrl: server,
-    accessToken: token,
-    userId,
-    deviceId,
-    sessionStore: new sdk.WebStorageSessionStore(localStorage),
-    cryptoStore: new LocalStorageCryptoStore(localStorage),
-  });
-
-  client.on('sync', async function(state, prevState, res) {
-    if (state !== 'PREPARED') return;
-    client.setGlobalErrorOnUnknownDevices(false);
-    try {
-      await client.joinRoom(room);
-      await client.sendEvent(
-        room,
-        'm.room.message',
-        {
-          msgtype: 'm.text',
-          format: 'org.matrix.custom.html',
-          body: message,
-          formatted_body: message,
-        },
-        '',
-      );
-    } catch (error) {
-      console.error('Job failed: ' + error.message);
-    }
-    client.stopClient();
-    process.exit(0);
-  });
-
-  return client;
-}
-
-async function sendMatrixMessage(contextArg, messageAsMarkdown, roomId) {
-  const converter = new showdown.Converter();
-  const messageAsHtml = converter.makeHtml(messageAsMarkdown);
-  const client = createClient(contextArg, roomId, messageAsHtml);
-  await client.initCrypto();
-  await client.startClient({ initialSyncLimit: 1 });
-}
-
-module.exports = {
-  sendMatrixMessage,
-};
@@ -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,16 +10,8 @@
  "dependencies": {
    "dotenv": "^16.0.0",
    "handlebars": "^4.7.7",
-    "matrix-js-sdk": "^9.3.0",
-    "node-localstorage": "^2.1.6",
-    "octokit": "^1.7.1",
-    "olm": "https://packages.matrix.org/npm/olm/olm-3.2.1.tgz",
-    "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"
+    "keybase-bot": "^3.6.1",
+    "octokit": "^1.7.1"
  },
  "devDependencies": {
    "prettier": "2.3.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"]
@@ -1,64 +0,0 @@
-name: CI for linting Typescript
-
-on:
-  push:
-    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'
-
-jobs:
-  build:
-    runs-on: custom-runner-linux
-    steps:
-    - uses: actions/checkout@v2
-    - name: Install rsync
-      run: sudo apt-get install rsync
-      continue-on-error: true
-    - uses: rlespinasse/github-slug-action@v3.x
-    - uses: actions/setup-node@v3
-      with:
-        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: npm install
-      working-directory: .github/workflows/support-files
-    - name: Matrix - Send Notification
-      env:
-        NYM_NOTIFICATION_KIND: ts-packages
-        NYM_PROJECT_NAME: "ts-packages"
-        NYM_CI_WWW_BASE: "${{ secrets.NYM_CI_WWW_BASE }}"
-        NYM_CI_WWW_LOCATION: "ts-${{ env.GITHUB_REF_SLUG }}"
-        GIT_COMMIT_MESSAGE: "${{ github.event.head_commit.message }}"
-        GIT_BRANCH: "${GITHUB_REF##*/}"
-        IS_SUCCESS: "${{ job.status == 'success' }}"
-        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 }}"
-      uses: docker://keybaseio/client:stable-node
-      with:
-        args: .github/workflows/support-files/notifications/entry_point.sh
@@ -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"
@@ -2,17 +2,11 @@ name: Nym Wallet (rust)

 on:
  push:
-    paths:
-      - 'nym-wallet/**'
-      - 'common/**'
-      - 'contracts/vesting/**'
-      - 'nym-api/nym-api-requests/**'
+    paths-ignore:
+      - 'explorer/**'
  pull_request:
-    paths:
-      - 'nym-wallet/**'
-      - 'common/**'
-      - 'contracts/vesting/**'
-      - 'nym-api/nym-api-requests/**'
+    paths-ignore:
+      - 'explorer/**'

 jobs:
  build:
@@ -22,7 +16,6 @@ jobs:
    steps:
      - name: Install Dependencies (Linux)
        run: sudo apt-get update && sudo apt-get -y install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev squashfs-tools
-        continue-on-error: true

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

      - uses: actions-rs/clippy-check@v1
        name: Clippy checks
-        continue-on-error: true
        with:
          token: ${{ secrets.GITHUB_TOKEN }}
          args: --manifest-path nym-wallet/Cargo.toml --workspace --all-features
@@ -2,13 +2,8 @@ name: Wasm Client

 on:
  pull_request:
-    paths:
-      - 'clients/webassembly/**'
-      - 'clients/client-core/**'
-      - 'common/**'
-      - 'contracts/**'
-      - 'gateway/gateway-requests/**'
-      - 'nym-api/nym-api-requests/**'
+    paths-ignore:
+      - 'explorer/**'

 jobs:
  wasm:
@@ -29,6 +24,16 @@ jobs:
          command: build
          args: --manifest-path clients/webassembly/Cargo.toml --target wasm32-unknown-unknown

+      - uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: --manifest-path clients/webassembly/Cargo.toml --target wasm32-unknown-unknown --features=coconut
+
+      - uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --manifest-path clients/webassembly/Cargo.toml
+
      - uses: actions-rs/cargo@v1
        with:
          command: fmt
@@ -38,8 +38,4 @@ validator-config
 validator-api-config.toml
 dist
 storybook-static
-envs/qwerty.env
-Cargo.lock
-nym-connect/Cargo.lock
-.parcel-cache
-**/.DS_Store
+envs/qwerty.env
@@ -1,8 +1,6 @@
 {
-  "mainnet": [
-    {
-      "nyxd_url": "https://rpc.nyx.nodes.guru/",
-      "api_url": "https://api.nyx.nodes.guru/"
-    }
-  ]
-}
+  "mainnet":[{
+    "nymd_url":"https://rpc.nyx.nodes.guru/",
+    "api_url":"https://api.nyx.nodes.guru/"
+  }]
+}
@@ -4,161 +4,26 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://

 ## [Unreleased]

-## [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)
-
 ### Added

- Remove Coconut feature flag ([#2793])
- Separate `nym-api` endpoints with values of "total-supply" and "circulating-supply" in `nym` ([#2964])
+- socks5: send status message for service ready, and network-requester error response

 ### Changed

- 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])
+- all-binaries: improved error logging ([#2686])
+- native client: bring shutdown logic up to the same level as socks5-client
+- nym-api, coconut-dkg contract: automatic, time-based dkg epoch state advancement ([#2670])

-[#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
+[#2686]: https://github.com/nymtech/nym/pull/2686
+[#2670]: https://github.com/nymtech/nym/pull/2670

-## [v1.1.8] (2023-01-31)
-
-### Added
-
- Rust SDK - Support SURBS (anonymous send + storage) ([#2754])
- dkg rerun from scratch and dkg-specific epochs ([#2810])
- Rename `'initial_supply'` field to `'total_supply'` in the circulating supply endpoint ([#2931])
- Circulating supply api endpoint (read the note inside before testing/deploying) ([#1902])
-
-### Changed
-
- nym-api: an `--id` flag is now always explicitly required ([#2873])
-
-[#2754]: https://github.com/nymtech/nym/issues/2754
-[#2810]: https://github.com/nymtech/nym/issues/2810
-[#2931]: https://github.com/nymtech/nym/issues/2931
-[#1902]: https://github.com/nymtech/nym/issues/1902
-[#2873]: https://github.com/nymtech/nym/issues/2873
-
-
-## [v1.1.7] (2023-01-24)
-
-### Added
-
- Gateways now shut down gracefully ([#2019]).
- Rust SDK - Initial version for nym-client ([#2669]).
- Introduce vesting contract query for addresses of all vesting accounts (required for the circulating supply calculation) ([#2778]).
- Add threshold value to the contract storage ([#1893])
-
-### Changed
-
- Refactor vesting account storage (and in particular, ACCOUNTS saving) ([#2795]).
- Move from manual advancing DKG state to an automatic process ([#2670]).
-
-### Fixed
-
- Gateways now shut down gracefully ([#2019]).
-
-[#2019]: https://github.com/nymtech/nym/issues/2019
-[#2669]: https://github.com/nymtech/nym/issues/2669
-[#2795]: https://github.com/nymtech/nym/issues/2795
-[#2778]: https://github.com/nymtech/nym/issues/2778
-[#2670]: https://github.com/nymtech/nym/issues/2670
-[#1893]: https://github.com/nymtech/nym/issues/1893
-
-## [v1.1.6] (2023-01-17)
-
-### Added
-
- nym-sdk: added initial version of a Rust client sdk
- nym-api: added `/circulating-supply` endpoint ([#2814])
- nym-api: add endpoint listing detailed gateway info by @octol in https://github.com/nymtech/nym/pull/2833
-
-### Changed
-
- streamline override_config functions -> there's a lot of duplicate if statements everywhere ([#2774])
- clean-up nym-api startup arguments/flags to use clap 3 and its macro-derived arguments ([#2772])
- renamed all references to validator_api to nym_api
- renamed all references to nymd to nyxd ([#2696])
- all-binaries: standarised argument names (note: old names should still be accepted) ([#2762]
-
-### Fixed
-
- nym-api: should now correctly use `rewarding.enabled` config flag ([#2753])
-
-[#2696]: https://github.com/nymtech/nym/pull/2696
-[#2753]: https://github.com/nymtech/nym/pull/2753
-[#2762]: https://github.com/nymtech/nym/pull/2762
-[#2814]: https://github.com/nymtech/nym/pull/2814
-[#2772]: https://github.com/nymtech/nym/pull/2772
-[#2774]: https://github.com/nymtech/nym/pull/2774
-
-## [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
-
- all-binaries: improved error logging in https://github.com/nymtech/nym/pull/2686
- native client: bring shutdown logic up to the same level as socks5-client in https://github.com/nymtech/nym/pull/2695
- nym-api, coconut-dkg contract: automatic, time-based dkg epoch state advancement in https://github.com/nymtech/nym/pull/2670
- DKG resharing unit test by @neacsu in https://github.com/nymtech/nym/pull/2668
- Renaming validator-api to nym-api by @futurechimp in https://github.com/nymtech/nym/pull/1863
- Modify wasm specific make targets by @neacsu in https://github.com/nymtech/nym/pull/2693
- client: create websocket handler builder by @octol in https://github.com/nymtech/nym/pull/2700
- Outfox and Lion by @durch in https://github.com/nymtech/nym/pull/2730
- Feature/multi surb transmission lanes by @jstuczyn in https://github.com/nymtech/nym/pull/2723
-
-## [v1.1.4] (2022-12-20)
-
-This release adds multiple Single Use Reply Blocks (SURBs) to allow arbitrarily-sized anonymized replies.
-At the moment this is turned off by default, but available for use by application developers.
-We will need to wait for network-requesters to upgrade to this new release, after which multi-SURB anonymization will become the default setting for the SOCKS proxy clients.
-
-The release also include some additional work for distributed key generation in the Coconut signing authority nodes.
-
-### Changed
-
- Feature/dkg contract threshold by @neacsu in https://github.com/nymtech/nym/pull/1885
- Multi-surbs by @jstuczyn in https://github.com/nymtech/nym/pull/2667
- Fix multi-surb backwards compatibility in pre 1.1.4 client config files by @jstuczyn in https://github.com/nymtech/nym/pull/2703
- fix: ignore corrupted surb storage and instead create fresh one by @jstuczyn in https://github.com/nymtech/nym/pull/2711
- socks5: rework waiting in inbound.rs by @octol in https://github.com/nymtech/nym/pull/1880

 ## [v1.1.3] (2022-12-13)

 ### Changed

 - validator-api: can recover from shutdown during DKG process ([#1872])
- clients: deduplicate gateway initialization, part of work towards a rust-sdk
+- clients: deduplicate gateway inititialization, part of work towards a rust-sdk
 - clients: keep all transmission lanes going at all times by making priority probabilistic
 - clients: ability to use multi-reply SURBs to send arbitrarily long messages fully anonymously whilst requesting additional reply blocks whenever they're about to run out ([#1796], [#1801], [#1804], [#1835], [#1858], [#1883]))

@@ -166,7 +31,7 @@ The release also include some additional work for distributed key generation in

 - network-requester: fix bug where websocket connection disconnect resulted in success error code
 - clients: fix a few panics handling the gateway-client
- mixnode, gateway, validator-api: Use mainnet values as defaults for URLs and mixnet contract ([#1884])
+- mixnode, gateway, validator-api: Use mainnet values as defaults for URLs and mixnet contract  ([#1884])
 - socks5: fixed bug where connections sometimes where closed too early
 - clients: improve message logging when received message fails to get reconstructed ([#1803])

@@ -186,7 +51,7 @@ The release also include some additional work for distributed key generation in

 - gateway: Renamed flag from `enabled/disabled_credentials_mode` to `only-coconut-credentials`
 - "Family" feature for node families + layers
- Initial coconut functionality including credentials and distributed key generation
+- Initial coconut functionality including credentials and distributed key generation 

 ## [v1.1.1](https://github.com/nymtech/nym/tree/v1.1.1) (2022-11-29)

@@ -222,6 +87,7 @@ The release also include some additional work for distributed key generation in
 [#1786]: https://github.com/nymtech/nym/pull/1786
 [#1805]: https://github.com/nymtech/nym/pull/1805

+
 ## [v1.1.0](https://github.com/nymtech/nym/tree/v1.1.0) (2022-11-09)

 ### Added
@@ -233,7 +99,7 @@ The release also include some additional work for distributed key generation in
 - native-client/socks5-client/wasm-client: `use_extended_packet_size` Debug config option to make the client use 'ExtendedPacketSize' for its traffic (32kB as opposed to 2kB in 1.0.2) ([#1671])
 - network-requester: added additional Blockstream Green wallet endpoint to `example.allowed.list` ([#1611])
 - validator-api: add `interval_operating_cost` and `profit_margin_percent` to compute reward estimation endpoint
- validator-client: added `query_contract_smart` and `query_contract_raw` on `NyxdClient` ([#1558])
+- validator-client: added `query_contract_smart` and `query_contract_raw` on `NymdClient` ([#1558])
 - wasm-client: uses updated wasm-compatible `client-core` so that it's now capable of packet retransmission, cover traffic and poisson delay (among other things!) ([#1673])

 ### Fixed
@@ -248,7 +114,7 @@ The release also include some additional work for distributed key generation in
 - gateway-client: will attempt to read now as many as 8 websocket messages at once, assuming they're already available on the socket ([#1669])
 - moved `Percent` struct to `contracts-common`, change affects explorer-api
 - socks5 client: graceful shutdown should fix error on disconnect in nym-connect ([#1591])
- validator-api: changed error serialization on `inclusion_probability`, `stake-saturation` and `reward-estimation` endpoints to provide more accurate information ([#1681])
+- validator-api: changed error serialization on `inclusion_probability`, `stake-saturation` and `reward-estimation` endpoints to provide more accurate information ([#1681]) 
 - validator-client: made `fee` argument optional for `execute` and `execute_multiple` ([#1541])
 - wasm-client: fixed build errors on MacOS and changed example JS code to use mainnet ([#1585])
 - validator-api: changes to internal SQL schema due to the mixnet contract revamp ([#1472])
@@ -276,6 +142,7 @@ The release also include some additional work for distributed key generation in
 [#1724]: https://github.com/nymtech/nym/pull/1724
 [#1725]: https://github.com/nymtech/nym/pull/1725

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

 ### Added
@@ -328,8 +195,9 @@ The release also include some additional work for distributed key generation in
 - All binaries and cosmwasm blobs are configured at runtime now; binaries are configured using environment variables or .env files and contracts keep the configuration parameters in storage ([#1463])
 - gateway, network-statistics: include gateway id in the sent statistical data ([#1478])
 - network explorer: tweak how active set probability is shown ([#1503])
- validator-api: rewarder set update fails without panicking on possible nyxd queries ([#1520])
- network-requester, socks5 client (nym-connect): send and receive respectively a message error to be displayed about filter check failure ([#1576])
+- validator-api: rewarder set update fails without panicking on possible nymd queries ([#1520])
+- network-requester, socks5 client (nym-connect): send and receive respectively a message error to be displayed about filter check failure ([#1576]) 
+

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

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

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

 **Implemented enhancements:**

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

 **Fixed bugs:**

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

 **Closed issues:**
@@ -525,7 +394,7 @@ The release also include some additional work for distributed key generation in
 - help!!! [\#712](https://github.com/nymtech/nym/issues/712)
 - UX feature request: show all delegated nodes in wallet [\#711](https://github.com/nymtech/nym/issues/711)
 - UX feature request: add current balance on wallet pages [\#710](https://github.com/nymtech/nym/issues/710)
- got sign issue from bot [\#709](https://github.com/nymtech/nym/issues/709)
+- got sign issue from bot  [\#709](https://github.com/nymtech/nym/issues/709)
 - As a wallet user, I would like to be able to log out of the wallet [\#706](https://github.com/nymtech/nym/issues/706)
 - As a wallet user, I would like to have a "receive" page where I can see my own wallet address [\#705](https://github.com/nymtech/nym/issues/705)
 - Update native client/socks client/mixnode/gateway `upgrade` command [\#689](https://github.com/nymtech/nym/issues/689)
@@ -535,7 +404,7 @@ The release also include some additional work for distributed key generation in
 - nym-socks5-client crash after opening Keybase team "Browse all channels" [\#494](https://github.com/nymtech/nym/issues/494)
 - Mixed Content problem [\#400](https://github.com/nymtech/nym/issues/400)
 - Gateway disk quota [\#137](https://github.com/nymtech/nym/issues/137)
- Simplify message encapsulation with regards to topology [\#127](https://github.com/nymtech/nym/issues/127)
+- Simplify message encapsulation with regards to topology  [\#127](https://github.com/nymtech/nym/issues/127)
 - Create constants for cli argument names [\#115](https://github.com/nymtech/nym/issues/115)
 - Using Blake3 as a hash function [\#103](https://github.com/nymtech/nym/issues/103)
 - Validator should decide which layer a node is in [\#86](https://github.com/nymtech/nym/issues/86)
@@ -591,10 +460,10 @@ The release also include some additional work for distributed key generation in
 - Feature/pre cosmrs updates [\#935](https://github.com/nymtech/nym/pull/935) ([jstuczyn](https://github.com/jstuczyn))
 - Feature/client on behalf [\#934](https://github.com/nymtech/nym/pull/934) ([neacsu](https://github.com/neacsu))
 - Webpack wallet prod configuration [\#933](https://github.com/nymtech/nym/pull/933) ([tommyv1987](https://github.com/tommyv1987))
- Adding tx_hash to wallet response [\#932](https://github.com/nymtech/nym/pull/932) ([futurechimp](https://github.com/futurechimp))
+- Adding tx\_hash to wallet response [\#932](https://github.com/nymtech/nym/pull/932) ([futurechimp](https://github.com/futurechimp))
 - Release/1.0.0 pre1 [\#931](https://github.com/nymtech/nym/pull/931) ([durch](https://github.com/durch))
 - Feature/identity verification [\#930](https://github.com/nymtech/nym/pull/930) ([jstuczyn](https://github.com/jstuczyn))
- Move cleaned up smart contracts to main code repo [\#929](https://github.com/nymtech/nym/pull/929) ([mfahampshire](https://github.com/mfahampshire))
+- Move cleaned up smart contracts to main code repo  [\#929](https://github.com/nymtech/nym/pull/929) ([mfahampshire](https://github.com/mfahampshire))
 - Feature/mixnet contract further adjustments [\#928](https://github.com/nymtech/nym/pull/928) ([jstuczyn](https://github.com/jstuczyn))
 - typo copy change for nodemap [\#926](https://github.com/nymtech/nym/pull/926) ([Aid19801](https://github.com/Aid19801))
 - Feature/UI enhancements for Desktop Wallet [\#925](https://github.com/nymtech/nym/pull/925) ([fmtabbara](https://github.com/fmtabbara))
@@ -607,7 +476,7 @@ The release also include some additional work for distributed key generation in
 - Feature/faucet page react [\#911](https://github.com/nymtech/nym/pull/911) ([fmtabbara](https://github.com/fmtabbara))
 - Feature/mixnet contract refactor [\#910](https://github.com/nymtech/nym/pull/910) ([futurechimp](https://github.com/futurechimp))
 - Update README.md [\#905](https://github.com/nymtech/nym/pull/905) ([tommyv1987](https://github.com/tommyv1987))
- BUG: Bond cell denom [\#904](https://github.com/nymtech/nym/pull/904) ([Aid19801](https://github.com/Aid19801))
+- BUG: Bond cell denom  [\#904](https://github.com/nymtech/nym/pull/904) ([Aid19801](https://github.com/Aid19801))
 - Explorer UI tests missing data-testid [\#903](https://github.com/nymtech/nym/pull/903) ([tommyv1987](https://github.com/tommyv1987))
 - Fix up Nym-Wallet README.md [\#899](https://github.com/nymtech/nym/pull/899) ([tommyv1987](https://github.com/tommyv1987))
 - Feature/batch delegator rewarding [\#898](https://github.com/nymtech/nym/pull/898) ([jstuczyn](https://github.com/jstuczyn))
@@ -625,7 +494,7 @@ The release also include some additional work for distributed key generation in
 - Reverted gateway registration handshake to its 0.11.0 version [\#882](https://github.com/nymtech/nym/pull/882) ([jstuczyn](https://github.com/jstuczyn))
 - Network Explorer [\#881](https://github.com/nymtech/nym/pull/881) ([mmsinclair](https://github.com/mmsinclair))
 - Feature/rewarding interval updates [\#880](https://github.com/nymtech/nym/pull/880) ([jstuczyn](https://github.com/jstuczyn))
- Put client_address and id in the correct order [\#875](https://github.com/nymtech/nym/pull/875) ([neacsu](https://github.com/neacsu))
+- Put client\_address and id in the correct order [\#875](https://github.com/nymtech/nym/pull/875) ([neacsu](https://github.com/neacsu))
 - remove gateway selection on delegation and undelegation pages [\#873](https://github.com/nymtech/nym/pull/873) ([fmtabbara](https://github.com/fmtabbara))
 - Set MSRV on all binaries to 1.56 [\#872](https://github.com/nymtech/nym/pull/872) ([jstuczyn](https://github.com/jstuczyn))
 - add native window items \(copy/paste\) via tauri [\#871](https://github.com/nymtech/nym/pull/871) ([fmtabbara](https://github.com/fmtabbara))
@@ -641,7 +510,7 @@ The release also include some additional work for distributed key generation in
 - Overflow checks in release [\#846](https://github.com/nymtech/nym/pull/846) ([jstuczyn](https://github.com/jstuczyn))
 - fix delegate success overflow [\#842](https://github.com/nymtech/nym/pull/842) ([fmtabbara](https://github.com/fmtabbara))
 - Feature NYM wallet webdriverio test [\#841](https://github.com/nymtech/nym/pull/841) ([tommyv1987](https://github.com/tommyv1987))
- Update nym_wallet.yml [\#840](https://github.com/nymtech/nym/pull/840) ([tommyv1987](https://github.com/tommyv1987))
+- Update nym\_wallet.yml [\#840](https://github.com/nymtech/nym/pull/840) ([tommyv1987](https://github.com/tommyv1987))
 - Feature/vouchers [\#837](https://github.com/nymtech/nym/pull/837) ([aniampio](https://github.com/aniampio))
 - Apply readable ids to elements on Nym Wallet [\#836](https://github.com/nymtech/nym/pull/836) ([tommyv1987](https://github.com/tommyv1987))
 - Feature/removal of monitor good nodes [\#833](https://github.com/nymtech/nym/pull/833) ([jstuczyn](https://github.com/jstuczyn))
@@ -665,8 +534,8 @@ The release also include some additional work for distributed key generation in
 - Created getters for AccountData [\#787](https://github.com/nymtech/nym/pull/787) ([jstuczyn](https://github.com/jstuczyn))
 - Feature/migrate hidden delegations [\#786](https://github.com/nymtech/nym/pull/786) ([neacsu](https://github.com/neacsu))
 - Feature/persistent gateway storage [\#784](https://github.com/nymtech/nym/pull/784) ([jstuczyn](https://github.com/jstuczyn))
- Replaced unwrap_or_else with unwrap_or_default [\#780](https://github.com/nymtech/nym/pull/780) ([jstuczyn](https://github.com/jstuczyn))
- Add block_height method to Delegation [\#778](https://github.com/nymtech/nym/pull/778) ([durch](https://github.com/durch))
+- Replaced unwrap\_or\_else with unwrap\_or\_default [\#780](https://github.com/nymtech/nym/pull/780) ([jstuczyn](https://github.com/jstuczyn))
+- Add block\_height method to Delegation [\#778](https://github.com/nymtech/nym/pull/778) ([durch](https://github.com/durch))
 - Make fee helpers public [\#777](https://github.com/nymtech/nym/pull/777) ([durch](https://github.com/durch))
 - re-enable bonding [\#776](https://github.com/nymtech/nym/pull/776) ([fmtabbara](https://github.com/fmtabbara))
 - Explorer-api: add API resource to show the delegations for each mix node [\#774](https://github.com/nymtech/nym/pull/774) ([mmsinclair](https://github.com/mmsinclair))
@@ -675,14 +544,14 @@ The release also include some additional work for distributed key generation in
 - Adding deps for building the Tauri wallet under Ubuntu [\#770](https://github.com/nymtech/nym/pull/770) ([futurechimp](https://github.com/futurechimp))
 - remove alert [\#767](https://github.com/nymtech/nym/pull/767) ([fmtabbara](https://github.com/fmtabbara))
 - Feature/consumable bandwidth [\#766](https://github.com/nymtech/nym/pull/766) ([neacsu](https://github.com/neacsu))
- Update coconut-rs and use hash_to_scalar from there [\#765](https://github.com/nymtech/nym/pull/765) ([neacsu](https://github.com/neacsu))
+- Update coconut-rs and use hash\_to\_scalar from there [\#765](https://github.com/nymtech/nym/pull/765) ([neacsu](https://github.com/neacsu))
 - Feature/active sets [\#764](https://github.com/nymtech/nym/pull/764) ([jstuczyn](https://github.com/jstuczyn))
 - add app alert banner [\#762](https://github.com/nymtech/nym/pull/762) ([fmtabbara](https://github.com/fmtabbara))
 - Updated cosmos-sdk [\#761](https://github.com/nymtech/nym/pull/761) ([jstuczyn](https://github.com/jstuczyn))
 - Feature/bond blockstamp [\#760](https://github.com/nymtech/nym/pull/760) ([neacsu](https://github.com/neacsu))
 - Feature/revert migration code [\#759](https://github.com/nymtech/nym/pull/759) ([neacsu](https://github.com/neacsu))
 - Bump next from 11.1.0 to 11.1.1 in /wallet-web [\#758](https://github.com/nymtech/nym/pull/758) ([dependabot[bot]](https://github.com/apps/dependabot))
- Add block_height in the Delegation structure as well [\#757](https://github.com/nymtech/nym/pull/757) ([neacsu](https://github.com/neacsu))
+- Add block\_height in the Delegation structure as well [\#757](https://github.com/nymtech/nym/pull/757) ([neacsu](https://github.com/neacsu))
 - Feature/add blockstamp [\#756](https://github.com/nymtech/nym/pull/756) ([neacsu](https://github.com/neacsu))
 - NetworkMonitorBuilder - starting the monitor after rocket has launched [\#754](https://github.com/nymtech/nym/pull/754) ([jstuczyn](https://github.com/jstuczyn))
 - Enabled validators api argument [\#753](https://github.com/nymtech/nym/pull/753) ([jstuczyn](https://github.com/jstuczyn))
@@ -694,21 +563,21 @@ The release also include some additional work for distributed key generation in
 - Feature/more reliable uptime calculation [\#747](https://github.com/nymtech/nym/pull/747) ([jstuczyn](https://github.com/jstuczyn))
 - Update template toml key [\#746](https://github.com/nymtech/nym/pull/746) ([neacsu](https://github.com/neacsu))
 - Feature/cred after handshake [\#745](https://github.com/nymtech/nym/pull/745) ([neacsu](https://github.com/neacsu))
- Reinstate the POST method blind_sign [\#744](https://github.com/nymtech/nym/pull/744) ([neacsu](https://github.com/neacsu))
+- Reinstate the POST method blind\_sign [\#744](https://github.com/nymtech/nym/pull/744) ([neacsu](https://github.com/neacsu))
 - explorer-api: add pending field to port check response [\#742](https://github.com/nymtech/nym/pull/742) ([mmsinclair](https://github.com/mmsinclair))
 - Feature/use delegation rates [\#741](https://github.com/nymtech/nym/pull/741) ([neacsu](https://github.com/neacsu))
 - Feature/copy to clipboard [\#740](https://github.com/nymtech/nym/pull/740) ([fmtabbara](https://github.com/fmtabbara))
 - Feature/update wallet with stake rates [\#739](https://github.com/nymtech/nym/pull/739) ([neacsu](https://github.com/neacsu))
 - Add stake reward rates and bump version of client [\#738](https://github.com/nymtech/nym/pull/738) ([neacsu](https://github.com/neacsu))
 - Bump next from 10.1.3 to 11.1.0 in /wallet-web [\#737](https://github.com/nymtech/nym/pull/737) ([dependabot[bot]](https://github.com/apps/dependabot))
- Feature/nyxd client integration [\#736](https://github.com/nymtech/nym/pull/736) ([jstuczyn](https://github.com/jstuczyn))
+- Feature/nymd client integration [\#736](https://github.com/nymtech/nym/pull/736) ([jstuczyn](https://github.com/jstuczyn))
 - Bug/fix parking lot on wasm [\#735](https://github.com/nymtech/nym/pull/735) ([neacsu](https://github.com/neacsu))
 - Explorer API: add new HTTP resource to decorate mix nodes with geoip locations [\#734](https://github.com/nymtech/nym/pull/734) ([mmsinclair](https://github.com/mmsinclair))
- Feature/completing nyxd client api [\#732](https://github.com/nymtech/nym/pull/732) ([jstuczyn](https://github.com/jstuczyn))
+- Feature/completing nymd client api [\#732](https://github.com/nymtech/nym/pull/732) ([jstuczyn](https://github.com/jstuczyn))
 - Explorer API - add port check and node description/stats proxy [\#731](https://github.com/nymtech/nym/pull/731) ([mmsinclair](https://github.com/mmsinclair))
- Feature/nyxd client fee handling [\#730](https://github.com/nymtech/nym/pull/730) ([jstuczyn](https://github.com/jstuczyn))
+- Feature/nymd client fee handling [\#730](https://github.com/nymtech/nym/pull/730) ([jstuczyn](https://github.com/jstuczyn))
 - Update DelegationCheck.tsx [\#725](https://github.com/nymtech/nym/pull/725) ([jessgess](https://github.com/jessgess))
- Rust nyxd/cosmwasm client [\#724](https://github.com/nymtech/nym/pull/724) ([jstuczyn](https://github.com/jstuczyn))
+- Rust nymd/cosmwasm client [\#724](https://github.com/nymtech/nym/pull/724) ([jstuczyn](https://github.com/jstuczyn))
 - Removed wasm feature bypassing cyclic dependencies [\#723](https://github.com/nymtech/nym/pull/723) ([jstuczyn](https://github.com/jstuczyn))
 - Updated used sphinx dependency to the most recent revision [\#722](https://github.com/nymtech/nym/pull/722) ([jstuczyn](https://github.com/jstuczyn))
 - update state management and validation [\#721](https://github.com/nymtech/nym/pull/721) ([fmtabbara](https://github.com/fmtabbara))
@@ -727,8 +596,10 @@ The release also include some additional work for distributed key generation in
 - Bond and delegation alerts [\#698](https://github.com/nymtech/nym/pull/698) ([fmtabbara](https://github.com/fmtabbara))
 - Bugfix/network monitor version check [\#697](https://github.com/nymtech/nym/pull/697) ([jstuczyn](https://github.com/jstuczyn))
 - Feature/other containers [\#692](https://github.com/nymtech/nym/pull/692) ([neacsu](https://github.com/neacsu))
- Using validator API instead of nyxd [\#690](https://github.com/nymtech/nym/pull/690) ([futurechimp](https://github.com/futurechimp))
+- Using validator API instead of nymd [\#690](https://github.com/nymtech/nym/pull/690) ([futurechimp](https://github.com/futurechimp))
 - Hang coconut issuance off the validator-api [\#679](https://github.com/nymtech/nym/pull/679) ([durch](https://github.com/durch))
 - Update hmac and blake3 [\#673](https://github.com/nymtech/nym/pull/673) ([durch](https://github.com/durch))

-\* _This Changelog was automatically generated by [github_changelog_generator](https://github.com/github-changelog-generator/github-changelog-generator)_
+
+
+\* *This Changelog was automatically generated by [github_changelog_generator](https://github.com/github-changelog-generator/github-changelog-generator)*
@@ -23,28 +23,27 @@ members = [
    "clients/native/websocket-requests",
    "clients/socks5",
    "common/bandwidth-claim-contract",
-    "common/bin-common",
    "common/client-libs/gateway-client",
    "common/client-libs/mixnet-client",
    "common/client-libs/validator-client",
+    "common/client-connections",
    "common/coconut-interface",
    "common/commands",
    "common/config",
    "common/cosmwasm-smart-contracts/coconut-bandwidth-contract",
    "common/cosmwasm-smart-contracts/coconut-dkg",
    "common/cosmwasm-smart-contracts/contracts-common",
-    "common/cosmwasm-smart-contracts/group-contract",
    "common/cosmwasm-smart-contracts/mixnet-contract",
    "common/cosmwasm-smart-contracts/multisig-contract",
    "common/cosmwasm-smart-contracts/vesting-contract",
-    "common/mobile-storage",
    "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",
@@ -67,18 +66,16 @@ members = [
    "common/topology",
    "common/types",
    "common/wasm-utils",
+    "common/completions",
    "explorer-api",
    "gateway",
    "gateway/gateway-requests",
    "integrations/bity",
    "mixnode",
-    "sdk/rust/nym-sdk",
-    "service-providers/common",
    "service-providers/network-requester",
    "service-providers/network-statistics",
    "nym-api",
    "nym-api/nym-api-requests",
-    "nym-outfox",
    "tools/nym-cli",
    "tools/ts-rs-cli"
 ]
@@ -94,27 +91,4 @@ default-members = [
    "explorer-api",
 ]

-exclude = ["explorer", "contracts", "clients/webassembly", "nym-wallet", "nym-connect/mobile/src-tauri", "nym-connect/desktop"]
-
-[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.63"
-cfg-if = "1.0.0"
-dotenv = "0.15.0"
-lazy_static = "1.4.0"
-log = "0.4"
-once_cell = "1.7.2"
-rand = "0.8.5"
-serde = "1.0.152"
-serde_json = "1.0.91"
-tap = "1.0.1"
-thiserror = "1.0.38"
-tokio = "1.24.1"
-url = "2.2"
+exclude = ["explorer", "contracts", "clients/webassembly", "nym-wallet", "nym-connect"]
@@ -2,12 +2,12 @@ test: clippy-all cargo-test wasm fmt
 test-all: test cargo-test-expensive
 no-clippy: build cargo-test wasm fmt
 happy: fmt clippy-happy test
-clippy-all: clippy-main clippy-main-examples clippy-all-contracts clippy-all-wallet clippy-all-connect clippy-all-connect-mobile clippy-all-wasm-client
-clippy-happy: clippy-happy-main clippy-happy-contracts clippy-happy-wallet clippy-happy-connect clippy-happy-connect-mobile
-cargo-test: test-main test-contracts test-wallet test-connect test-connect-mobile
-cargo-test-expensive: test-main-expensive test-contracts-expensive test-wallet-expensive test-connect-expensive
-build: build-contracts build-wallet build-main build-main-examples build-connect build-connect-mobile build-wasm-client
-fmt: fmt-main fmt-contracts fmt-wallet fmt-connect fmt-connect-mobile fmt-wasm-client
+clippy-all: clippy-main clippy-coconut 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 test-coconut test-wasm-client
+cargo-test-expensive: test-main-expensive test-contracts-expensive test-wallet-expensive test-connect-expensive test-coconut-expensive
+build: build-contracts build-wallet build-main build-connect build-wasm-client
+fmt: fmt-main fmt-contracts fmt-wallet fmt-connect fmt-wasm-client

 clippy-happy-main:
 	cargo clippy
@@ -19,16 +19,13 @@ clippy-happy-wallet:
 	cargo clippy --manifest-path nym-wallet/Cargo.toml

 clippy-happy-connect:
-	cargo clippy --manifest-path nym-connect/desktop/Cargo.toml
-
-clippy-happy-connect-mobile:
-	cargo clippy --manifest-path nym-connect/mobile/src-tauri/Cargo.toml
+	cargo clippy --manifest-path nym-connect/Cargo.toml

 clippy-main:
 	cargo clippy --workspace -- -D warnings

-clippy-main-examples:
-	cargo clippy --workspace --examples -- -D warnings
+clippy-coconut:
+	cargo clippy --workspace --features coconut -- -D warnings

 clippy-wasm:
 	cargo clippy --manifest-path clients/webassembly/Cargo.toml --target wasm32-unknown-unknown --workspace -- -D warnings
@@ -41,10 +38,7 @@ clippy-all-wallet:
 	cargo clippy --workspace --manifest-path nym-wallet/Cargo.toml --all-features -- -D warnings

 clippy-all-connect:
-	cargo clippy --workspace --manifest-path nym-connect/desktop/Cargo.toml --all-features -- -D warnings
-
-clippy-all-connect-mobile:
-	cargo clippy --workspace --manifest-path nym-connect/mobile/src-tauri/Cargo.toml --all-features -- -D warnings
+	cargo clippy --workspace --manifest-path nym-connect/Cargo.toml --all-features -- -D warnings

 clippy-all-wasm-client:
 	cargo clippy --workspace --manifest-path clients/webassembly/Cargo.toml --all-features --target wasm32-unknown-unknown -- -D warnings
@@ -52,9 +46,16 @@ clippy-all-wasm-client:
 test-main:
 	cargo test --workspace

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

+test-coconut-expensive:
+	cargo test --workspace --features coconut -- --ignored
+
 test-contracts:
 	cargo test --manifest-path contracts/Cargo.toml --all-features

@@ -67,24 +68,18 @@ test-wallet:
 test-wallet-expensive:
 	cargo test --manifest-path nym-wallet/Cargo.toml --all-features -- --ignored

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

 test-connect-expensive:
-	cargo test --manifest-path nym-connect/desktop/Cargo.toml --all-features -- --ignored
-
-test-connect-mobile:
-	cargo test --manifest-path nym-connect/mobile/src-tauri/Cargo.toml --all-features
-
-test-connect-mobile-expensive:
-	cargo test --manifest-path nym-connect/mobile/src-tauri/Cargo.toml --all-features -- --ignored
+	cargo test --manifest-path nym-connect/Cargo.toml --all-features -- --ignored

 build-main:
 	cargo build --workspace

-build-main-examples:
-	cargo build --workspace --examples
-
 build-contracts:
 	cargo build --manifest-path contracts/Cargo.toml --workspace

@@ -92,10 +87,7 @@ build-wallet:
 	cargo build --manifest-path nym-wallet/Cargo.toml --workspace

 build-connect:
-	cargo build --manifest-path nym-connect/desktop/Cargo.toml --workspace
-
-build-connect-mobile:
-	cargo build --manifest-path nym-connect/mobile/src-tauri/Cargo.toml --workspace
+	cargo build --manifest-path nym-connect/Cargo.toml --workspace

 build-explorer-api:
 	cargo build --manifest-path explorer-api/Cargo.toml --workspace
@@ -116,10 +108,7 @@ fmt-wallet:
 	cargo fmt --manifest-path nym-wallet/Cargo.toml --all

 fmt-connect:
-	cargo fmt --manifest-path nym-connect/desktop/Cargo.toml --all
-
-fmt-connect-mobile:
-	cargo fmt --manifest-path nym-connect/mobile/src-tauri/Cargo.toml --all
+	cargo fmt --manifest-path nym-connect/Cargo.toml --all

 fmt-wasm-client:
 	cargo fmt --manifest-path clients/webassembly/Cargo.toml --all
@@ -133,6 +122,3 @@ mixnet-opt: wasm
 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
@@ -1,9 +1,8 @@
 [package]
 name = "client-core"
-version = "1.1.10"
+version = "1.1.3"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
 edition = "2021"
-rust-version = "1.66"

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

@@ -13,35 +12,36 @@ dirs = "4.0"
 dashmap = "5.4.0"
 futures = "0.3"
 humantime-serde = "1.0"
-log = { workspace = true }
+log = "0.4"
 rand = { version = "0.7.3", features = ["wasm-bindgen"] }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0.89"
 tap = "1.0.1"
 thiserror = "1.0.34"
 url = { version ="2.2", features = ["serde"] }
-tokio = { version = "1.24.1", features = ["macros"]}
+tokio = { version = "1.21.2", 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" }
+task = { path = "../../common/task" }

 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio-stream]
-version = "0.1.11"
+version = "0.1.9"
 features = ["time"]

 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio]
-version = "1.24.1"
+version = "1.21.2"
 features = ["time"]

 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.sqlx]
@@ -74,11 +74,12 @@ features = ["wasm-bindgen"]
 tempfile = "3.1.0"

 [build-dependencies]
-tokio = { version = "1.24.1", features = ["rt-multi-thread", "macros"] }
+tokio = { version = "1.21.2", features = ["rt-multi-thread", "macros"] }
 sqlx = { version = "0.6.2", features = ["runtime-tokio-rustls", "sqlite", "macros", "migrate"] }

 [features]
 default = []
 fs-surb-storage = ["sqlx"]
 wasm = ["gateway-client/wasm"]
+coconut = ["gateway-client/coconut", "gateway-requests/coconut"]

@@ -9,9 +9,9 @@ async fn main() {
        use std::env;

        let out_dir = env::var("OUT_DIR").unwrap();
-        let database_path = format!("{out_dir}/fs-surbs-example.sqlite");
+        let database_path = format!("{}/fs-surbs-example.sqlite", out_dir);

-        let mut conn = SqliteConnection::connect(&format!("sqlite://{database_path}?mode=rwc"))
+        let mut conn = SqliteConnection::connect(&format!("sqlite://{}?mode=rwc", database_path))
            .await
            .expect("Failed to create SQLx database connection");

@@ -1,11 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-//
-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.minimum_reply_surb_storage_threshold,
-        max_surb_threshold: debug_config.maximum_reply_surb_storage_threshold,
-    }
-}
@@ -21,75 +21,35 @@ use crate::client::topology_control::{
 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")]
-use gateway_client::wasm_mockups::CosmWasmClient;
 use gateway_client::{
    AcknowledgementReceiver, AcknowledgementSender, GatewayClient, MixnetMessageReceiver,
    MixnetMessageSender,
 };
 use log::{debug, info};
-use nym_crypto::asymmetric::{encryption, identity};
-use nym_sphinx::acknowledgements::AckKey;
-use nym_sphinx::addressing::clients::Recipient;
-use nym_sphinx::addressing::nodes::NodeIdentity;
-use nym_sphinx::receiver::ReconstructedMessage;
-use nym_task::connections::{ConnectionCommandReceiver, ConnectionCommandSender, LaneQueueLengths};
-use nym_task::{TaskClient, TaskManager};
+use nymsphinx::acknowledgements::AckKey;
+use nymsphinx::addressing::clients::Recipient;
+use nymsphinx::addressing::nodes::NodeIdentity;
 use std::sync::Arc;
 use std::time::Duration;
 use tap::TapFallible;
+use task::{TaskClient, TaskManager};
 use url::Url;
-#[cfg(not(target_arch = "wasm32"))]
-use validator_client::nyxd::CosmWasmClient;
-
-use super::received_buffer::ReceivedBufferMessage;

 #[cfg(all(not(target_arch = "wasm32"), feature = "fs-surb-storage"))]
 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,
-}
-
-impl ClientOutput {
-    pub fn register_receiver(
-        &mut self,
-    ) -> Result<mpsc::UnboundedReceiver<Vec<ReconstructedMessage>>, ClientCoreError> {
-        let (reconstructed_sender, reconstructed_receiver) = mpsc::unbounded();
-
-        self.received_buffer_request_sender
-            .unbounded_send(ReceivedBufferMessage::ReceiverAnnounce(
-                reconstructed_sender,
-            ))
-            .map_err(|_| ClientCoreError::FailedToRegisterReceiver)?;
-
-        Ok(reconstructed_receiver)
-    }
-}
-
-pub struct ClientState {
    pub shared_lane_queue_lengths: LaneQueueLengths,
-    pub reply_controller_sender: ReplyControllerSender,
+    pub received_buffer_request_sender: ReceivedBufferRequestSender,
 }

 pub enum ClientInputStatus {
@@ -120,33 +80,7 @@ impl ClientOutputStatus {
    }
 }

-#[derive(Copy, Clone, PartialEq, Eq)]
-pub enum CredentialsToggle {
-    Enabled,
-    Disabled,
-}
-
-impl CredentialsToggle {
-    pub fn is_enabled(&self) -> bool {
-        self == &CredentialsToggle::Enabled
-    }
-
-    pub fn is_disabled(&self) -> bool {
-        self == &CredentialsToggle::Disabled
-    }
-}
-
-impl From<bool> for CredentialsToggle {
-    fn from(value: bool) -> Self {
-        if value {
-            CredentialsToggle::Enabled
-        } else {
-            CredentialsToggle::Disabled
-        }
-    }
-}
-
-pub struct BaseClientBuilder<'a, B, C: Clone> {
+pub struct BaseClientBuilder<'a, B> {
    // due to wasm limitations I had to split it like this : (
    gateway_config: &'a GatewayEndpointConfig,
    debug_config: &'a DebugConfig,
@@ -154,21 +88,20 @@ pub struct BaseClientBuilder<'a, B, C: Clone> {
    nym_api_endpoints: Vec<Url>,
    reply_storage_backend: B,

-    bandwidth_controller: Option<BandwidthController<C>>,
+    bandwidth_controller: Option<BandwidthController>,
    key_manager: KeyManager,
 }

-impl<'a, B, C> BaseClientBuilder<'a, B, C>
+impl<'a, B> BaseClientBuilder<'a, B>
 where
    B: ReplyStorageBackend + Send + Sync + 'static,
-    C: CosmWasmClient + Sync + Send + Clone + 'static,
 {
    pub fn new_from_base_config<T>(
        base_config: &'a Config<T>,
        key_manager: KeyManager,
-        bandwidth_controller: Option<BandwidthController<C>>,
+        bandwidth_controller: Option<BandwidthController>,
        reply_storage_backend: B,
-    ) -> BaseClientBuilder<'a, B, C> {
+    ) -> BaseClientBuilder<'a, B> {
        BaseClientBuilder {
            gateway_config: base_config.get_gateway_endpoint_config(),
            debug_config: base_config.get_debug_config(),
@@ -184,15 +117,15 @@ where
        gateway_config: &'a GatewayEndpointConfig,
        debug_config: &'a DebugConfig,
        key_manager: KeyManager,
-        bandwidth_controller: Option<BandwidthController<C>>,
+        bandwidth_controller: Option<BandwidthController>,
        reply_storage_backend: B,
-        credentials_toggle: CredentialsToggle,
+        disabled_credentials: bool,
        nym_api_endpoints: Vec<Url>,
-    ) -> BaseClientBuilder<'a, B, C> {
+    ) -> BaseClientBuilder<'a, B> {
        BaseClientBuilder {
            gateway_config,
            debug_config,
-            disabled_credentials: credentials_toggle.is_disabled(),
+            disabled_credentials,
            nym_api_endpoints,
            reply_storage_backend,
            bandwidth_controller,
@@ -297,11 +230,15 @@ where
        mixnet_message_sender: MixnetMessageSender,
        ack_sender: AcknowledgementSender,
        shutdown: TaskClient,
-    ) -> Result<GatewayClient<C>, ClientCoreError> {
+    ) -> Result<GatewayClient, ClientCoreError<B>> {
        let gateway_id = self.gateway_config.gateway_id.clone();
        if gateway_id.is_empty() {
            return Err(ClientCoreError::GatewayIdUnknown);
        }
+        let gateway_owner = self.gateway_config.gateway_owner.clone();
+        if gateway_owner.is_empty() {
+            return Err(ClientCoreError::GatewayOwnerUnknown);
+        }
        let gateway_address = self.gateway_config.gateway_listener.clone();
        if gateway_address.is_empty() {
            return Err(ClientCoreError::GatwayAddressUnknown);
@@ -311,10 +248,9 @@ where
            .map_err(ClientCoreError::UnableToCreatePublicKeyFromGatewayId)?;

        // disgusting wasm workaround since there's no key persistence there (nor `client init`)
-        let shared_key = if self.key_manager.is_gateway_key_set() {
+        let shared_key = if self.key_manager.gateway_key_set() {
            Some(self.key_manager.gateway_shared_key())
        } else {
-            log::info!("Gateway key not set! Will proceed anyway.");
            None
        };

@@ -322,6 +258,7 @@ where
            gateway_address,
            self.key_manager.identity_keypair(),
            gateway_identity,
+            gateway_owner,
            shared_key,
            mixnet_message_sender,
            ack_sender,
@@ -348,7 +285,7 @@ where
        refresh_rate: Duration,
        topology_accessor: TopologyAccessor,
        shutdown: TaskClient,
-    ) -> Result<(), ClientCoreError> {
+    ) -> Result<(), ClientCoreError<B>> {
        let topology_refresher_config = TopologyRefresherConfig::new(
            nym_api_urls,
            refresh_rate,
@@ -379,7 +316,7 @@ where
    // over it. Perhaps GatewayClient needs to be thread-shareable or have some channel for
    // requests?
    fn start_mix_traffic_controller(
-        gateway_client: GatewayClient<C>,
+        gateway_client: GatewayClient,
        shutdown: TaskClient,
    ) -> BatchMixMessageSender {
        info!("Starting mix traffic controller...");
@@ -391,42 +328,24 @@ where
    async fn setup_persistent_reply_storage(
        backend: B,
        shutdown: TaskClient,
-    ) -> Result<CombinedReplyStorage, ClientCoreError>
-    where
-        <B as ReplyStorageBackend>::StorageError: Sync + Send,
-    {
-        if backend.is_active() {
-            log::trace!("Setup persistent reply storage");
-            let persistent_storage = PersistentReplyStorage::new(backend);
-            let mem_store = persistent_storage
-                .load_state_from_backend()
+    ) -> Result<CombinedReplyStorage, ClientCoreError<B>> {
+        let persistent_storage = PersistentReplyStorage::new(backend);
+        let mem_store = persistent_storage
+            .load_state_from_backend()
+            .await
+            .map_err(|err| ClientCoreError::SurbStorageError { source: err })?;
+
+        let store_clone = mem_store.clone();
+        spawn_future(async move {
+            persistent_storage
+                .flush_on_shutdown(store_clone, shutdown)
                .await
-                .map_err(|err| ClientCoreError::SurbStorageError {
-                    source: Box::new(err),
-                })?;
+        });

-            let store_clone = mem_store.clone();
-            spawn_future(async move {
-                persistent_storage
-                    .flush_on_shutdown(store_clone, shutdown)
-                    .await
-            });
-
-            Ok(mem_store)
-        } else {
-            log::trace!("Setup inactive reply storage");
-            Ok(backend
-                .get_inactive_storage()
-                .map_err(|err| ClientCoreError::SurbStorageError {
-                    source: Box::new(err),
-                })?)
-        }
+        Ok(mem_store)
    }

-    pub async fn start_base(mut self) -> Result<BaseClient, ClientCoreError>
-    where
-        <B as ReplyStorageBackend>::StorageError: Sync + Send,
-    {
+    pub async fn start_base(mut self) -> Result<BaseClient, ClientCoreError<B>> {
        info!("Starting nym client");
        // channels for inter-component communication
        // TODO: make the channels be internally created by the relevant components
@@ -452,7 +371,7 @@ where

        // channels responsible for dealing with reply-related fun
        let (reply_controller_sender, reply_controller_receiver) =
-            reply_controller::requests::new_control_channels();
+            reply_controller::new_control_channels();

        let self_address = self.as_mix_recipient();

@@ -518,7 +437,7 @@ where
            input_receiver,
            sphinx_message_sender.clone(),
            reply_storage,
-            reply_controller_sender.clone(),
+            reply_controller_sender,
            reply_controller_receiver,
            shared_lane_queue_lengths.clone(),
            client_connection_rx,
@@ -548,13 +467,10 @@ where
            },
            client_output: ClientOutputStatus::AwaitingConsumer {
                client_output: ClientOutput {
+                    shared_lane_queue_lengths,
                    received_buffer_request_sender,
                },
            },
-            client_state: ClientState {
-                shared_lane_queue_lengths,
-                reply_controller_sender,
-            },
            task_manager,
        })
    }
@@ -563,7 +479,6 @@ where
 pub struct BaseClient {
    pub client_input: ClientInputStatus,
    pub client_output: ClientOutputStatus,
-    pub client_state: ClientState,

    pub task_manager: TaskManager,
 }
@@ -14,15 +14,13 @@ use time::OffsetDateTime;
 async fn setup_fresh_backend<P: AsRef<Path>>(
    db_path: P,
    debug_config: &DebugConfig,
-) -> Result<fs_backend::Backend, ClientCoreError> {
+) -> Result<fs_backend::Backend, ClientCoreError<fs_backend::Backend>> {
    info!("creating fresh surb database");
    let mut storage_backend = match fs_backend::Backend::init(db_path).await {
        Ok(backend) => backend,
        Err(err) => {
            error!("failed to setup persistent storage backend for our reply needs: {err}");
-            return Err(ClientCoreError::SurbStorageError {
-                source: Box::new(err),
-            });
+            return Err(ClientCoreError::SurbStorageError { source: err });
        }
    };

@@ -36,21 +34,11 @@ async fn setup_fresh_backend<P: AsRef<Path>>(
    storage_backend
        .init_fresh(&mem_store)
        .await
-        .map_err(|err| ClientCoreError::SurbStorageError {
-            source: Box::new(err),
-        })?;
+        .map_err(|err| ClientCoreError::SurbStorageError { source: err })?;

    Ok(storage_backend)
 }

-fn setup_inactive_backend(debug_config: &DebugConfig) -> fs_backend::Backend {
-    info!("creating inactive surb database");
-    fs_backend::Backend::new_inactive(
-        debug_config.minimum_reply_surb_storage_threshold,
-        debug_config.maximum_reply_surb_storage_threshold,
-    )
-}
-
 fn archive_corrupted_database<P: AsRef<Path>>(db_path: P) -> io::Result<()> {
    let db_path = db_path.as_ref();
    debug_assert!(db_path.exists());
@@ -61,7 +49,7 @@ fn archive_corrupted_database<P: AsRef<Path>>(db_path: P) -> io::Result<()> {

    let new_extension =
        if let Some(existing_extension) = db_path.extension().and_then(|ext| ext.to_str()) {
-            format!("{existing_extension}.{suffix}")
+            format!("{existing_extension}.{}", suffix)
        } else {
            suffix
        };
@@ -73,28 +61,23 @@ fn archive_corrupted_database<P: AsRef<Path>>(db_path: P) -> io::Result<()> {
 }

 pub async fn setup_fs_reply_surb_backend<P: AsRef<Path>>(
-    db_path: Option<P>,
+    db_path: P,
    debug_config: &DebugConfig,
-) -> Result<fs_backend::Backend, ClientCoreError> {
-    if let Some(db_path) = db_path {
-        // if the database file doesnt exist, initialise fresh storage, otherwise attempt to load
-        // the existing one
-        let db_path = db_path.as_ref();
-        if db_path.exists() {
-            info!("loading existing surb database");
-            match fs_backend::Backend::try_load(db_path).await {
-                Ok(backend) => Ok(backend),
-                Err(err) => {
-                    error!("failed to setup persistent storage backend for our reply needs: {err}. We're going to create a fresh database instead. This behaviour might change in the future");
+) -> Result<fs_backend::Backend, ClientCoreError<fs_backend::Backend>> {
+    // if the database file doesnt exist, initialise fresh storage, otherwise attempt to load the existing one
+    let db_path = db_path.as_ref();
+    if db_path.exists() {
+        info!("loading existing surb database");
+        match fs_backend::Backend::try_load(db_path).await {
+            Ok(backend) => Ok(backend),
+            Err(err) => {
+                error!("failed to setup persistent storage backend for our reply needs: {err}. We're going to create a fresh database instead. This behaviour might change in the future");

-                    archive_corrupted_database(db_path)?;
-                    setup_fresh_backend(db_path, debug_config).await
-                }
+                archive_corrupted_database(db_path)?;
+                setup_fresh_backend(db_path, debug_config).await
            }
-        } else {
-            setup_fresh_backend(db_path, debug_config).await
        }
    } else {
-        Ok(setup_inactive_backend(debug_config))
+        setup_fresh_backend(db_path, debug_config).await
    }
 }
@@ -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,14 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-#[cfg(not(target_arch = "wasm32"))]
-mod non_wasm;
-
-#[cfg(target_arch = "wasm32")]
-mod wasm;
-
-#[cfg(not(target_arch = "wasm32"))]
-pub use non_wasm::*;
-
-#[cfg(target_arch = "wasm32")]
-pub use wasm::*;
@@ -1,13 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-pub use tokio::time::*;
-pub type IntervalStream = tokio_stream::wrappers::IntervalStream;
-
-pub(crate) fn get_time_now() -> Instant {
-    Instant::now()
-}
-
-pub(crate) fn new_interval_stream(polling_rate: Duration) -> IntervalStream {
-    tokio_stream::wrappers::IntervalStream::new(tokio::time::interval(polling_rate))
-}
@@ -1,16 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use std::time::Duration;
-use wasm_timer;
-
-pub use wasm_timer::*;
-pub type IntervalStream = gloo_timers::future::IntervalStream;
-
-pub(crate) fn get_time_now() -> Instant {
-    wasm_timer::Instant::now()
-}
-
-pub(crate) fn new_interval_stream(polling_rate: Duration) -> IntervalStream {
-    gloo_timers::future::IntervalStream::new(polling_rate.as_millis() as u32)
-}
@@ -1,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;
@@ -17,7 +17,6 @@ use std::sync::Arc;
 // use the old key after new one was issued.

 // Remember that Arc<T> has Deref implementation for T
-#[derive(Clone)]
 pub struct KeyManager {
    /// identity key associated with the client instance.
    identity_keypair: Arc<identity::KeyPair>,
@@ -42,6 +41,9 @@ pub struct KeyManager {
 */

 impl KeyManager {
+    // this is actually **NOT** dead code
+    // I have absolutely no idea why the compiler insists it's unused. The call happens during client::init::execute
+    #[allow(dead_code)]
    /// Creates new instance of a [`KeyManager`]
    pub fn new<R>(rng: &mut R) -> Self
    where
@@ -55,161 +57,87 @@ impl KeyManager {
        }
    }

-    pub fn from_keys(
-        id_keypair: identity::KeyPair,
-        enc_keypair: encryption::KeyPair,
-        gateway_shared_key: SharedKeys,
-        ack_key: AckKey,
-    ) -> Self {
-        Self {
-            identity_keypair: Arc::new(id_keypair),
-            encryption_keypair: Arc::new(enc_keypair),
-            gateway_shared_key: Some(Arc::new(gateway_shared_key)),
-            ack_key: Arc::new(ack_key),
-        }
+    // this is actually **NOT** dead code
+    // I have absolutely no idea why the compiler insists it's unused. The call happens during client::init::execute
+    #[allow(dead_code)]
+    /// After shared key with the gateway is derived, puts its ownership to this instance of a [`KeyManager`].
+    pub fn insert_gateway_shared_key(&mut self, gateway_shared_key: Arc<SharedKeys>) {
+        self.gateway_shared_key = Some(gateway_shared_key)
    }

-    /// Loads previously stored client keys from the disk.
-    fn load_client_keys(client_pathfinder: &ClientKeyPathfinder) -> io::Result<Self> {
+    /// Loads previously stored keys from the disk.
+    pub fn load_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 gateway_shared_key: SharedKeys =
+            pemstore::load_key(client_pathfinder.gateway_shared_key())?;

+        let ack_key: AckKey = pemstore::load_key(client_pathfinder.ack_key())?;
+
+        // TODO: ack key is never stored so it is generated now. But perhaps it should be stored
+        // after all for consistency sake?
        Ok(KeyManager {
            identity_keypair: Arc::new(identity_keypair),
            encryption_keypair: Arc::new(encryption_keypair),
-            gateway_shared_key: None,
+            gateway_shared_key: Some(Arc::new(gateway_shared_key)),
            ack_key: Arc::new(ack_key),
        })
    }

-    /// Loads previously stored keys from the disk. Fails if not all, including the shared gateway
-    /// key, is available.
-    pub fn load_keys(client_pathfinder: &ClientKeyPathfinder) -> io::Result<Self> {
-        let mut key_manager = Self::load_client_keys(client_pathfinder)?;
-
-        let gateway_shared_key: SharedKeys =
-            nym_pemstore::load_key(client_pathfinder.gateway_shared_key())?;
-
-        key_manager.gateway_shared_key = Some(Arc::new(gateway_shared_key));
-
-        Ok(key_manager)
-    }
-
-    /// Loads previously stored keys from the disk. Fails if client keys are not availabe, but the
-    /// shared gateway key is optional.
-    pub fn load_keys_but_gateway_is_optional(
-        client_pathfinder: &ClientKeyPathfinder,
-    ) -> io::Result<Self> {
-        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());
-
-        // It's ok if the gateway key was not found
-        let gateway_shared_key = match gateway_shared_key {
-            Err(err) if err.kind() == io::ErrorKind::NotFound => Ok(None),
-            Err(err) => Err(err),
-            Ok(key) => Ok(Some(key)),
-        }?;
-
-        key_manager.gateway_shared_key = gateway_shared_key.map(Arc::new);
-
-        Ok(key_manager)
-    }
-
+    // this is actually **NOT** dead code
+    // I have absolutely no idea why the compiler insists it's unused. The call happens during client::init::execute
+    #[allow(dead_code)]
    /// Stores all available keys on the disk.
    // While perhaps there is no much point in storing the `AckKey` on the disk,
    // 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!"),
+            None => warn!("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())?
            }
        }

        Ok(())
    }

-    pub fn store_gateway_key(&self, client_pathfinder: &ClientKeyPathfinder) -> io::Result<()> {
-        match self.gateway_shared_key.as_ref() {
-            None => {
-                return Err(io::Error::new(
-                    io::ErrorKind::Other,
-                    "trying to store a non-existing key",
-                ))
-            }
-            Some(gate_key) => {
-                nym_pemstore::store_key(gate_key.as_ref(), client_pathfinder.gateway_shared_key())?
-            }
-        }
-
-        Ok(())
-    }
-
-    /// Overwrite the existing identity keypair
-    pub fn set_identity_keypair(&mut self, id_keypair: identity::KeyPair) {
-        self.identity_keypair = Arc::new(id_keypair);
-    }
-
    /// Gets an atomically reference counted pointer to [`identity::KeyPair`].
    pub fn identity_keypair(&self) -> Arc<identity::KeyPair> {
        Arc::clone(&self.identity_keypair)
    }

-    /// Overwrite the existing encryption keypair
-    pub fn set_encryption_keypair(&mut self, enc_keypair: encryption::KeyPair) {
-        self.encryption_keypair = Arc::new(enc_keypair);
-    }
-
    /// Gets an atomically reference counted pointer to [`encryption::KeyPair`].
    pub fn encryption_keypair(&self) -> Arc<encryption::KeyPair> {
        Arc::clone(&self.encryption_keypair)
    }

-    /// Overwrite the existing ack key
-    pub fn set_ack_key(&mut self, ack_key: AckKey) {
-        self.ack_key = Arc::new(ack_key);
-    }
-
-    /// Gets an atomically reference counted pointer to [`AckKey`].
-    pub fn ack_key(&self) -> Arc<AckKey> {
-        Arc::clone(&self.ack_key)
-    }
-
-    /// After shared key with the gateway is derived, puts its ownership to this instance of a [`KeyManager`].
-    pub fn insert_gateway_shared_key(&mut self, gateway_shared_key: Arc<SharedKeys>) {
-        self.gateway_shared_key = Some(gateway_shared_key)
-    }
-
    /// Gets an atomically reference counted pointer to [`SharedKey`].
    // since this function is not fully public, it is not expected to be used externally and
    // hence it's up to us to ensure it's called in correct context
@@ -221,7 +149,12 @@ impl KeyManager {
        )
    }

-    pub fn is_gateway_key_set(&self) -> bool {
+    pub fn gateway_key_set(&self) -> bool {
        self.gateway_shared_key.is_some()
    }
+
+    /// Gets an atomically reference counted pointer to [`AckKey`].
+    pub fn ack_key(&self) -> Arc<AckKey> {
+        Arc::clone(&self.ack_key)
+    }
 }
@@ -2,13 +2,9 @@
 // SPDX-License-Identifier: Apache-2.0

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

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

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

    // TODO: this is temporary work-around.
@@ -28,13 +24,8 @@ pub struct MixTrafficController<C: Clone> {
    consecutive_gateway_failure_count: usize,
 }

-impl<C> MixTrafficController<C>
-where
-    C: CosmWasmClient + Sync + Send + Clone + 'static,
-{
-    pub fn new(
-        gateway_client: GatewayClient<C>,
-    ) -> (MixTrafficController<C>, BatchMixMessageSender) {
+impl MixTrafficController {
+    pub fn new(gateway_client: GatewayClient) -> (MixTrafficController, BatchMixMessageSender) {
        let (sphinx_message_sender, sphinx_message_receiver) =
            tokio::sync::mpsc::channel(MIX_MESSAGE_RECEIVER_BUFFER_SIZE);
        (
@@ -66,7 +57,7 @@ where
                if self.consecutive_gateway_failure_count == MAX_FAILURE_COUNT {
                    // todo: in the future this should initiate a 'graceful' shutdown or try
                    // to reconnect?
-                    panic!("failed to send sphinx packet to the gateway {MAX_FAILURE_COUNT} times in a row - assuming the gateway is dead. Can't do anything about it yet :(")
+                    panic!("failed to send sphinx packet to the gateway {} times in a row - assuming the gateway is dead. Can't do anything about it yet :(", MAX_FAILURE_COUNT)
                }
            }
            Ok(_) => {
@@ -76,7 +67,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");

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

 pub mod base_client;
 pub mod cover_traffic_stream;
-pub(crate) mod helpers;
 pub mod inbound_messages;
 pub mod key_manager;
 pub mod mix_traffic;
@@ -11,4 +10,3 @@ pub mod real_messages_control;
 pub mod received_buffer;
 pub mod replies;
 pub mod topology_control;
-pub(crate) mod transmission_buffer;
@@ -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;
@@ -213,11 +213,7 @@ impl ActionController {
    }

    // note: when the entry expires it's automatically removed from pending_acks_timers
-    fn handle_expired_ack_timer(
-        &mut self,
-        expired_ack: Expired<FragmentIdentifier>,
-        task_client: &mut nym_task::TaskClient,
-    ) {
+    fn handle_expired_ack_timer(&mut self, expired_ack: Expired<FragmentIdentifier>) {
        // I'm honestly not sure how to handle it, because getting it means other things in our
        // system are already misbehaving. If we ever see this panic, then I guess we should worry
        // about it. Perhaps just reschedule it at later point?
@@ -235,16 +231,9 @@ impl ActionController {
            // downgrading an arc and then upgrading vs cloning is difference of 30ns vs 15ns
            // so it's literally a NO difference while it might prevent us from unnecessarily
            // resending data (in maybe 1 in 1 million cases, but it's something)
-            if self
-                .retransmission_sender
+            self.retransmission_sender
                .unbounded_send(Arc::downgrade(pending_ack_data))
-                .is_err()
-            {
-                assert!(
-                    task_client.is_shutdown_poll(),
-                    "Failed to send pending ack for retransmission"
-                );
-            }
+                .unwrap()
        } else {
            // this shouldn't cause any issues but shouldn't have happened to begin with!
            error!("An already removed pending ack has expired")
@@ -260,7 +249,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() {
@@ -275,7 +264,7 @@ impl ActionController {
                    }
                },
                expired_ack = self.pending_acks_timers.next() => match expired_ack {
-                    Some(expired_ack) => self.handle_expired_ack_timer(expired_ack, &mut shutdown),
+                    Some(expired_ack) => self.handle_expired_ack_timer(expired_ack),
                    None => {
                        log::trace!("ActionController: Stopping since ack channel closed");
                        break;
@@ -286,7 +275,10 @@ impl ActionController {
                }
            }
        }
-        shutdown.recv_timeout().await;
+        #[cfg(not(target_arch = "wasm32"))]
+        tokio::time::timeout(Duration::from_secs(5), shutdown.recv())
+            .await
+            .expect("Task stopped without shutdown called");
        log::debug!("ActionController: Exiting");
    }
 }
@@ -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,22 @@ 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)]
@@ -279,7 +278,7 @@ where
        reply_surb: ReplySurb,
        amount: u32,
    ) -> Result<(), SurbWrappedPreparationError> {
-        debug!("requesting {amount} reply SURBs from {from}");
+        debug!("requesting {amount} reply SURBs from {from:?}");

        let surbs_request =
            ReplyMessage::new_surb_request_message(self.config.sender_address, amount);
@@ -295,11 +294,19 @@ where
            )))
    }

-    pub(crate) async fn send_retransmission_reply_chunks(
+    // the only difference between this method and `try_send_reply_chunks` is that
+    // here we are not creating acks as acks are already in memory waiting to get cleared.
+    // we are only updating their existing delays
+    pub(crate) async fn try_send_retransmission_reply_chunks(
        &mut self,
-        prepared_fragments: Vec<PreparedFragment>,
+        fragments: Vec<Fragment>,
+        reply_surbs: Vec<ReplySurb>,
        lane: TransmissionLane,
-    ) {
+    ) -> Result<(), SurbWrappedPreparationError> {
+        let prepared_fragments = self
+            .prepare_reply_chunks_for_sending(fragments.clone(), reply_surbs)
+            .await?;
+
        let mut real_messages = Vec::with_capacity(prepared_fragments.len());

        for prepared in prepared_fragments {
@@ -308,58 +315,33 @@ where
        }

        self.forward_messages(real_messages, lane).await;
+        Ok(())
    }

-    pub(crate) async fn try_send_reply_chunks_on_lane(
+    pub(crate) async fn try_send_reply_chunks(
        &mut self,
        target: AnonymousSenderTag,
        fragments: Vec<Fragment>,
        reply_surbs: Vec<ReplySurb>,
        lane: TransmissionLane,
-    ) -> Result<(), SurbWrappedPreparationError> {
-        // TODO: technically this is performing an unnecessary cloning, but in the grand scheme of things
-        // is it really that bad?
-        self.try_send_reply_chunks(
-            target,
-            fragments.into_iter().map(|f| (lane, f)).collect(),
-            reply_surbs,
-        )
-        .await
-    }
-
-    pub(crate) async fn try_send_reply_chunks(
-        &mut self,
-        target: AnonymousSenderTag,
-        fragments: Vec<(TransmissionLane, Fragment)>,
-        reply_surbs: Vec<ReplySurb>,
    ) -> Result<(), SurbWrappedPreparationError> {
        let prepared_fragments = self
-            .prepare_reply_chunks_for_sending(
-                fragments.iter().map(|(_, f)| f.clone()).collect(),
-                reply_surbs,
-            )
+            .prepare_reply_chunks_for_sending(fragments.clone(), reply_surbs)
            .await?;

        let mut pending_acks = Vec::with_capacity(fragments.len());
-        let mut to_forward: HashMap<_, Vec<_>> = HashMap::new();
+        let mut real_messages = Vec::with_capacity(fragments.len());

        for (raw, prepared) in fragments.into_iter().zip(prepared_fragments.into_iter()) {
-            let lane = raw.0;
-            let fragment = raw.1;
-
            let real_message = RealMessage::new(prepared.mix_packet, prepared.fragment_identifier);
            let delay = prepared.total_delay;
-            let pending_ack = PendingAcknowledgement::new_anonymous(fragment, delay, target, false);
+            let pending_ack = PendingAcknowledgement::new_anonymous(raw, delay, target, false);

-            let entry = to_forward.entry(lane).or_default();
-            entry.push(real_message);
+            real_messages.push(real_message);
            pending_acks.push(pending_ack);
        }

-        for (lane, real_messages) in to_forward {
-            self.forward_messages(real_messages, lane).await;
-        }
-
+        self.forward_messages(real_messages, lane).await;
        self.insert_pending_acks(pending_acks);
        Ok(())
    }
@@ -485,7 +467,7 @@ where
        Ok(prepared_fragment)
    }

-    pub(crate) async fn prepare_reply_chunks_for_sending(
+    async fn prepare_reply_chunks_for_sending(
        &mut self,
        fragments: Vec<Fragment>,
        reply_surbs: Vec<ReplySurb>,
@@ -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;
@@ -81,11 +81,7 @@ pub struct Config {

    /// Defines maximum amount of time the client is going to wait for reply surbs before explicitly asking
    /// for more even though in theory they wouldn't need to.
-    maximum_reply_surb_rerequest_waiting_period: Duration,
-
-    /// Defines maximum amount of time the client is going to wait for reply surbs before
-    /// deciding it's never going to get them and would drop all pending messages
-    maximum_reply_surb_drop_waiting_period: Duration,
+    maximum_reply_surb_waiting_period: Duration,

    /// Defines maximum amount of time given reply surb is going to be valid for.
    /// This is going to be superseded by key rotation once implemented.
@@ -123,8 +119,7 @@ impl<'a> From<&'a Config> for reply_controller::Config {
            cfg.minimum_reply_surb_request_size,
            cfg.maximum_reply_surb_request_size,
            cfg.maximum_allowed_reply_surb_request_size,
-            cfg.maximum_reply_surb_rerequest_waiting_period,
-            cfg.maximum_reply_surb_drop_waiting_period,
+            cfg.maximum_reply_surb_waiting_period,
            cfg.maximum_reply_surb_age,
            cfg.maximum_reply_key_age,
        )
@@ -166,10 +161,8 @@ impl Config {
                .maximum_reply_surb_request_size,
            maximum_allowed_reply_surb_request_size: base_client_debug_config
                .maximum_allowed_reply_surb_request_size,
-            maximum_reply_surb_rerequest_waiting_period: base_client_debug_config
-                .maximum_reply_surb_rerequest_waiting_period,
-            maximum_reply_surb_drop_waiting_period: base_client_debug_config
-                .maximum_reply_surb_drop_waiting_period,
+            maximum_reply_surb_waiting_period: base_client_debug_config
+                .maximum_reply_surb_waiting_period,
            maximum_reply_surb_age: base_client_debug_config.maximum_reply_surb_age,
            maximum_reply_key_age: base_client_debug_config.maximum_reply_key_age,
        }
@@ -270,7 +263,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;
@@ -1,25 +1,23 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use self::sending_delay_controller::SendingDelayController;
 use crate::client::mix_traffic::BatchMixMessageSender;
 use crate::client::real_messages_control::acknowledgement_control::SentPacketNotificationSender;
 use crate::client::topology_control::TopologyAccessor;
-use crate::client::transmission_buffer::TransmissionBuffer;
+use client_connections::{
+    ConnectionCommand, ConnectionCommandReceiver, ConnectionId, LaneQueueLengths, TransmissionLane,
+};
 use futures::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;
@@ -31,7 +29,22 @@ use tokio::time;
 #[cfg(target_arch = "wasm32")]
 use wasm_timer;

+use self::{
+    sending_delay_controller::SendingDelayController, transmission_buffer::TransmissionBuffer,
+};
+
 mod sending_delay_controller;
+mod transmission_buffer;
+
+#[cfg(not(target_arch = "wasm32"))]
+fn get_time_now() -> time::Instant {
+    time::Instant::now()
+}
+
+#[cfg(target_arch = "wasm32")]
+fn get_time_now() -> wasm_timer::Instant {
+    wasm_timer::Instant::now()
+}

 /// Configurable parameters of the `OutQueueControl`
 pub(crate) struct Config {
@@ -122,7 +135,7 @@ where

    /// Buffer containing all incoming real messages keyed by transmission lane, that we will send
    /// out to the mixnet.
-    transmission_buffer: TransmissionBuffer<RealMessage>,
+    transmission_buffer: TransmissionBuffer,

    /// Incoming channel for being notified of closed connections, so that we can close lanes
    /// corresponding to connections. To avoid sending traffic unnecessary
@@ -149,10 +162,6 @@ impl From<PreparedFragment> for RealMessage {
 }

 impl RealMessage {
-    pub(crate) fn packet_size(&self) -> usize {
-        self.mix_packet.sphinx_packet().len()
-    }
-
    pub(crate) fn new(mix_packet: MixPacket, fragment_id: FragmentIdentifier) -> Self {
        RealMessage {
            mix_packet,
@@ -198,7 +207,7 @@ where
            real_receiver,
            rng,
            topology_access,
-            transmission_buffer: TransmissionBuffer::new(),
+            transmission_buffer: Default::default(),
            client_connection_rx,
            lane_queue_lengths,
        }
@@ -319,9 +328,7 @@ where

    fn pop_next_message(&mut self) -> Option<RealMessage> {
        // Pop the next message from the transmission buffer
-        let (lane, real_next) = self
-            .transmission_buffer
-            .pop_next_message_at_random(&mut self.rng)?;
+        let (lane, real_next) = self.transmission_buffer.pop_next_message_at_random()?;

        // Update the published queue length
        let lane_length = self.transmission_buffer.lane_length(&lane);
@@ -342,6 +349,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 +428,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 +469,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();
@@ -469,10 +478,14 @@ where
        let mult = self.sending_delay_controller.current_multiplier();
        let delay = self.current_average_message_sending_delay().as_millis();
        let status_str = if self.config.disable_poisson_packet_distribution {
-            format!("Status: {lanes} lanes, backlog: {backlog:.2} kiB ({packets}), no delay")
+            format!(
+                "Status: {lanes} lanes, backlog: {:.2} kiB ({packets}), no delay",
+                backlog
+            )
        } else {
            format!(
-                "Status: {lanes} lanes, backlog: {backlog:.2} kiB ({packets}), avg delay: {delay}ms ({mult})"
+                "Status: {lanes} lanes, backlog: {:.2} kiB ({packets}), avg delay: {}ms ({mult})",
+                backlog, delay
            )
        };
        if packets > 1000 {
@@ -501,7 +514,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"))]
@@ -529,7 +542,9 @@ where
                    }
                }
            }
-            shutdown.recv_timeout().await;
+            tokio::time::timeout(Duration::from_secs(5), shutdown.recv())
+                .await
+                .expect("Task stopped without shutdown called");
        }

        #[cfg(target_arch = "wasm32")]
@@ -1,9 +1,14 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::client::helpers::{get_time_now, Instant};
+use super::get_time_now;
 use std::time::Duration;

+#[cfg(not(target_arch = "wasm32"))]
+use tokio::time;
+#[cfg(target_arch = "wasm32")]
+use wasm_timer;
+
 // The minimum time between increasing the average delay between packets. If we hit the ceiling in
 // the available buffer space we want to take somewhat swift action, but we still need to give a
 // short time to give the channel a chance reduce pressure.
@@ -34,11 +39,19 @@ pub(crate) struct SendingDelayController {
    lower_bound: u32,

    /// To make sure we don't change the multiplier to fast, we limit a change to some duration
-    time_when_changed: Instant,
+    #[cfg(not(target_arch = "wasm32"))]
+    time_when_changed: time::Instant,
+
+    #[cfg(target_arch = "wasm32")]
+    time_when_changed: wasm_timer::Instant,

    /// If we have a long enough time without any backpressure detected we try reducing the sending
    /// delay multiplier
-    time_when_backpressure_detected: Instant,
+    #[cfg(not(target_arch = "wasm32"))]
+    time_when_backpressure_detected: time::Instant,
+
+    #[cfg(target_arch = "wasm32")]
+    time_when_backpressure_detected: wasm_timer::Instant,
 }

 impl Default for SendingDelayController {
@@ -1,57 +1,38 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::client::helpers::{get_time_now, Instant};
-use crate::client::real_messages_control::real_traffic_stream::RealMessage;
-use nym_sphinx::chunking::fragment::Fragment;
-use nym_task::connections::TransmissionLane;
+use client_connections::TransmissionLane;
 use rand::{seq::SliceRandom, Rng};
 use std::{
    collections::{HashMap, HashSet, VecDeque},
    time::Duration,
 };

+#[cfg(not(target_arch = "wasm32"))]
+use tokio::time;
+
+#[cfg(target_arch = "wasm32")]
+use wasm_timer;
+
+use super::{get_time_now, RealMessage};
+
 // The number of lanes included in the oldest set. Used when we need to prioritize traffic.
 const OLDEST_LANE_SET_SIZE: usize = 4;
 // As a way of prune connections we also check for timeouts.
 const MSG_CONSIDERED_STALE_AFTER_SECS: u64 = 10 * 60;

-pub(crate) trait SizedData {
-    fn data_size(&self) -> usize;
-}
-
-impl SizedData for RealMessage {
-    fn data_size(&self) -> usize {
-        self.packet_size()
-    }
-}
-
-impl SizedData for Fragment {
-    fn data_size(&self) -> usize {
-        // note that raw `Fragment` is smaller than sphinx packet payload
-        // as it doesn't include surb-ack or the [shared] key materials
-        self.payload_size()
-    }
-}
-
 #[derive(Default)]
-pub(crate) struct TransmissionBuffer<T> {
-    buffer: HashMap<TransmissionLane, LaneBufferEntry<T>>,
+pub(crate) struct TransmissionBuffer {
+    buffer: HashMap<TransmissionLane, LaneBufferEntry>,
 }

-impl<T> TransmissionBuffer<T> {
-    pub(crate) fn new() -> Self {
-        TransmissionBuffer {
-            buffer: HashMap::new(),
-        }
-    }
-
+impl TransmissionBuffer {
    #[allow(unused)]
    pub(crate) fn is_empty(&self) -> bool {
        self.buffer.is_empty()
    }

-    pub(crate) fn remove(&mut self, lane: &TransmissionLane) -> Option<LaneBufferEntry<T>> {
+    pub(crate) fn remove(&mut self, lane: &TransmissionLane) -> Option<LaneBufferEntry> {
        self.buffer.remove(lane)
    }

@@ -76,22 +57,20 @@ impl<T> TransmissionBuffer<T> {
            .collect()
    }

+    #[cfg(not(target_arch = "wasm32"))]
    pub(crate) fn total_size(&self) -> usize {
        self.buffer.values().map(LaneBufferEntry::len).sum()
    }

    #[cfg(not(target_arch = "wasm32"))]
-    pub(crate) fn total_size_in_bytes(&self) -> usize
-    where
-        T: SizedData,
-    {
+    pub(crate) fn total_size_in_bytes(&self) -> usize {
        self.buffer
            .values()
            .map(|lane_buffer_entry| {
                lane_buffer_entry
-                    .items
+                    .real_messages
                    .iter()
-                    .map(|item| item.data_size())
+                    .map(|real_message| real_message.mix_packet.sphinx_packet().len())
                    .sum::<usize>()
            })
            .sum()
@@ -113,51 +92,42 @@ impl<T> TransmissionBuffer<T> {
            .collect()
    }

-    pub(crate) fn store<I: IntoIterator<Item = T>>(&mut self, lane: &TransmissionLane, items: I) {
+    pub(crate) fn store(&mut self, lane: &TransmissionLane, real_messages: Vec<RealMessage>) {
        if let Some(lane_buffer_entry) = self.buffer.get_mut(lane) {
-            lane_buffer_entry.extend(items);
+            lane_buffer_entry.append(real_messages);
        } else {
            self.buffer
-                .insert(*lane, LaneBufferEntry::new(items.into_iter().collect()));
+                .insert(*lane, LaneBufferEntry::new(real_messages));
        }
    }

-    pub(crate) fn store_multiple(&mut self, items: Vec<(TransmissionLane, T)>) {
-        for (lane, item) in items {
-            self.buffer
-                .entry(lane)
-                .or_insert_with(LaneBufferEntry::new_empty)
-                .push_item(item)
-        }
-    }
-
-    fn pick_random_lane<R: Rng + ?Sized>(&self, rng: &mut R) -> Option<&TransmissionLane> {
+    fn pick_random_lane(&self) -> Option<&TransmissionLane> {
        let lanes: Vec<&TransmissionLane> = self.buffer.keys().collect();
-        lanes.choose(rng).copied()
+        lanes.choose(&mut rand::thread_rng()).copied()
    }

-    fn pick_random_small_lane<R: Rng + ?Sized>(&self, rng: &mut R) -> Option<&TransmissionLane> {
+    fn pick_random_small_lane(&self) -> Option<&TransmissionLane> {
        let lanes: Vec<&TransmissionLane> = self
            .buffer
            .iter()
            .filter(|(_, v)| v.is_small())
            .map(|(k, _)| k)
            .collect();
-        lanes.choose(rng).copied()
+        lanes.choose(&mut rand::thread_rng()).copied()
    }

    // 2/3 chance to pick from the old lanes
-    fn pick_random_old_lane<R: Rng + ?Sized>(&self, rng: &mut R) -> Option<TransmissionLane> {
+    fn pick_random_old_lane(&self) -> Option<TransmissionLane> {
        let rand = &mut rand::thread_rng();
        if rand.gen_ratio(2, 3) {
            let lanes = self.get_oldest_set();
            lanes.choose(rand).copied()
        } else {
-            self.pick_random_lane(rng).copied()
+            self.pick_random_lane().copied()
        }
    }

-    fn pop_front_from_lane(&mut self, lane: &TransmissionLane) -> Option<T> {
+    fn pop_front_from_lane(&mut self, lane: &TransmissionLane) -> Option<RealMessage> {
        let real_msgs_queued = self.buffer.get_mut(lane)?;
        let real_next = real_msgs_queued.pop_front()?;
        real_msgs_queued.messages_transmitted += 1;
@@ -167,48 +137,19 @@ impl<T> TransmissionBuffer<T> {
        Some(real_next)
    }

-    pub(crate) fn pop_at_most_n_next_messages_at_random(
-        &mut self,
-        n: usize,
-    ) -> Option<Vec<(TransmissionLane, T)>> {
-        // let start = Instant::now();
-
-        if self.buffer.is_empty() {
-            return None;
-        }
-
-        let rng = &mut rand::thread_rng();
-        let mut items = Vec::with_capacity(n);
-
-        while items.len() < n {
-            let Some(next) = self.pop_next_message_at_random(rng) else {
-               break
-            };
-            items.push(next)
-        }
-
-        // todo!("time time taken");
-
-        Some(items)
-    }
-
-    pub(crate) fn pop_next_message_at_random<R: Rng + ?Sized>(
-        &mut self,
-        // turns out the caller always have access to some rng, so no point in instantiating new one
-        rng: &mut R,
-    ) -> Option<(TransmissionLane, T)> {
+    pub(crate) fn pop_next_message_at_random(&mut self) -> Option<(TransmissionLane, RealMessage)> {
        if self.buffer.is_empty() {
            return None;
        }

        // Very basic heuristic where we prioritize according to small lanes first, the older lanes
        // to try to finish lanes when possible, then the rest.
-        let lane = if let Some(small_lane) = self.pick_random_small_lane(rng) {
+        let lane = if let Some(small_lane) = self.pick_random_small_lane() {
            *small_lane
-        } else if let Some(old_lane) = self.pick_random_old_lane(rng) {
+        } else if let Some(old_lane) = self.pick_random_old_lane() {
            old_lane
        } else {
-            *self.pick_random_lane(rng)?
+            *self.pick_random_lane()?
        };

        let msg = self.pop_front_from_lane(&lane)?;
@@ -230,46 +171,35 @@ impl<T> TransmissionBuffer<T> {
    }
 }

-pub(crate) struct LaneBufferEntry<T> {
-    pub items: VecDeque<T>,
+pub(crate) struct LaneBufferEntry {
+    pub real_messages: VecDeque<RealMessage>,
    pub messages_transmitted: usize,
-    pub time_for_last_activity: Instant,
+    #[cfg(not(target_arch = "wasm32"))]
+    pub time_for_last_activity: time::Instant,
+    #[cfg(target_arch = "wasm32")]
+    pub time_for_last_activity: wasm_timer::Instant,
 }

-impl<T> LaneBufferEntry<T> {
-    fn new_empty() -> Self {
+impl LaneBufferEntry {
+    fn new(real_messages: Vec<RealMessage>) -> Self {
        LaneBufferEntry {
-            items: VecDeque::new(),
+            real_messages: real_messages.into(),
            messages_transmitted: 0,
            time_for_last_activity: get_time_now(),
        }
    }

-    fn new(items: VecDeque<T>) -> Self {
-        LaneBufferEntry {
-            items,
-            messages_transmitted: 0,
-            time_for_last_activity: get_time_now(),
-        }
-    }
-
-    fn push_item(&mut self, item: T) {
-        self.items.push_back(item);
-        // I'm not updating time here on purpose. This method is called just after `new_empty`,
-        // where the time is already set. Furthermore, this method is called there multiple times at once
-    }
-
-    fn extend<I: IntoIterator<Item = T>>(&mut self, items: I) {
-        self.items.extend(items);
+    fn append(&mut self, real_messages: Vec<RealMessage>) {
+        self.real_messages.append(&mut real_messages.into());
        self.time_for_last_activity = get_time_now();
    }

-    fn pop_front(&mut self) -> Option<T> {
-        self.items.pop_front()
+    fn pop_front(&mut self) -> Option<RealMessage> {
+        self.real_messages.pop_front()
    }

    fn is_small(&self) -> bool {
-        self.items.len() < 100
+        self.real_messages.len() < 100
    }

    fn is_stale(&self) -> bool {
@@ -278,10 +208,10 @@ impl<T> LaneBufferEntry<T> {
    }

    fn len(&self) -> usize {
-        self.items.len()
+        self.real_messages.len()
    }

    fn is_empty(&self) -> bool {
-        self.items.is_empty()
+        self.real_messages.is_empty()
    }
 }
@@ -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;

@@ -47,7 +47,7 @@ struct ReceivedMessagesBufferInner {

 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;
        }
@@ -399,7 +399,7 @@ impl RequestReceiver {
        }
    }

-    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! {
@@ -438,7 +438,7 @@ impl FragmentedMessageReceiver {
        }
    }

-    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 FragmentedMessageReceiver with graceful shutdown support");
        while !shutdown.is_shutdown() {
            tokio::select! {
@@ -488,7 +488,7 @@ impl ReceivedMessagesBufferController {
        }
    }

-    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;

@@ -4,34 +4,133 @@
 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 futures::channel::oneshot;
+use client_connections::TransmissionLane;
+use futures::channel::mpsc;
 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;
-use std::collections::{BTreeMap, HashMap};
+use std::collections::{BTreeMap, HashMap, VecDeque};
 use std::sync::{Arc, Weak};
 use std::time::Duration;
 use time::OffsetDateTime;

-use crate::client::helpers::new_interval_stream;
-use crate::client::transmission_buffer::TransmissionBuffer;
-pub(crate) use requests::{ReplyControllerMessage, ReplyControllerReceiver, ReplyControllerSender};
+#[cfg(not(target_arch = "wasm32"))]
+type IntervalStream = tokio_stream::wrappers::IntervalStream;

-pub mod requests;
+#[cfg(target_arch = "wasm32")]
+type IntervalStream = gloo_timers::future::IntervalStream;
+
+pub(crate) fn new_control_channels() -> (ReplyControllerSender, ReplyControllerReceiver) {
+    let (tx, rx) = mpsc::unbounded();
+    (tx.into(), rx)
+}
+
+#[derive(Debug, Clone)]
+pub(crate) struct ReplyControllerSender(mpsc::UnboundedSender<ReplyControllerMessage>);
+
+impl From<mpsc::UnboundedSender<ReplyControllerMessage>> for ReplyControllerSender {
+    fn from(inner: mpsc::UnboundedSender<ReplyControllerMessage>) -> Self {
+        ReplyControllerSender(inner)
+    }
+}
+
+impl ReplyControllerSender {
+    pub(crate) fn send_retransmission_data(
+        &self,
+        recipient: AnonymousSenderTag,
+        timed_out_ack: Weak<PendingAcknowledgement>,
+        extra_surb_request: bool,
+    ) {
+        self.0
+            .unbounded_send(ReplyControllerMessage::RetransmitReply {
+                recipient,
+                timed_out_ack,
+                extra_surb_request,
+            })
+            .expect("ReplyControllerReceiver has died!")
+    }
+
+    pub(crate) fn send_reply(
+        &self,
+        recipient: AnonymousSenderTag,
+        message: Vec<u8>,
+        lane: TransmissionLane,
+    ) {
+        self.0
+            .unbounded_send(ReplyControllerMessage::SendReply {
+                recipient,
+                message,
+                lane,
+            })
+            .expect("ReplyControllerReceiver has died!")
+    }
+
+    pub(crate) fn send_additional_surbs(
+        &self,
+        sender_tag: AnonymousSenderTag,
+        reply_surbs: Vec<ReplySurb>,
+        from_surb_request: bool,
+    ) {
+        self.0
+            .unbounded_send(ReplyControllerMessage::AdditionalSurbs {
+                sender_tag,
+                reply_surbs,
+                from_surb_request,
+            })
+            .expect("ReplyControllerReceiver has died!")
+    }
+
+    pub(crate) fn send_additional_surbs_request(&self, recipient: Recipient, amount: u32) {
+        self.0
+            .unbounded_send(ReplyControllerMessage::AdditionalSurbsRequest {
+                recipient: Box::new(recipient),
+                amount,
+            })
+            .expect("ReplyControllerReceiver has died!")
+    }
+}
+
+pub(crate) type ReplyControllerReceiver = mpsc::UnboundedReceiver<ReplyControllerMessage>;
+
+#[derive(Debug)]
+pub(crate) enum ReplyControllerMessage {
+    RetransmitReply {
+        recipient: AnonymousSenderTag,
+        timed_out_ack: Weak<PendingAcknowledgement>,
+        extra_surb_request: bool,
+    },
+
+    SendReply {
+        recipient: AnonymousSenderTag,
+        message: Vec<u8>,
+        lane: TransmissionLane,
+    },
+
+    AdditionalSurbs {
+        sender_tag: AnonymousSenderTag,
+        reply_surbs: Vec<ReplySurb>,
+        from_surb_request: bool,
+    },
+
+    // Should this also be handled in here? it's technically a completely different side of the pipe
+    // let's see how it works when combined, might split it before creating PR
+    AdditionalSurbsRequest {
+        recipient: Box<Recipient>,
+        amount: u32,
+    },
+}

 pub struct Config {
    min_surb_request_size: u32,
    max_surb_request_size: u32,
    maximum_allowed_reply_surb_request_size: u32,
-    max_surb_rerequest_waiting_period: Duration,
-    max_surb_drop_waiting_period: Duration,
+    max_surb_waiting_period: Duration,
    max_reply_surb_age: Duration,
    max_reply_key_age: Duration,
 }
@@ -41,8 +140,7 @@ impl Config {
        min_surb_request_size: u32,
        max_surb_request_size: u32,
        maximum_allowed_reply_surb_request_size: u32,
-        max_surb_rerequest_waiting_period: Duration,
-        max_surb_drop_waiting_period: Duration,
+        max_surb_waiting_period: Duration,
        max_reply_surb_age: Duration,
        max_reply_key_age: Duration,
    ) -> Self {
@@ -50,8 +148,7 @@ impl Config {
            min_surb_request_size,
            max_surb_request_size,
            maximum_allowed_reply_surb_request_size,
-            max_surb_rerequest_waiting_period,
-            max_surb_drop_waiting_period,
+            max_surb_waiting_period,
            max_reply_surb_age,
            max_reply_key_age,
        }
@@ -75,7 +172,7 @@ pub struct ReplyController<R> {
    // of surbs required to send the message through
    // expected_reliability: f32,
    request_receiver: ReplyControllerReceiver,
-    pending_replies: HashMap<AnonymousSenderTag, TransmissionBuffer<Fragment>>,
+    pending_replies: HashMap<AnonymousSenderTag, VecDeque<Fragment>>,

    /// Retransmission packets that have already timed out and are waiting for additional reply SURBs
    /// so that they could be sent back to the network. Once we receive more SURBs, we should send them ASAP.
@@ -107,28 +204,17 @@ where
        }
    }

-    fn insert_pending_replies<I: IntoIterator<Item = Fragment>>(
+    /// Inserts the pending replies into the BACK of the queue fn insert_pending_replies<V: Into<VecDeque<Fragment>>>(
+    fn insert_pending_replies<V: Into<VecDeque<Fragment>>>(
        &mut self,
        recipient: &AnonymousSenderTag,
-        fragments: I,
-        lane: TransmissionLane,
+        fragments: V,
    ) {
-        self.pending_replies
-            .entry(*recipient)
-            .or_insert_with(TransmissionBuffer::new)
-            .store(&lane, fragments)
-    }
-
-    fn re_insert_pending_replies(
-        &mut self,
-        recipient: &AnonymousSenderTag,
-        fragments: Vec<(TransmissionLane, Fragment)>,
-    ) {
-        // the buffer should ALWAYS exist at this point, if it doesn't, it's a bug...
-        self.pending_replies
-            .entry(*recipient)
-            .or_insert_with(TransmissionBuffer::new)
-            .store_multiple(fragments)
+        if let Some(existing) = self.pending_replies.get_mut(recipient) {
+            existing.append(&mut fragments.into())
+        } else {
+            self.pending_replies.insert(*recipient, fragments.into());
+        }
    }

    fn re_insert_pending_retransmission(
@@ -158,7 +244,7 @@ where
        let pending_queue_size = self
            .pending_replies
            .get(target)
-            .map(|pending_queue| pending_queue.total_size())
+            .map(|pending_queue| pending_queue.len())
            .unwrap_or_default();

        let retransmission_queue = self
@@ -213,61 +299,42 @@ where
        }

        trace!("handling reply to {:?}", recipient_tag);
-        let mut fragments = self.message_handler.split_reply_message(data);
-        let total_size = fragments.len();
-        trace!("This reply requires {:?} SURBs", total_size);
+        let fragments = self.message_handler.split_reply_message(data);

-        let available_surbs = self
+        let required_surbs = fragments.len();
+        trace!("This reply requires {:?} SURBs", required_surbs);
+
+        // TODO: edge case:
+        // we're making a lot of requests and have to request a lot of surbs
+        // (but at some point we run out of surbs for surb requests)
+
+        let (surbs, _surbs_left) = self
            .full_reply_storage
            .surbs_storage_ref()
-            .available_surbs(&recipient_tag);
-        let min_surbs_threshold = self
-            .full_reply_storage
-            .surbs_storage_ref()
-            .min_surb_threshold();
+            .get_reply_surbs(&recipient_tag, required_surbs);

-        let max_to_send = if available_surbs > min_surbs_threshold {
-            min(fragments.len(), available_surbs - min_surbs_threshold)
-        } else {
-            0
-        };
+        if let Some(reply_surbs) = surbs {
+            if let Err(err) = self
+                .message_handler
+                .try_send_reply_chunks(recipient_tag, fragments, reply_surbs, lane)
+                .await
+            {
+                let err = err.return_unused_surbs(
+                    self.full_reply_storage.surbs_storage_ref(),
+                    &recipient_tag,
+                );
+                warn!("failed to send reply to {:?} - {err}", recipient_tag);

-        if max_to_send > 0 {
-            let (surbs, _surbs_left) = self
-                .full_reply_storage
-                .surbs_storage_ref()
-                .get_reply_surbs(&recipient_tag, max_to_send);
-
-            if let Some(reply_surbs) = surbs {
-                let to_send = fragments.drain(..max_to_send).collect::<Vec<_>>();
-                if let Err(err) = self
-                    .message_handler
-                    .try_send_reply_chunks_on_lane(
-                        recipient_tag,
-                        to_send.clone(),
-                        reply_surbs,
-                        lane,
-                    )
-                    .await
-                {
-                    let err = err.return_unused_surbs(
-                        self.full_reply_storage.surbs_storage_ref(),
-                        &recipient_tag,
-                    );
-                    warn!("failed to send reply to {recipient_tag}: {err}");
-                    self.insert_pending_replies(&recipient_tag, to_send, lane);
-                }
+                // TODO: should we buffer that data to try again?
            }
-        }
+        } else {
+            // we don't have enough surbs for this reply
+            self.insert_pending_replies(&recipient_tag, fragments);

-        // if there's leftover data we didn't send because we didn't have enough (or any) surbs - buffer it
-        if !fragments.is_empty() {
-            self.insert_pending_replies(&recipient_tag, fragments, lane);
-        }
-
-        if self.should_request_more_surbs(&recipient_tag) {
-            self.request_reply_surbs_for_queue_clearing(recipient_tag)
-                .await;
+            if self.should_request_more_surbs(&recipient_tag) {
+                self.request_reply_surbs_for_queue_clearing(recipient_tag)
+                    .await;
+            }
        }
    }

@@ -331,18 +398,35 @@ where
        };

        let mut to_take = Vec::new();
+        let mut to_remove = Vec::new();

-        while to_take.len() < max_to_clear {
-            if let Some((_, data)) = pending.pop_first() {
-                // no need to do anything if we failed to upgrade the reference,
-                // it means we got the ack while the data was waiting in the queue
-                if let Some(upgraded) = data.upgrade() {
-                    to_take.push(upgraded)
+        // TODO: once rust 1.66.0 is stabilised on 15.12.22, just change it to
+        // `.pop_front()` to directly take ownership
+        for (k, data) in pending.iter() {
+            let upgraded = match data.upgrade() {
+                Some(upgraded) => upgraded,
+                None => {
+                    // we got the ack while the data was waiting in the queue
+                    to_remove.push(*k);
+                    continue;
                }
-            } else {
-                // our map is empty!
+            };
+
+            to_take.push(upgraded);
+
+            // we have taken as many entries as we could have
+            if to_take.len() >= max_to_clear {
                break;
            }
+            // TODO: use if upgraded.is_extra_surb_request() to bypass the limit
+        }
+
+        for ack in &to_take {
+            pending.remove(&ack.inner_fragment_identifier());
+        }
+
+        for id in to_remove {
+            pending.remove(&id);
        }

        if to_take.is_empty() {
@@ -363,47 +447,46 @@ where

        let to_send_vec = to_take.iter().map(|ack| ack.fragment_data()).collect();

-        let prepared_fragments = match self
+        if let Err(err) = self
            .message_handler
-            .prepare_reply_chunks_for_sending(to_send_vec, surbs_for_reply)
+            .try_send_retransmission_reply_chunks(
+                to_send_vec,
+                surbs_for_reply,
+                TransmissionLane::Retransmission,
+            )
            .await
        {
-            Ok(prepared) => prepared,
-            Err(err) => {
-                let err =
-                    err.return_unused_surbs(self.full_reply_storage.surbs_storage_ref(), &target);
-                self.re_insert_pending_retransmission(&target, to_take);
+            let err = err.return_unused_surbs(self.full_reply_storage.surbs_storage_ref(), &target);
+            self.re_insert_pending_retransmission(&target, to_take);

-                warn!(
-                    "failed to clear pending retransmission queue for {:?} - {err}",
-                    target
-                );
-                return;
-            }
-        };
-
-        // we can't fail at this point, so drop all references to acks so that timer updates wouldn't blow up
-        drop(to_take);
-
-        self.message_handler
-            .send_retransmission_reply_chunks(prepared_fragments, TransmissionLane::Retransmission)
-            .await;
+            warn!(
+                "failed to clear pending retransmission queue for {:?} - {err}",
+                target
+            );
+        }
    }

    fn pop_at_most_pending_replies(
        &mut self,
        from: &AnonymousSenderTag,
        amount: usize,
-    ) -> Option<Vec<(TransmissionLane, Fragment)>> {
+    ) -> Option<VecDeque<Fragment>> {
        // if possible, pop all pending replies, if not, pop only entries for which we'd have a reply surb
-        let total = self.pending_replies.get(from)?.total_size();
+        let total = self.pending_replies.get(from)?.len();
        trace!("pending queue has {total} elements");
        if total == 0 {
            return None;
        }
-        self.pending_replies
-            .get_mut(from)?
-            .pop_at_most_n_next_messages_at_random(amount)
+        if total < amount {
+            self.pending_replies.remove(from)
+        } else {
+            Some(
+                self.pending_replies
+                    .get_mut(from)?
+                    .drain(..amount)
+                    .collect(),
+            )
+        }
    }

    async fn try_clear_pending_queue(&mut self, target: AnonymousSenderTag) {
@@ -427,9 +510,9 @@ where

        // we're guaranteed to not get more entries than we have reply surbs for
        if let Some(to_send) = self.pop_at_most_pending_replies(&target, max_to_clear) {
-            let to_send_clone = to_send.clone();
+            let to_send_vec = to_send.iter().cloned().collect::<Vec<_>>();

-            if to_send_clone.is_empty() {
+            if to_send_vec.is_empty() {
                panic!(
                    "please let the devs know if you ever see this message (reply_controller.rs)"
                );
@@ -438,22 +521,27 @@ where
            let (surbs_for_reply, _) = self
                .full_reply_storage
                .surbs_storage_ref()
-                .get_reply_surbs(&target, to_send_clone.len());
+                .get_reply_surbs(&target, to_send_vec.len());

            let Some(surbs_for_reply) = surbs_for_reply else {
                error!("somehow different task has stolen our reply surbs! - this should have been impossible");
-                self.re_insert_pending_replies(&target, to_send);
+                self.insert_pending_replies(&target, to_send);
                return;
            };

            if let Err(err) = self
                .message_handler
-                .try_send_reply_chunks(target, to_send_clone, surbs_for_reply)
+                .try_send_reply_chunks(
+                    target,
+                    to_send_vec,
+                    surbs_for_reply,
+                    TransmissionLane::General,
+                )
                .await
            {
                let err =
                    err.return_unused_surbs(self.full_reply_storage.surbs_storage_ref(), &target);
-                self.re_insert_pending_replies(&target, to_send);
+                self.insert_pending_replies(&target, to_send);
                warn!("failed to clear pending queue for {:?} - {err}", target);
            }
        } else {
@@ -624,30 +712,6 @@ where
        }
    }

-    // to be honest this doesn't make a lot of sense in the context of `connection_id`,
-    // it should really be asked per tag
-    fn handle_lane_queue_length(
-        &self,
-        connection_id: ConnectionId,
-        response_channel: oneshot::Sender<usize>,
-    ) {
-        // TODO: if we ever have duplicate ids for different senders, it means our rng is super weak
-        // thus I don't think we have to worry about it?
-        let lane = TransmissionLane::ConnectionId(connection_id);
-        for buf in self.pending_replies.values() {
-            if let Some(length) = buf.lane_length(&lane) {
-                if response_channel.send(length).is_err() {
-                    error!("the requester for lane queue length has dropped the response channel!")
-                }
-                return;
-            }
-        }
-        // make sure that if we didn't find that lane, we reply with 0
-        if response_channel.send(0).is_err() {
-            error!("the requester for lane queue length has dropped the response channel!")
-        }
-    }
-
    async fn handle_request(&mut self, request: ReplyControllerMessage) {
        match request {
            ReplyControllerMessage::RetransmitReply {
@@ -671,26 +735,19 @@ where
                self.handle_received_surbs(sender_tag, reply_surbs, from_surb_request)
                    .await
            }
-            ReplyControllerMessage::LaneQueueLength {
-                connection_id,
-                response_channel,
-            } => self.handle_lane_queue_length(connection_id, response_channel),
            ReplyControllerMessage::AdditionalSurbsRequest { recipient, amount } => {
                self.handle_surb_request(*recipient, amount).await
            }
        }
    }

-    // TODO: modify this method to more accurately determine the amount of surbs it needs to request
-    // it should take into consideration the average latency, sending rate and queue size.
-    // it should request as many surbs as it takes to saturate its sending rate before next batch arrives
    async fn request_reply_surbs_for_queue_clearing(&mut self, target: AnonymousSenderTag) {
        trace!("requesting surbs for queues clearing");

        let pending_queue_size = self
            .pending_replies
            .get(&target)
-            .map(|pending_queue| pending_queue.total_size())
+            .map(|pending_queue| pending_queue.len())
            .unwrap_or_default();

        let retransmission_queue = self
@@ -730,7 +787,7 @@ where
            }

            let Some(last_received) = self.full_reply_storage.surbs_storage_ref().surbs_last_received_at(pending_reply_target) else {
-                error!("we have {} pending replies for {pending_reply_target}, but we somehow never received any reply surbs from them!", vals.total_size());
+                error!("we have {} pending replies for {pending_reply_target}, but we somehow never received any reply surbs from them!", vals.len());
                to_remove.push(*pending_reply_target);
                continue;
            };
@@ -745,13 +802,9 @@ where

            let diff = now - last_received_time;

-            if diff > self.config.max_surb_rerequest_waiting_period {
-                if diff > self.config.max_surb_drop_waiting_period {
-                    to_remove.push(*pending_reply_target)
-                } else {
-                    debug!("We haven't received any surbs in {:?} from {pending_reply_target}. Going to explicitly ask for more", diff);
-                    to_request.push(*pending_reply_target);
-                }
+            if diff > self.config.max_surb_waiting_period {
+                warn!("We haven't received any surbs in {:?} from {pending_reply_target}. Going to explicitly ask for more", diff);
+                to_request.push(*pending_reply_target);
            }
        }

@@ -830,20 +883,23 @@ where
        }
    }

-    // #[cfg(not(target_arch = "wasm32"))]
-    // async fn log_status(&self) {
-    //     todo!()
-    // }
+    fn create_interval_stream(polling_rate: Duration) -> IntervalStream {
+        #[cfg(not(target_arch = "wasm32"))]
+        return tokio_stream::wrappers::IntervalStream::new(tokio::time::interval(polling_rate));

-    pub(crate) async fn run_with_shutdown(&mut self, mut shutdown: nym_task::TaskClient) {
+        #[cfg(target_arch = "wasm32")]
+        return gloo_timers::future::IntervalStream::new(polling_rate.as_millis() as u32);
+    }
+
+    pub(crate) async fn run_with_shutdown(&mut self, mut shutdown: task::TaskClient) {
        debug!("Started ReplyController with graceful shutdown support");

        let polling_rate = Duration::from_secs(5);
-        let mut stale_inspection = new_interval_stream(polling_rate);
+        let mut stale_inspection = Self::create_interval_stream(polling_rate);

        // this is in the order of hours/days so we don't have to poll it that often
        let polling_rate = Duration::from_secs(self.config.max_reply_surb_age.as_secs() / 10);
-        let mut invalidation_inspection = new_interval_stream(polling_rate);
+        let mut invalidation_inspection = Self::create_interval_stream(polling_rate);

        while !shutdown.is_shutdown() {
            tokio::select! {
@@ -1,154 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::client::real_messages_control::acknowledgement_control::PendingAcknowledgement;
-use 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 std::sync::Weak;
-
-pub(crate) fn new_control_channels() -> (ReplyControllerSender, ReplyControllerReceiver) {
-    let (tx, rx) = mpsc::unbounded();
-    (tx.into(), rx)
-}
-
-#[derive(Debug, Clone)]
-pub struct ReplyControllerSender(mpsc::UnboundedSender<ReplyControllerMessage>);
-
-impl From<mpsc::UnboundedSender<ReplyControllerMessage>> for ReplyControllerSender {
-    fn from(inner: mpsc::UnboundedSender<ReplyControllerMessage>) -> Self {
-        ReplyControllerSender(inner)
-    }
-}
-
-impl ReplyControllerSender {
-    pub(crate) fn send_retransmission_data(
-        &self,
-        recipient: AnonymousSenderTag,
-        timed_out_ack: Weak<PendingAcknowledgement>,
-        extra_surb_request: bool,
-    ) {
-        self.0
-            .unbounded_send(ReplyControllerMessage::RetransmitReply {
-                recipient,
-                timed_out_ack,
-                extra_surb_request,
-            })
-            .expect("ReplyControllerReceiver has died!")
-    }
-
-    pub(crate) fn send_reply(
-        &self,
-        recipient: AnonymousSenderTag,
-        message: Vec<u8>,
-        lane: TransmissionLane,
-    ) {
-        self.0
-            .unbounded_send(ReplyControllerMessage::SendReply {
-                recipient,
-                message,
-                lane,
-            })
-            .expect("ReplyControllerReceiver has died!")
-    }
-
-    pub(crate) fn send_additional_surbs(
-        &self,
-        sender_tag: AnonymousSenderTag,
-        reply_surbs: Vec<ReplySurb>,
-        from_surb_request: bool,
-    ) {
-        self.0
-            .unbounded_send(ReplyControllerMessage::AdditionalSurbs {
-                sender_tag,
-                reply_surbs,
-                from_surb_request,
-            })
-            .expect("ReplyControllerReceiver has died!")
-    }
-
-    pub(crate) fn send_additional_surbs_request(&self, recipient: Recipient, amount: u32) {
-        self.0
-            .unbounded_send(ReplyControllerMessage::AdditionalSurbsRequest {
-                recipient: Box::new(recipient),
-                amount,
-            })
-            .expect("ReplyControllerReceiver has died!")
-    }
-
-    pub async fn get_lane_queue_length(&self, connection_id: ConnectionId) -> usize {
-        let (response_tx, response_rx) = oneshot::channel();
-        self.0
-            .unbounded_send(ReplyControllerMessage::LaneQueueLength {
-                connection_id,
-                response_channel: response_tx,
-            })
-            .expect("ReplyControllerReceiver has died!");
-
-        match response_rx.await {
-            Ok(length) => length,
-            Err(_) => {
-                error!("The reply controller has dropped our response channel!");
-                // TODO: should we panic here instead? this message implies something weird and unrecoverable has happened
-                0
-            }
-        }
-    }
-}
-
-pub struct ReplyQueueLengths {
-    reply_controller_sender: ReplyControllerSender,
-}
-
-impl ReplyQueueLengths {
-    pub fn new(reply_controller_sender: ReplyControllerSender) -> Self {
-        Self {
-            reply_controller_sender,
-        }
-    }
-
-    pub async fn get_lane_queue_length(&self, connection_id: ConnectionId) -> usize {
-        self.reply_controller_sender
-            .get_lane_queue_length(connection_id)
-            .await
-    }
-}
-
-pub(crate) type ReplyControllerReceiver = mpsc::UnboundedReceiver<ReplyControllerMessage>;
-
-#[derive(Debug)]
-pub(crate) enum ReplyControllerMessage {
-    RetransmitReply {
-        recipient: AnonymousSenderTag,
-        timed_out_ack: Weak<PendingAcknowledgement>,
-        extra_surb_request: bool,
-    },
-
-    SendReply {
-        recipient: AnonymousSenderTag,
-        message: Vec<u8>,
-        lane: TransmissionLane,
-    },
-
-    AdditionalSurbs {
-        sender_tag: AnonymousSenderTag,
-        reply_surbs: Vec<ReplySurb>,
-        from_surb_request: bool,
-    },
-
-    // this one doesn't belong here either...
-    LaneQueueLength {
-        connection_id: ConnectionId,
-        response_channel: oneshot::Sender<usize>,
-    },
-
-    // Should this also be handled in here? it's technically a completely different side of the pipe
-    // let's see how it works when combined, might split it before creating PR
-    AdditionalSurbsRequest {
-        recipient: Box<Recipient>,
-        amount: u32,
-    },
-}
@@ -5,11 +5,8 @@ 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)]
 pub struct Backend {
    empty: Empty,
 }
@@ -29,18 +26,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.minimum_reply_surb_storage_threshold,
-                max_surb_threshold: debug_config.maximum_reply_surb_storage_threshold,
-            },
-        })
-    }
-
    async fn flush_surb_storage(
        &mut self,
        storage: &CombinedReplyStorage,
@@ -55,8 +40,4 @@ impl ReplyStorageBackend for Backend {
    async fn load_surb_storage(&self) -> Result<CombinedReplyStorage, Self::StorageError> {
        self.empty.load_surb_storage().await
    }
-
-    fn get_inactive_storage(&self) -> Result<CombinedReplyStorage, Self::StorageError> {
-        self.empty.get_inactive_storage()
-    }
 }
@@ -10,12 +10,6 @@ pub enum StorageError {
    #[error("the provided database path doesn't have a filename defined")]
    DatabasePathWithoutFilename { provided_path: PathBuf },

-    #[error("unable to create the directory for the database")]
-    DatabasePathUnableToCreateParentDirectory {
-        provided_path: PathBuf,
-        source: io::Error,
-    },
-
    #[error("failed to rename our databse file - {source}")]
    DatabaseRenameError {
        #[source]
@@ -56,9 +50,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>,
-    },
 }
@@ -20,16 +20,6 @@ impl StorageManager {
        database_path: P,
        fresh: bool,
    ) -> Result<Self, StorageError> {
-        // ensure the whole directory structure exists
-        if let Some(parent_dir) = database_path.as_ref().parent() {
-            std::fs::create_dir_all(parent_dir).map_err(|source| {
-                StorageError::DatabasePathUnableToCreateParentDirectory {
-                    provided_path: database_path.as_ref().to_path_buf(),
-                    source,
-                }
-            })?;
-        }
-
        let mut opts = sqlx::sqlite::SqliteConnectOptions::new()
            .filename(database_path)
            .create_if_missing(fresh);
@@ -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;
@@ -23,49 +22,11 @@ mod error;
 mod manager;
 mod models;

-#[derive(Debug)]
-enum StorageManagerState {
-    Storage(StorageManager),
-    Inactive(InactiveMetadata),
-}
-
-// When the storage backaed is initialized as inactive, it will still contain metadata parameters
-// that will be needed when the in-mem storage is fetched for use.
-#[derive(Debug)]
-struct InactiveMetadata {
-    pub minimum_reply_surb_storage_threshold: usize,
-    pub maximum_reply_surb_storage_threshold: usize,
-}
-
-impl StorageManagerState {
-    fn get(&self) -> &StorageManager {
-        match self {
-            StorageManagerState::Storage(manager) => manager,
-            StorageManagerState::Inactive(_) => {
-                panic!("tried to get storage of an inactive backend")
-            }
-        }
-    }
-
-    fn get_mut(&mut self) -> &mut StorageManager {
-        match self {
-            StorageManagerState::Storage(manager) => manager,
-            StorageManagerState::Inactive(_) => {
-                panic!("tried to get storage of an inactive backend")
-            }
-        }
-    }
-
-    fn is_active(&self) -> bool {
-        matches!(self, StorageManagerState::Storage(_))
-    }
-}
-
 #[derive(Debug)]
 pub struct Backend {
    temporary_old_path: Option<PathBuf>,
    database_path: PathBuf,
-    manager: StorageManagerState,
+    manager: StorageManager,
 }

 impl Backend {
@@ -79,30 +40,15 @@ impl Backend {
            });
        }

-        let manager = StorageManager::init(database_path, true).await?;
-        manager.create_status_table().await?;
-
        let backend = Backend {
            temporary_old_path: None,
            database_path: owned_path,
-            manager: StorageManagerState::Storage(manager),
+            manager: StorageManager::init(database_path, true).await?,
        };

-        Ok(backend)
-    }
+        backend.manager.create_status_table().await?;

-    pub fn new_inactive(
-        minimum_reply_surb_storage_threshold: usize,
-        maximum_reply_surb_storage_threshold: usize,
-    ) -> Self {
-        Backend {
-            temporary_old_path: None,
-            database_path: PathBuf::new(),
-            manager: StorageManagerState::Inactive(InactiveMetadata {
-                minimum_reply_surb_storage_threshold,
-                maximum_reply_surb_storage_threshold,
-            }),
-        }
+        Ok(backend)
    }

    pub async fn try_load<P: AsRef<Path>>(database_path: P) -> Result<Self, StorageError> {
@@ -173,12 +119,12 @@ impl Backend {
        Ok(Backend {
            temporary_old_path: None,
            database_path: owned_path,
-            manager: StorageManagerState::Storage(manager),
+            manager,
        })
    }

    async fn close_pool(&mut self) {
-        self.manager.get_mut().connection_pool.close().await;
+        self.manager.connection_pool.close().await;
    }

    async fn rotate(&mut self) -> Result<(), StorageError> {
@@ -197,9 +143,8 @@ impl Backend {

        fs::rename(&self.database_path, &temp_old)
            .map_err(|err| StorageError::DatabaseRenameError { source: err })?;
-        self.manager =
-            StorageManagerState::Storage(StorageManager::init(&self.database_path, true).await?);
-        self.manager.get_mut().create_status_table().await?;
+        self.manager = StorageManager::init(&self.database_path, true).await?;
+        self.manager.create_status_table().await?;

        self.temporary_old_path = Some(temp_old);
        Ok(())
@@ -216,27 +161,26 @@ impl Backend {
    }

    async fn start_storage_flush(&self) -> Result<(), StorageError> {
-        Ok(self.manager.get().set_flush_status(true).await?)
+        Ok(self.manager.set_flush_status(true).await?)
    }

    async fn end_storage_flush(&self) -> Result<(), StorageError> {
        self.manager
-            .get()
            .set_previous_flush_timestamp(OffsetDateTime::now_utc().unix_timestamp())
            .await?;
-        Ok(self.manager.get().set_flush_status(false).await?)
+        Ok(self.manager.set_flush_status(false).await?)
    }

    async fn start_client_use(&self) -> Result<(), StorageError> {
-        Ok(self.manager.get().set_client_in_use_status(true).await?)
+        Ok(self.manager.set_client_in_use_status(true).await?)
    }

    async fn stop_client_use(&self) -> Result<(), StorageError> {
-        Ok(self.manager.get().set_client_in_use_status(false).await?)
+        Ok(self.manager.set_client_in_use_status(false).await?)
    }

    async fn get_stored_tags(&self) -> Result<UsedSenderTags, StorageError> {
-        let stored = self.manager.get().get_tags().await?;
+        let stored = self.manager.get_tags().await?;

        // stop at the first instance of corruption. if even a single entry is malformed,
        // something weird has happened and we can't trust the rest of the data
@@ -252,7 +196,6 @@ impl Backend {
        for map_ref in tags.as_raw_iter() {
            let (recipient, tag) = map_ref.pair();
            self.manager
-                .get()
                .insert_tag(StoredSenderTag::new(*recipient, *tag))
                .await?;
        }
@@ -260,7 +203,7 @@ impl Backend {
    }

    async fn get_stored_reply_keys(&self) -> Result<SentReplyKeys, StorageError> {
-        let stored = self.manager.get().get_reply_keys().await?;
+        let stored = self.manager.get_reply_keys().await?;

        // stop at the first instance of corruption. if even a single entry is malformed,
        // something weird has happened and we can't trust the rest of the data
@@ -276,7 +219,6 @@ impl Backend {
        for map_ref in reply_keys.as_raw_iter() {
            let (digest, key) = map_ref.pair();
            self.manager
-                .get()
                .insert_reply_key(StoredReplyKey::new(*digest, *key))
                .await?;
        }
@@ -284,7 +226,7 @@ impl Backend {
    }

    async fn get_stored_reply_surbs(&self) -> Result<ReceivedReplySurbsMap, StorageError> {
-        let surb_senders = self.manager.get().get_surb_senders().await?;
+        let surb_senders = self.manager.get_surb_senders().await?;

        let metadata = self.get_reply_surb_storage_metadata().await?;
        let mut received_surbs = Vec::with_capacity(surb_senders.len());
@@ -294,7 +236,6 @@ impl Backend {
                sender.try_into()?;
            let stored_surbs = self
                .manager
-                .get()
                .get_reply_surbs(sender_id)
                .await?
                .into_iter()
@@ -322,7 +263,6 @@ impl Backend {
            let (tag, received_surbs) = map_ref.pair();
            let sender_id = self
                .manager
-                .get()
                .insert_surb_sender(StoredSurbSender::new(
                    *tag,
                    received_surbs.surbs_last_received_at(),
@@ -331,7 +271,6 @@ impl Backend {

            for reply_surb in received_surbs.surbs_ref() {
                self.manager
-                    .get()
                    .insert_reply_surb(StoredReplySurb::new(sender_id, reply_surb))
                    .await?
            }
@@ -343,7 +282,6 @@ impl Backend {
        &self,
    ) -> Result<ReplySurbStorageMetadata, StorageError> {
        self.manager
-            .get()
            .get_reply_surb_storage_metadata()
            .await
            .map_err(Into::into)
@@ -354,7 +292,6 @@ impl Backend {
        reply_surbs: &ReceivedReplySurbsMap,
    ) -> Result<(), StorageError> {
        self.manager
-            .get()
            .insert_reply_surb_storage_metadata(ReplySurbStorageMetadata::new(
                reply_surbs.min_surb_threshold(),
                reply_surbs.max_surb_threshold(),
@@ -368,24 +305,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()
-    }
-
    async fn start_storage_session(&self) -> Result<(), Self::StorageError> {
        self.start_client_use().await
    }
@@ -423,18 +342,6 @@ impl ReplyStorageBackend for Backend {
        Ok(CombinedReplyStorage::load(reply_keys, reply_surbs, tags))
    }

-    fn get_inactive_storage(&self) -> Result<CombinedReplyStorage, Self::StorageError> {
-        match self.manager {
-            StorageManagerState::Storage(_) => {
-                panic!("tried to get inactive storage from an active storage backend")
-            }
-            StorageManagerState::Inactive(ref state) => Ok(CombinedReplyStorage::new(
-                state.minimum_reply_surb_storage_threshold,
-                state.maximum_reply_surb_storage_threshold,
-            )),
-        }
-    }
-
    async fn stop_storage_session(self) -> Result<(), Self::StorageError> {
        self.stop_client_use().await
    }
@@ -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 {
@@ -44,7 +44,8 @@ impl TryFrom<StoredSenderTag> for (RecipientBytes, AnonymousSenderTag) {
        let Ok(sender_tag_bytes) = value.tag.try_into() else {
            return Err(StorageError::CorruptedData {
                details: format!(
-                    "the retrieved sender tag has length of {tag_len} while {SENDER_TAG_SIZE} was expected",
+                    "the retrieved sender tag has length of {tag_len} while {} was expected",
+                    SENDER_TAG_SIZE
                ),
            });
        };
@@ -131,7 +132,8 @@ impl TryFrom<StoredSurbSender> for (AnonymousSenderTag, i64) {
        let Ok(sender_tag_bytes) = value.tag.try_into() else {
            return Err(StorageError::CorruptedData {
                details: format!(
-                    "the retrieved sender tag has length of {tag_len} while {SENDER_TAG_SIZE} was expected",
+                    "the retrieved sender tag has length of {tag_len} while {} was expected",
+                    SENDER_TAG_SIZE
                ),
            });
        };
@@ -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")]
@@ -19,27 +19,16 @@ pub mod fs_backend;
 #[error("no information provided")]
 pub struct UndefinedError;

-#[derive(Debug)]
 pub struct Empty {
    // we need to keep 'basic' metadata here to "load" the CombinedReplyStorage
-    pub min_surb_threshold: usize,
-    pub max_surb_threshold: usize,
+    min_surb_threshold: usize,
+    max_surb_threshold: usize,
 }

 #[async_trait]
 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.minimum_reply_surb_storage_threshold,
-            max_surb_threshold: debug_config.maximum_reply_surb_storage_threshold,
-        })
-    }
-
    async fn flush_surb_storage(
        &mut self,
        _storage: &CombinedReplyStorage,
@@ -60,28 +49,12 @@ impl ReplyStorageBackend for Empty {
            self.max_surb_threshold,
        ))
    }
-
-    fn get_inactive_storage(&self) -> Result<CombinedReplyStorage, Self::StorageError> {
-        Ok(CombinedReplyStorage::new(
-            self.min_surb_threshold,
-            self.max_surb_threshold,
-        ))
-    }
 }

 #[async_trait]
 pub trait ReplyStorageBackend: Sized {
    type StorageError: Error + 'static;

-    async fn new(
-        debug_config: &crate::config::DebugConfig,
-        db_path: Option<PathBuf>,
-    ) -> Result<Self, Self::StorageError>;
-
-    fn is_active(&self) -> bool {
-        true
-    }
-
    async fn start_storage_session(&self) -> Result<(), Self::StorageError> {
        Ok(())
    }
@@ -99,11 +72,6 @@ pub trait ReplyStorageBackend: Sized {

    async fn load_surb_storage(&self) -> Result<CombinedReplyStorage, Self::StorageError>;

-    /// In the case the storage backend is initialized in an inactive state (persisting data is
-    /// disabled), we might still need to fetch the (in-mem) storage and the parameters it was
-    /// created with.
-    fn get_inactive_storage(&self) -> Result<CombinedReplyStorage, Self::StorageError>;
-
    async fn stop_storage_session(self) -> Result<(), Self::StorageError> {
        Ok(())
    }
@@ -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"))]
@@ -4,15 +4,15 @@
 use crate::spawn_future;
 use futures::StreamExt;
 use log::*;
-use nym_sphinx::addressing::clients::Recipient;
-use nym_sphinx::params::DEFAULT_NUM_MIX_HOPS;
-use nym_topology::{nym_topology_from_detailed, NymTopology, NymTopologyError};
+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
@@ -152,7 +152,7 @@ impl TopologyRefresherConfig {
 }

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

    nym_api_urls: Vec<Url>,
@@ -168,9 +168,7 @@ impl TopologyRefresher {
        cfg.nym_api_urls.shuffle(&mut thread_rng());

        TopologyRefresher {
-            validator_client: validator_client::client::NymApiClient::new(
-                cfg.nym_api_urls[0].clone(),
-            ),
+            validator_client: validator_client::client::ApiClient::new(cfg.nym_api_urls[0].clone()),
            client_version: cfg.client_version,
            nym_api_urls: cfg.nym_api_urls,
            topology_accessor,
@@ -306,7 +304,7 @@ impl TopologyRefresher {
        self.topology_accessor.ensure_is_routable().await
    }

-    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 TopologyRefresher with graceful shutdown support");

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

-use nym_config::defaults::NymNetworkDetails;
-use nym_config::{NymConfig, OptionalSet, DB_FILE_NAME};
-use nym_sphinx::params::PacketSize;
+use config::{NymConfig, DB_FILE_NAME};
+use nymsphinx::params::PacketSize;
 use serde::{Deserialize, Serialize};
 use std::marker::PhantomData;
 use std::path::PathBuf;
@@ -45,8 +44,7 @@ const DEFAULT_MAXIMUM_REPLY_SURB_REQUEST_SIZE: u32 = 100;

 const DEFAULT_MAXIMUM_ALLOWED_SURB_REQUEST_SIZE: u32 = 500;

-const DEFAULT_MAXIMUM_REPLY_SURB_REREQUEST_WAITING_PERIOD: Duration = Duration::from_secs(10);
-const DEFAULT_MAXIMUM_REPLY_SURB_DROP_WAITING_PERIOD: Duration = Duration::from_secs(5 * 60);
+const DEFAULT_MAXIMUM_REPLY_SURB_WAITING_PERIOD: Duration = Duration::from_secs(10);

 // 12 hours
 const DEFAULT_MAXIMUM_REPLY_SURB_AGE: Duration = Duration::from_secs(12 * 60 * 60);
@@ -72,15 +70,12 @@ pub struct Config<T> {
    #[serde(default)]
    debug: DebugConfig,
 }
-
 impl<T> ClientCoreConfigTrait for Config<T> {
    fn get_gateway_endpoint(&self) -> &GatewayEndpointConfig {
        &self.client.gateway_endpoint
    }
 }

-impl<T> OptionalSet for Config<T> where T: NymConfig {}
-
 impl<T> Config<T> {
    pub fn new<S: Into<String>>(id: S) -> Self
    where
@@ -89,7 +84,6 @@ impl<T> Config<T> {
        Config::default().with_id(id)
    }

-    #[must_use]
    pub fn with_id<S: Into<String>>(mut self, id: S) -> Self
    where
        T: NymConfig,
@@ -166,49 +160,26 @@ impl<T> Config<T> {
        changes_made
    }

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

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

-    pub fn with_gateway_endpoint(mut self, gateway_endpoint: GatewayEndpointConfig) -> Self {
-        self.client.gateway_endpoint = gateway_endpoint;
-        self
-    }
-
    pub fn with_gateway_id<S: Into<String>>(&mut self, id: S) {
        self.client.gateway_endpoint.gateway_id = id.into();
    }

-    pub fn with_custom_nyxd(mut self, urls: Vec<Url>) -> Self {
-        self.client.nyxd_urls = urls;
-        self
-    }
-
-    pub fn set_custom_nyxd(&mut self, nyxd_urls: Vec<Url>) {
-        self.client.nyxd_urls = nyxd_urls;
-    }
-
-    pub fn with_custom_nym_apis(mut self, nym_api_urls: Vec<Url>) -> Self {
-        self.client.nym_api_urls = nym_api_urls;
-        self
+    pub fn set_custom_validators(&mut self, validator_urls: Vec<Url>) {
+        self.client.validator_urls = validator_urls;
    }

    pub fn set_custom_nym_apis(&mut self, nym_api_urls: Vec<Url>) {
        self.client.nym_api_urls = nym_api_urls;
    }

-    pub fn with_high_default_traffic_volume(mut self, enabled: bool) -> Self {
-        if enabled {
-            self.set_high_default_traffic_volume();
-        }
-        self
-    }
-
    pub fn set_high_default_traffic_volume(&mut self) {
        self.debug.average_packet_delay = Duration::from_millis(10);
        // basically don't really send cover messages
@@ -217,13 +188,6 @@ impl<T> Config<T> {
        self.debug.message_sending_average_delay = Duration::from_millis(4);
    }

-    pub fn with_disabled_cover_traffic(mut self, disabled: bool) -> Self {
-        if disabled {
-            self.set_no_cover_traffic()
-        }
-        self
-    }
-
    pub fn set_no_cover_traffic(&mut self) {
        self.debug.disable_loop_cover_traffic_stream = true;
        self.debug.disable_main_poisson_packet_distribution = true;
@@ -270,7 +234,7 @@ impl<T> Config<T> {
    }

    pub fn get_validator_endpoints(&self) -> Vec<Url> {
-        self.client.nyxd_urls.clone()
+        self.client.validator_urls.clone()
    }

    pub fn get_nym_api_endpoints(&self) -> Vec<Url> {
@@ -378,12 +342,8 @@ impl<T> Config<T> {
        self.debug.maximum_allowed_reply_surb_request_size
    }

-    pub fn get_maximum_reply_surb_rerequest_waiting_period(&self) -> Duration {
-        self.debug.maximum_reply_surb_rerequest_waiting_period
-    }
-
-    pub fn get_maximum_reply_surb_drop_waiting_period(&self) -> Duration {
-        self.debug.maximum_reply_surb_drop_waiting_period
+    pub fn get_maximum_reply_surb_waiting_period(&self) -> Duration {
+        self.debug.maximum_reply_surb_waiting_period
    }

    pub fn get_maximum_reply_surb_age(&self) -> Duration {
@@ -435,8 +395,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(),
@@ -460,9 +420,9 @@ pub struct Client<T> {
    #[serde(default)]
    disabled_credentials_mode: bool,

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

    /// Addresses to APIs running on validator from which the client gets the view of the network.
    #[serde(alias = "validator_api_urls")]
@@ -511,29 +471,13 @@ pub struct Client<T> {

 impl<T: NymConfig> Default for Client<T> {
    fn default() -> Self {
-        let network = NymNetworkDetails::new_mainnet();
-        let nyxd_urls = network
-            .endpoints
-            .iter()
-            .map(|validator| validator.nyxd_url())
-            .collect();
-        let nym_api_urls = network
-            .endpoints
-            .iter()
-            .filter_map(|validator| validator.api_url())
-            .collect::<Vec<_>>();
-
-        if nym_api_urls.is_empty() {
-            panic!("we do not have any default nym-api urls available!")
-        }
-
        // there must be explicit checks for whether id is not empty later
        Client {
            version: env!("CARGO_PKG_VERSION").to_string(),
            id: "".to_string(),
            disabled_credentials_mode: true,
-            nyxd_urls,
-            nym_api_urls,
+            validator_urls: vec![],
+            nym_api_urls: vec![],
            private_identity_key_file: Default::default(),
            public_identity_key_file: Default::default(),
            private_encryption_key_file: Default::default(),
@@ -551,35 +495,35 @@ impl<T: NymConfig> Default for Client<T> {

 impl<T: NymConfig> Client<T> {
    fn default_private_identity_key_file(id: &str) -> PathBuf {
-        T::default_data_directory(id).join("private_identity.pem")
+        T::default_data_directory(Some(id)).join("private_identity.pem")
    }

    fn default_public_identity_key_file(id: &str) -> PathBuf {
-        T::default_data_directory(id).join("public_identity.pem")
+        T::default_data_directory(Some(id)).join("public_identity.pem")
    }

    fn default_private_encryption_key_file(id: &str) -> PathBuf {
-        T::default_data_directory(id).join("private_encryption.pem")
+        T::default_data_directory(Some(id)).join("private_encryption.pem")
    }

    fn default_public_encryption_key_file(id: &str) -> PathBuf {
-        T::default_data_directory(id).join("public_encryption.pem")
+        T::default_data_directory(Some(id)).join("public_encryption.pem")
    }

    fn default_gateway_shared_key_file(id: &str) -> PathBuf {
-        T::default_data_directory(id).join("gateway_shared.pem")
+        T::default_data_directory(Some(id)).join("gateway_shared.pem")
    }

    fn default_ack_key_file(id: &str) -> PathBuf {
-        T::default_data_directory(id).join("ack_key.pem")
+        T::default_data_directory(Some(id)).join("ack_key.pem")
    }

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

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

@@ -673,12 +617,7 @@ pub struct DebugConfig {
    /// Defines maximum amount of time the client is going to wait for reply surbs before explicitly asking
    /// for more even though in theory they wouldn't need to.
    #[serde(with = "humantime_serde")]
-    pub maximum_reply_surb_rerequest_waiting_period: Duration,
-
-    /// Defines maximum amount of time the client is going to wait for reply surbs before
-    /// deciding it's never going to get them and would drop all pending messages
-    #[serde(with = "humantime_serde")]
-    pub maximum_reply_surb_drop_waiting_period: Duration,
+    pub maximum_reply_surb_waiting_period: Duration,

    /// Defines maximum amount of time given reply surb is going to be valid for.
    /// This is going to be superseded by key rotation once implemented.
@@ -719,9 +658,7 @@ impl Default for DebugConfig {
            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_waiting_period: DEFAULT_MAXIMUM_REPLY_SURB_WAITING_PERIOD,
            maximum_reply_surb_age: DEFAULT_MAXIMUM_REPLY_SURB_AGE,
            maximum_reply_key_age: DEFAULT_MAXIMUM_REPLY_KEY_AGE,
        }
@@ -2,17 +2,17 @@
 // SPDX-License-Identifier: Apache-2.0

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

 #[derive(Debug)]
 pub struct ClientKeyPathfinder {
-    pub identity_private_key: PathBuf,
-    pub identity_public_key: PathBuf,
-    pub encryption_private_key: PathBuf,
-    pub encryption_public_key: PathBuf,
-    pub gateway_shared_key: PathBuf,
-    pub ack_key: PathBuf,
+    identity_private_key: PathBuf,
+    identity_public_key: PathBuf,
+    encryption_private_key: PathBuf,
+    encryption_public_key: PathBuf,
+    gateway_shared_key: PathBuf,
+    ack_key: PathBuf,
 }

 impl ClientKeyPathfinder {
@@ -22,8 +22,8 @@ impl ClientKeyPathfinder {
        ClientKeyPathfinder {
            identity_private_key: config_dir.join("private_identity.pem"),
            identity_public_key: config_dir.join("public_identity.pem"),
-            encryption_private_key: config_dir.join("private_encryption.pem"),
-            encryption_public_key: config_dir.join("public_encryption.pem"),
+            encryption_private_key: config_dir.join("public_encryption.pem"),
+            encryption_public_key: config_dir.join("private_encryption.pem"),
            gateway_shared_key: config_dir.join("gateway_shared.pem"),
            ack_key: config_dir.join("ack_key.pem"),
        }
@@ -40,28 +40,6 @@ impl ClientKeyPathfinder {
        }
    }

-    pub fn any_file_exists(&self) -> bool {
-        matches!(self.identity_public_key.try_exists(), Ok(true))
-            || matches!(self.identity_private_key.try_exists(), Ok(true))
-            || matches!(self.encryption_public_key.try_exists(), Ok(true))
-            || matches!(self.encryption_private_key.try_exists(), Ok(true))
-            || matches!(self.gateway_shared_key.try_exists(), Ok(true))
-            || matches!(self.ack_key.try_exists(), Ok(true))
-    }
-
-    pub fn any_file_exists_and_return(&self) -> Option<PathBuf> {
-        file_exists(&self.identity_public_key)
-            .or_else(|| file_exists(&self.identity_private_key))
-            .or_else(|| file_exists(&self.encryption_public_key))
-            .or_else(|| file_exists(&self.encryption_private_key))
-            .or_else(|| file_exists(&self.gateway_shared_key))
-            .or_else(|| file_exists(&self.ack_key))
-    }
-
-    pub fn gateway_key_file_exists(&self) -> bool {
-        matches!(self.gateway_shared_key.try_exists(), Ok(true))
-    }
-
    pub fn private_identity_key(&self) -> &Path {
        &self.identity_private_key
    }
@@ -86,10 +64,3 @@ impl ClientKeyPathfinder {
        &self.ack_key
    }
 }
-
-fn file_exists(path: &Path) -> Option<PathBuf> {
-    if matches!(path.try_exists(), Ok(true)) {
-        return Some(path.to_path_buf());
-    }
-    None
-}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
fmtabbara	43d6908d22	display loading modal for initial loading of values run cargo fmt fix clippy error minor fixes	2022-12-19 09:38:00 +00:00
fmtabbara	e10f291ee9	set active set to be always true	2022-12-19 09:38:00 +00:00
Jon Häggblad	ecc89ced08	Make ComputeRewardEstParam derive Debug	2022-12-19 09:38:00 +00:00
fmtabbara	1e10c247bc	calculate saturation tidy Use NodeId in compute_mixnode_reward_estimation only call handleCalculation on button click fix validation tests tweak calculations calculate stake saturation pick up and display errors pass profit margin and operator cost as args rebase develop rebase develop fix profit margin validation tidy up refactor requests for rewards playground wip	2022-12-19 09:38:00 +00:00
fmtabbara	4584f35a2a	get mixnode reward estimation separarte handleCalculate function into own file add mix-id to bondedNode state remove unused imports	2022-12-19 09:38:00 +00:00
fmtabbara	41fa03862e	get node uptime	2022-12-19 09:38:00 +00:00
fmtabbara	66303d7ca4	init playground with default values add more default values env updates	2022-12-19 09:38:00 +00:00
fmtabbara	480f8a0a53	update validation for rewards playground	2022-12-19 09:38:00 +00:00
fmtabbara	ecb0f11bbb	add initial rewards calculation run make file	2022-12-19 09:38:00 +00:00
fmtabbara	fe223b5a60	apy playground ui update calc button style validator-api-client and wallet: compute mixnode reward estimation	2022-12-19 09:37:45 +00:00
fmtabbara	b9e52d22d1	add print to pdf package	2022-12-19 09:36:56 +00:00
fmtabbara	ecdf192b47	initial ui for test my node use svg for node path adjust layout for overiew page add stories for test my node remove placeholder nav item add top margin to app bar add print to pdf functionality for node test results	2022-12-19 09:36:56 +00:00