Remove mixnode modifications

* wip

* updated gateways 'sign' command

* in-wallet verification of mix bonding signature

* changed signature of vesting contract trait method

* updated wallet bonding endpoints

* tauri commands for generating signing payloads

* renamed signer to sender

* verifying new signatures in the contract

* fixed existing mixnet unit tests

* unit tests for invalid signatures

* fixed other usages of MessageSignature + FromStr

* using base58-encoded serialization

* removed owner-signature from details response

* added ability to construct bonding payloads via nym-cli

* removed signature from bonding payload args

* moved 'message_type' from 'ContractMessageContent' to 'SignableMessage'

* refactor(wallet-rust): rename owner_signature args

* feat(wallet-bonding): handle user signature

* feat(wallet-bonding): fix bonding

* feat(wallet-bonding): fix lint issue

* feat(wallet-bonding): ui adjustment

* make the location field mandatory for payload signing

* feat(wallet-bonding): remove ownersignature field, remove dead code

---------

Co-authored-by: Jędrzej Stuczyński <jedrzej.stuczynski@gmail.com>
Co-authored-by: Tommy Verrall <tommyvez@protonmail.com>

.github/workflows/audit.yml

@@ -35,20 +35,20 @@ jobs:
         with:
           name: report
           path: .github/workflows/support-files/notifications
-      - name: Keybase - Node Install
+      - name: install npm
+        uses: actions/setup-node@v3
+        with:
+          node-version: 16
+      - name: Matrix - Node Install
         run: npm install
         working-directory: .github/workflows/support-files
-      - name: Keybase - Send Notification
+      - name: Matrix - Send Notification
         env:
           NYM_NOTIFICATION_KIND: security
           NYM_PROJECT_NAME: "Daily security report"
           GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
-          KEYBASE_NYMBOT_USERNAME: "${{ secrets.KEYBASE_NYMBOT_USERNAME }}"
-          KEYBASE_NYMBOT_PAPERKEY: "${{ secrets.KEYBASE_NYMBOT_PAPERKEY }}"
-          KEYBASE_NYMBOT_TEAM: "${{ secrets.KEYBASE_NYMBOT_TEAM }}"
-          KEYBASE_NYM_CHANNEL: "security"
           MATRIX_SERVER: "${{ secrets.MATRIX_SERVER }}"
-          MATRIX_ROOM: "${{ secrets.MATRIX_ROOM }}"
+          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 }}"

.github/workflows/audit_on_dispatch.yml

@@ -1,58 +0,0 @@
-name: Daily security audit
-
-on: workflow_dispatch
-jobs:
-  cargo-deny:
-    runs-on: ubuntu-20.04
-    steps:
-      - name: Checkout repository code
-        uses: actions/checkout@v2
-      - name: Install rust toolchain
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-      - name: Install cargo deny
-        run: cargo install --locked cargo-deny
-      - name: Run cargo deny
-        run: |
-          find . -name Cargo.toml -exec cargo deny --manifest-path {} check \
-            advisories -A advisory-not-detected  --hide-inclusion-graph \; &> \
-            >(uniq  &> .github/workflows/support-files/notifications/deny.message )
-      - uses: actions/upload-artifact@v3
-        with:
-          name: report
-          path: .github/workflows/support-files/notifications/deny.message
-  notification:
-    needs: cargo-deny
-    runs-on: custom-runner-linux
-    steps:
-      - name: Check out repository code
-        uses: actions/checkout@v2
-      - name: Download report from previous job
-        uses: actions/download-artifact@v3
-        with:
-          name: report
-          path: .github/workflows/support-files/notifications
-      - uses: actions/setup-node@v3
-        with:
-          node-version: 16
-      - name: Keybase - Node Install
-        run: npm install
-        working-directory: .github/workflows/support-files
-      - name: Keybase - Send Notification
-        env:
-          NYM_NOTIFICATION_KIND: security
-          NYM_PROJECT_NAME: "Daily security report"
-          GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
-          KEYBASE_NYMBOT_USERNAME: "${{ secrets.KEYBASE_NYMBOT_USERNAME }}"
-          KEYBASE_NYMBOT_PAPERKEY: "${{ secrets.KEYBASE_NYMBOT_PAPERKEY }}"
-          KEYBASE_NYMBOT_TEAM: "${{ secrets.KEYBASE_NYMBOT_TEAM }}"
-          KEYBASE_NYM_CHANNEL: "security"
-          MATRIX_SERVER: "${{ secrets.MATRIX_SERVER }}"
-          MATRIX_ROOM: "${{ secrets.MATRIX_ROOM }}"
-          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

.github/workflows/build-and-upload-binaries-ci.yml

@@ -0,0 +1,116 @@
+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: Install wasm-opt
+        run: cargo install wasm-opt
+
+      - 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/"

.github/workflows/build-and-upload-binaries.yml

@@ -0,0 +1,59 @@
+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

.github/workflows/build-ts-packages.yml

@@ -12,6 +12,7 @@ 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:
@@ -42,10 +43,10 @@ jobs:
         REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
         TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/ts-${{ env.GITHUB_REF_SLUG }}-example
         EXCLUDE: "/dist/, /node_modules/"
-    - name: Keybase - Node Install
+    - name: Matrix - Node Install
       run: npm install
       working-directory: .github/workflows/support-files
-    - name: Keybase - Send Notification
+    - name: Matrix - Send Notification
       env:
         NYM_NOTIFICATION_KIND: ts-packages
         NYM_PROJECT_NAME: "ts-packages"
@@ -53,10 +54,6 @@ 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 }}"

.github/workflows/build.yml

@@ -2,11 +2,33 @@ name: Continuous integration
 
 on:
   push:
-    paths-ignore:
-      - 'explorer/**'
+    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/**'
   pull_request:
-    paths-ignore:
-      - 'explorer/**'
+    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/**'
 
 jobs:
   build:
@@ -17,6 +39,7 @@ 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 libudev-dev squashfs-tools
+        continue-on-error: true
 
       - name: Check out repository code
         uses: actions/checkout@v2
@@ -41,48 +64,34 @@ 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 --all-features
+          args: --workspace
 
       - name: Run expensive tests
         if: github.ref == 'refs/heads/develop' || github.event.pull_request.base.ref == 'develop' || github.event.pull_request.base.ref == 'master'
         uses: actions-rs/cargo@v1
         with:
           command: test
-          args: --workspace --all-features -- --ignored
+          args: --workspace -- --ignored
 
       - uses: actions-rs/clippy-check@v1
         name: Clippy checks
         continue-on-error: true
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
-          args: --workspace --all-features
+          args: --workspace
 
       - name: Run clippy
         uses: actions-rs/cargo@v1
         with:
           command: clippy
-          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
+          args: --workspace --all-targets -- -D warnings

.github/workflows/check-merge-conflicts.yml

@@ -0,0 +1,61 @@
+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}}

.github/workflows/ci-binary-checker.yml

@@ -0,0 +1,56 @@
+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/
+        
+      

.github/workflows/connect-android-build.yml

@@ -0,0 +1,138 @@
+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: ???

.github/workflows/connect-desktop-ci.yml

@@ -1,13 +1,13 @@
-name: CI for nym-connect
+name: CI for nym-connect - Desktop
 
 on:
   push:
     paths:
-      - 'nym-connect/**'
+      - 'nym-connect/desktop/**'
 
 defaults:
   run:
-    working-directory: nym-connect
+    working-directory: nym-connect/desktop
 
 jobs:
   build:
@@ -16,6 +16,7 @@ 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:
@@ -33,15 +34,15 @@ jobs:
       env:
         SSH_PRIVATE_KEY: ${{ secrets.CI_WWW_SSH_PRIVATE_KEY }}
         ARGS: "-rltgoDzvO --delete"
-        SOURCE: "nym-connect/storybook-static/"
+        SOURCE: "nym-connect/desktop/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: Keybase - Node Install
+    - name: Matrix - Node Install
       run: npm install
       working-directory: .github/workflows/support-files
-    - name: Keybase - Send Notification
+    - name: Matrix - Send Notification
       env:
         NYM_NOTIFICATION_KIND: nym-connect
         NYM_PROJECT_NAME: "nym-connect"
@@ -49,10 +50,6 @@ 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 }}"

.github/workflows/connect-desktop.yml

@@ -1,18 +1,36 @@
-name: Nym Connect (rust)
+name: Nym Connect - desktop (Rust)
 
 on:
   push:
-    paths-ignore:
-      - 'explorer/**'
+    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 ]
+    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
@@ -29,29 +47,29 @@ jobs:
         uses: actions-rs/cargo@v1
         with:
           command: build
-          args: --manifest-path nym-connect/Cargo.toml --workspace
+          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/Cargo.toml --workspace
+          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/Cargo.toml --all -- --check
+          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/Cargo.toml --workspace --all-features
+          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/Cargo.toml --workspace --all-features -- -D warnings
+          args: --manifest-path nym-connect/desktop/Cargo.toml --workspace --all-features -- -D warnings

.github/workflows/connect-mobile.yml

@@ -0,0 +1,72 @@
+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

.github/workflows/contracts-build.yml

@@ -6,17 +6,11 @@ on:
 
 jobs:
   build:
-    runs-on: ubuntu-20.04
+    if: ${{ (startsWith(github.ref, 'refs/tags/nym-contracts-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
+    runs-on: [self-hosted, custom-runner-linux]
     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:
@@ -25,6 +19,9 @@ jobs:
           override: true
           components: rustfmt, clippy
 
+      - name: Install wasm-opt
+        run: cargo install wasm-opt
+
       - name: Build release contracts
         run: make wasm
 

.github/workflows/contracts.yml

@@ -2,11 +2,13 @@ name: Contracts
 
 on:
   push:
-    paths-ignore:
-      - 'explorer/**'
+    paths:
+      - 'contracts/**'
+      - 'common/**'
   pull_request:
     paths-ignore:
-      - 'explorer/**'
+      - 'contracts/**'
+      - 'common/**'
 
 jobs:
   matrix_prep:

.github/workflows/network-explorer-api.yml

@@ -1,56 +0,0 @@
-name: CI for Network Explorer API
-
-on:
-  workflow_dispatch:
-  release:
-    types: [created]
-    
-env:
-  NETWORK: mainnet    
-
-jobs:
-  publish-nym:
-    strategy:
-      fail-fast: false
-      matrix:
-        platform: [ubuntu-20.04]
-
-    runs-on: ${{ matrix.platform }}
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Install Dependencies (Linux)
-        run: sudo apt-get update && sudo apt-get -y install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libudev-dev squashfs-tools
-
-      - name: Check the release tag starts with `nym-explorer-api-`
-        if: startsWith(github.ref, 'refs/tags/nym-explorer-api-') == false && github.event_name != 'workflow_dispatch'
-        uses: actions/github-script@v3
-        with:
-          script: |
-            core.setFailed('Release tag did not start with nym-explorer-api-...')
-
-      - name: Install Rust stable
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-
-      - name: Build all explorer-api
-        uses: actions-rs/cargo@v1
-        with:
-          command: build
-          args: --manifest-path explorer-api/Cargo.toml --workspace --release
-
-      - name: Upload Artifact
-        uses: actions/upload-artifact@v3
-        with:
-          name: my-artifact
-          path: |
-            target/release/explorer-api
-          retention-days: 30
-
-      - name: Upload to release based on tag name
-        uses: softprops/action-gh-release@v1
-        if: github.event_name == 'release'
-        with:
-          files: |
-            target/release/explorer-api

.github/workflows/network-explorer.yml

@@ -17,6 +17,7 @@ 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:
@@ -56,10 +57,10 @@ jobs:
         REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
         TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/ne-sb-${{ env.GITHUB_REF_SLUG }}
         EXCLUDE: "/dist/, /node_modules/"
-    - name: Keybase - Node Install
+    - name: Matrix - Node Install
       run: npm install
       working-directory: .github/workflows/support-files
-    - name: Keybase - Send Notification
+    - name: Matrix - Send Notification
       env:
         NYM_NOTIFICATION_KIND: network-explorer
         NYM_PROJECT_NAME: "Network Explorer"
@@ -68,10 +69,6 @@ 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 }}"

.github/workflows/nightly_build.yml

@@ -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@v2
+      - uses: actions/checkout@v3
       - id: set-matrix
         uses: JoshuaTheMiller/conditional-build-matrix@main
         with:
@@ -25,10 +25,11 @@ 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@v2
+        uses: actions/checkout@v3
 
       - name: Install rust toolchain
         uses: actions-rs/toolchain@v1
@@ -38,15 +39,33 @@ 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 (because Windows is being annoying)
+      - name: Reclaim some disk space
         uses: actions-rs/cargo@v1
-        if: ${{ matrix.os == 'windows-latest' }}
+        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' }}
         with:
           command: clean
 
@@ -56,9 +75,9 @@ jobs:
           command: test
           args: --workspace
 
-      - name: Reclaim some disk space (because Windows is being annoying)
+      - name: Reclaim some disk space
         uses: actions-rs/cargo@v1
-        if: ${{ matrix.os == 'windows-latest' }}
+        if: ${{ matrix.os == 'windows-latest' || matrix.os == 'ubuntu-20.04' }}
         with:
           command: clean
 
@@ -67,17 +86,11 @@ jobs:
         uses: actions-rs/cargo@v1
         with:
           command: test
-          args: --workspace --all-features -- --ignored
+          args: --workspace -- --ignored
 
-      - name: Check formatting
+      - name: Reclaim some disk space
         uses: actions-rs/cargo@v1
-        with:
-          command: fmt
-          args: --all -- --check
-
-      - name: Reclaim some disk space (because Windows is being annoying)
-        uses: actions-rs/cargo@v1
-        if: ${{ matrix.os == 'windows-latest' }}
+        if: ${{ matrix.os == 'windows-latest' || matrix.os == 'ubuntu-20.04' }}
         with:
           command: clean
 
@@ -86,7 +99,7 @@ jobs:
         continue-on-error: true
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
-          args: --all-features
+          args: --workspace
 
       - name: Run clippy
         uses: actions-rs/cargo@v1
@@ -101,38 +114,6 @@ 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
@@ -166,12 +147,17 @@ jobs:
       - name: Collect jobs status
         uses: technote-space/workflow-conclusion-action@v2
       - name: Check out repository code
-        uses: actions/checkout@v2
-      - name: Keybase - Node Install
+        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
         if: env.WORKFLOW_CONCLUSION == 'failure'
         run: npm install
         working-directory: .github/workflows/support-files
-      - name: Keybase - Send Notification
+      - name: Matrix - Send Notification
         if: env.WORKFLOW_CONCLUSION == 'failure'
         env:
           NYM_NOTIFICATION_KIND: nightly
@@ -179,13 +165,9 @@ 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 }}"
+          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 }}"

.github/workflows/nightly_build_release.yml

@@ -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]+' | 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]+$' | sort -V | tail -n 1 | sed 's/  origin\///')" >> $GITHUB_OUTPUT
   build:
     needs: [get_release,matrix_prep]
     strategy:
@@ -38,6 +38,7 @@ 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
@@ -53,15 +54,33 @@ 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 (because Windows is being annoying)
+      - name: Reclaim some disk space
         uses: actions-rs/cargo@v1
-        if: ${{ matrix.os == 'windows-latest' }}
+        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' }}
         with:
           command: clean
 
@@ -71,9 +90,9 @@ jobs:
           command: test
           args: --workspace
 
-      - name: Reclaim some disk space (because Windows is being annoying)
+      - name: Reclaim some disk space
         uses: actions-rs/cargo@v1
-        if: ${{ matrix.os == 'windows-latest' }}
+        if: ${{ matrix.os == 'windows-latest' || matrix.os == 'ubuntu-20.04' }}
         with:
           command: clean
 
@@ -82,17 +101,11 @@ jobs:
         uses: actions-rs/cargo@v1
         with:
           command: test
-          args: --workspace --all-features -- --ignored
+          args: --workspace -- --ignored
 
-      - name: Check formatting
+      - name: Reclaim some disk space
         uses: actions-rs/cargo@v1
-        with:
-          command: fmt
-          args: --all -- --check
-
-      - name: Reclaim some disk space (because Windows is being annoying)
-        uses: actions-rs/cargo@v1
-        if: ${{ matrix.os == 'windows-latest' }}
+        if: ${{ matrix.os == 'windows-latest' || matrix.os == 'ubuntu-20.04' }}
         with:
           command: clean
 
@@ -101,7 +114,7 @@ jobs:
         continue-on-error: true
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
-          args: --all-features
+          args: --workspace
 
       - name: Run clippy
         uses: actions-rs/cargo@v1
@@ -116,38 +129,6 @@ 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
@@ -182,11 +163,16 @@ jobs:
         uses: technote-space/workflow-conclusion-action@v2
       - name: Check out repository code
         uses: actions/checkout@v3
-      - name: Keybase - Node Install
+      - name: install npm
+        uses: actions/setup-node@v3
+        if: env.WORKFLOW_CONCLUSION == 'failure'
+        with:
+          node-version: 16
+      - name: Matrix - Node Install
         if: env.WORKFLOW_CONCLUSION == 'failure'
         run: npm install
         working-directory: .github/workflows/support-files
-      - name: Keybase - Send Notification
+      - name: Matrix - Send Notification
         if: env.WORKFLOW_CONCLUSION == 'failure'
         env:
           NYM_NOTIFICATION_KIND: nightly
@@ -194,13 +180,9 @@ 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 }}"
+          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 }}"

.github/workflows/nightly_build_release2.yml

@@ -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]+' | 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]+$' | sort -V | tail -n 2 | head -n 1 | sed 's/  origin\///')" >> $GITHUB_OUTPUT
   build:
     needs: [get_release,matrix_prep]
     strategy:
@@ -38,6 +38,7 @@ 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
@@ -53,6 +54,12 @@ 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:
@@ -65,6 +72,18 @@ 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:
@@ -73,7 +92,7 @@ jobs:
 
       - name: Reclaim some disk space (because Windows is being annoying)
         uses: actions-rs/cargo@v1
-        if: ${{ matrix.os == 'windows-latest' }}
+        if: ${{ matrix.os == 'windows-latest' || matrix.os == 'ubuntu-20.04' }}
         with:
           command: clean
 
@@ -82,13 +101,7 @@ jobs:
         uses: actions-rs/cargo@v1
         with:
           command: test
-          args: --workspace --all-features -- --ignored
-
-      - name: Check formatting
-        uses: actions-rs/cargo@v1
-        with:
-          command: fmt
-          args: --all -- --check
+          args: --workspace -- --ignored
 
       - name: Reclaim some disk space (because Windows is being annoying)
         uses: actions-rs/cargo@v1
@@ -101,7 +114,7 @@ jobs:
         continue-on-error: true
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
-          args: --all-features
+          args: --workspace
 
       - name: Run clippy
         uses: actions-rs/cargo@v1
@@ -116,38 +129,6 @@ 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
@@ -182,11 +163,16 @@ jobs:
         uses: technote-space/workflow-conclusion-action@v2
       - name: Check out repository code
         uses: actions/checkout@v3
-      - name: Keybase - Node Install
+      - name: install npm
+        uses: actions/setup-node@v3
+        if: env.WORKFLOW_CONCLUSION == 'failure'
+        with:
+          node-version: 16
+      - name: Matrix - Node Install
         if: env.WORKFLOW_CONCLUSION == 'failure'
         run: npm install
         working-directory: .github/workflows/support-files
-      - name: Keybase - Send Notification
+      - name: Matrix - Send Notification
         if: env.WORKFLOW_CONCLUSION == 'failure'
         env:
           NYM_NOTIFICATION_KIND: nightly
@@ -194,13 +180,9 @@ 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 }}"
+          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 }}"

.github/workflows/nym-cli-publish.yml

@@ -1,50 +0,0 @@
-name: Publish Nym CLI binaries
-
-on:
-  workflow_dispatch:
-  release:
-    types: [created]
-    
-env:
-  NETWORK: mainnet
-
-jobs:
-  publish-nym-cli:
-    strategy:
-      fail-fast: false
-      matrix:
-        platform: [ubuntu-20.04, windows-latest, macos-latest]
-
-    runs-on: ${{ matrix.platform }}
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Check the release tag starts with `nym-cli-`
-        if: startsWith(github.ref, 'refs/tags/nym-cli-') == false && github.event_name != 'workflow_dispatch'
-        uses: actions/github-script@v3
-        with:
-          script: |
-            core.setFailed('Release tag did not start with nym-cli-...')
-
-      - name: Install Rust stable
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-
-      - name: Build binary
-        run: make build-nym-cli
-
-      - name: Upload Artifact
-        uses: actions/upload-artifact@v3
-        with:
-          name: nym-cli-${{ matrix.platform }}
-          path: |
-            target/release/nym-cli*
-          retention-days: 30
-
-      - name: Upload to release based on tag name
-        uses: softprops/action-gh-release@v1
-        if: github.event_name == 'release'
-        with:
-          files: |
-            target/release/nym-cli

.github/workflows/nym-connect-publish-macos.yml

@@ -1,4 +1,4 @@
-name: Publish Nym Connect (MacOS)
+name: Publish Nym Connect - desktop (MacOS)
 on:
   workflow_dispatch:
   release:
@@ -6,10 +6,11 @@ on:
 
 defaults:
   run:
-    working-directory: nym-connect
+    working-directory: nym-connect/desktop
 
 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:
@@ -19,13 +20,6 @@ jobs:
     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:
@@ -79,7 +73,7 @@ jobs:
         uses: actions/upload-artifact@v3
         with:
           name: nym-connect_1.0.0_x64.dmg
-          path: nym-connect/target/release/bundle/dmg/nym-connect_1.0.0_x64.dmg
+          path: nym-connect/desktop/target/release/bundle/dmg/nym-connect_1.0.0_x64.dmg
           retention-days: 30
 
       - name: Clean up keychain
@@ -92,5 +86,5 @@ jobs:
         if: github.event_name == 'release'
         with:
           files: |
-            nym-connect/target/release/bundle/dmg/*.dmg
-            nym-connect/target/release/bundle/macos/*.app.tar.gz*
+            nym-connect/desktop/target/release/bundle/dmg/*.dmg
+            nym-connect/desktop/target/release/bundle/macos/*.app.tar.gz*

.github/workflows/nym-connect-publish-ubuntu.yml

@@ -1,4 +1,4 @@
-name: Publish Nym Connect (Ubuntu)
+name: Publish Nym Connect - desktop (Ubuntu)
 on:
   workflow_dispatch:
   release:
@@ -6,14 +6,15 @@ on:
 
 defaults:
   run:
-    working-directory: nym-connect
+    working-directory: nym-connect/desktop
 
 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: [ubuntu-20.04]
+        platform: [custom-runner-linux]
 
     runs-on: ${{ matrix.platform }}
     steps:
@@ -23,17 +24,13 @@ jobs:
         run: >
           sudo apt-get update &&
           sudo apt-get install -y webkit2gtk-4.0 libayatana-appindicator3-dev
-      - 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-...')
+        continue-on-error: true
 
       - name: Node v16
         uses: actions/setup-node@v3
         with:
           node-version: 16
+
       - name: Install Rust stable
         uses: actions-rs/toolchain@v1
         with:
@@ -56,7 +53,7 @@ jobs:
         uses: actions/upload-artifact@v3
         with:
           name: nym-connect.AppImage.tar.gz
-          path: nym-connect/target/release/bundle/appimage/nym-connect_1.0.0_amd64.AppImage
+          path: nym-connect/desktop/target/release/bundle/appimage/nym-connect_1.0.0_amd64.AppImage
           retention-days: 30
 
       - name: Upload to release based on tag name
@@ -64,5 +61,5 @@ jobs:
         if: github.event_name == 'release'
         with:
           files: |
-            nym-connect/target/release/bundle/appimage/*.AppImage
-            nym-connect/target/release/bundle/appimage/*.AppImage.tar.gz*
+            nym-connect/desktop/target/release/bundle/appimage/*.AppImage
+            nym-connect/desktop/target/release/bundle/appimage/*.AppImage.tar.gz*

.github/workflows/nym-connect-publish-windows10.yml

@@ -1,4 +1,4 @@
-name: Publish Nym Connect (Windows 10)
+name: Publish Nym Connect - desktop (Windows 10)
 on:
   workflow_dispatch:
   release:
@@ -6,10 +6,11 @@ on:
 
 defaults:
   run:
-    working-directory: nym-connect
+    working-directory: nym-connect/desktop
 
 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:
@@ -27,13 +28,6 @@ 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 }}
@@ -62,7 +56,7 @@ jobs:
           encodedString: ${{ secrets.WALLET_ADMIN_ADDRESS }}
 
       - name: Install app dependencies
-        run: yarn
+        run: yarn --network-timeout 100000
 
       - name: Build and sign it
         env:
@@ -78,7 +72,7 @@ jobs:
         uses: actions/upload-artifact@v3
         with:
           name: 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
+          path: nym-connect/desktop/target/release/bundle/msi/nym-connect_1.0.0_x64_en-US.msi
           retention-days: 30
 
       - name: Upload to release based on tag name
@@ -86,5 +80,5 @@ jobs:
         if: github.event_name == 'release'
         with:
           files: |
-            nym-connect/target/release/bundle/msi/*.msi
-            nym-connect/target/release/bundle/msi/*.msi.zip*
+            nym-connect/desktop/target/release/bundle/msi/*.msi
+            nym-connect/desktop/target/release/bundle/msi/*.msi.zip*

.github/workflows/nym-release-publish.yml

@@ -16,10 +16,11 @@ env:
 
 jobs:
   publish-nym:
+    if: ${{ (startsWith(github.ref, 'refs/tags/nym-binaries-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
     strategy:
       fail-fast: false
       matrix:
-        platform: [ubuntu-20.04]
+        platform: [custom-runner-linux]
 
     runs-on: ${{ matrix.platform }}
     steps:
@@ -27,13 +28,7 @@ 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
-
-      - 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-...')
+        continue-on-error: true
             
       - name: Sets env vars for tokio if set in manual dispatch inputs
         run: |
@@ -56,6 +51,7 @@ jobs:
         with:
           name: my-artifact
           path: |
+            target/release/explorer-api
             target/release/nym-client
             target/release/nym-gateway
             target/release/nym-mixnode
@@ -71,6 +67,7 @@ jobs:
         if: github.event_name == 'release'
         with:
           files: |
+            target/release/explorer-api
             target/release/nym-client
             target/release/nym-gateway
             target/release/nym-mixnode

.github/workflows/nym-wallet-publish-macos.yml

@@ -10,6 +10,7 @@ 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:
@@ -19,13 +20,6 @@ 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:

.github/workflows/nym-wallet-publish-ubuntu.yml

@@ -9,10 +9,11 @@ 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:
-        platform: [ubuntu-20.04]
+        platform: [custom-runner-linux]
 
     runs-on: ${{ matrix.platform }}
     steps:
@@ -22,17 +23,13 @@ jobs:
         run: >
           sudo apt-get update &&
           sudo apt-get install -y webkit2gtk-4.0
-      - 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-...')
+        continue-on-error: true
 
       - name: Node v16
         uses: actions/setup-node@v3
         with:
           node-version: 16
+
       - name: Install Rust stable
         uses: actions-rs/toolchain@v1
         with:

.github/workflows/nym-wallet-publish-windows10.yml

@@ -1,5 +1,6 @@
 name: Publish Nym Wallet (Windows 10)
 on:
+  workflow_dispatch:
   release:
     types: [created]
 
@@ -9,6 +10,7 @@ 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:
@@ -26,13 +28,6 @@ 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 }}
@@ -61,7 +56,7 @@ jobs:
           encodedString: ${{ secrets.WALLET_ADMIN_ADDRESS }}
 
       - name: Install app dependencies
-        run: yarn
+        run: yarn --network-timeout 100000
 
       - name: Build and sign it
         env:
@@ -73,8 +68,16 @@ 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

.github/workflows/nym-wallet-storybook.yml

@@ -12,6 +12,7 @@ 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,10 +35,10 @@ jobs:
         REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
         TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/wallet-${{ env.GITHUB_REF_SLUG }}
         EXCLUDE: "/dist/, /node_modules/"
-    - name: Keybase - Node Install
+    - name: Matrix - Node Install
       run: npm install
       working-directory: .github/workflows/support-files
-    - name: Keybase - Send Notification
+    - name: Matrix - Send Notification
       env:
         NYM_NOTIFICATION_KIND: nym-wallet
         NYM_PROJECT_NAME: "nym-wallet"
@@ -45,10 +46,6 @@ 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 }}"

.github/workflows/nym_wallet.yml

@@ -26,6 +26,7 @@ jobs:
           libappindicator3-dev
           webkit2gtk-driver
           xvfb
+        continue-on-error: true
 
       - name: Install minimal stable
         uses: actions-rs/toolchain@v1

.github/workflows/run-api-tests.yml

@@ -0,0 +1,36 @@
+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

.github/workflows/support-files/.env.example

@@ -1,7 +1,3 @@
-KEYBASE_NYM_CHANNEL=
-KEYBASE_NYMBOT_USERNAME=
-KEYBASE_NYMBOT_PAPERKEY=
-
 MATRIX_SERVER=
 MATRIX_ROOM=
 MATRIX_ROOM_OF_SHAME=
@@ -39,4 +35,4 @@ NYM_CI_WWW_BASE=example.com
 # Nightly builds
 WORKFLOW_CONCLUSION=success
 
-SHOW_DEBUG=true
+SHOW_DEBUG=true

.github/workflows/support-files/README.md

@@ -4,7 +4,7 @@ This is a collection of scripts and files to support GitHub Actions.
 
 ## Sending Notifications
 
-These scripts send CI notifications to Keybase by creating messages from templates and env vars passed from GitHub Actions.
+These scripts send CI notifications to Matrix by creating messages from templates and env vars passed from GitHub Actions.
 
 ### Adding notifications to a GitHub Action
 
@@ -19,10 +19,11 @@ jobs:
       env:
         NYM_NOTIFICATION_KIND: "my-component"
         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"
+        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 }}"
         IS_SUCCESS: "${{ job.status == 'success' }}"
       uses: docker://keybaseio/client:stable-node
       with:
@@ -34,8 +35,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`
-    - 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` 
+    - 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`
 
 ### Running locally
 
@@ -43,7 +44,7 @@ You will need:
 - Node 16 LTS
 - npm
 
-Copy `.github/workflows/support-files/.env.example` to `.github/workflows/support-files/.env` and valid Keybase credentials.
+Copy `.github/workflows/support-files/.env.example` to `.github/workflows/support-files/.env` and valid Matrix credentials.
 
 Then run `npm install` to get dependencies.
 
@@ -55,4 +56,4 @@ npm install
 cp .env.example .env
 vi .env
 npm run dev
-```
+```

.github/workflows/support-files/git-merge-check.sh

@@ -0,0 +1,62 @@
+#!/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

.github/workflows/support-files/network-explorer/templates/failure

@@ -1,9 +1,14 @@
 🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥
 > :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:
 ```

.github/workflows/support-files/network-explorer/templates/success

@@ -1,10 +1,16 @@
 🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩
 > :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 }}:
 ```

.github/workflows/support-files/nightly/index.js

@@ -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');
+    .join('\n\n');
 
   return template({ ...context, jobResults });
 }

.github/workflows/support-files/nightly/templates/failure

@@ -1,9 +1,15 @@
 🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥
 > :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 }}

.github/workflows/support-files/nightly/templates/success

@@ -1,9 +1,15 @@
 🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩
 > :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 }}

.github/workflows/support-files/notifications/send_message.js

@@ -1,6 +1,5 @@
 require('dotenv').config();
 
-const Bot = require('keybase-bot');
 const { sendMatrixMessage } = require('./send_message_to_matrix');
 
 let context = {
@@ -24,21 +23,6 @@ function validateContext() {
       'Please set env var NYM_PROJECT_NAME with the project name for displaying in notification messages',
     );
   }
-  if (!context.env.KEYBASE_NYM_CHANNEL) {
-    throw new Error(
-      'Please set env var KEYBASE_NYM_CHANNEL with the channel name for the notification message',
-    );
-  }
-  if (!context.env.KEYBASE_NYMBOT_USERNAME) {
-    throw new Error(
-      'Username is not defined. Please set env var KEYBASE_NYMBOT_USERNAME',
-    );
-  }
-  if (!context.env.KEYBASE_NYMBOT_PAPERKEY) {
-    throw new Error(
-      'Paperkey is not defined. Please set env var KEYBASE_NYMBOT_PAPERKEY',
-    );
-  }
   if (context.env.MATRIX_ROOM) {
     if (!context.env.MATRIX_SERVER) {
       throw new Error(
@@ -84,12 +68,6 @@ 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)
@@ -99,40 +77,6 @@ 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
@@ -169,7 +113,6 @@ async function main() {
     console.log(messageBody);
     console.log('-----------------------------------------');
   }
-  await sendKeybaseMessage(messageBody);
   if(context.env.MATRIX_ROOM) {
     await sendMatrixMessage(context, messageBody, context.env.MATRIX_ROOM)
   }

.github/workflows/support-files/notifications/send_message_to_matrix.js

@@ -5,12 +5,7 @@ const localStorage = new LocalStorage('./scratch');
 const {
   LocalStorageCryptoStore,
 } = require('matrix-js-sdk/lib/crypto/store/localStorage-crypto-store');
-
-const vfile = require('to-vfile');
-const unified = require('unified');
-const remarkParse = require('remark-parse');
-const remarkHtml = require('remark-html');
-const emoji = require('remark-emoji');
+var showdown  = require('showdown');
 
 // hide all matrix client output
 console.error = (error) => console.log('❌ error: ', error);
@@ -59,17 +54,9 @@ function createClient(context, room, message) {
   return client;
 }
 
-async function markdownToHtml(messageAsMarkdown) {
-  const file = await unified()
-    .use(emoji)
-    .use(remarkParse)
-    .use(remarkHtml)
-    .process(await vfile({ path: 'test.md', contents: messageAsMarkdown}));
-  return String(file);
-}
-
 async function sendMatrixMessage(contextArg, messageAsMarkdown, roomId) {
-  const messageAsHtml = await markdownToHtml(messageAsMarkdown);
+  const converter = new showdown.Converter();
+  const messageAsHtml = converter.makeHtml(messageAsMarkdown);
   const client = createClient(contextArg, roomId, messageAsHtml);
   await client.initCrypto();
   await client.startClient({ initialSyncLimit: 1 });

.github/workflows/support-files/nym-connect/templates/failure

@@ -1,9 +1,14 @@
 🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥
 > :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:
 ```

.github/workflows/support-files/nym-connect/templates/success

@@ -1,9 +1,14 @@
 🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩
 > :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 }}:
 ```

.github/workflows/support-files/nym-wallet/templates/failure

@@ -1,9 +1,14 @@
 🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥
 > :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:
 ```

.github/workflows/support-files/nym-wallet/templates/success

@@ -1,13 +1,18 @@
 🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩
 > :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 }}:
 ```

.github/workflows/support-files/package.json

@@ -1,6 +1,6 @@
 {
-  "name": "send-keybase-message",
-  "description": "Sends a notification message with the keybase package that fails when piped into the keybase CLI",
+  "name": "send-matrix-message",
+  "description": "Sends a notification message with the matrix sdk",
   "version": "1.0.0",
   "private": true,
   "scripts": {
@@ -10,7 +10,6 @@
   "dependencies": {
     "dotenv": "^16.0.0",
     "handlebars": "^4.7.7",
-    "keybase-bot": "^3.6.1",
     "matrix-js-sdk": "^9.3.0",
     "node-localstorage": "^2.1.6",
     "octokit": "^1.7.1",
@@ -18,6 +17,7 @@
     "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"
   },

.github/workflows/support-files/ts-packages/templates/failure

@@ -1,9 +1,14 @@
 🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥
 > :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:
 ```

.github/workflows/support-files/ts-packages/templates/success

@@ -1,14 +1,20 @@
 🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩
 > :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 }}:
 ```

.github/workflows/tag-and-release.yml

@@ -0,0 +1,46 @@
+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"]

.github/workflows/typescript-lint.yml

@@ -0,0 +1,64 @@
+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

.github/workflows/update-versions-and-changelog.yaml

@@ -0,0 +1,95 @@
+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"

.github/workflows/wallet.yml

@@ -2,11 +2,17 @@ name: Nym Wallet (rust)
 
 on:
   push:
-    paths-ignore:
-      - 'explorer/**'
+    paths:
+      - 'nym-wallet/**'
+      - 'common/**'
+      - 'contracts/vesting/**'
+      - 'nym-api/nym-api-requests/**'
   pull_request:
-    paths-ignore:
-      - 'explorer/**'
+    paths:
+      - 'nym-wallet/**'
+      - 'common/**'
+      - 'contracts/vesting/**'
+      - 'nym-api/nym-api-requests/**'
 
 jobs:
   build:
@@ -16,6 +22,7 @@ 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

.github/workflows/wasm_client_build.yml

@@ -2,8 +2,13 @@ name: Wasm Client
 
 on:
   pull_request:
-    paths-ignore:
-      - 'explorer/**'
+    paths:
+      - 'clients/webassembly/**'
+      - 'clients/client-core/**'
+      - 'common/**'
+      - 'contracts/**'
+      - 'gateway/gateway-requests/**'
+      - 'nym-api/nym-api-requests/**'
 
 jobs:
   wasm:
@@ -24,16 +29,6 @@ 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

.gitignore

@@ -41,3 +41,6 @@ storybook-static
 envs/qwerty.env
 Cargo.lock
 nym-connect/Cargo.lock
+.parcel-cache
+**/.DS_Store
+cpu-cycles/libcpucycles/build

CHANGELOG.md

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

Cargo.toml

@@ -22,29 +22,28 @@ members = [
     "clients/native",
     "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/build-information",
     "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/crypto/dkg",
+    "common/dkg",
     "common/execute",
     "common/inclusion-probability",
     "common/ledger",
-    "common/logging",
     "common/mixnode-common",
     "common/network-defaults",
     "common/nonexhaustive-delayqueue",
@@ -67,13 +66,13 @@ 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",
@@ -94,4 +93,27 @@ default-members = [
     "explorer-api",
 ]
 
-exclude = ["explorer", "contracts", "clients/webassembly", "nym-wallet", "nym-connect"]
+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.64"
+cfg-if = "1.0.0"
+dotenvy = "0.15.6"
+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"

Makefile

@@ -1,13 +1,22 @@
 test: clippy-all cargo-test wasm fmt
+test-no-mobile: clippy-all-no-mobile cargo-test-no-mobile wasm fmt-no-mobile
 test-all: test cargo-test-expensive
+test-all-no-mobile: test-no-mobile cargo-test-expensive
 no-clippy: build cargo-test wasm fmt
+no-clippy-no-mobile: build-no-mobile cargo-test-no-mobile wasm fmt-no-mobile
 happy: fmt clippy-happy test
-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
+happy-no-mobile: fmt-no-mobile clippy-happy-no-mobile test-no-mobile
+clippy-all: clippy-all-no-mobile clippy-all-connect-mobile
+clippy-all-no-mobile: clippy-main clippy-main-examples clippy-all-contracts clippy-all-wallet clippy-all-connect clippy-all-wasm-client
+clippy-happy: clippy-happy-no-mobile clippy-happy-connect-mobile
+clippy-happy-no-mobile: clippy-happy-main clippy-happy-contracts clippy-happy-wallet clippy-happy-connect
+cargo-test: cargo-test-no-mobile test-connect-mobile
+cargo-test-no-mobile: test-main test-contracts test-wallet test-connect 
+cargo-test-expensive: test-main-expensive test-contracts-expensive test-wallet-expensive test-connect-expensive
+build: build-no-mobile build-connect-mobile 
+build-no-mobile: build-contracts build-wallet build-main build-main-examples build-connect build-wasm-client 
+fmt: fmt-no-mobile fmt-connect-mobile
+fmt-no-mobile: fmt-main fmt-contracts fmt-wallet fmt-connect fmt-wasm-client
 
 clippy-happy-main:
 	cargo clippy
@@ -19,13 +28,16 @@ clippy-happy-wallet:
 	cargo clippy --manifest-path nym-wallet/Cargo.toml
 
 clippy-happy-connect:
-	cargo clippy --manifest-path nym-connect/Cargo.toml
+	cargo clippy --manifest-path nym-connect/desktop/Cargo.toml
+
+clippy-happy-connect-mobile:
+	cargo clippy --manifest-path nym-connect/mobile/src-tauri/Cargo.toml
 
 clippy-main:
 	cargo clippy --workspace -- -D warnings
 
-clippy-coconut:
-	cargo clippy --workspace --features coconut -- -D warnings
+clippy-main-examples:
+	cargo clippy --workspace --examples -- -D warnings
 
 clippy-wasm:
 	cargo clippy --manifest-path clients/webassembly/Cargo.toml --target wasm32-unknown-unknown --workspace -- -D warnings
@@ -38,7 +50,10 @@ 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/Cargo.toml --all-features -- -D warnings
+	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
 
 clippy-all-wasm-client:
 	cargo clippy --workspace --manifest-path clients/webassembly/Cargo.toml --all-features --target wasm32-unknown-unknown -- -D warnings
@@ -46,16 +61,9 @@ 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
 
@@ -68,18 +76,24 @@ test-wallet:
 test-wallet-expensive:
 	cargo test --manifest-path nym-wallet/Cargo.toml --all-features -- --ignored
 
-test-wasm-client:
-	cargo test --workspace --manifest-path clients/webassembly/Cargo.toml --all-features
-
 test-connect:
-	cargo test --manifest-path nym-connect/Cargo.toml --all-features
+	cargo test --manifest-path nym-connect/desktop/Cargo.toml --all-features
 
 test-connect-expensive:
-	cargo test --manifest-path nym-connect/Cargo.toml --all-features -- --ignored
+	cargo test --manifest-path nym-connect/desktop/Cargo.toml --all-features -- --ignored
+
+test-connect-mobile:
+	cargo test --manifest-path nym-connect/mobile/src-tauri/Cargo.toml --all-features
+
+test-connect-mobile-expensive:
+	cargo test --manifest-path nym-connect/mobile/src-tauri/Cargo.toml --all-features -- --ignored
 
 build-main:
 	cargo build --workspace
 
+build-main-examples:
+	cargo build --workspace --examples
+
 build-contracts:
 	cargo build --manifest-path contracts/Cargo.toml --workspace
 
@@ -87,7 +101,10 @@ build-wallet:
 	cargo build --manifest-path nym-wallet/Cargo.toml --workspace
 
 build-connect:
-	cargo build --manifest-path nym-connect/Cargo.toml --workspace
+	cargo build --manifest-path nym-connect/desktop/Cargo.toml --workspace
+
+build-connect-mobile:
+	cargo build --manifest-path nym-connect/mobile/src-tauri/Cargo.toml --workspace
 
 build-explorer-api:
 	cargo build --manifest-path explorer-api/Cargo.toml --workspace
@@ -108,13 +125,18 @@ fmt-wallet:
 	cargo fmt --manifest-path nym-wallet/Cargo.toml --all
 
 fmt-connect:
-	cargo fmt --manifest-path nym-connect/Cargo.toml --all
+	cargo fmt --manifest-path nym-connect/desktop/Cargo.toml --all
+
+fmt-connect-mobile:
+	cargo fmt --manifest-path nym-connect/mobile/src-tauri/Cargo.toml --all
 
 fmt-wasm-client:
 	cargo fmt --manifest-path clients/webassembly/Cargo.toml --all
 
 wasm:
 	RUSTFLAGS='-C link-arg=-s' cargo build --manifest-path contracts/Cargo.toml --release --target wasm32-unknown-unknown
+	wasm-opt -Os contracts/target/wasm32-unknown-unknown/release/vesting_contract.wasm -o contracts/target/wasm32-unknown-unknown/release/vesting_contract.wasm
+	wasm-opt -Os contracts/target/wasm32-unknown-unknown/release/mixnet_contract.wasm -o contracts/target/wasm32-unknown-unknown/release/mixnet_contract.wasm
 
 mixnet-opt: wasm
 	cd contracts/mixnet && make opt
@@ -122,3 +144,6 @@ 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

README.md

@@ -16,7 +16,7 @@ The platform is composed of multiple Rust crates. Top-level executable binary cr
 * nym-wallet - a desktop wallet implemented using the [Tauri](https://tauri.studio/en/docs/about/intro) framework. 
 
 [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg?style=for-the-badge)](https://opensource.org/licenses/Apache-2.0)
-[![Build Status](https://img.shields.io/github/workflow/status/nymtech/nym/Continuous%20integration/develop?style=for-the-badge&logo=github-actions)](https://github.com/nymtech/nym/actions?query=branch%3Adevelop)
+[![Build Status](https://img.shields.io/github/actions/workflow/status/nymtech/nym/build.yml?branch=develop&style=for-the-badge&logo=github-actions)](https://github.com/nymtech/nym/actions?query=branch%3Adevelop)
 
 
 ### Building

clients/client-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "client-core"
-version = "1.1.5"
+version = "1.1.12"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
 edition = "2021"
 rust-version = "1.66"
@@ -8,34 +8,38 @@ rust-version = "1.66"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-async-trait = { version = "0.1.58" }
+async-trait = { workspace = true }
 dirs = "4.0"
 dashmap = "5.4.0"
 futures = "0.3"
 humantime-serde = "1.0"
-log = "0.4"
+log = { workspace = true }
 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"] }
+tungstenite = { version = "0.13.0", default-features = false }
 tokio = { version = "1.24.1", features = ["macros"]}
 time = "0.3.17"
 
 # internal
-config = { path = "../../common/config" }
-client-connections = { path = "../../common/client-connections" }
-crypto = { path = "../../common/crypto" }
+nym-config = { path = "../../common/config" }
+nym-crypto = { path = "../../common/crypto" }
 gateway-client = { path = "../../common/client-libs/gateway-client" }
 #gateway-client = { path = "../../common/client-libs/gateway-client", default-features = false, features = ["wasm", "coconut"] }
 gateway-requests = { path = "../../gateway/gateway-requests" }
-nonexhaustive-delayqueue = { path = "../../common/nonexhaustive-delayqueue" }
-nymsphinx = { path = "../../common/nymsphinx" }
-pemstore = { path = "../../common/pemstore" }
-topology = { path = "../../common/topology" }
+nym-nonexhaustive-delayqueue = { path = "../../common/nonexhaustive-delayqueue" }
+nym-sphinx = { path = "../../common/nymsphinx" }
+nym-pemstore = { path = "../../common/pemstore" }
+nym-topology = { path = "../../common/topology" }
 validator-client = { path = "../../common/client-libs/validator-client", default-features = false }
-task = { path = "../../common/task" }
+nym-task = { path = "../../common/task" }
+
+[target."cfg(not(target_arch = \"wasm32\"))".dependencies.validator-client]
+path = "../../common/client-libs/validator-client"
+features = ["nyxd-client"]
 
 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio-stream]
 version = "0.1.11"
@@ -45,6 +49,9 @@ features = ["time"]
 version = "1.24.1"
 features = ["time"]
 
+[target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio-tungstenite]
+version = "0.14"
+
 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.sqlx]
 version = "0.6.2"
 features = ["runtime-tokio-rustls", "sqlite", "macros", "migrate"]
@@ -66,6 +73,7 @@ features = ["futures"]
 
 [target."cfg(target_arch = \"wasm32\")".dependencies.wasm-utils]
 path = "../../common/wasm-utils"
+features = ["websocket"]
 
 [target."cfg(target_arch = \"wasm32\")".dependencies.time]
 version = "0.3.17"
@@ -82,5 +90,4 @@ sqlx = { version = "0.6.2", features = ["runtime-tokio-rustls", "sqlite", "macro
 default = []
 fs-surb-storage = ["sqlx"]
 wasm = ["gateway-client/wasm"]
-coconut = ["gateway-client/coconut", "gateway-requests/coconut"]
 

clients/client-core/src/client/base_client/helpers.rs

@@ -0,0 +1,11 @@
+// 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,
+    }
+}

clients/client-core/src/client/base_client/mod.rs

@@ -15,41 +15,61 @@ use crate::client::replies::reply_controller::{ReplyControllerReceiver, ReplyCon
 use crate::client::replies::reply_storage::{
     CombinedReplyStorage, PersistentReplyStorage, ReplyStorageBackend, SentReplyKeys,
 };
+use crate::client::topology_control::nym_api_provider::NymApiTopologyProvider;
 use crate::client::topology_control::{
     TopologyAccessor, TopologyRefresher, TopologyRefresherConfig,
 };
 use crate::config::{Config, DebugConfig, GatewayEndpointConfig};
 use crate::error::ClientCoreError;
 use crate::spawn_future;
-use client_connections::{ConnectionCommandReceiver, ConnectionCommandSender, LaneQueueLengths};
-use crypto::asymmetric::{encryption, identity};
 use futures::channel::mpsc;
 use gateway_client::bandwidth::BandwidthController;
+#[cfg(target_arch = "wasm32")]
+use gateway_client::wasm_mockups::CosmWasmClient;
 use gateway_client::{
     AcknowledgementReceiver, AcknowledgementSender, GatewayClient, MixnetMessageReceiver,
     MixnetMessageSender,
 };
 use log::{debug, info};
-use nymsphinx::acknowledgements::AckKey;
-use nymsphinx::addressing::clients::Recipient;
-use nymsphinx::addressing::nodes::NodeIdentity;
-use nymsphinx::receiver::ReconstructedMessage;
+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 nym_topology::provider_trait::TopologyProvider;
 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,
 }
@@ -73,6 +93,7 @@ impl ClientOutput {
 pub struct ClientState {
     pub shared_lane_queue_lengths: LaneQueueLengths,
     pub reply_controller_sender: ReplyControllerSender,
+    pub topology_accessor: TopologyAccessor,
 }
 
 pub enum ClientInputStatus {
@@ -129,7 +150,7 @@ impl From<bool> for CredentialsToggle {
     }
 }
 
-pub struct BaseClientBuilder<'a, B> {
+pub struct BaseClientBuilder<'a, B, C: Clone> {
     // due to wasm limitations I had to split it like this : (
     gateway_config: &'a GatewayEndpointConfig,
     debug_config: &'a DebugConfig,
@@ -137,20 +158,22 @@ pub struct BaseClientBuilder<'a, B> {
     nym_api_endpoints: Vec<Url>,
     reply_storage_backend: B,
 
-    bandwidth_controller: Option<BandwidthController>,
+    custom_topology_provider: Option<Box<dyn TopologyProvider>>,
+    bandwidth_controller: Option<BandwidthController<C>>,
     key_manager: KeyManager,
 }
 
-impl<'a, B> BaseClientBuilder<'a, B>
+impl<'a, B, C> BaseClientBuilder<'a, B, C>
 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>,
+        bandwidth_controller: Option<BandwidthController<C>>,
         reply_storage_backend: B,
-    ) -> BaseClientBuilder<'a, B> {
+    ) -> BaseClientBuilder<'a, B, C> {
         BaseClientBuilder {
             gateway_config: base_config.get_gateway_endpoint_config(),
             debug_config: base_config.get_debug_config(),
@@ -159,6 +182,7 @@ where
             bandwidth_controller,
             reply_storage_backend,
             key_manager,
+            custom_topology_provider: None,
         }
     }
 
@@ -166,22 +190,28 @@ where
         gateway_config: &'a GatewayEndpointConfig,
         debug_config: &'a DebugConfig,
         key_manager: KeyManager,
-        bandwidth_controller: Option<BandwidthController>,
+        bandwidth_controller: Option<BandwidthController<C>>,
         reply_storage_backend: B,
         credentials_toggle: CredentialsToggle,
         nym_api_endpoints: Vec<Url>,
-    ) -> BaseClientBuilder<'a, B> {
+    ) -> BaseClientBuilder<'a, B, C> {
         BaseClientBuilder {
             gateway_config,
             debug_config,
             disabled_credentials: credentials_toggle.is_disabled(),
             nym_api_endpoints,
             reply_storage_backend,
+            custom_topology_provider: None,
             bandwidth_controller,
             key_manager,
         }
     }
 
+    pub fn with_topology_provider(mut self, provider: Box<dyn TopologyProvider>) -> Self {
+        self.custom_topology_provider = Some(provider);
+        self
+    }
+
     pub fn as_mix_recipient(&self) -> Recipient {
         Recipient::new(
             *self.key_manager.identity_keypair().public_key(),
@@ -279,18 +309,14 @@ where
         mixnet_message_sender: MixnetMessageSender,
         ack_sender: AcknowledgementSender,
         shutdown: TaskClient,
-    ) -> Result<GatewayClient, ClientCoreError> {
+    ) -> Result<GatewayClient<C>, ClientCoreError> {
         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);
+            return Err(ClientCoreError::GatewayAddressUnknown);
         }
 
         let gateway_identity = identity::PublicKey::from_base58_string(gateway_id)
@@ -300,6 +326,7 @@ where
         let shared_key = if self.key_manager.is_gateway_key_set() {
             Some(self.key_manager.gateway_shared_key())
         } else {
+            log::info!("Gateway key not set! Will proceed anyway.");
             None
         };
 
@@ -307,7 +334,6 @@ where
             gateway_address,
             self.key_manager.identity_keypair(),
             gateway_identity,
-            gateway_owner,
             shared_key,
             mixnet_message_sender,
             ack_sender,
@@ -327,25 +353,38 @@ where
         Ok(gateway_client)
     }
 
+    fn setup_topology_provider(
+        custom_provider: Option<Box<dyn TopologyProvider>>,
+        nym_api_urls: Vec<Url>,
+    ) -> Box<dyn TopologyProvider> {
+        // if no custom provider was ... provided ..., create one using nym-api
+        custom_provider.unwrap_or_else(|| {
+            Box::new(NymApiTopologyProvider::new(
+                nym_api_urls,
+                env!("CARGO_PKG_VERSION").to_string(),
+            ))
+        })
+    }
+
     // future responsible for periodically polling directory server and updating
     // the current global view of topology
     async fn start_topology_refresher(
-        nym_api_urls: Vec<Url>,
+        topology_provider: Box<dyn TopologyProvider>,
         refresh_rate: Duration,
         topology_accessor: TopologyAccessor,
         shutdown: TaskClient,
     ) -> Result<(), ClientCoreError> {
-        let topology_refresher_config = TopologyRefresherConfig::new(
-            nym_api_urls,
-            refresh_rate,
-            env!("CARGO_PKG_VERSION").to_string(),
+        let topology_refresher_config = TopologyRefresherConfig::new(refresh_rate);
+
+        let mut topology_refresher = TopologyRefresher::new(
+            topology_refresher_config,
+            topology_accessor,
+            topology_provider,
         );
-        let mut topology_refresher =
-            TopologyRefresher::new(topology_refresher_config, topology_accessor);
         // before returning, block entire runtime to refresh the current network view so that any
         // components depending on topology would see a non-empty view
         info!("Obtaining initial network topology");
-        topology_refresher.refresh().await;
+        topology_refresher.try_refresh().await;
 
         if let Err(err) = topology_refresher.ensure_topology_is_routable().await {
             log::error!(
@@ -365,7 +404,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,
+        gateway_client: GatewayClient<C>,
         shutdown: TaskClient,
     ) -> BatchMixMessageSender {
         info!("Starting mix traffic controller...");
@@ -381,22 +420,32 @@ where
     where
         <B as ReplyStorageBackend>::StorageError: Sync + Send,
     {
-        let persistent_storage = PersistentReplyStorage::new(backend);
-        let mem_store = persistent_storage
-            .load_state_from_backend()
-            .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)
+        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()
                 .await
-        });
+                .map_err(|err| ClientCoreError::SurbStorageError {
+                    source: Box::new(err),
+                })?;
 
-        Ok(mem_store)
+            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),
+                })?)
+        }
     }
 
     pub async fn start_base(mut self) -> Result<BaseClient, ClientCoreError>
@@ -444,8 +493,12 @@ where
         )
         .await?;
 
+        let topology_provider = Self::setup_topology_provider(
+            self.custom_topology_provider.take(),
+            self.nym_api_endpoints,
+        );
         Self::start_topology_refresher(
-            self.nym_api_endpoints.clone(),
+            topology_provider,
             self.debug_config.topology_refresh_rate,
             shared_topology_accessor.clone(),
             task_manager.subscribe(),
@@ -506,7 +559,7 @@ where
                 self.debug_config,
                 self.key_manager.ack_key(),
                 self_address,
-                shared_topology_accessor,
+                shared_topology_accessor.clone(),
                 sphinx_message_sender,
                 task_manager.subscribe(),
             );
@@ -530,6 +583,7 @@ where
             client_state: ClientState {
                 shared_lane_queue_lengths,
                 reply_controller_sender,
+                topology_accessor: shared_topology_accessor,
             },
             task_manager,
         })

clients/client-core/src/client/base_client/non_wasm_helpers.rs

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::client::replies::reply_storage::{
-    self, fs_backend, CombinedReplyStorage, ReplyStorageBackend,
+    fs_backend, CombinedReplyStorage, ReplyStorageBackend,
 };
 use crate::config::DebugConfig;
 use crate::error::ClientCoreError;
@@ -43,6 +43,14 @@ async fn setup_fresh_backend<P: AsRef<Path>>(
     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());
@@ -65,30 +73,28 @@ 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: P,
+    db_path: Option<P>,
     debug_config: &DebugConfig,
 ) -> Result<fs_backend::Backend, ClientCoreError> {
-    // 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");
+    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");
 
-                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 {
-        setup_fresh_backend(db_path, debug_config).await
-    }
-}
-
-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,
+        Ok(setup_inactive_backend(debug_config))
     }
 }

clients/client-core/src/client/cover_traffic_stream.rs

@@ -7,11 +7,11 @@ use crate::spawn_future;
 use futures::task::{Context, Poll};
 use futures::{Future, Stream, StreamExt};
 use log::*;
-use nymsphinx::acknowledgements::AckKey;
-use nymsphinx::addressing::clients::Recipient;
-use nymsphinx::cover::generate_loop_cover_packet;
-use nymsphinx::params::PacketSize;
-use nymsphinx::utils::sample_poisson_duration;
+use 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 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 gatway can't keep up");
+                    log::warn!("Failed to send sphinx packet - gateway or connection to gateway can't keep up");
                 }
                 TrySendError::Closed(_) => {
                     log::warn!("Failed to send cover message - channel closed");
@@ -213,7 +213,7 @@ impl LoopCoverTrafficStream<OsRng> {
         tokio::task::yield_now().await;
     }
 
-    pub fn start_with_shutdown(mut self, mut shutdown: task::TaskClient) {
+    pub fn start_with_shutdown(mut self, mut shutdown: nym_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);

clients/client-core/src/client/inbound_messages.rs

@@ -1,6 +1,6 @@
-use client_connections::TransmissionLane;
-use nymsphinx::addressing::clients::Recipient;
-use nymsphinx::anonymous_replies::requests::AnonymousSenderTag;
+use nym_sphinx::addressing::clients::Recipient;
+use nym_sphinx::anonymous_replies::requests::AnonymousSenderTag;
+use nym_task::connections::TransmissionLane;
 
 pub type InputMessageSender = tokio::sync::mpsc::Sender<InputMessage>;
 pub type InputMessageReceiver = tokio::sync::mpsc::Receiver<InputMessage>;
@@ -77,4 +77,12 @@ impl InputMessage {
             lane,
         }
     }
+
+    pub fn lane(&self) -> &TransmissionLane {
+        match self {
+            InputMessage::Regular { lane, .. }
+            | InputMessage::Anonymous { lane, .. }
+            | InputMessage::Reply { lane, .. } => lane,
+        }
+    }
 }

clients/client-core/src/client/key_manager.rs

@@ -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 nymsphinx::acknowledgements::AckKey;
+use nym_crypto::asymmetric::{encryption, identity};
+use nym_sphinx::acknowledgements::AckKey;
 use rand::{CryptoRng, RngCore};
 use std::io;
 use std::sync::Arc;
@@ -72,17 +72,17 @@ impl KeyManager {
     /// Loads previously stored client keys from the disk.
     fn load_client_keys(client_pathfinder: &ClientKeyPathfinder) -> io::Result<Self> {
         let identity_keypair: identity::KeyPair =
-            pemstore::load_keypair(&pemstore::KeyPairPath::new(
+            nym_pemstore::load_keypair(&nym_pemstore::KeyPairPath::new(
                 client_pathfinder.private_identity_key().to_owned(),
                 client_pathfinder.public_identity_key().to_owned(),
             ))?;
         let encryption_keypair: encryption::KeyPair =
-            pemstore::load_keypair(&pemstore::KeyPairPath::new(
+            nym_pemstore::load_keypair(&nym_pemstore::KeyPairPath::new(
                 client_pathfinder.private_encryption_key().to_owned(),
                 client_pathfinder.public_encryption_key().to_owned(),
             ))?;
 
-        let ack_key: AckKey = pemstore::load_key(client_pathfinder.ack_key())?;
+        let ack_key: AckKey = nym_pemstore::load_key(client_pathfinder.ack_key())?;
 
         Ok(KeyManager {
             identity_keypair: Arc::new(identity_keypair),
@@ -98,7 +98,7 @@ impl KeyManager {
         let mut key_manager = Self::load_client_keys(client_pathfinder)?;
 
         let gateway_shared_key: SharedKeys =
-            pemstore::load_key(client_pathfinder.gateway_shared_key())?;
+            nym_pemstore::load_key(client_pathfinder.gateway_shared_key())?;
 
         key_manager.gateway_shared_key = Some(Arc::new(gateway_shared_key));
 
@@ -113,7 +113,7 @@ impl KeyManager {
         let mut key_manager = Self::load_client_keys(client_pathfinder)?;
 
         let gateway_shared_key: Result<SharedKeys, io::Error> =
-            pemstore::load_key(client_pathfinder.gateway_shared_key());
+            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 {
@@ -132,27 +132,27 @@ impl KeyManager {
     // it is done so for the consistency sake so that you wouldn't require an rng instance
     // during `load_keys` to generate the said key.
     pub fn store_keys(&self, client_pathfinder: &ClientKeyPathfinder) -> io::Result<()> {
-        pemstore::store_keypair(
+        nym_pemstore::store_keypair(
             self.identity_keypair.as_ref(),
-            &pemstore::KeyPairPath::new(
+            &nym_pemstore::KeyPairPath::new(
                 client_pathfinder.private_identity_key().to_owned(),
                 client_pathfinder.public_identity_key().to_owned(),
             ),
         )?;
-        pemstore::store_keypair(
+        nym_pemstore::store_keypair(
             self.encryption_keypair.as_ref(),
-            &pemstore::KeyPairPath::new(
+            &nym_pemstore::KeyPairPath::new(
                 client_pathfinder.private_encryption_key().to_owned(),
                 client_pathfinder.public_encryption_key().to_owned(),
             ),
         )?;
 
-        pemstore::store_key(self.ack_key.as_ref(), client_pathfinder.ack_key())?;
+        nym_pemstore::store_key(self.ack_key.as_ref(), client_pathfinder.ack_key())?;
 
         match self.gateway_shared_key.as_ref() {
             None => debug!("No gateway shared key available to store!"),
             Some(gate_key) => {
-                pemstore::store_key(gate_key.as_ref(), client_pathfinder.gateway_shared_key())?
+                nym_pemstore::store_key(gate_key.as_ref(), client_pathfinder.gateway_shared_key())?
             }
         }
 
@@ -168,7 +168,7 @@ impl KeyManager {
                 ))
             }
             Some(gate_key) => {
-                pemstore::store_key(gate_key.as_ref(), client_pathfinder.gateway_shared_key())?
+                nym_pemstore::store_key(gate_key.as_ref(), client_pathfinder.gateway_shared_key())?
             }
         }
 

clients/client-core/src/client/mix_traffic.rs

@@ -2,9 +2,13 @@
 // 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 nymsphinx::forwarding::packet::MixPacket;
+use nym_sphinx::forwarding::packet::MixPacket;
+#[cfg(not(target_arch = "wasm32"))]
+use validator_client::nyxd::CosmWasmClient;
 
 pub type BatchMixMessageSender = tokio::sync::mpsc::Sender<Vec<MixPacket>>;
 pub type BatchMixMessageReceiver = tokio::sync::mpsc::Receiver<Vec<MixPacket>>;
@@ -13,10 +17,10 @@ pub type BatchMixMessageReceiver = tokio::sync::mpsc::Receiver<Vec<MixPacket>>;
 pub const MIX_MESSAGE_RECEIVER_BUFFER_SIZE: usize = 32;
 const MAX_FAILURE_COUNT: usize = 100;
 
-pub struct MixTrafficController {
+pub struct MixTrafficController<C: Clone> {
     // TODO: most likely to be replaced by some higher level construct as
     // later on gateway_client will need to be accessible by other entities
-    gateway_client: GatewayClient,
+    gateway_client: GatewayClient<C>,
     mix_rx: BatchMixMessageReceiver,
 
     // TODO: this is temporary work-around.
@@ -24,8 +28,13 @@ pub struct MixTrafficController {
     consecutive_gateway_failure_count: usize,
 }
 
-impl MixTrafficController {
-    pub fn new(gateway_client: GatewayClient) -> (MixTrafficController, BatchMixMessageSender) {
+impl<C> MixTrafficController<C>
+where
+    C: CosmWasmClient + Sync + Send + Clone + 'static,
+{
+    pub fn new(
+        gateway_client: GatewayClient<C>,
+    ) -> (MixTrafficController<C>, BatchMixMessageSender) {
         let (sphinx_message_sender, sphinx_message_receiver) =
             tokio::sync::mpsc::channel(MIX_MESSAGE_RECEIVER_BUFFER_SIZE);
         (
@@ -67,7 +76,7 @@ impl MixTrafficController {
         }
     }
 
-    pub fn start_with_shutdown(mut self, mut shutdown: task::TaskClient) {
+    pub fn start_with_shutdown(mut self, mut shutdown: nym_task::TaskClient) {
         spawn_future(async move {
             debug!("Started MixTrafficController with graceful shutdown support");
 

clients/client-core/src/client/real_messages_control/acknowledgement_control/acknowledgement_listener.rs

@@ -5,7 +5,7 @@ use super::action_controller::{AckActionSender, Action};
 use futures::StreamExt;
 use gateway_client::AcknowledgementReceiver;
 use log::*;
-use nymsphinx::{
+use nym_sphinx::{
     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: task::TaskClient) {
+    pub(super) async fn run_with_shutdown(&mut self, mut shutdown: nym_task::TaskClient) {
         debug!("Started AcknowledgementListener with graceful shutdown support");
 
         while !shutdown.is_shutdown() {

clients/client-core/src/client/real_messages_control/acknowledgement_control/action_controller.rs

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

clients/client-core/src/client/real_messages_control/acknowledgement_control/input_message_listener.rs

@@ -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 nymsphinx::addressing::clients::Recipient;
-use nymsphinx::anonymous_replies::requests::AnonymousSenderTag;
+use nym_sphinx::addressing::clients::Recipient;
+use nym_sphinx::anonymous_replies::requests::AnonymousSenderTag;
+use nym_task::connections::TransmissionLane;
 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: task::TaskClient) {
+    pub(super) async fn run_with_shutdown(&mut self, mut shutdown: nym_task::TaskClient) {
         debug!("Started InputMessageListener with graceful shutdown support");
 
         while !shutdown.is_shutdown() {

clients/client-core/src/client/real_messages_control/acknowledgement_control/mod.rs

@@ -15,9 +15,9 @@ use action_controller::AckActionReceiver;
 use futures::channel::mpsc;
 use gateway_client::AcknowledgementReceiver;
 use log::*;
-use nymsphinx::anonymous_replies::requests::AnonymousSenderTag;
-use nymsphinx::params::PacketSize;
-use nymsphinx::{
+use nym_sphinx::anonymous_replies::requests::AnonymousSenderTag;
+use nym_sphinx::params::PacketSize;
+use nym_sphinx::{
     acknowledgements::AckKey,
     addressing::clients::Recipient,
     chunking::fragment::{Fragment, FragmentIdentifier},
@@ -249,7 +249,7 @@ where
         }
     }
 
-    pub(super) fn start_with_shutdown(self, shutdown: task::TaskClient) {
+    pub(super) fn start_with_shutdown(self, shutdown: nym_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;

clients/client-core/src/client/real_messages_control/acknowledgement_control/retransmission_request_listener.rs

@@ -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 nymsphinx::addressing::clients::Recipient;
-use nymsphinx::chunking::fragment::Fragment;
-use nymsphinx::preparer::PreparedFragment;
+use nym_sphinx::addressing::clients::Recipient;
+use nym_sphinx::chunking::fragment::Fragment;
+use nym_sphinx::preparer::PreparedFragment;
+use nym_task::connections::TransmissionLane;
 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: task::TaskClient) {
+    pub(super) async fn run_with_shutdown(&mut self, mut shutdown: nym_task::TaskClient) {
         debug!("Started RetransmissionRequestListener with graceful shutdown support");
 
         while !shutdown.is_shutdown() {

clients/client-core/src/client/real_messages_control/acknowledgement_control/sent_notification_listener.rs

@@ -5,7 +5,7 @@ use super::action_controller::{AckActionSender, Action};
 use super::SentPacketNotificationReceiver;
 use futures::StreamExt;
 use log::*;
-use nymsphinx::chunking::fragment::{FragmentIdentifier, COVER_FRAG_ID};
+use nym_sphinx::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: task::TaskClient) {
+    pub(super) async fn run_with_shutdown(&mut self, mut shutdown: nym_task::TaskClient) {
         debug!("Started SentNotificationListener with graceful shutdown support");
 
         while !shutdown.is_shutdown() {

clients/client-core/src/client/real_messages_control/message_handler.rs

@@ -8,23 +8,23 @@ use crate::client::real_messages_control::real_traffic_stream::{
 use crate::client::real_messages_control::{AckActionSender, Action};
 use crate::client::replies::reply_storage::{ReceivedReplySurbsMap, SentReplyKeys, UsedSenderTags};
 use crate::client::topology_control::{TopologyAccessor, TopologyReadPermit};
-use client_connections::TransmissionLane;
 use log::{debug, error, info, trace, warn};
-use 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 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 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)]

clients/client-core/src/client/real_messages_control/mod.rs

@@ -21,13 +21,13 @@ use crate::{
     },
     spawn_future,
 };
-use client_connections::{ConnectionCommandReceiver, LaneQueueLengths};
 use futures::channel::mpsc;
 use gateway_client::AcknowledgementReceiver;
 use log::*;
-use nymsphinx::acknowledgements::AckKey;
-use nymsphinx::addressing::clients::Recipient;
-use nymsphinx::params::PacketSize;
+use nym_sphinx::acknowledgements::AckKey;
+use nym_sphinx::addressing::clients::Recipient;
+use nym_sphinx::params::PacketSize;
+use nym_task::connections::{ConnectionCommandReceiver, LaneQueueLengths};
 use rand::{rngs::OsRng, CryptoRng, Rng};
 use std::sync::Arc;
 use std::time::Duration;
@@ -81,7 +81,11 @@ 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_waiting_period: Duration,
+    maximum_reply_surb_rerequest_waiting_period: Duration,
+
+    /// Defines maximum amount of time the client is going to wait for reply surbs before
+    /// deciding it's never going to get them and would drop all pending messages
+    maximum_reply_surb_drop_waiting_period: Duration,
 
     /// Defines maximum amount of time given reply surb is going to be valid for.
     /// This is going to be superseded by key rotation once implemented.
@@ -119,7 +123,8 @@ 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_waiting_period,
+            cfg.maximum_reply_surb_rerequest_waiting_period,
+            cfg.maximum_reply_surb_drop_waiting_period,
             cfg.maximum_reply_surb_age,
             cfg.maximum_reply_key_age,
         )
@@ -161,8 +166,10 @@ 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_waiting_period: base_client_debug_config
-                .maximum_reply_surb_waiting_period,
+            maximum_reply_surb_rerequest_waiting_period: base_client_debug_config
+                .maximum_reply_surb_rerequest_waiting_period,
+            maximum_reply_surb_drop_waiting_period: base_client_debug_config
+                .maximum_reply_surb_drop_waiting_period,
             maximum_reply_surb_age: base_client_debug_config.maximum_reply_surb_age,
             maximum_reply_key_age: base_client_debug_config.maximum_reply_key_age,
         }
@@ -263,7 +270,7 @@ impl RealMessagesController<OsRng> {
         }
     }
 
-    pub fn start_with_shutdown(self, shutdown: task::TaskClient) {
+    pub fn start_with_shutdown(self, shutdown: nym_task::TaskClient) {
         let mut out_queue_control = self.out_queue_control;
         let ack_control = self.ack_control;
         let mut reply_control = self.reply_control;

clients/client-core/src/client/real_messages_control/real_traffic_stream.rs

@@ -6,20 +6,20 @@ use crate::client::mix_traffic::BatchMixMessageSender;
 use crate::client::real_messages_control::acknowledgement_control::SentPacketNotificationSender;
 use crate::client::topology_control::TopologyAccessor;
 use crate::client::transmission_buffer::TransmissionBuffer;
-use client_connections::{
-    ConnectionCommand, ConnectionCommandReceiver, ConnectionId, LaneQueueLengths, TransmissionLane,
-};
 use futures::task::{Context, Poll};
 use futures::{Future, Stream, StreamExt};
 use log::*;
-use 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 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 rand::{CryptoRng, Rng};
 use std::pin::Pin;
 use std::sync::Arc;
@@ -342,7 +342,6 @@ 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!(),
             }
         }
 
@@ -421,7 +420,6 @@ 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!(),
             }
         }
 
@@ -462,7 +460,7 @@ where
     }
 
     #[cfg(not(target_arch = "wasm32"))]
-    fn log_status(&self, shutdown: &mut task::TaskClient) {
+    fn log_status(&self, shutdown: &mut nym_task::TaskClient) {
         use crate::error::ClientCoreStatusMessage;
 
         let packets = self.transmission_buffer.total_size();
@@ -503,7 +501,7 @@ where
         }
     }
 
-    pub(super) async fn run_with_shutdown(&mut self, mut shutdown: task::TaskClient) {
+    pub(super) async fn run_with_shutdown(&mut self, mut shutdown: nym_task::TaskClient) {
         debug!("Started OutQueueControl with graceful shutdown support");
 
         #[cfg(not(target_arch = "wasm32"))]

clients/client-core/src/client/received_buffer.rs

@@ -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 nymsphinx::anonymous_replies::requests::{
+use nym_crypto::asymmetric::encryption;
+use nym_crypto::Digest;
+use nym_sphinx::anonymous_replies::requests::{
     RepliableMessage, RepliableMessageContent, ReplyMessage, ReplyMessageContent,
 };
-use nymsphinx::anonymous_replies::{encryption_key::EncryptionKeyDigest, SurbEncryptionKey};
-use nymsphinx::message::{NymMessage, PlainMessage};
-use nymsphinx::params::ReplySurbKeyDigestAlgorithm;
-use nymsphinx::receiver::{MessageReceiver, MessageRecoveryError, ReconstructedMessage};
+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 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 nymsphinx::cover::is_cover(fragment_data) {
+        if nym_sphinx::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: task::TaskClient) {
+    async fn run_with_shutdown(&mut self, mut shutdown: nym_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: task::TaskClient) {
+    async fn run_with_shutdown(&mut self, mut shutdown: nym_task::TaskClient) {
         debug!("Started FragmentedMessageReceiver with graceful shutdown support");
         while !shutdown.is_shutdown() {
             tokio::select! {
@@ -488,7 +488,7 @@ impl ReceivedMessagesBufferController {
         }
     }
 
-    pub fn start_with_shutdown(self, shutdown: task::TaskClient) {
+    pub fn start_with_shutdown(self, shutdown: nym_task::TaskClient) {
         let mut fragmented_message_receiver = self.fragmented_message_receiver;
         let mut request_receiver = self.request_receiver;
 

clients/client-core/src/client/replies/reply_controller/mod.rs

@@ -4,14 +4,14 @@
 use crate::client::real_messages_control::acknowledgement_control::PendingAcknowledgement;
 use crate::client::real_messages_control::message_handler::{MessageHandler, PreparationError};
 use crate::client::replies::reply_storage::CombinedReplyStorage;
-use client_connections::{ConnectionId, TransmissionLane};
 use futures::channel::oneshot;
 use futures::StreamExt;
 use log::{debug, error, info, trace, warn};
-use nymsphinx::addressing::clients::Recipient;
-use nymsphinx::anonymous_replies::requests::AnonymousSenderTag;
-use nymsphinx::anonymous_replies::ReplySurb;
-use nymsphinx::chunking::fragment::{Fragment, FragmentIdentifier};
+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 rand::{CryptoRng, Rng};
 use std::cmp::{max, min};
 use std::collections::btree_map::Entry;
@@ -30,7 +30,8 @@ pub struct Config {
     min_surb_request_size: u32,
     max_surb_request_size: u32,
     maximum_allowed_reply_surb_request_size: u32,
-    max_surb_waiting_period: Duration,
+    max_surb_rerequest_waiting_period: Duration,
+    max_surb_drop_waiting_period: Duration,
     max_reply_surb_age: Duration,
     max_reply_key_age: Duration,
 }
@@ -40,7 +41,8 @@ impl Config {
         min_surb_request_size: u32,
         max_surb_request_size: u32,
         maximum_allowed_reply_surb_request_size: u32,
-        max_surb_waiting_period: Duration,
+        max_surb_rerequest_waiting_period: Duration,
+        max_surb_drop_waiting_period: Duration,
         max_reply_surb_age: Duration,
         max_reply_key_age: Duration,
     ) -> Self {
@@ -48,7 +50,8 @@ impl Config {
             min_surb_request_size,
             max_surb_request_size,
             maximum_allowed_reply_surb_request_size,
-            max_surb_waiting_period,
+            max_surb_rerequest_waiting_period,
+            max_surb_drop_waiting_period,
             max_reply_surb_age,
             max_reply_key_age,
         }
@@ -742,9 +745,13 @@ where
 
             let diff = now - last_received_time;
 
-            if diff > self.config.max_surb_waiting_period {
-                warn!("We haven't received any surbs in {:?} from {pending_reply_target}. Going to explicitly ask for more", diff);
-                to_request.push(*pending_reply_target);
+            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);
+                }
             }
         }
 
@@ -828,7 +835,7 @@ where
     //     todo!()
     // }
 
-    pub(crate) async fn run_with_shutdown(&mut self, mut shutdown: task::TaskClient) {
+    pub(crate) async fn run_with_shutdown(&mut self, mut shutdown: nym_task::TaskClient) {
         debug!("Started ReplyController with graceful shutdown support");
 
         let polling_rate = Duration::from_secs(5);

clients/client-core/src/client/replies/reply_controller/requests.rs

@@ -2,12 +2,12 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::client::real_messages_control::acknowledgement_control::PendingAcknowledgement;
-use client_connections::{ConnectionId, TransmissionLane};
 use futures::channel::{mpsc, oneshot};
 use log::error;
-use nymsphinx::addressing::clients::Recipient;
-use nymsphinx::anonymous_replies::requests::AnonymousSenderTag;
-use nymsphinx::anonymous_replies::ReplySurb;
+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) {

clients/client-core/src/client/replies/reply_storage/backend/browser_backend.rs

@@ -5,6 +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)]
@@ -27,6 +29,18 @@ 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,
@@ -41,4 +55,8 @@ 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()
+    }
 }

clients/client-core/src/client/replies/reply_storage/backend/fs_backend/error.rs

@@ -10,6 +10,12 @@ 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]
@@ -50,4 +56,9 @@ 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>,
+    },
 }

clients/client-core/src/client/replies/reply_storage/backend/fs_backend/manager.rs

@@ -20,6 +20,16 @@ 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);

clients/client-core/src/client/replies/reply_storage/backend/fs_backend/mod.rs

@@ -1,6 +1,7 @@
 // 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,
@@ -11,7 +12,7 @@ use crate::client::replies::reply_storage::{
 };
 use async_trait::async_trait;
 use log::{error, info, warn};
-use nymsphinx::anonymous_replies::requests::AnonymousSenderTag;
+use nym_sphinx::anonymous_replies::requests::AnonymousSenderTag;
 use std::fs;
 use std::path::{Path, PathBuf};
 use time::OffsetDateTime;
@@ -22,11 +23,49 @@ 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: StorageManager,
+    manager: StorageManagerState,
 }
 
 impl Backend {
@@ -40,17 +79,32 @@ 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: StorageManager::init(database_path, true).await?,
+            manager: StorageManagerState::Storage(manager),
         };
 
-        backend.manager.create_status_table().await?;
-
         Ok(backend)
     }
 
+    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,
+            }),
+        }
+    }
+
     pub async fn try_load<P: AsRef<Path>>(database_path: P) -> Result<Self, StorageError> {
         let owned_path: PathBuf = database_path.as_ref().into();
         if owned_path.file_name().is_none() {
@@ -101,30 +155,33 @@ impl Backend {
         // (assuming no key rotation has happened)
         // but the way it's currently coded, everyone will purge old data
         let since_last_flush = OffsetDateTime::now_utc() - last_flush;
-        if since_last_flush.whole_days() > 0 {
-            info!("it's been over {} days and {} hours since we last used our data store. our reply surbs are already outdated - we're going to purge them now.", since_last_flush.whole_days(), since_last_flush.whole_hours());
+        let days = since_last_flush.whole_days();
+        let hours = since_last_flush.whole_hours() % 24;
+
+        if days > 0 {
+            info!("it's been over {days} days and {hours} hours since we last used our data store. our reply surbs are already outdated - we're going to purge them now.");
             manager.delete_all_reply_surb_data().await?;
         }
 
-        if since_last_flush.whole_days() > 1 {
-            info!("it's been over {} days and {} hours since we last used our data store. our reply keys are already outdated - we're going to purge them now.", since_last_flush.whole_days(), since_last_flush.whole_hours());
+        if days > 1 {
+            info!("it's been over {days} days and {hours} hours since we last used our data store. our reply keys are already outdated - we're going to purge them now.");
             manager.delete_all_reply_keys().await?;
         }
 
-        if since_last_flush.whole_days() > 2 {
-            info!("it's been over {} days and {} hours since we last used our data store. our used sender tags are already outdated - we're going to purge them now.", since_last_flush.whole_days(), since_last_flush.whole_hours());
+        if days > 2 {
+            info!("it's been over {days} days and {hours} hours since we last used our data store. our used sender tags are already outdated - we're going to purge them now.");
             manager.delete_all_tags().await?;
         }
 
         Ok(Backend {
             temporary_old_path: None,
             database_path: owned_path,
-            manager,
+            manager: StorageManagerState::Storage(manager),
         })
     }
 
     async fn close_pool(&mut self) {
-        self.manager.connection_pool.close().await;
+        self.manager.get_mut().connection_pool.close().await;
     }
 
     async fn rotate(&mut self) -> Result<(), StorageError> {
@@ -143,8 +200,9 @@ impl Backend {
 
         fs::rename(&self.database_path, &temp_old)
             .map_err(|err| StorageError::DatabaseRenameError { source: err })?;
-        self.manager = StorageManager::init(&self.database_path, true).await?;
-        self.manager.create_status_table().await?;
+        self.manager =
+            StorageManagerState::Storage(StorageManager::init(&self.database_path, true).await?);
+        self.manager.get_mut().create_status_table().await?;
 
         self.temporary_old_path = Some(temp_old);
         Ok(())
@@ -161,26 +219,27 @@ impl Backend {
     }
 
     async fn start_storage_flush(&self) -> Result<(), StorageError> {
-        Ok(self.manager.set_flush_status(true).await?)
+        Ok(self.manager.get().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.set_flush_status(false).await?)
+        Ok(self.manager.get().set_flush_status(false).await?)
     }
 
     async fn start_client_use(&self) -> Result<(), StorageError> {
-        Ok(self.manager.set_client_in_use_status(true).await?)
+        Ok(self.manager.get().set_client_in_use_status(true).await?)
     }
 
     async fn stop_client_use(&self) -> Result<(), StorageError> {
-        Ok(self.manager.set_client_in_use_status(false).await?)
+        Ok(self.manager.get().set_client_in_use_status(false).await?)
     }
 
     async fn get_stored_tags(&self) -> Result<UsedSenderTags, StorageError> {
-        let stored = self.manager.get_tags().await?;
+        let stored = self.manager.get().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
@@ -196,6 +255,7 @@ 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?;
         }
@@ -203,7 +263,7 @@ impl Backend {
     }
 
     async fn get_stored_reply_keys(&self) -> Result<SentReplyKeys, StorageError> {
-        let stored = self.manager.get_reply_keys().await?;
+        let stored = self.manager.get().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
@@ -219,6 +279,7 @@ 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?;
         }
@@ -226,7 +287,7 @@ impl Backend {
     }
 
     async fn get_stored_reply_surbs(&self) -> Result<ReceivedReplySurbsMap, StorageError> {
-        let surb_senders = self.manager.get_surb_senders().await?;
+        let surb_senders = self.manager.get().get_surb_senders().await?;
 
         let metadata = self.get_reply_surb_storage_metadata().await?;
         let mut received_surbs = Vec::with_capacity(surb_senders.len());
@@ -236,6 +297,7 @@ impl Backend {
                 sender.try_into()?;
             let stored_surbs = self
                 .manager
+                .get()
                 .get_reply_surbs(sender_id)
                 .await?
                 .into_iter()
@@ -263,6 +325,7 @@ 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(),
@@ -271,6 +334,7 @@ impl Backend {
 
             for reply_surb in received_surbs.surbs_ref() {
                 self.manager
+                    .get()
                     .insert_reply_surb(StoredReplySurb::new(sender_id, reply_surb))
                     .await?
             }
@@ -282,6 +346,7 @@ impl Backend {
         &self,
     ) -> Result<ReplySurbStorageMetadata, StorageError> {
         self.manager
+            .get()
             .get_reply_surb_storage_metadata()
             .await
             .map_err(Into::into)
@@ -292,6 +357,7 @@ 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(),
@@ -305,6 +371,24 @@ 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
     }
@@ -342,6 +426,18 @@ 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
     }

clients/client-core/src/client/replies/reply_storage/backend/fs_backend/models.rs

@@ -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 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;
+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;
 
 #[derive(Debug, Clone)]
 pub(crate) struct StoredSenderTag {

clients/client-core/src/client/replies/reply_storage/backend/mod.rs

@@ -3,7 +3,7 @@
 
 use crate::client::replies::reply_storage::CombinedReplyStorage;
 use async_trait::async_trait;
-use std::error::Error;
+use std::{error::Error, path::PathBuf};
 use thiserror::Error;
 
 #[cfg(target_arch = "wasm32")]
@@ -30,6 +30,16 @@ pub struct Empty {
 impl ReplyStorageBackend for Empty {
     type StorageError = UndefinedError;
 
+    async fn new(
+        debug_config: &crate::config::DebugConfig,
+        _db_path: Option<PathBuf>,
+    ) -> Result<Self, Self::StorageError> {
+        Ok(Self {
+            min_surb_threshold: debug_config.minimum_reply_surb_storage_threshold,
+            max_surb_threshold: debug_config.maximum_reply_surb_storage_threshold,
+        })
+    }
+
     async fn flush_surb_storage(
         &mut self,
         _storage: &CombinedReplyStorage,
@@ -50,12 +60,28 @@ 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(())
     }
@@ -73,6 +99,11 @@ 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(())
     }

clients/client-core/src/client/replies/reply_storage/key_storage.rs

@@ -3,8 +3,8 @@
 
 use dashmap::iter::Iter;
 use dashmap::DashMap;
-use nymsphinx::anonymous_replies::encryption_key::EncryptionKeyDigest;
-use nymsphinx::anonymous_replies::SurbEncryptionKey;
+use nym_sphinx::anonymous_replies::encryption_key::EncryptionKeyDigest;
+use nym_sphinx::anonymous_replies::SurbEncryptionKey;
 use std::ops::Deref;
 use std::sync::Arc;
 use time::OffsetDateTime;

clients/client-core/src/client/replies/reply_storage/mod.rs

@@ -37,7 +37,7 @@ where
     pub async fn flush_on_shutdown(
         mut self,
         mem_state: CombinedReplyStorage,
-        mut shutdown: task::TaskClient,
+        mut shutdown: nym_task::TaskClient,
     ) {
         use log::{debug, error, info, warn};
 

clients/client-core/src/client/replies/reply_storage/surb_storage.rs

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

clients/client-core/src/client/replies/reply_storage/tag_storage.rs

@@ -2,8 +2,8 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use dashmap::DashMap;
-use nymsphinx::addressing::clients::{Recipient, RecipientBytes};
-use nymsphinx::anonymous_replies::requests::AnonymousSenderTag;
+use nym_sphinx::addressing::clients::{Recipient, RecipientBytes};
+use nym_sphinx::anonymous_replies::requests::AnonymousSenderTag;
 use std::sync::Arc;
 
 #[cfg(all(not(target_arch = "wasm32"), feature = "fs-surb-storage"))]

clients/client-core/src/client/topology_control.rs

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

clients/client-core/src/client/topology_control/accessor.rs

@@ -0,0 +1,154 @@
+// Copyright 2021-2023 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use nym_sphinx::addressing::clients::Recipient;
+use nym_sphinx::params::DEFAULT_NUM_MIX_HOPS;
+use nym_topology::{NymTopology, NymTopologyError};
+use std::ops::Deref;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::Arc;
+use tokio::sync::{Notify, RwLock, RwLockReadGuard};
+
+#[derive(Debug)]
+pub struct TopologyAccessorInner {
+    controlled_manually: AtomicBool,
+    released_manual_control: Notify,
+    // `RwLock` *seems to* be the better approach for this as write access is only requested every
+    // few seconds, while reads are needed every single packet generated.
+    // However, proper benchmarks will be needed to determine if `RwLock` is indeed a better
+    // approach than a `Mutex`
+    topology: RwLock<Option<NymTopology>>,
+}
+
+impl TopologyAccessorInner {
+    fn new() -> Self {
+        TopologyAccessorInner {
+            controlled_manually: AtomicBool::new(false),
+            released_manual_control: Notify::new(),
+            topology: RwLock::new(None),
+        }
+    }
+
+    async fn update(&self, new: Option<NymTopology>) {
+        *self.topology.write().await = new;
+    }
+}
+
+pub struct TopologyReadPermit<'a> {
+    permit: RwLockReadGuard<'a, Option<NymTopology>>,
+}
+
+impl<'a> Deref for TopologyReadPermit<'a> {
+    type Target = Option<NymTopology>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.permit
+    }
+}
+
+impl<'a> TopologyReadPermit<'a> {
+    /// Using provided topology read permit, tries to get an immutable reference to the underlying
+    /// topology. For obvious reasons the lifetime of the topology reference is bound to the permit.
+    pub(crate) fn try_get_valid_topology_ref(
+        &'a self,
+        ack_recipient: &Recipient,
+        packet_recipient: Option<&Recipient>,
+    ) -> Result<&'a NymTopology, NymTopologyError> {
+        // 1. Have we managed to get anything from the refresher, i.e. have the nym-api queries gone through?
+        let topology = self
+            .permit
+            .as_ref()
+            .ok_or(NymTopologyError::EmptyNetworkTopology)?;
+
+        // 2. does it have any mixnode at all?
+        // 3. does it have any gateways at all?
+        // 4. does it have a mixnode on each layer?
+        topology.ensure_can_construct_path_through(DEFAULT_NUM_MIX_HOPS)?;
+
+        // 5. does it contain OUR gateway (so that we could create an ack packet)?
+        if !topology.gateway_exists(ack_recipient.gateway()) {
+            return Err(NymTopologyError::NonExistentGatewayError {
+                identity_key: ack_recipient.gateway().to_base58_string(),
+            });
+        }
+
+        // 6. for our target recipient, does it contain THEIR gateway (so that we could create
+        if let Some(recipient) = packet_recipient {
+            if !topology.gateway_exists(recipient.gateway()) {
+                return Err(NymTopologyError::NonExistentGatewayError {
+                    identity_key: recipient.gateway().to_base58_string(),
+                });
+            }
+        }
+
+        Ok(topology)
+    }
+}
+
+impl<'a> From<RwLockReadGuard<'a, Option<NymTopology>>> for TopologyReadPermit<'a> {
+    fn from(read_permit: RwLockReadGuard<'a, Option<NymTopology>>) -> Self {
+        TopologyReadPermit {
+            permit: read_permit,
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct TopologyAccessor {
+    inner: Arc<TopologyAccessorInner>,
+}
+
+impl TopologyAccessor {
+    pub fn new() -> Self {
+        TopologyAccessor {
+            inner: Arc::new(TopologyAccessorInner::new()),
+        }
+    }
+
+    pub fn controlled_manually(&self) -> bool {
+        self.inner.controlled_manually.load(Ordering::SeqCst)
+    }
+
+    pub async fn get_read_permit(&self) -> TopologyReadPermit<'_> {
+        self.inner.topology.read().await.into()
+    }
+
+    pub(crate) async fn update_global_topology(&self, new_topology: Option<NymTopology>) {
+        self.inner.update(new_topology).await;
+    }
+
+    pub(crate) async fn wait_for_released_manual_control(&self) {
+        self.inner.released_manual_control.notified().await
+    }
+
+    pub async fn current_topology(&self) -> Option<NymTopology> {
+        self.inner.topology.read().await.clone()
+    }
+
+    pub async fn manually_change_topology(&self, new_topology: NymTopology) {
+        self.inner.controlled_manually.store(true, Ordering::SeqCst);
+        self.inner.update(Some(new_topology)).await;
+    }
+
+    pub fn release_manual_control(&self) {
+        self.inner
+            .controlled_manually
+            .store(false, Ordering::SeqCst);
+        self.inner.released_manual_control.notify_waiters();
+    }
+
+    // only used by the client at startup to get a slightly more reasonable error message
+    // (currently displays as unused because health checker is disabled due to required changes)
+    pub async fn ensure_is_routable(&self) -> Result<(), NymTopologyError> {
+        match self.inner.topology.read().await.deref() {
+            None => Err(NymTopologyError::EmptyNetworkTopology),
+            Some(ref topology) => topology.ensure_can_construct_path_through(DEFAULT_NUM_MIX_HOPS),
+        }
+    }
+}
+
+impl Default for TopologyAccessor {
+    fn default() -> Self {
+        TopologyAccessor::new()
+    }
+}

clients/client-core/src/client/topology_control/mod.rs

@@ -0,0 +1,115 @@
+// Copyright 2021-2023 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::spawn_future;
+pub(crate) use accessor::{TopologyAccessor, TopologyReadPermit};
+use futures::StreamExt;
+use log::*;
+use nym_topology::provider_trait::TopologyProvider;
+use nym_topology::NymTopologyError;
+use std::time::Duration;
+
+mod accessor;
+pub(crate) mod nym_api_provider;
+
+// TODO: move it to config later
+const MAX_FAILURE_COUNT: usize = 10;
+
+pub struct TopologyRefresherConfig {
+    refresh_rate: Duration,
+}
+
+impl TopologyRefresherConfig {
+    pub fn new(refresh_rate: Duration) -> Self {
+        TopologyRefresherConfig { refresh_rate }
+    }
+}
+
+pub struct TopologyRefresher {
+    topology_provider: Box<dyn TopologyProvider>,
+    topology_accessor: TopologyAccessor,
+
+    refresh_rate: Duration,
+    consecutive_failure_count: usize,
+}
+
+impl TopologyRefresher {
+    pub fn new(
+        cfg: TopologyRefresherConfig,
+        topology_accessor: TopologyAccessor,
+        topology_provider: Box<dyn TopologyProvider>,
+    ) -> Self {
+        TopologyRefresher {
+            topology_provider,
+            topology_accessor,
+            refresh_rate: cfg.refresh_rate,
+            consecutive_failure_count: 0,
+        }
+    }
+
+    pub fn change_topology_provider(&mut self, provider: Box<dyn TopologyProvider>) {
+        self.topology_provider = provider;
+    }
+
+    pub async fn try_refresh(&mut self) {
+        trace!("Refreshing the topology");
+
+        if self.topology_accessor.controlled_manually() {
+            info!("topology is being controlled manually - we're going to wait until the control is released...");
+            self.topology_accessor
+                .wait_for_released_manual_control()
+                .await;
+        }
+
+        let new_topology = self.topology_provider.get_new_topology().await;
+        if new_topology.is_none() {
+            warn!("failed to obtain new network topology");
+        }
+
+        if new_topology.is_none() && self.consecutive_failure_count < MAX_FAILURE_COUNT {
+            // if we failed to grab this topology, but the one before it was alright, let's assume
+            // validator had a tiny hiccup and use the old data
+            warn!("we're going to keep on using the old topology for this iteration");
+            self.consecutive_failure_count += 1;
+            return;
+        } else if new_topology.is_some() {
+            self.consecutive_failure_count = 0;
+        }
+
+        self.topology_accessor
+            .update_global_topology(new_topology)
+            .await;
+    }
+
+    pub async fn ensure_topology_is_routable(&self) -> Result<(), NymTopologyError> {
+        self.topology_accessor.ensure_is_routable().await
+    }
+
+    pub fn start_with_shutdown(mut self, mut shutdown: nym_task::TaskClient) {
+        spawn_future(async move {
+            debug!("Started TopologyRefresher with graceful shutdown support");
+
+            #[cfg(not(target_arch = "wasm32"))]
+            let mut interval = tokio_stream::wrappers::IntervalStream::new(tokio::time::interval(
+                self.refresh_rate,
+            ));
+
+            #[cfg(target_arch = "wasm32")]
+            let mut interval =
+                gloo_timers::future::IntervalStream::new(self.refresh_rate.as_millis() as u32);
+
+            while !shutdown.is_shutdown() {
+                tokio::select! {
+                    _ = interval.next() => {
+                        self.try_refresh().await;
+                    },
+                    _ = shutdown.recv() => {
+                        log::trace!("TopologyRefresher: Received shutdown");
+                    },
+                }
+            }
+            shutdown.recv_timeout().await;
+            log::debug!("TopologyRefresher: Exiting");
+        })
+    }
+}

clients/client-core/src/client/topology_control/nym_api_provider.rs

@@ -0,0 +1,106 @@
+// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use async_trait::async_trait;
+use log::{error, warn};
+use nym_topology::provider_trait::TopologyProvider;
+use nym_topology::{nym_topology_from_detailed, NymTopology, NymTopologyError};
+use rand::prelude::SliceRandom;
+use rand::thread_rng;
+use url::Url;
+
+pub(crate) struct NymApiTopologyProvider {
+    validator_client: validator_client::client::NymApiClient,
+    nym_api_urls: Vec<Url>,
+
+    client_version: String,
+    currently_used_api: usize,
+}
+
+impl NymApiTopologyProvider {
+    pub(crate) fn new(mut nym_api_urls: Vec<Url>, client_version: String) -> Self {
+        nym_api_urls.shuffle(&mut thread_rng());
+
+        NymApiTopologyProvider {
+            validator_client: validator_client::client::NymApiClient::new(nym_api_urls[0].clone()),
+            nym_api_urls,
+            client_version,
+            currently_used_api: 0,
+        }
+    }
+
+    fn use_next_nym_api(&mut self) {
+        if self.nym_api_urls.len() == 1 {
+            warn!("There's only a single nym API available - it won't be possible to use a different one");
+            return;
+        }
+
+        self.currently_used_api = (self.currently_used_api + 1) % self.nym_api_urls.len();
+        self.validator_client
+            .change_nym_api(self.nym_api_urls[self.currently_used_api].clone())
+    }
+
+    /// Verifies whether nodes a reasonably distributed among all mix layers.
+    ///
+    /// In ideal world we would have 33% nodes on layer 1, 33% on layer 2 and 33% on layer 3.
+    /// However, this is a rather unrealistic expectation, instead we check whether there exists
+    /// a layer with more than 66% of nodes or with fewer than 15% and if so, we trigger a failure.
+    ///
+    /// # Arguments
+    ///
+    /// * `topology`: active topology constructed from validator api data
+    fn check_layer_distribution(
+        &self,
+        active_topology: &NymTopology,
+    ) -> Result<(), NymTopologyError> {
+        let lower_threshold = 0.15;
+        let upper_threshold = 0.66;
+        active_topology.ensure_even_layer_distribution(lower_threshold, upper_threshold)
+    }
+
+    async fn get_current_compatible_topology(&mut self) -> Option<NymTopology> {
+        let mixnodes = match self.validator_client.get_cached_active_mixnodes().await {
+            Err(err) => {
+                error!("failed to get network mixnodes - {err}");
+                return None;
+            }
+            Ok(mixes) => mixes,
+        };
+
+        let gateways = match self.validator_client.get_cached_gateways().await {
+            Err(err) => {
+                error!("failed to get network gateways - {err}");
+                return None;
+            }
+            Ok(gateways) => gateways,
+        };
+
+        let topology = nym_topology_from_detailed(mixnodes, gateways)
+            .filter_system_version(&self.client_version);
+
+        if let Err(err) = self.check_layer_distribution(&topology) {
+            warn!("The current filtered active topology has extremely skewed layer distribution. It cannot be used: {err}");
+            self.use_next_nym_api();
+            None
+        } else {
+            Some(topology)
+        }
+    }
+}
+
+// hehe, wasm
+#[cfg(not(target_arch = "wasm32"))]
+#[async_trait]
+impl TopologyProvider for NymApiTopologyProvider {
+    async fn get_new_topology(&mut self) -> Option<NymTopology> {
+        self.get_current_compatible_topology().await
+    }
+}
+
+#[cfg(target_arch = "wasm32")]
+#[async_trait(?Send)]
+impl TopologyProvider for NymApiTopologyProvider {
+    async fn get_new_topology(&mut self) -> Option<NymTopology> {
+        self.get_current_compatible_topology().await
+    }
+}

clients/client-core/src/client/transmission_buffer.rs

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

clients/client-core/src/config/mod.rs

@@ -1,9 +1,9 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use config::defaults::NymNetworkDetails;
-use config::{NymConfig, OptionalSet, DB_FILE_NAME};
-use nymsphinx::params::PacketSize;
+use nym_config::defaults::NymNetworkDetails;
+use nym_config::{NymConfig, OptionalSet, CRED_DB_FILE_NAME};
+use nym_sphinx::params::PacketSize;
 use serde::{Deserialize, Serialize};
 use std::marker::PhantomData;
 use std::path::PathBuf;
@@ -45,7 +45,8 @@ const DEFAULT_MAXIMUM_REPLY_SURB_REQUEST_SIZE: u32 = 100;
 
 const DEFAULT_MAXIMUM_ALLOWED_SURB_REQUEST_SIZE: u32 = 500;
 
-const DEFAULT_MAXIMUM_REPLY_SURB_WAITING_PERIOD: Duration = Duration::from_secs(10);
+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);
 
 // 12 hours
 const DEFAULT_MAXIMUM_REPLY_SURB_AGE: Duration = Duration::from_secs(12 * 60 * 60);
@@ -170,10 +171,15 @@ impl<T> Config<T> {
         self
     }
 
-    pub fn with_gateway_endpoint(&mut self, gateway_endpoint: GatewayEndpointConfig) {
+    pub fn set_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();
     }
@@ -372,8 +378,12 @@ impl<T> Config<T> {
         self.debug.maximum_allowed_reply_surb_request_size
     }
 
-    pub fn get_maximum_reply_surb_waiting_period(&self) -> Duration {
-        self.debug.maximum_reply_surb_waiting_period
+    pub fn get_maximum_reply_surb_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_age(&self) -> Duration {
@@ -425,8 +435,8 @@ impl GatewayEndpointConfig {
     }
 }
 
-impl From<topology::gateway::Node> for GatewayEndpointConfig {
-    fn from(node: topology::gateway::Node) -> GatewayEndpointConfig {
+impl From<nym_topology::gateway::Node> for GatewayEndpointConfig {
+    fn from(node: nym_topology::gateway::Node) -> GatewayEndpointConfig {
         let gateway_listener = node.clients_address();
         GatewayEndpointConfig {
             gateway_id: node.identity_key.to_base58_string(),
@@ -541,35 +551,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(Some(id)).join("private_identity.pem")
+        T::default_data_directory(id).join("private_identity.pem")
     }
 
     fn default_public_identity_key_file(id: &str) -> PathBuf {
-        T::default_data_directory(Some(id)).join("public_identity.pem")
+        T::default_data_directory(id).join("public_identity.pem")
     }
 
     fn default_private_encryption_key_file(id: &str) -> PathBuf {
-        T::default_data_directory(Some(id)).join("private_encryption.pem")
+        T::default_data_directory(id).join("private_encryption.pem")
     }
 
     fn default_public_encryption_key_file(id: &str) -> PathBuf {
-        T::default_data_directory(Some(id)).join("public_encryption.pem")
+        T::default_data_directory(id).join("public_encryption.pem")
     }
 
     fn default_gateway_shared_key_file(id: &str) -> PathBuf {
-        T::default_data_directory(Some(id)).join("gateway_shared.pem")
+        T::default_data_directory(id).join("gateway_shared.pem")
     }
 
     fn default_ack_key_file(id: &str) -> PathBuf {
-        T::default_data_directory(Some(id)).join("ack_key.pem")
+        T::default_data_directory(id).join("ack_key.pem")
     }
 
     fn default_reply_surb_database_path(id: &str) -> PathBuf {
-        T::default_data_directory(Some(id)).join("persistent_reply_store.sqlite")
+        T::default_data_directory(id).join("persistent_reply_store.sqlite")
     }
 
     fn default_database_path(id: &str) -> PathBuf {
-        T::default_data_directory(Some(id)).join(DB_FILE_NAME)
+        T::default_data_directory(id).join(CRED_DB_FILE_NAME)
     }
 }
 
@@ -663,7 +673,12 @@ 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_waiting_period: Duration,
+    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,
 
     /// 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.
@@ -704,7 +719,9 @@ 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_waiting_period: DEFAULT_MAXIMUM_REPLY_SURB_WAITING_PERIOD,
+            maximum_reply_surb_rerequest_waiting_period:
+                DEFAULT_MAXIMUM_REPLY_SURB_REREQUEST_WAITING_PERIOD,
+            maximum_reply_surb_drop_waiting_period: DEFAULT_MAXIMUM_REPLY_SURB_DROP_WAITING_PERIOD,
             maximum_reply_surb_age: DEFAULT_MAXIMUM_REPLY_SURB_AGE,
             maximum_reply_key_age: DEFAULT_MAXIMUM_REPLY_KEY_AGE,
         }

clients/client-core/src/config/persistence/key_pathfinder.rs

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::config::Config;
-use config::NymConfig;
+use nym_config::NymConfig;
 use std::path::{Path, PathBuf};
 
 #[derive(Debug)]

clients/client-core/src/error.rs

@@ -1,9 +1,10 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crypto::asymmetric::identity::Ed25519RecoveryError;
 use gateway_client::error::GatewayClientError;
-use topology::NymTopologyError;
+use nym_crypto::asymmetric::identity::Ed25519RecoveryError;
+use nym_topology::gateway::GatewayConversionError;
+use nym_topology::NymTopologyError;
 use validator_client::ValidatorClientError;
 
 #[derive(thiserror::Error, Debug)]
@@ -53,7 +54,32 @@ pub enum ClientCoreError {
     GatewayOwnerUnknown,
 
     #[error("The address of the gateway is unknown - did you run init?")]
-    GatwayAddressUnknown,
+    GatewayAddressUnknown,
+
+    #[error("The gateway is malformed: {source}")]
+    MalformedGateway {
+        #[from]
+        source: GatewayConversionError,
+    },
+
+    #[error("failed to establish connection to gateway: {source}")]
+    GatewayConnectionFailure {
+        #[from]
+        source: tungstenite::Error,
+    },
+
+    #[cfg(target_arch = "wasm32")]
+    #[error("failed to establish gateway connection (wasm)")]
+    GatewayJsConnectionFailure,
+
+    #[error("Gateway connection was abruptly closed")]
+    GatewayConnectionAbruptlyClosed,
+
+    #[error("Timed out while trying to establish gateway connection")]
+    GatewayConnectionTimeout,
+
+    #[error("No ping measurements for the gateway ({identity}) performed")]
+    NoGatewayMeasurements { identity: String },
 
     #[error("failed to register receiver for reconstructed mixnet messages")]
     FailedToRegisterReceiver,

clients/client-core/src/init/helpers.rs

@@ -6,48 +6,223 @@ use crate::{
     config::{persistence::key_pathfinder::ClientKeyPathfinder, Config},
     error::ClientCoreError,
 };
-use config::NymConfig;
-use crypto::asymmetric::identity;
+use futures::{SinkExt, StreamExt};
 use gateway_client::GatewayClient;
 use gateway_requests::registration::handshake::SharedKeys;
-use rand::{seq::SliceRandom, thread_rng};
+use log::{debug, info, trace, warn};
+use nym_config::NymConfig;
+use nym_crypto::asymmetric::identity;
+use nym_topology::{filter::VersionFilterable, gateway};
+use rand::{seq::SliceRandom, thread_rng, Rng};
 use std::{sync::Arc, time::Duration};
 use tap::TapFallible;
-use topology::{filter::VersionFilterable, gateway};
+use tungstenite::Message;
 use url::Url;
 
-pub(super) async fn query_gateway_details(
-    validator_servers: Vec<Url>,
-    chosen_gateway_id: Option<identity::PublicKey>,
-) -> Result<gateway::Node, ClientCoreError> {
-    let nym_api = validator_servers
-        .choose(&mut thread_rng())
+#[cfg(not(target_arch = "wasm32"))]
+use tokio::net::TcpStream;
+#[cfg(not(target_arch = "wasm32"))]
+use tokio::time::Instant;
+#[cfg(not(target_arch = "wasm32"))]
+use tokio_tungstenite::connect_async;
+#[cfg(not(target_arch = "wasm32"))]
+use tokio_tungstenite::{MaybeTlsStream, WebSocketStream};
+#[cfg(not(target_arch = "wasm32"))]
+use validator_client::nyxd::SigningNyxdClient;
+
+#[cfg(not(target_arch = "wasm32"))]
+type WsConn = WebSocketStream<MaybeTlsStream<TcpStream>>;
+
+#[cfg(target_arch = "wasm32")]
+use gateway_client::wasm_mockups::SigningNyxdClient;
+#[cfg(target_arch = "wasm32")]
+use wasm_timer::Instant;
+#[cfg(target_arch = "wasm32")]
+use wasm_utils::websocket::JSWebsocket;
+
+#[cfg(target_arch = "wasm32")]
+type WsConn = JSWebsocket;
+
+const MEASUREMENTS: usize = 3;
+
+#[cfg(not(target_arch = "wasm32"))]
+const CONN_TIMEOUT: Duration = Duration::from_millis(1500);
+const PING_TIMEOUT: Duration = Duration::from_millis(1000);
+
+struct GatewayWithLatency {
+    gateway: gateway::Node,
+    latency: Duration,
+}
+
+impl GatewayWithLatency {
+    fn new(gateway: gateway::Node, latency: Duration) -> Self {
+        GatewayWithLatency { gateway, latency }
+    }
+}
+
+async fn current_gateways<R: Rng>(
+    rng: &mut R,
+    nym_apis: Vec<Url>,
+) -> Result<Vec<gateway::Node>, ClientCoreError> {
+    let nym_api = nym_apis
+        .choose(rng)
         .ok_or(ClientCoreError::ListOfNymApisIsEmpty)?;
-    let validator_client = validator_client::client::NymApiClient::new(nym_api.clone());
+    let client = validator_client::client::NymApiClient::new(nym_api.clone());
 
     log::trace!("Fetching list of gateways from: {}", nym_api);
-    let gateways = validator_client.get_cached_gateways().await?;
+
+    let gateways = client.get_cached_gateways().await?;
     let valid_gateways = gateways
         .into_iter()
         .filter_map(|gateway| gateway.try_into().ok())
         .collect::<Vec<gateway::Node>>();
 
+    // we were always filtering by version so I'm not removing that 'feature'
     let filtered_gateways = valid_gateways.filter_by_version(env!("CARGO_PKG_VERSION"));
+    Ok(filtered_gateways)
+}
 
-    // if we have chosen particular gateway - use it, otherwise choose a random one.
-    // (remember that in active topology all gateways have at least 100 reputation so should
-    // be working correctly)
-    if let Some(gateway_id) = chosen_gateway_id {
-        filtered_gateways
-            .iter()
-            .find(|gateway| gateway.identity_key == gateway_id)
-            .ok_or_else(|| ClientCoreError::NoGatewayWithId(gateway_id.to_string()))
-            .cloned()
+#[cfg(not(target_arch = "wasm32"))]
+async fn connect(endpoint: &str) -> Result<WsConn, ClientCoreError> {
+    match tokio::time::timeout(CONN_TIMEOUT, connect_async(endpoint)).await {
+        Err(_elapsed) => Err(ClientCoreError::GatewayConnectionTimeout),
+        Ok(Err(conn_failure)) => Err(conn_failure.into()),
+        Ok(Ok((stream, _))) => Ok(stream),
+    }
+}
+
+#[cfg(target_arch = "wasm32")]
+async fn connect(endpoint: &str) -> Result<WsConn, ClientCoreError> {
+    JSWebsocket::new(endpoint).map_err(|_| ClientCoreError::GatewayJsConnectionFailure)
+}
+
+async fn measure_latency(gateway: gateway::Node) -> Result<GatewayWithLatency, ClientCoreError> {
+    let addr = gateway.clients_address();
+    trace!(
+        "establishing connection to {} ({addr})...",
+        gateway.identity_key,
+    );
+    let mut stream = connect(&addr).await?;
+
+    let mut results = Vec::new();
+    for _ in 0..MEASUREMENTS {
+        let measurement_future = async {
+            let ping_content = vec![1, 2, 3];
+            let start = Instant::now();
+            stream.send(Message::Ping(ping_content.clone())).await?;
+
+            match stream.next().await {
+                Some(Ok(Message::Pong(content))) => {
+                    if content == ping_content {
+                        let elapsed = Instant::now().duration_since(start);
+                        trace!("current ping time: {elapsed:?}");
+                        results.push(elapsed);
+                    } else {
+                        warn!("received a pong message with different content? wtf.")
+                    }
+                }
+                Some(Ok(_)) => warn!("received a message that's not a pong!"),
+                Some(Err(err)) => return Err(err.into()),
+                None => return Err(ClientCoreError::GatewayConnectionAbruptlyClosed),
+            }
+
+            Ok::<(), ClientCoreError>(())
+        };
+
+        // thanks to wasm we can't use tokio::time::timeout : (
+        #[cfg(not(target_arch = "wasm32"))]
+        let timeout = tokio::time::sleep(PING_TIMEOUT);
+        #[cfg(not(target_arch = "wasm32"))]
+        tokio::pin!(timeout);
+
+        #[cfg(target_arch = "wasm32")]
+        let mut timeout = wasm_timer::Delay::new(PING_TIMEOUT);
+
+        tokio::select! {
+            _ = &mut timeout => {
+                warn!("timed out while trying to perform measurement...")
+            }
+            res = measurement_future => res?,
+        }
+    }
+
+    let count = results.len() as u64;
+    if count == 0 {
+        return Err(ClientCoreError::NoGatewayMeasurements {
+            identity: gateway.identity_key.to_base58_string(),
+        });
+    }
+
+    let sum: Duration = results.into_iter().sum();
+    let avg = Duration::from_nanos(sum.as_nanos() as u64 / count);
+
+    Ok(GatewayWithLatency::new(gateway, avg))
+}
+
+async fn choose_gateway_by_latency<R: Rng>(
+    rng: &mut R,
+    gateways: Vec<gateway::Node>,
+) -> Result<gateway::Node, ClientCoreError> {
+    info!("choosing gateway by latency...");
+
+    let mut gateways_with_latency = Vec::new();
+    for gateway in gateways {
+        let id = *gateway.identity();
+        trace!("measuring latency to {id}...");
+        let with_latency = match measure_latency(gateway).await {
+            Ok(res) => res,
+            Err(err) => {
+                warn!("failed to measure {id}: {err}");
+                continue;
+            }
+        };
+        debug!(
+            "{id} ({}): {:?}",
+            with_latency.gateway.location, with_latency.latency
+        );
+        gateways_with_latency.push(with_latency)
+    }
+
+    let chosen = gateways_with_latency
+        .choose_weighted(rng, |item| 1. / item.latency.as_secs_f32())
+        .expect("invalid selection weight!");
+
+    info!(
+        "chose gateway {} (located at {}) with average latency of {:?}",
+        chosen.gateway.identity_key, chosen.gateway.location, chosen.latency
+    );
+
+    Ok(chosen.gateway.clone())
+}
+
+fn uniformly_random_gateway<R: Rng>(
+    rng: &mut R,
+    gateways: Vec<gateway::Node>,
+) -> Result<gateway::Node, ClientCoreError> {
+    gateways
+        .choose(rng)
+        .ok_or(ClientCoreError::NoGatewaysOnNetwork)
+        .cloned()
+}
+
+pub(super) async fn query_gateway_details(
+    validator_servers: Vec<Url>,
+    chosen_gateway_id: Option<identity::PublicKey>,
+    by_latency: bool,
+) -> Result<gateway::Node, ClientCoreError> {
+    let mut rng = thread_rng();
+    let gateways = current_gateways(&mut rng, validator_servers).await?;
+
+    // if we set an explicit gateway, use that one and nothing else
+    if let Some(explicitly_chosen) = chosen_gateway_id {
+        gateways
+            .into_iter()
+            .find(|gateway| gateway.identity_key == explicitly_chosen)
+            .ok_or_else(|| ClientCoreError::NoGatewayWithId(explicitly_chosen.to_string()))
+    } else if by_latency {
+        choose_gateway_by_latency(&mut rng, gateways).await
     } else {
-        filtered_gateways
-            .choose(&mut rand::thread_rng())
-            .ok_or(ClientCoreError::NoGatewaysOnNetwork)
-            .cloned()
+        uniformly_random_gateway(&mut rng, gateways)
     }
 }
 
@@ -56,10 +231,9 @@ pub(super) async fn register_with_gateway(
     our_identity: Arc<identity::KeyPair>,
 ) -> Result<Arc<SharedKeys>, ClientCoreError> {
     let timeout = Duration::from_millis(1500);
-    let mut gateway_client = GatewayClient::new_init(
+    let mut gateway_client: GatewayClient<SigningNyxdClient> = GatewayClient::new_init(
         gateway.clients_address(),
         gateway.identity_key,
-        gateway.owner.clone(),
         our_identity.clone(),
         timeout,
     );

clients/client-core/src/init/mod.rs

@@ -5,13 +5,13 @@
 
 use std::fmt::Display;
 
-use nymsphinx::addressing::{clients::Recipient, nodes::NodeIdentity};
+use nym_sphinx::addressing::{clients::Recipient, nodes::NodeIdentity};
 use rand::rngs::OsRng;
 use serde::Serialize;
 use tap::TapFallible;
 
-use config::NymConfig;
-use crypto::asymmetric::{encryption, identity};
+use nym_config::NymConfig;
+use nym_crypto::asymmetric::{encryption, identity};
 use url::Url;
 
 use crate::client::key_manager::KeyManager;
@@ -77,9 +77,11 @@ pub async fn register_with_gateway(
     key_manager: &mut KeyManager,
     nym_api_endpoints: Vec<Url>,
     chosen_gateway_id: Option<identity::PublicKey>,
+    by_latency: bool,
 ) -> Result<GatewayEndpointConfig, ClientCoreError> {
     // Get the gateway details of the gateway we will use
-    let gateway = helpers::query_gateway_details(nym_api_endpoints, chosen_gateway_id).await?;
+    let gateway =
+        helpers::query_gateway_details(nym_api_endpoints, chosen_gateway_id, by_latency).await?;
     log::debug!("Querying gateway gives: {}", gateway);
 
     let our_identity = key_manager.identity_keypair();
@@ -102,6 +104,7 @@ pub async fn setup_gateway_from_config<C, T>(
     register_gateway: bool,
     user_chosen_gateway_id: Option<identity::PublicKey>,
     config: &Config<T>,
+    by_latency: bool,
 ) -> Result<GatewayEndpointConfig, ClientCoreError>
 where
     C: NymConfig + ClientCoreConfigTrait,
@@ -117,9 +120,12 @@ where
     }
 
     // Else, we preceed by querying the nym-api
-    let gateway =
-        helpers::query_gateway_details(config.get_nym_api_endpoints(), user_chosen_gateway_id)
-            .await?;
+    let gateway = helpers::query_gateway_details(
+        config.get_nym_api_endpoints(),
+        user_chosen_gateway_id,
+        by_latency,
+    )
+    .await?;
     log::debug!("Querying gateway gives: {}", gateway);
 
     // If we are not registering, just return this and assume the caller has the keys already and
@@ -149,7 +155,7 @@ pub fn load_existing_gateway_config<T>(id: &str) -> Result<GatewayEndpointConfig
 where
     T: NymConfig + ClientCoreConfigTrait,
 {
-    T::load_from_file(Some(id))
+    T::load_from_file(id)
         .map(|existing_config| existing_config.get_gateway_endpoint().clone())
         .map_err(|err| {
             log::error!(
@@ -182,13 +188,13 @@ pub fn get_client_address_from_stored_keys<T>(
     config: &Config<T>,
 ) -> Result<Recipient, ClientCoreError>
 where
-    T: config::NymConfig,
+    T: nym_config::NymConfig,
 {
     fn load_identity_keys(
         pathfinder: &ClientKeyPathfinder,
     ) -> Result<identity::KeyPair, ClientCoreError> {
         let identity_keypair: identity::KeyPair =
-            pemstore::load_keypair(&pemstore::KeyPairPath::new(
+            nym_pemstore::load_keypair(&nym_pemstore::KeyPairPath::new(
                 pathfinder.private_identity_key().to_owned(),
                 pathfinder.public_identity_key().to_owned(),
             ))
@@ -200,7 +206,7 @@ where
         pathfinder: &ClientKeyPathfinder,
     ) -> Result<encryption::KeyPair, ClientCoreError> {
         let sphinx_keypair: encryption::KeyPair =
-            pemstore::load_keypair(&pemstore::KeyPairPath::new(
+            nym_pemstore::load_keypair(&nym_pemstore::KeyPairPath::new(
                 pathfinder.private_encryption_key().to_owned(),
                 pathfinder.public_encryption_key().to_owned(),
             ))

clients/credential/Cargo.toml

@@ -7,23 +7,21 @@ edition = "2021"
 
 [dependencies]
 bip39 = "1.0.1"
-cfg-if = "0.1"
 clap = { version = "4.0", features = ["cargo", "derive"] }
+log = "0.4"
 rand = "0.7.3"
 serde = { version = "1.0", features = ["derive"] }
 thiserror = "1.0"
 url = "2.2"
 tokio = { version = "1.24.1", features = ["rt-multi-thread", "net", "signal", "macros"] } # async runtime
 
-coconut-interface = { path = "../../common/coconut-interface" }
-config = { path = "../../common/config" }
-completions = { path = "../../common/completions" }
-credentials = { path = "../../common/credentials" }
-credential-storage = { path = "../../common/credential-storage" }
-crypto = { path = "../../common/crypto", features = ["rand", "asymmetric", "symmetric", "aes", "hashing"] }
-network-defaults = { path = "../../common/network-defaults" }
-pemstore = { path = "../../common/pemstore" }
+nym-coconut-interface = { path = "../../common/coconut-interface" }
+nym-config = { path = "../../common/config" }
+nym-credentials = { path = "../../common/credentials" }
+nym-credential-storage = { path = "../../common/credential-storage" }
+nym-crypto = { path = "../../common/crypto", features = ["rand", "asymmetric", "symmetric", "aes", "hashing"] }
+nym-bin-common = { path = "../../common/bin-common"}
+nym-network-defaults = { path = "../../common/network-defaults" }
+nym-pemstore = { path = "../../common/pemstore" }
 validator-client = { path = "../../common/client-libs/validator-client", features = ["nyxd-client"] }
 
-[features]
-coconut = ["credentials/coconut"]

clients/credential/src/client.rs

@@ -3,7 +3,7 @@
 
 use crate::error::Result;
 use bip39::Mnemonic;
-use network_defaults::{NymNetworkDetails, VOUCHER_INFO};
+use nym_network_defaults::{NymNetworkDetails, VOUCHER_INFO};
 use std::str::FromStr;
 use url::Url;
 use validator_client::nyxd;