gateway: stray println that should be eprintln

* revamped calculation of spendable coins and behaviour of stakes

* added new queries to the VestingQueryClient

* fixed return types for the query client

* updated wallet commands

* updated common commands

* 🔥 removed dead and commented out code

* comment regarding the 'state_dump_decoder'

* query for withdrawn coins

.github/workflows/audit.yml

@@ -39,18 +39,14 @@ jobs:
         uses: actions/setup-node@v3
         with:
           node-version: 16
-      - 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: 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 }}"

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

@@ -34,7 +34,7 @@ on:
       - 'tools/ts-rs-cli/**'
 
 env:
-  NETWORK: mainnet    
+  NETWORK: mainnet
 
 jobs:
   publish-nym:
@@ -46,7 +46,7 @@ jobs:
     runs-on: ${{ matrix.platform }}
     steps:
       - uses: actions/checkout@v3
-      
+
       - name: Prepare build output directory
         shell: bash
         env:
@@ -110,4 +110,3 @@ jobs:
           REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
           TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/builds/
           EXCLUDE: "/dist/, /node_modules/"
-

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

@@ -43,10 +43,10 @@ jobs:
         REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
         TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/ts-${{ env.GITHUB_REF_SLUG }}-example
         EXCLUDE: "/dist/, /node_modules/"
-    - name: 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"
@@ -54,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/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/nc-android-apk.yml

@@ -9,11 +9,11 @@ on:
 jobs:
   build:
     name: Build APK
-    runs-on: ubuntu-latest
+    runs-on: custom-runner-linux
     env:
       ANDROID_HOME: ${{ github.workspace }}/android-sdk
       NDK_VERSION: 25.1.8937393
-      NDK_HOME: ${{ env.ANDROID_HOME }}/ndk/${{ env.NDK_VERSION }}
+      NDK_HOME: ${{ github.workspace }}/android-sdk/ndk/25.1.8937393
       SDK_PLATFORM_VERSION: android-33
       SDK_BUILDTOOLS_VERSION: 33.0.1
 
@@ -25,6 +25,7 @@ jobs:
           sudo apt-get -y install \
           libwebkit2gtk-4.0-dev \
           build-essential \
+          unzip \
           curl \
           wget \
           libssl-dev \
@@ -33,6 +34,9 @@ jobs:
           libayatana-appindicator3-dev \
           librsvg2-dev
 
+      - name: Checkout
+        uses: actions/checkout@v3
+
       - name: Install Java
         uses: actions/setup-java@v3
         with:
@@ -80,9 +84,6 @@ jobs:
           npm i -g yarn
           yarn --version
 
-      - name: Checkout
-        uses: actions/checkout@v3
-
       - name: Build frontend code
         run: |
           yarn install --frozen-lockfile
@@ -92,36 +93,42 @@ jobs:
       - name: Build APK
         working-directory: nym-connect-android
         env:
+          ANDROID_SDK_ROOT: ${{ env.ANDROID_HOME }}
           WRY_ANDROID_PACKAGE: net.nymtech.nym_connect_android
           WRY_ANDROID_LIBRARY: nym_connect_android
         # TODO build with release profile (--release), it will requires
         # to sign the APK. For now build with debug profile to avoid that
-        run: cargo tauri android build --debug --apk
+        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: |
-          mv nym-connect-android/src-tauri/gen/android/nym_connect_android/app/build/outputs/apk/universal/debug/app-universal-debug.apk \
-            nym-connect-debug.apk
+          mkdir apk/
+          mv nym-connect-android/src-tauri/gen/android/nym_connect_android/app/build/outputs/apk/arm64/debug/app-arm64-debug.apk \
+            apk/nym-connect-arm64-debug.apk
+          mv nym-connect-android/src-tauri/gen/android/nym_connect_android/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: nym-connect-debug.apk
+          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: ???
+  # 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/network-explorer.yml

@@ -57,10 +57,10 @@ jobs:
         REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
         TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/ne-sb-${{ env.GITHUB_REF_SLUG }}
         EXCLUDE: "/dist/, /node_modules/"
-    - name: 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"
@@ -69,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:
@@ -29,7 +29,7 @@ jobs:
         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
@@ -147,17 +147,17 @@ jobs:
       - name: Collect jobs status
         uses: technote-space/workflow-conclusion-action@v2
       - name: Check out repository code
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
       - name: install npm
         uses: actions/setup-node@v3
         if: env.WORKFLOW_CONCLUSION == 'failure'
         with:
           node-version: 16
-      - name: Keybase - Node Install
+      - 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
@@ -165,10 +165,6 @@ 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 }}"

.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:
@@ -54,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:
@@ -66,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:
@@ -74,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
 
@@ -83,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
@@ -102,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
@@ -156,11 +168,11 @@ jobs:
         if: env.WORKFLOW_CONCLUSION == 'failure'
         with:
           node-version: 16
-      - name: Keybase - Node Install
+      - 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
@@ -168,10 +180,6 @@ 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 }}"

.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:
@@ -54,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:
@@ -66,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:
@@ -74,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
 
@@ -83,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
@@ -102,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
@@ -156,11 +168,11 @@ jobs:
         if: env.WORKFLOW_CONCLUSION == 'failure'
         with:
           node-version: 16
-      - name: Keybase - Node Install
+      - 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
@@ -168,10 +180,6 @@ 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 }}"

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

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

.github/workflows/nym-connect.yml

@@ -39,10 +39,10 @@ jobs:
         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"
@@ -50,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/nym-wallet-storybook.yml

@@ -35,10 +35,10 @@ jobs:
         REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
         TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/wallet-${{ env.GITHUB_REF_SLUG }}
         EXCLUDE: "/dist/, /node_modules/"
-    - name: 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"
@@ -46,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/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/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/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",

.github/workflows/typescript-lint.yml

@@ -24,11 +24,11 @@ jobs:
     - name: Setup yarn
       run: npm install -g yarn
     - name: Lint
-      run: yarn && yarn lint && yarn tsc
-    - name: Keybase - Node Install
+      run: yarn && yarn build && yarn lint && yarn tsc
+    - 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"
@@ -36,10 +36,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 }}"

CHANGELOG.md

@@ -2,19 +2,52 @@
 
 Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-# [Unreleased]
+## [Unreleased]
+
+## [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 and unify builds ([#2890])
-- native-client: is now capable of listening for requests on sockets different than `127.0.0.1` ([#2939]). This can be specified via `--host` flag during `init` or `run`. Alternatively a custom `host` can be set in `config.toml` file under `socket` section.
-- dkg resharing mode ([#2936])
+- Remove Coconut feature flag ([#2793])
+- Separate `nym-api` endpoints with values of "total-supply" and "circulating-supply" in `nym` ([#2964])
 
-[#2890]: https://github.com/nymtech/nym/pull/2890
-[#2939]: https://github.com/nymtech/nym/pull/2939
-[#2936]: https://github.com/nymtech/nym/pull/2936
+### Changed
 
-# [v1.1.8] (2023-01-31)
+- 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
 
@@ -34,7 +67,7 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://
 [#2873]: https://github.com/nymtech/nym/issues/2873
 
 
-# [v1.1.7] (2023-01-24)
+## [v1.1.7] (2023-01-24)
 
 ### Added
 
@@ -90,12 +123,6 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://
 
 ### Added
 
-### Changed
-
-## [v1.1.5] (2023-01-10)
-
-### Added
-
 - socks5: send status message for service ready, and network-requester error response in https://github.com/nymtech/nym/pull/2715
 
 ### Changed

Cargo.toml

@@ -107,8 +107,11 @@ edition = "2021"
 
 [workspace.dependencies]
 async-trait = "0.1.63"
+lazy_static = "1.4.0"
 log = "0.4"
-thiserror = "1.0.38"
 serde = "1.0.152"
 serde_json = "1.0.91"
+tap = "1.0.1"
+thiserror = "1.0.38"
 tokio = "1.24.1"
+url = "2.2"

clients/client-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "client-core"
-version = "1.1.8"
+version = "1.1.10"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
 edition = "2021"
 rust-version = "1.66"
@@ -26,13 +26,13 @@ time = "0.3.17"
 # internal
 config = { path = "../../common/config" }
 client-connections = { path = "../../common/client-connections" }
-crypto = { path = "../../common/crypto" }
+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" }
+nym-pemstore = { path = "../../common/pemstore" }
 topology = { path = "../../common/topology" }
 validator-client = { path = "../../common/client-libs/validator-client", default-features = false }
 task = { path = "../../common/task" }

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

@@ -22,7 +22,6 @@ 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")]
@@ -32,6 +31,7 @@ use gateway_client::{
     MixnetMessageSender,
 };
 use log::{debug, info};
+use nym_crypto::asymmetric::{encryption, identity};
 use nymsphinx::acknowledgements::AckKey;
 use nymsphinx::addressing::clients::Recipient;
 use nymsphinx::addressing::nodes::NodeIdentity;
@@ -51,11 +51,22 @@ 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,
 }
@@ -303,6 +314,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
         };
 

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

@@ -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,9 +2,9 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::config::persistence::key_pathfinder::ClientKeyPathfinder;
-use crypto::asymmetric::{encryption, identity};
 use gateway_requests::registration::handshake::SharedKeys;
 use log::*;
+use nym_crypto::asymmetric::{encryption, identity};
 use nymsphinx::acknowledgements::AckKey;
 use rand::{CryptoRng, RngCore};
 use std::io;
@@ -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/real_messages_control/real_traffic_stream.rs

@@ -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!(),
             }
         }
 

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

@@ -4,13 +4,13 @@
 use crate::client::replies::reply_controller::ReplyControllerSender;
 use crate::client::replies::reply_storage::SentReplyKeys;
 use crate::spawn_future;
-use crypto::asymmetric::encryption;
-use crypto::Digest;
 use futures::channel::mpsc;
 use futures::lock::Mutex;
 use futures::StreamExt;
 use gateway_client::MixnetMessageReceiver;
 use log::*;
+use nym_crypto::asymmetric::encryption;
+use nym_crypto::Digest;
 use nymsphinx::anonymous_replies::requests::{
     RepliableMessage, RepliableMessageContent, ReplyMessage, ReplyMessageContent,
 };

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,

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

@@ -56,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/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,
@@ -367,6 +368,20 @@ 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()
     }

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

@@ -3,8 +3,8 @@
 
 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 nym_crypto::generic_array::typenum::Unsigned;
+use nym_crypto::Digest;
 use nymsphinx::addressing::clients::{Recipient, RecipientBytes};
 use nymsphinx::anonymous_replies::encryption_key::EncryptionKeyDigest;
 use nymsphinx::anonymous_replies::requests::{AnonymousSenderTag, SENDER_TAG_SIZE};

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,
@@ -63,6 +73,11 @@ impl ReplyStorageBackend for Empty {
 pub trait ReplyStorageBackend: Sized {
     type StorageError: Error + 'static;
 
+    async fn new(
+        debug_config: &crate::config::DebugConfig,
+        db_path: Option<PathBuf>,
+    ) -> Result<Self, Self::StorageError>;
+
     fn is_active(&self) -> bool {
         true
     }

clients/client-core/src/error.rs

@@ -1,8 +1,8 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crypto::asymmetric::identity::Ed25519RecoveryError;
 use gateway_client::error::GatewayClientError;
+use nym_crypto::asymmetric::identity::Ed25519RecoveryError;
 use topology::NymTopologyError;
 use validator_client::ValidatorClientError;
 

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

@@ -7,11 +7,11 @@ use crate::{
     error::ClientCoreError,
 };
 use config::NymConfig;
-use crypto::asymmetric::identity;
 #[cfg(target_arch = "wasm32")]
 use gateway_client::wasm_mockups::SigningNyxdClient;
 use gateway_client::GatewayClient;
 use gateway_requests::registration::handshake::SharedKeys;
+use nym_crypto::asymmetric::identity;
 use rand::{seq::SliceRandom, thread_rng};
 use std::{sync::Arc, time::Duration};
 use tap::TapFallible;

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

@@ -11,7 +11,7 @@ use serde::Serialize;
 use tap::TapFallible;
 
 use config::NymConfig;
-use crypto::asymmetric::{encryption, identity};
+use nym_crypto::asymmetric::{encryption, identity};
 use url::Url;
 
 use crate::client::key_manager::KeyManager;
@@ -188,7 +188,7 @@ where
         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 +200,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

@@ -8,6 +8,7 @@ edition = "2021"
 [dependencies]
 bip39 = "1.0.1"
 clap = { version = "4.0", features = ["cargo", "derive"] }
+log = "0.4"
 rand = "0.7.3"
 serde = { version = "1.0", features = ["derive"] }
 thiserror = "1.0"
@@ -19,8 +20,9 @@ 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"] }
+nym-crypto = { path = "../../common/crypto", features = ["rand", "asymmetric", "symmetric", "aes", "hashing"] }
+logging = { path = "../../common/logging"}
 network-defaults = { path = "../../common/network-defaults" }
-pemstore = { path = "../../common/pemstore" }
+nym-pemstore = { path = "../../common/pemstore" }
 validator-client = { path = "../../common/client-libs/validator-client", features = ["nyxd-client"] }
 

clients/credential/src/commands.rs

@@ -1,8 +1,9 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use clap::{Args, Subcommand};
+use clap::{ArgGroup, Args, Subcommand};
 use completions::ArgShell;
+use log::*;
 use rand::rngs::OsRng;
 use std::str::FromStr;
 
@@ -11,19 +12,21 @@ use credential_storage::storage::Storage;
 use credential_storage::PersistentStorage;
 use credentials::coconut::bandwidth::{BandwidthVoucher, TOTAL_ATTRIBUTES};
 use credentials::coconut::utils::obtain_aggregate_signature;
-use crypto::asymmetric::{encryption, identity};
-use network_defaults::{NymNetworkDetails, VOUCHER_INFO};
+use network_defaults::VOUCHER_INFO;
+use nym_crypto::asymmetric::{encryption, identity};
 use validator_client::nyxd::traits::DkgQueryClient;
 use validator_client::nyxd::tx::Hash;
-use validator_client::{CoconutApiClient, Config};
+use validator_client::nyxd::CosmWasmClient;
+use validator_client::CoconutApiClient;
 
 use crate::client::Client;
 use crate::error::{CredentialClientError, Result};
+use crate::recovery_storage::RecoveryStorage;
 use crate::state::{KeyPair, State};
 
 #[derive(Subcommand)]
 pub(crate) enum Command {
-    /// Run the binary
+    /// Run the binary to obtain a credential
     Run(Run),
 
     /// Generate shell completions
@@ -34,6 +37,11 @@ pub(crate) enum Command {
 }
 
 #[derive(Args)]
+#[clap(group(
+ArgGroup::new("recov")
+.required(true)
+.args(&["amount", "recovery_mode"]),
+))]
 pub(crate) struct Run {
     /// Home directory of the client that is supposed to use the credential.
     #[clap(long)]
@@ -47,15 +55,25 @@ pub(crate) struct Run {
     #[clap(long)]
     pub(crate) mnemonic: String,
 
-    /// The amount of utokens the credential will hold
-    #[clap(long)]
+    /// The amount of utokens the credential will hold. If recovery mode is enabled, this value
+    /// is not needed
+    #[clap(long, default_value = "0")]
     pub(crate) amount: u64,
+
+    /// Path to a directory used to store recovery files for unconsumed deposits
+    #[clap(long)]
+    pub(crate) recovery_dir: std::path::PathBuf,
+
+    /// Recovery mode, when enabled, tries to recover any deposit data dumped in recovery_dir
+    #[clap(long)]
+    pub(crate) recovery_mode: bool,
 }
 
 pub(crate) async fn deposit(nyxd_url: &str, mnemonic: &str, amount: u64) -> Result<State> {
     let mut rng = OsRng;
     let signing_keypair = KeyPair::from(identity::KeyPair::new(&mut rng));
     let encryption_keypair = KeyPair::from(encryption::KeyPair::new(&mut rng));
+    let params = Parameters::new(TOTAL_ATTRIBUTES).unwrap();
 
     let client = Client::new(nyxd_url, mnemonic);
     let tx_hash = client
@@ -67,20 +85,25 @@ pub(crate) async fn deposit(nyxd_url: &str, mnemonic: &str, amount: u64) -> Resu
         )
         .await?;
 
-    let state = State {
-        amount,
-        tx_hash,
-        signing_keypair,
-        encryption_keypair,
-    };
+    let voucher = BandwidthVoucher::new(
+        &params,
+        amount.to_string(),
+        VOUCHER_INFO.to_string(),
+        Hash::from_str(&tx_hash).map_err(|_| CredentialClientError::InvalidTxHash)?,
+        identity::PrivateKey::from_base58_string(&signing_keypair.private_key)?,
+        encryption::PrivateKey::from_base58_string(&encryption_keypair.private_key)?,
+    );
+
+    let state = State { voucher, params };
 
     Ok(state)
 }
 
-pub(crate) async fn get_credential(state: &State, shared_storage: PersistentStorage) -> Result<()> {
-    let network_details = NymNetworkDetails::new_from_env();
-    let config = Config::try_from_nym_network_details(&network_details)?;
-    let client = validator_client::Client::new_query(config)?;
+pub(crate) async fn get_credential<C: Clone + CosmWasmClient + Send + Sync>(
+    state: &State,
+    client: validator_client::Client<C>,
+    shared_storage: PersistentStorage,
+) -> Result<()> {
     let epoch_id = client.nyxd.get_current_epoch().await?.epoch_id;
     let threshold = client
         .nyxd
@@ -89,30 +112,20 @@ pub(crate) async fn get_credential(state: &State, shared_storage: PersistentStor
         .ok_or(CredentialClientError::NoThreshold)?;
     let coconut_api_clients = CoconutApiClient::all_coconut_api_clients(&client, epoch_id).await?;
 
-    let params = Parameters::new(TOTAL_ATTRIBUTES).unwrap();
-    let bandwidth_credential_attributes = BandwidthVoucher::new(
-        &params,
-        state.amount.to_string(),
-        VOUCHER_INFO.to_string(),
-        Hash::from_str(&state.tx_hash).map_err(|_| CredentialClientError::InvalidTxHash)?,
-        identity::PrivateKey::from_base58_string(&state.signing_keypair.private_key)?,
-        encryption::PrivateKey::from_base58_string(&state.encryption_keypair.private_key)?,
-    );
-
     let signature = obtain_aggregate_signature(
-        &params,
-        &bandwidth_credential_attributes,
+        &state.params,
+        &state.voucher,
         &coconut_api_clients,
         threshold,
     )
     .await?;
-    println!("Signature: {:?}", signature.to_bs58());
+    info!("Signature: {:?}", signature.to_bs58());
     shared_storage
         .insert_coconut_credential(
-            state.amount.to_string(),
+            state.voucher.get_voucher_value(),
             VOUCHER_INFO.to_string(),
-            bandwidth_credential_attributes.get_private_attributes()[0].to_bs58(),
-            bandwidth_credential_attributes.get_private_attributes()[1].to_bs58(),
+            state.voucher.get_private_attributes()[0].to_bs58(),
+            state.voucher.get_private_attributes()[1].to_bs58(),
             signature.to_bs58(),
             epoch_id.to_string(),
         )
@@ -120,3 +133,33 @@ pub(crate) async fn get_credential(state: &State, shared_storage: PersistentStor
 
     Ok(())
 }
+
+pub(crate) async fn recover_credentials<C: Clone + CosmWasmClient + Send + Sync>(
+    client: validator_client::Client<C>,
+    recovery_storage: &RecoveryStorage,
+    shared_storage: PersistentStorage,
+) -> Result<()> {
+    for voucher in recovery_storage.unconsumed_vouchers()? {
+        let state = State {
+            voucher,
+            params: Parameters::new(TOTAL_ATTRIBUTES).unwrap(),
+        };
+        if let Err(e) = get_credential(&state, client.clone(), shared_storage.clone()).await {
+            error!(
+                "Could not recover deposit {} due to {:?}, try again later",
+                state.voucher.tx_hash(),
+                e
+            )
+        } else {
+            info!(
+                "Converted deposit {} to a credential, removing recovery data for it",
+                state.voucher.tx_hash()
+            );
+            if let Err(e) = recovery_storage.remove_voucher(state.voucher.tx_hash().to_string()) {
+                warn!("Could not remove recovery data - {:?}", e);
+            }
+        }
+    }
+
+    Ok(())
+}

clients/credential/src/error.rs

@@ -1,12 +1,13 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
+use std::time::SystemTimeError;
 use thiserror::Error;
 
 use credential_storage::error::StorageError;
 use credentials::error::Error as CredentialError;
-use crypto::asymmetric::encryption::KeyRecoveryError;
-use crypto::asymmetric::identity::Ed25519RecoveryError;
+use nym_crypto::asymmetric::encryption::KeyRecoveryError;
+use nym_crypto::asymmetric::identity::Ed25519RecoveryError;
 use validator_client::nyxd::error::NyxdError;
 use validator_client::ValidatorClientError;
 
@@ -14,6 +15,9 @@ pub type Result<T> = std::result::Result<T, CredentialClientError>;
 
 #[derive(Error, Debug)]
 pub enum CredentialClientError {
+    #[error("IO error: {0}")]
+    IOError(#[from] std::io::Error),
+
     #[error("Nyxd error: {0}")]
     Nyxd(#[from] NyxdError),
 
@@ -35,6 +39,9 @@ pub enum CredentialClientError {
     #[error("Could not use shared storage")]
     SharedStorageError(#[from] StorageError),
 
+    #[error("Could not get system time")]
+    SysTimeError(#[from] SystemTimeError),
+
     #[error("Threshold not set yet")]
     NoThreshold,
 }

clients/credential/src/main.rs

@@ -4,15 +4,25 @@
 mod client;
 mod commands;
 mod error;
+mod recovery_storage;
 mod state;
 
 use commands::*;
 use completions::fig_generate;
 use config::{DATA_DIR, DB_FILE_NAME};
 use error::Result;
-use network_defaults::setup_env;
+use log::*;
+use network_defaults::{setup_env, NymNetworkDetails};
+use std::process::exit;
+use std::time::{Duration, SystemTime};
 
 use clap::{CommandFactory, Parser};
+use logging::setup_logging;
+use validator_client::nyxd::traits::DkgQueryClient;
+use validator_client::nyxd::CosmWasmClient;
+use validator_client::Config;
+
+const SAFETY_BUFFER_SECS: u64 = 60; // 1 minute
 
 #[derive(Parser)]
 #[clap(author = "Nymtech", version, about)]
@@ -25,9 +35,36 @@ struct Cli {
     pub(crate) command: Command,
 }
 
+async fn block_until_coconut_is_available<C: Clone + CosmWasmClient + Send + Sync>(
+    client: &validator_client::Client<C>,
+) -> Result<()> {
+    loop {
+        let epoch = client.nyxd.get_current_epoch().await?;
+        let current_timestamp_secs = SystemTime::now()
+            .duration_since(SystemTime::UNIX_EPOCH)?
+            .as_secs();
+        if epoch.state.is_final() {
+            if current_timestamp_secs + SAFETY_BUFFER_SECS >= epoch.finish_timestamp.seconds() {
+                info!("In the next {} minute(s), a transition will take place in the coconut system. Deposits should be halted in this time for safety reasons.", SAFETY_BUFFER_SECS / 60);
+                exit(0);
+            }
+
+            break;
+        } else {
+            // Use 20 additional seconds to avoid the exact moment of going into the final epoch state
+            let secs_until_final = epoch.final_timestamp_secs() + 20 - current_timestamp_secs;
+            info!("Approximately {} seconds until coconut is available. Sleeping until then. You can safely kill the process at any moment.", secs_until_final);
+            std::thread::sleep(Duration::from_secs(secs_until_final));
+        }
+    }
+
+    Ok(())
+}
+
 #[tokio::main]
 async fn main() -> Result<()> {
     let args = Cli::parse();
+    setup_logging();
     setup_env(args.config_env_file.as_ref());
     let bin_name = "nym-credential-client";
 
@@ -35,9 +72,34 @@ async fn main() -> Result<()> {
         Command::Run(r) => {
             let db_path = r.client_home_directory.join(DATA_DIR).join(DB_FILE_NAME);
             let shared_storage = credential_storage::initialise_storage(db_path).await;
+            let recovery_storage = recovery_storage::RecoveryStorage::new(r.recovery_dir)?;
 
-            let state = deposit(&r.nyxd_url, &r.mnemonic, r.amount).await?;
-            get_credential(&state, shared_storage).await?;
+            let network_details = NymNetworkDetails::new_from_env();
+            let config = Config::try_from_nym_network_details(&network_details)?;
+            let client = validator_client::Client::new_query(config)?;
+
+            block_until_coconut_is_available(&client).await?;
+            info!("Starting depositing funds, don't kill the process");
+
+            if !r.recovery_mode {
+                let state = deposit(&r.nyxd_url, &r.mnemonic, r.amount).await?;
+                if get_credential(&state, client, shared_storage)
+                    .await
+                    .is_err()
+                {
+                    warn!("Failed to obtain credential. Dumping recovery data.",);
+                    match recovery_storage.insert_voucher(&state.voucher) {
+                        Ok(file_path) => {
+                            warn!("Dumped recovery data to {:?}. Try using recovery mode to convert it to a credential", file_path);
+                        }
+                        Err(e) => {
+                            error!("Could not dump recovery data to file system due to {:?}, the deposit will be lost!", e)
+                        }
+                    }
+                }
+            } else {
+                recover_credentials(client, &recovery_storage, shared_storage).await?;
+            }
         }
         Command::Completions(c) => c.generate(&mut crate::Cli::command(), bin_name),
         Command::GenerateFigSpec => fig_generate(&mut crate::Cli::command(), bin_name),

clients/credential/src/recovery_storage.rs

@@ -0,0 +1,56 @@
+// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use credentials::coconut::bandwidth::BandwidthVoucher;
+use std::fs::{create_dir_all, read_dir, File};
+use std::io::{Read, Write};
+use std::path::PathBuf;
+
+pub struct RecoveryStorage {
+    recovery_dir: PathBuf,
+}
+
+impl RecoveryStorage {
+    pub fn new(recovery_dir: PathBuf) -> std::io::Result<Self> {
+        create_dir_all(&recovery_dir)?;
+        Ok(Self { recovery_dir })
+    }
+
+    pub fn unconsumed_vouchers(&self) -> std::io::Result<impl Iterator<Item = BandwidthVoucher>> {
+        Ok(read_dir(&self.recovery_dir)?
+            .filter_map(|entry| entry.ok())
+            .filter_map(|entry| {
+                let path = entry.path();
+                if path.is_file() {
+                    Some(path)
+                } else {
+                    None
+                }
+            })
+            .filter_map(|path| File::open(path).ok())
+            .filter_map(|mut f| {
+                let mut buff = Vec::new();
+                if f.read_to_end(&mut buff).is_ok() {
+                    Some(buff)
+                } else {
+                    None
+                }
+            })
+            .filter_map(|buff| BandwidthVoucher::try_from_bytes(&buff).ok()))
+    }
+
+    pub fn insert_voucher(&self, voucher: &BandwidthVoucher) -> std::io::Result<PathBuf> {
+        let file_name = voucher.tx_hash().to_string();
+        let file_path = self.recovery_dir.join(file_name);
+        let mut file = File::create(&file_path)?;
+        let buff = voucher.to_bytes();
+        file.write_all(&buff)?;
+
+        Ok(file_path)
+    }
+
+    pub fn remove_voucher(&self, file_name: String) -> std::io::Result<()> {
+        let file_path = self.recovery_dir.join(file_name);
+        std::fs::remove_file(file_path)
+    }
+}

clients/credential/src/state.rs

@@ -1,11 +1,11 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use serde::{Deserialize, Serialize};
+use coconut_interface::Parameters;
+use credentials::coconut::bandwidth::BandwidthVoucher;
 
-use crypto::asymmetric::{encryption, identity};
+use nym_crypto::asymmetric::{encryption, identity};
 
-#[derive(Clone, Debug, Deserialize, Serialize)]
 pub(crate) struct KeyPair {
     pub public_key: String,
     pub private_key: String,
@@ -29,10 +29,7 @@ impl From<encryption::KeyPair> for KeyPair {
     }
 }
 
-#[derive(Clone, Debug, Deserialize, Serialize)]
 pub(crate) struct State {
-    pub amount: u64,
-    pub tx_hash: String,
-    pub signing_keypair: KeyPair,
-    pub encryption_keypair: KeyPair,
+    pub voucher: BandwidthVoucher,
+    pub params: Parameters,
 }

clients/native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nym-client"
-version = "1.1.8"
+version = "1.1.10"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>", "Jędrzej Stuczyński <andrew@nymtech.net>"]
 description = "Implementation of the Nym Client"
 edition = "2021"
@@ -42,13 +42,13 @@ config = { path = "../../common/config" }
 completions = { path = "../../common/completions" }
 credential-storage = { path = "../../common/credential-storage" }
 credentials = { path = "../../common/credentials" }
-crypto = { path = "../../common/crypto" }
+nym-crypto = { path = "../../common/crypto" }
 logging = { path = "../../common/logging"}
 gateway-client = { path = "../../common/client-libs/gateway-client" }
 gateway-requests = { path = "../../gateway/gateway-requests" }
 network-defaults = { path = "../../common/network-defaults" }
 nymsphinx = { path = "../../common/nymsphinx" }
-pemstore = { path = "../../common/pemstore" }
+nym-pemstore = { path = "../../common/pemstore" }
 task = { path = "../../common/task" }
 topology = { path = "../../common/topology" }
 validator-client = { path = "../../common/client-libs/validator-client", features = ["nyxd-client"] }

clients/native/src/commands/init.rs

@@ -8,7 +8,7 @@ use crate::{
 };
 use clap::Args;
 use config::NymConfig;
-use crypto::asymmetric::identity;
+use nym_crypto::asymmetric::identity;
 use nymsphinx::addressing::clients::Recipient;
 use serde::Serialize;
 use std::fmt::Display;
@@ -31,7 +31,7 @@ pub(crate) struct Init {
     force_register_gateway: bool,
 
     /// Comma separated list of rest endpoints of the nyxd validators
-    #[clap(long, alias = "nymd_validators", value_delimiter = ',', hide = true)]
+    #[clap(long, alias = "nyxd_validators", value_delimiter = ',', hide = true)]
     nyxd_urls: Option<Vec<url::Url>>,
 
     /// Comma separated list of rest endpoints of the API validators

clients/native/src/commands/run.rs

@@ -12,8 +12,8 @@ use crate::{
 
 use clap::Args;
 use config::NymConfig;
-use crypto::asymmetric::identity;
 use log::*;
+use nym_crypto::asymmetric::identity;
 use version_checker::is_minor_version_compatible;
 
 #[derive(Args, Clone)]
@@ -23,7 +23,7 @@ pub(crate) struct Run {
     id: String,
 
     /// Comma separated list of rest endpoints of the nyxd validators
-    #[clap(long, alias = "nymd_validators", value_delimiter = ',', hide = true)]
+    #[clap(long, alias = "nyxd_validators", value_delimiter = ',', hide = true)]
     nyxd_urls: Option<Vec<url::Url>>,
 
     /// Comma separated list of rest endpoints of the API validators

clients/socks5/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nym-socks5-client"
-version = "1.1.8"
+version = "1.1.10"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
 description = "A SOCKS5 localhost proxy that converts incoming messages to Sphinx and sends them to a Nym address"
 edition = "2021"
@@ -36,14 +36,14 @@ completions = { path = "../../common/completions" }
 credential-storage = { path = "../../common/credential-storage", optional = true }
 mobile-storage = { path = "../../common/mobile-storage", optional = true }
 credentials = { path = "../../common/credentials" }
-crypto = { path = "../../common/crypto" }
+nym-crypto = { path = "../../common/crypto" }
 logging = { path = "../../common/logging"}
 gateway-client = { path = "../../common/client-libs/gateway-client" }
 gateway-requests = { path = "../../gateway/gateway-requests" }
 network-defaults = { path = "../../common/network-defaults" }
 nymsphinx = { path = "../../common/nymsphinx" }
 ordered-buffer = { path = "../../common/socks5/ordered-buffer" }
-pemstore = { path = "../../common/pemstore" }
+nym-pemstore = { path = "../../common/pemstore" }
 proxy-helpers = { path = "../../common/socks5/proxy-helpers" }
 service-providers-common = { path = "../../service-providers/common" }
 socks5-requests = { path = "../../common/socks5/requests" }

clients/socks5/src/client/mod.rs

@@ -18,6 +18,7 @@ use client_core::client::key_manager::KeyManager;
 use client_core::config::persistence::key_pathfinder::ClientKeyPathfinder;
 use futures::channel::mpsc;
 use futures::StreamExt;
+#[cfg(not(feature = "mobile"))]
 use gateway_client::bandwidth::BandwidthController;
 use log::*;
 use nymsphinx::addressing::clients::Recipient;
@@ -69,6 +70,7 @@ impl NymClient {
         }
     }
 
+    #[cfg(not(feature = "mobile"))]
     async fn create_bandwidth_controller(config: &Config) -> BandwidthController<QueryNyxdClient> {
         let details = network_defaults::NymNetworkDetails::new_from_env();
         let mut client_config = validator_client::Config::try_from_nym_network_details(&details)

clients/socks5/src/commands/init.rs

@@ -8,7 +8,7 @@ use crate::{
 };
 use clap::Args;
 use config::NymConfig;
-use crypto::asymmetric::identity;
+use nym_crypto::asymmetric::identity;
 use nymsphinx::addressing::clients::Recipient;
 use serde::Serialize;
 use std::fmt::Display;
@@ -43,7 +43,7 @@ pub(crate) struct Init {
     force_register_gateway: bool,
 
     /// Comma separated list of rest endpoints of the nyxd validators
-    #[clap(long, alias = "nymd_validators", value_delimiter = ',', hide = true)]
+    #[clap(long, alias = "nyxd_validators", value_delimiter = ',', hide = true)]
     nyxd_urls: Option<Vec<url::Url>>,
 
     /// Comma separated list of rest endpoints of the API validators

clients/socks5/src/commands/run.rs

@@ -9,8 +9,8 @@ use crate::{
 
 use clap::Args;
 use config::NymConfig;
-use crypto::asymmetric::identity;
 use log::*;
+use nym_crypto::asymmetric::identity;
 use nymsphinx::addressing::clients::Recipient;
 use version_checker::is_minor_version_compatible;
 
@@ -43,7 +43,7 @@ pub(crate) struct Run {
     gateway: Option<identity::PublicKey>,
 
     /// Comma separated list of rest endpoints of the nyxd validators
-    #[clap(long, alias = "nymd_validators", value_delimiter = ',', hide = true)]
+    #[clap(long, alias = "nyxd_validators", value_delimiter = ',', hide = true)]
     nyxd_urls: Option<Vec<url::Url>>,
 
     /// Comma separated list of rest endpoints of the Nym APIs

clients/socks5/src/socks/server.rs

@@ -10,7 +10,7 @@ use client_core::client::{
 };
 use log::*;
 use nymsphinx::addressing::clients::Recipient;
-use proxy_helpers::connection_controller::{BroadcastActiveConnections, Controller};
+use proxy_helpers::connection_controller::Controller;
 use std::net::SocketAddr;
 use tap::TapFallible;
 use task::TaskClient;
@@ -69,7 +69,7 @@ impl SphinxSocksServer {
         // controller for managing all active connections
         let (mut active_streams_controller, controller_sender) = Controller::new(
             client_connection_tx,
-            BroadcastActiveConnections::Off,
+            //BroadcastActiveConnections::Off,
             self.shutdown.clone(),
         );
         tokio::spawn(async move {

clients/webassembly/Cargo.toml

@@ -34,7 +34,7 @@ client-core = { path = "../client-core", default-features = false, features = ["
 client-connections = { path = "../../common/client-connections" }
 coconut-interface = { path = "../../common/coconut-interface" }
 credentials = { path = "../../common/credentials" }
-crypto = { path = "../../common/crypto" }
+nym-crypto = { path = "../../common/crypto" }
 nymsphinx = { path = "../../common/nymsphinx" }
 topology = { path = "../../common/topology" }
 gateway-client = { path = "../../common/client-libs/gateway-client", default-features = false, features = ["wasm"] }

common/client-connections/src/lib.rs

@@ -25,12 +25,6 @@ pub enum ConnectionCommand {
     // Announce that at a connection was closed. E.g the `OutQueueControl` uses this to discard
     // transmission lanes.
     Close(ConnectionId),
-
-    // In the network requester for example, we usually want to broadcast active connections
-    // regularly, so we know what connections we need to request lane queue lengths for from the
-    // client.
-    // In the socks5-client, this is not needed since have direct access to the lane queue lengths.
-    ActiveConnections(Vec<ConnectionId>),
 }
 
 // The `OutQueueControl` publishes the backlog per lane, primarily so that upstream can slow down

common/client-libs/gateway-client/Cargo.toml

@@ -20,11 +20,11 @@ tokio = { version = "1.24.1", features = ["macros"] }
 # internal
 coconut-interface = { path = "../../coconut-interface" }
 credentials = { path = "../../credentials" }
-crypto = { path = "../../crypto" }
+nym-crypto = { path = "../../crypto" }
 gateway-requests = { path = "../../../gateway/gateway-requests" }
 network-defaults = { path = "../../network-defaults" }
 nymsphinx = { path = "../../nymsphinx" }
-pemstore = { path = "../../pemstore" }
+nym-pemstore = { path = "../../pemstore" }
 validator-client = { path = "../validator-client" }
 task = { path = "../../task" }
 serde = { version = "1.0", features = ["derive"]}

common/client-libs/gateway-client/src/client.rs

@@ -10,7 +10,6 @@ pub use crate::packet_router::{
 use crate::socket_state::{PartiallyDelegated, SocketState};
 use crate::{cleanup_socket_message, try_decrypt_binary_message};
 use coconut_interface::Credential;
-use crypto::asymmetric::identity;
 use futures::{SinkExt, StreamExt};
 use gateway_requests::authentication::encrypted_address::EncryptedAddressBytes;
 use gateway_requests::iv::IV;
@@ -18,6 +17,7 @@ use gateway_requests::registration::handshake::{client_handshake, SharedKeys};
 use gateway_requests::{BinaryRequest, ClientControlRequest, ServerResponse, PROTOCOL_VERSION};
 use log::*;
 use network_defaults::{REMAINING_BANDWIDTH_THRESHOLD, TOKENS_TO_BURN};
+use nym_crypto::asymmetric::identity;
 use nymsphinx::forwarding::packet::MixPacket;
 use rand::rngs::OsRng;
 use std::convert::TryFrom;
@@ -441,6 +441,7 @@ where
         }
 
         debug_assert!(self.connection.is_available());
+        log::trace!("Registering gateway");
 
         // it's fine to instantiate it here as it's only used once (during authentication or registration)
         // and putting it into the GatewayClient struct would be a hassle

common/client-libs/validator-client/Cargo.toml

@@ -12,13 +12,13 @@ base64 = "0.13"
 colored = "2.0"
 
 coconut-dkg-common = { path = "../../cosmwasm-smart-contracts/coconut-dkg" }
-contracts-common = { path = "../../cosmwasm-smart-contracts/contracts-common" }
-mixnet-contract-common = { path= "../../cosmwasm-smart-contracts/mixnet-contract" }
-vesting-contract-common = { path= "../../cosmwasm-smart-contracts/vesting-contract" }
+nym-contracts-common = { path = "../../cosmwasm-smart-contracts/contracts-common" }
+nym-mixnet-contract-common = { path= "../../cosmwasm-smart-contracts/mixnet-contract" }
+nym-vesting-contract-common = { path= "../../cosmwasm-smart-contracts/vesting-contract" }
 coconut-bandwidth-contract-common = { path= "../../cosmwasm-smart-contracts/coconut-bandwidth-contract" }
 multisig-contract-common = { path = "../../cosmwasm-smart-contracts/multisig-contract" }
 group-contract-common = { path = "../../cosmwasm-smart-contracts/group-contract" }
-vesting-contract = { path = "../../../contracts/vesting" }
+nym-vesting-contract = { path = "../../../contracts/vesting" }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 reqwest = { version = "0.11", features = ["json"] }

common/client-libs/validator-client/src/client.rs

@@ -4,9 +4,6 @@
 use crate::{nym_api, ValidatorClientError};
 use coconut_dkg_common::types::NodeIndex;
 use coconut_interface::VerificationKey;
-use mixnet_contract_common::mixnode::MixNodeDetails;
-use mixnet_contract_common::MixId;
-use mixnet_contract_common::{GatewayBond, IdentityKeyRef};
 use nym_api_requests::coconut::{
     BlindSignRequestBody, BlindedSignatureResponse, VerifyCredentialBody, VerifyCredentialResponse,
 };
@@ -14,6 +11,9 @@ use nym_api_requests::models::{
     GatewayCoreStatusResponse, MixnodeCoreStatusResponse, MixnodeStatusResponse,
     RewardEstimationResponse, StakeSaturationResponse,
 };
+use nym_mixnet_contract_common::mixnode::MixNodeDetails;
+use nym_mixnet_contract_common::MixId;
+use nym_mixnet_contract_common::{GatewayBond, IdentityKeyRef};
 
 #[cfg(feature = "nyxd-client")]
 use crate::nyxd::traits::{DkgQueryClient, MixnetQueryClient, MultisigQueryClient};
@@ -30,17 +30,17 @@ use coconut_interface::Base58;
 #[cfg(feature = "nyxd-client")]
 use cw3::ProposalResponse;
 #[cfg(feature = "nyxd-client")]
-use mixnet_contract_common::{
+use network_defaults::NymNetworkDetails;
+#[cfg(feature = "nyxd-client")]
+use nym_api_requests::models::MixNodeBondAnnotated;
+#[cfg(feature = "nyxd-client")]
+use nym_mixnet_contract_common::{
     families::{Family, FamilyHead},
     mixnode::MixNodeBond,
     pending_events::{PendingEpochEvent, PendingIntervalEvent},
     Delegation, IdentityKey, RewardedSetNodeStatus, UnbondedMixnode,
 };
 #[cfg(feature = "nyxd-client")]
-use network_defaults::NymNetworkDetails;
-#[cfg(feature = "nyxd-client")]
-use nym_api_requests::models::MixNodeBondAnnotated;
-#[cfg(feature = "nyxd-client")]
 use std::str::FromStr;
 use url::Url;
 
@@ -934,16 +934,6 @@ impl NymApiClient {
         Ok(self.nym_api_client.blind_sign(request_body).await?)
     }
 
-    pub async fn partial_bandwidth_credential(
-        &self,
-        request_body: &str,
-    ) -> Result<BlindedSignatureResponse, ValidatorClientError> {
-        Ok(self
-            .nym_api_client
-            .partial_bandwidth_credential(request_body)
-            .await?)
-    }
-
     pub async fn verify_bandwidth_credential(
         &self,
         request_body: &VerifyCredentialBody,

common/client-libs/validator-client/src/nym_api/mod.rs

@@ -3,8 +3,6 @@
 
 use crate::nym_api::error::NymAPIError;
 use crate::nym_api::routes::{CORE_STATUS_COUNT, SINCE_ARG};
-use mixnet_contract_common::mixnode::MixNodeDetails;
-use mixnet_contract_common::{GatewayBond, IdentityKeyRef, MixId};
 use nym_api_requests::coconut::{
     BlindSignRequestBody, BlindedSignatureResponse, VerifyCredentialBody, VerifyCredentialResponse,
 };
@@ -15,6 +13,8 @@ use nym_api_requests::models::{
     MixnodeUptimeHistoryResponse, RequestError, RewardEstimationResponse, StakeSaturationResponse,
     UptimeResponse,
 };
+use nym_mixnet_contract_common::mixnode::MixNodeDetails;
+use nym_mixnet_contract_common::{GatewayBond, IdentityKeyRef, MixId};
 use reqwest::Response;
 use serde::{Deserialize, Serialize};
 use url::Url;
@@ -449,23 +449,6 @@ impl Client {
         .await
     }
 
-    pub async fn partial_bandwidth_credential(
-        &self,
-        request_body: &str,
-    ) -> Result<BlindedSignatureResponse, NymAPIError> {
-        self.post_nym_api(
-            &[
-                routes::API_VERSION,
-                routes::COCONUT_ROUTES,
-                routes::BANDWIDTH,
-                routes::COCONUT_PARTIAL_BANDWIDTH_CREDENTIAL,
-            ],
-            NO_PARAMS,
-            request_body,
-        )
-        .await
-    }
-
     pub async fn verify_bandwidth_credential(
         &self,
         request_body: &VerifyCredentialBody,

common/client-libs/validator-client/src/nym_api/routes.rs

@@ -14,7 +14,6 @@ pub const COCONUT_ROUTES: &str = "coconut";
 pub const BANDWIDTH: &str = "bandwidth";
 
 pub const COCONUT_BLIND_SIGN: &str = "blind-sign";
-pub const COCONUT_PARTIAL_BANDWIDTH_CREDENTIAL: &str = "partial-bandwidth-credential";
 pub const COCONUT_VERIFY_BANDWIDTH_CREDENTIAL: &str = "verify-bandwidth-credential";
 
 pub const STATUS_ROUTES: &str = "status";

common/client-libs/validator-client/src/nyxd/mod.rs

@@ -17,13 +17,13 @@ use cosmrs::rpc::HttpClientUrl;
 use cosmrs::tx::Msg;
 use execute::execute;
 use log::debug;
-use mixnet_contract_common::MixId;
 use network_defaults::{ChainDetails, NymNetworkDetails};
+use nym_mixnet_contract_common::MixId;
+use nym_vesting_contract_common::ExecuteMsg as VestingExecuteMsg;
+use nym_vesting_contract_common::PledgeCap;
 use serde::{Deserialize, Serialize};
 use std::convert::TryInto;
 use std::time::SystemTime;
-use vesting_contract_common::ExecuteMsg as VestingExecuteMsg;
-use vesting_contract_common::PledgeCap;
 
 pub use crate::nyxd::cosmwasm_client::client::CosmWasmClient;
 pub use crate::nyxd::cosmwasm_client::signing_client::SigningCosmWasmClient;

common/client-libs/validator-client/src/nyxd/traits/dkg_signing_client.rs

@@ -8,7 +8,7 @@ use async_trait::async_trait;
 use coconut_dkg_common::msg::ExecuteMsg as DkgExecuteMsg;
 use coconut_dkg_common::types::EncodedBTEPublicKeyWithProof;
 use coconut_dkg_common::verification_key::VerificationKeyShare;
-use contracts_common::dealings::ContractSafeBytes;
+use nym_contracts_common::dealings::ContractSafeBytes;
 
 #[async_trait]
 pub trait DkgSigningClient {

common/client-libs/validator-client/src/nyxd/traits/mixnet_query_client.rs

@@ -6,17 +6,17 @@ use crate::nyxd::error::NyxdError;
 use crate::nyxd::NyxdClient;
 use async_trait::async_trait;
 use cosmrs::AccountId;
-use mixnet_contract_common::delegation::{MixNodeDelegationResponse, OwnerProxySubKey};
-use mixnet_contract_common::families::Family;
-use mixnet_contract_common::mixnode::{
+use nym_mixnet_contract_common::delegation::{MixNodeDelegationResponse, OwnerProxySubKey};
+use nym_mixnet_contract_common::families::Family;
+use nym_mixnet_contract_common::mixnode::{
     MixNodeDetails, MixnodeRewardingDetailsResponse, PagedMixnodesDetailsResponse,
     PagedUnbondedMixnodesResponse, StakeSaturationResponse, UnbondedMixnodeResponse,
 };
-use mixnet_contract_common::reward_params::{Performance, RewardingParams};
-use mixnet_contract_common::rewarding::{
+use nym_mixnet_contract_common::reward_params::{Performance, RewardingParams};
+use nym_mixnet_contract_common::rewarding::{
     EstimatedCurrentEpochRewardResponse, PendingRewardResponse,
 };
-use mixnet_contract_common::{
+use nym_mixnet_contract_common::{
     delegation, ContractBuildInformation, ContractState, ContractStateParams,
     CurrentIntervalResponse, EpochEventId, GatewayBondResponse, GatewayOwnershipResponse,
     IdentityKey, IntervalEventId, LayerDistribution, MixId, MixOwnershipResponse,

common/client-libs/validator-client/src/nyxd/traits/mixnet_signing_client.rs

@@ -8,9 +8,9 @@ use crate::nyxd::error::NyxdError;
 use crate::nyxd::{Fee, NyxdClient, SigningCosmWasmClient};
 use async_trait::async_trait;
 use cosmrs::AccountId;
-use mixnet_contract_common::mixnode::{MixNodeConfigUpdate, MixNodeCostParams};
-use mixnet_contract_common::reward_params::{IntervalRewardingParamsUpdate, Performance};
-use mixnet_contract_common::{
+use nym_mixnet_contract_common::mixnode::{MixNodeConfigUpdate, MixNodeCostParams};
+use nym_mixnet_contract_common::reward_params::{IntervalRewardingParamsUpdate, Performance};
+use nym_mixnet_contract_common::{
     ContractStateParams, ExecuteMsg as MixnetExecuteMsg, Gateway, LayerAssignment, MixId, MixNode,
 };
 

common/client-libs/validator-client/src/nyxd/traits/vesting_query_client.rs

@@ -6,16 +6,16 @@ pub use crate::nyxd::cosmwasm_client::client::CosmWasmClient;
 use crate::nyxd::error::NyxdError;
 use crate::nyxd::NyxdClient;
 use async_trait::async_trait;
-use contracts_common::ContractBuildInformation;
 use cosmwasm_std::{Coin as CosmWasmCoin, Timestamp};
-use mixnet_contract_common::MixId;
-use serde::Deserialize;
-use vesting_contract::vesting::Account;
-use vesting_contract_common::{
+use nym_contracts_common::ContractBuildInformation;
+use nym_mixnet_contract_common::MixId;
+use nym_vesting_contract_common::{
     messages::QueryMsg as VestingQueryMsg, AccountVestingCoins, AccountsResponse,
     AllDelegationsResponse, BaseVestingAccountInfo, DelegationTimesResponse,
     OriginalVestingResponse, Period, PledgeData, VestingCoinsResponse, VestingDelegation,
 };
+use serde::Deserialize;
+use vesting_contract::vesting::Account;
 
 #[async_trait]
 pub trait VestingQueryClient {
@@ -134,28 +134,68 @@ pub trait VestingQueryClient {
         .await
     }
 
-    async fn delegated_free(
+    async fn get_historical_vesting_staking_reward(
         &self,
         vesting_account_address: &str,
-        block_time: Option<Timestamp>,
     ) -> Result<Coin, NyxdError> {
-        self.query_vesting_contract::<CosmWasmCoin>(VestingQueryMsg::GetDelegatedFree {
+        self.query_vesting_contract::<CosmWasmCoin>(
+            VestingQueryMsg::GetHistoricalVestingStakingReward {
+                vesting_account_address: vesting_account_address.to_string(),
+            },
+        )
+        .await
+        .map(Into::into)
+    }
+
+    async fn get_spendable_vested_coins(
+        &self,
+        vesting_account_address: &str,
+    ) -> Result<Coin, NyxdError> {
+        self.query_vesting_contract::<CosmWasmCoin>(VestingQueryMsg::GetSpendableVestedCoins {
             vesting_account_address: vesting_account_address.to_string(),
-            block_time,
         })
         .await
         .map(Into::into)
     }
 
-    /// Returns the total amount of delegated tokens that have vested
-    async fn delegated_vesting(
+    async fn get_spendable_reward_coins(
         &self,
         vesting_account_address: &str,
-        block_time: Option<Timestamp>,
     ) -> Result<Coin, NyxdError> {
-        self.query_vesting_contract::<CosmWasmCoin>(VestingQueryMsg::GetDelegatedVesting {
+        self.query_vesting_contract::<CosmWasmCoin>(VestingQueryMsg::GetSpendableRewardCoins {
+            vesting_account_address: vesting_account_address.to_string(),
+        })
+        .await
+        .map(Into::into)
+    }
+
+    async fn get_delegated_coins(&self, vesting_account_address: &str) -> Result<Coin, NyxdError> {
+        self.query_vesting_contract::<CosmWasmCoin>(VestingQueryMsg::GetDelegatedCoins {
+            vesting_account_address: vesting_account_address.to_string(),
+        })
+        .await
+        .map(Into::into)
+    }
+
+    async fn get_pledged_coins(&self, vesting_account_address: &str) -> Result<Coin, NyxdError> {
+        self.query_vesting_contract::<CosmWasmCoin>(VestingQueryMsg::GetPledgedCoins {
+            vesting_account_address: vesting_account_address.to_string(),
+        })
+        .await
+        .map(Into::into)
+    }
+
+    async fn get_staked_coins(&self, vesting_account_address: &str) -> Result<Coin, NyxdError> {
+        self.query_vesting_contract::<CosmWasmCoin>(VestingQueryMsg::GetStakedCoins {
+            vesting_account_address: vesting_account_address.to_string(),
+        })
+        .await
+        .map(Into::into)
+    }
+
+    async fn get_withdrawn_coins(&self, vesting_account_address: &str) -> Result<Coin, NyxdError> {
+        self.query_vesting_contract::<CosmWasmCoin>(VestingQueryMsg::GetWithdrawnCoins {
             vesting_account_address: vesting_account_address.to_string(),
-            block_time,
         })
         .await
         .map(Into::into)

common/client-libs/validator-client/src/nyxd/traits/vesting_signing_client.rs

@@ -6,10 +6,12 @@ use crate::nyxd::cosmwasm_client::types::ExecuteResult;
 use crate::nyxd::error::NyxdError;
 use crate::nyxd::{Coin, Fee, NyxdClient};
 use async_trait::async_trait;
-use mixnet_contract_common::mixnode::{MixNodeConfigUpdate, MixNodeCostParams};
-use mixnet_contract_common::{Gateway, MixId, MixNode};
-use vesting_contract_common::messages::{ExecuteMsg as VestingExecuteMsg, VestingSpecification};
-use vesting_contract_common::PledgeCap;
+use nym_mixnet_contract_common::mixnode::{MixNodeConfigUpdate, MixNodeCostParams};
+use nym_mixnet_contract_common::{Gateway, MixId, MixNode};
+use nym_vesting_contract_common::messages::{
+    ExecuteMsg as VestingExecuteMsg, VestingSpecification,
+};
+use nym_vesting_contract_common::PledgeCap;
 
 #[async_trait]
 pub trait VestingSigningClient {

common/commands/Cargo.toml

@@ -30,8 +30,8 @@ cosmwasm-std = { version = "1.0.0" }
 
 validator-client = { path = "../client-libs/validator-client", features = ["nyxd-client"] }
 network-defaults = { path = "../network-defaults" }
-mixnet-contract-common = { path = "../cosmwasm-smart-contracts/mixnet-contract" }
-vesting-contract-common = { path = "../cosmwasm-smart-contracts/vesting-contract" }
+nym-mixnet-contract-common = { path = "../cosmwasm-smart-contracts/mixnet-contract" }
+nym-vesting-contract-common = { path = "../cosmwasm-smart-contracts/vesting-contract" }
 coconut-bandwidth-contract-common = { path = "../cosmwasm-smart-contracts/coconut-bandwidth-contract" }
 coconut-dkg-common = { path = "../cosmwasm-smart-contracts/coconut-dkg" }
 multisig-contract-common = { path = "../cosmwasm-smart-contracts/multisig-contract" }

common/commands/src/validator/cosmwasm/generators/mixnet.rs

@@ -5,7 +5,7 @@ use clap::Parser;
 use log::{debug, info};
 
 use cosmwasm_std::Decimal;
-use mixnet_contract_common::{InitialRewardingParams, InstantiateMsg, Percent};
+use nym_mixnet_contract_common::{InitialRewardingParams, InstantiateMsg, Percent};
 use std::str::FromStr;
 use std::time::Duration;
 use validator_client::nyxd::AccountId;

common/commands/src/validator/cosmwasm/generators/vesting.rs

@@ -6,8 +6,8 @@ use std::str::FromStr;
 use clap::Parser;
 use log::{debug, info};
 
+use nym_vesting_contract_common::InitMsg;
 use validator_client::nyxd::AccountId;
-use vesting_contract_common::InitMsg;
 
 #[derive(Debug, Parser)]
 pub struct Args {

common/commands/src/validator/mixnet/delegators/delegate_to_mixnode.rs

@@ -4,7 +4,7 @@
 use crate::context::SigningClient;
 use clap::Parser;
 use log::info;
-use mixnet_contract_common::{Coin, MixId};
+use nym_mixnet_contract_common::{Coin, MixId};
 use validator_client::nyxd::traits::{MixnetQueryClient, MixnetSigningClient};
 
 #[derive(Debug, Parser)]

common/commands/src/validator/mixnet/delegators/query_for_delegations.rs

@@ -9,7 +9,7 @@ use crate::utils::{pretty_cosmwasm_coin, show_error_passthrough};
 
 use comfy_table::Table;
 use cosmwasm_std::Addr;
-use mixnet_contract_common::{Delegation, PendingEpochEvent, PendingEpochEventKind};
+use nym_mixnet_contract_common::{Delegation, PendingEpochEvent, PendingEpochEventKind};
 
 #[derive(Debug, Parser)]
 pub struct Args {}

common/commands/src/validator/mixnet/delegators/rewards/claim_delegator_reward.rs

@@ -4,7 +4,7 @@
 use crate::context::SigningClient;
 use clap::Parser;
 use log::info;
-use mixnet_contract_common::MixId;
+use nym_mixnet_contract_common::MixId;
 use validator_client::nyxd::traits::{MixnetQueryClient, MixnetSigningClient};
 
 #[derive(Debug, Parser)]

common/commands/src/validator/mixnet/delegators/rewards/vesting_claim_delegator_reward.rs

@@ -4,7 +4,7 @@
 use crate::context::SigningClient;
 use clap::Parser;
 use log::info;
-use mixnet_contract_common::MixId;
+use nym_mixnet_contract_common::MixId;
 use validator_client::nyxd::traits::{MixnetQueryClient, MixnetSigningClient};
 
 #[derive(Debug, Parser)]

common/commands/src/validator/mixnet/delegators/undelegate_from_mixnode.rs

@@ -4,7 +4,7 @@
 use crate::context::SigningClient;
 use clap::Parser;
 use log::info;
-use mixnet_contract_common::MixId;
+use nym_mixnet_contract_common::MixId;
 use validator_client::nyxd::traits::{MixnetQueryClient, MixnetSigningClient};
 
 #[derive(Debug, Parser)]

common/commands/src/validator/mixnet/delegators/vesting_delegate_to_mixnode.rs

@@ -4,7 +4,7 @@
 use clap::Parser;
 use log::info;
 
-use mixnet_contract_common::{Coin, MixId};
+use nym_mixnet_contract_common::{Coin, MixId};
 use validator_client::nyxd::traits::MixnetQueryClient;
 use validator_client::nyxd::VestingSigningClient;
 

common/commands/src/validator/mixnet/delegators/vesting_undelegate_from_mixnode.rs

@@ -3,7 +3,7 @@
 
 use clap::Parser;
 use log::info;
-use mixnet_contract_common::MixId;
+use nym_mixnet_contract_common::MixId;
 use validator_client::nyxd::traits::MixnetQueryClient;
 use validator_client::nyxd::VestingSigningClient;
 

common/commands/src/validator/mixnet/operators/gateway/bond_gateway.rs

@@ -4,8 +4,8 @@
 use crate::context::SigningClient;
 use clap::Parser;
 use log::{info, warn};
-use mixnet_contract_common::Coin;
 use network_defaults::{DEFAULT_CLIENT_LISTENING_PORT, DEFAULT_MIX_LISTENING_PORT};
+use nym_mixnet_contract_common::Coin;
 use validator_client::nyxd::traits::MixnetSigningClient;
 
 #[derive(Debug, Parser)]
@@ -55,7 +55,7 @@ pub async fn bond_gateway(args: Args, client: SigningClient) {
         return;
     }
 
-    let gateway = mixnet_contract_common::Gateway {
+    let gateway = nym_mixnet_contract_common::Gateway {
         host: args.host,
         mix_port: args.mix_port.unwrap_or(DEFAULT_MIX_LISTENING_PORT),
         clients_port: args.clients_port.unwrap_or(DEFAULT_CLIENT_LISTENING_PORT),

common/commands/src/validator/mixnet/operators/gateway/vesting_bond_gateway.rs

@@ -4,8 +4,8 @@
 use crate::context::SigningClient;
 use clap::Parser;
 use log::{info, warn};
-use mixnet_contract_common::{Coin, Gateway};
 use network_defaults::{DEFAULT_CLIENT_LISTENING_PORT, DEFAULT_MIX_LISTENING_PORT};
+use nym_mixnet_contract_common::{Coin, Gateway};
 use validator_client::nyxd::VestingSigningClient;
 
 #[derive(Debug, Parser)]

common/commands/src/validator/mixnet/operators/mixnode/bond_mixnode.rs

@@ -5,10 +5,10 @@ use clap::Parser;
 use cosmwasm_std::Uint128;
 use log::{info, warn};
 
-use mixnet_contract_common::{Coin, MixNodeCostParams, Percent};
 use network_defaults::{
     DEFAULT_HTTP_API_LISTENING_PORT, DEFAULT_MIX_LISTENING_PORT, DEFAULT_VERLOC_LISTENING_PORT,
 };
+use nym_mixnet_contract_common::{Coin, MixNodeCostParams, Percent};
 use validator_client::nyxd::traits::MixnetSigningClient;
 use validator_client::nyxd::CosmWasmCoin;
 
@@ -70,7 +70,7 @@ pub async fn bond_mixnode(args: Args, client: SigningClient) {
         return;
     }
 
-    let mixnode = mixnet_contract_common::MixNode {
+    let mixnode = nym_mixnet_contract_common::MixNode {
         host: args.host,
         mix_port: args.mix_port.unwrap_or(DEFAULT_MIX_LISTENING_PORT),
         verloc_port: args.verloc_port.unwrap_or(DEFAULT_VERLOC_LISTENING_PORT),

common/commands/src/validator/mixnet/operators/mixnode/settings/update_config.rs

@@ -4,7 +4,7 @@
 use crate::context::SigningClient;
 use clap::Parser;
 use log::info;
-use mixnet_contract_common::MixNodeConfigUpdate;
+use nym_mixnet_contract_common::MixNodeConfigUpdate;
 use validator_client::nyxd::traits::{MixnetQueryClient, MixnetSigningClient};
 
 #[derive(Debug, Parser)]

common/commands/src/validator/mixnet/operators/mixnode/settings/vesting_update_config.rs

@@ -4,7 +4,7 @@
 use crate::context::SigningClient;
 use clap::Parser;
 use log::info;
-use mixnet_contract_common::MixNodeConfigUpdate;
+use nym_mixnet_contract_common::MixNodeConfigUpdate;
 use validator_client::nyxd::traits::MixnetQueryClient;
 use validator_client::nyxd::VestingSigningClient;
 

common/commands/src/validator/mixnet/operators/mixnode/vesting_bond_mixnode.rs

@@ -5,11 +5,11 @@ use crate::context::SigningClient;
 use clap::Parser;
 use cosmwasm_std::Uint128;
 use log::{info, warn};
-use mixnet_contract_common::{Coin, MixNodeCostParams};
-use mixnet_contract_common::{MixNode, Percent};
 use network_defaults::{
     DEFAULT_HTTP_API_LISTENING_PORT, DEFAULT_MIX_LISTENING_PORT, DEFAULT_VERLOC_LISTENING_PORT,
 };
+use nym_mixnet_contract_common::{Coin, MixNodeCostParams};
+use nym_mixnet_contract_common::{MixNode, Percent};
 use validator_client::nyxd::{CosmWasmCoin, VestingSigningClient};
 
 #[derive(Debug, Parser)]

common/commands/src/validator/vesting/create_vesting_schedule.rs

@@ -6,13 +6,13 @@ use std::str::FromStr;
 use clap::Parser;
 use log::info;
 
-use mixnet_contract_common::Coin;
 use network_defaults::NymNetworkDetails;
+use nym_mixnet_contract_common::Coin;
+use nym_vesting_contract_common::messages::VestingSpecification;
+use nym_vesting_contract_common::PledgeCap;
 use validator_client::nyxd::AccountId;
 use validator_client::nyxd::VestingSigningClient;
 use validator_client::nyxd::{CosmosCoin, Denom};
-use vesting_contract_common::messages::VestingSpecification;
-use vesting_contract_common::PledgeCap;
 
 use crate::context::SigningClient;
 

common/commands/src/validator/vesting/query_vesting_schedule.rs

@@ -53,8 +53,10 @@ pub async fn query(args: Args, client: QueryClient, address_from_mnemonic: Optio
 
     // TODO: get better copy text for what these are
     let vesting_coins = client.vesting_coins(&vesting_address, None).await;
-    let delegated_vesting = client.delegated_vesting(&vesting_address, None).await;
-    let delegated_free = client.delegated_free(&vesting_address, None).await;
+    let delegated = client.get_delegated_coins(&vesting_address).await;
+    let pledged = client.get_pledged_coins(&vesting_address).await;
+    let withdrawn = client.get_withdrawn_coins(&vesting_address).await;
+    let staked = client.get_staked_coins(&vesting_address).await;
 
     original_vesting.as_ref().map_or_else(show_error, |res| {
         println!(
@@ -139,11 +141,17 @@ pub async fn query(args: Args, client: QueryClient, address_from_mnemonic: Optio
     vesting_coins.map_or_else(show_error, |res| {
         println!("Vesting coins:     {}   ({})", pretty_coin(&res), res);
     });
-    delegated_vesting.map_or_else(show_error, |res| {
-        println!("Delegated vesting: {}   ({})", pretty_coin(&res), res);
+    withdrawn.map_or_else(show_error, |res| {
+        println!("Withdrawn:         {}   ({})", pretty_coin(&res), res);
     });
-    delegated_free.map_or_else(show_error, |res| {
-        println!("Delegation free:   {}   ({})", pretty_coin(&res), res);
+    delegated.map_or_else(show_error, |res| {
+        println!("Delegated:         {}   ({})", pretty_coin(&res), res);
+    });
+    pledged.map_or_else(show_error, |res| {
+        println!("Pledged:           {}   ({})", pretty_coin(&res), res);
+    });
+    staked.map_or_else(show_error, |res| {
+        println!("Staked:            {}   ({})", pretty_coin(&res), res);
     });
 
     println!();

common/cosmwasm-smart-contracts/coconut-dkg/Cargo.toml

@@ -11,5 +11,5 @@ cw-utils = "0.13.4"
 schemars = "0.8"
 serde = { version = "1.0.103", default-features = false, features = ["derive"] }
 
-contracts-common = { path = "../contracts-common" }
-multisig-contract-common = { path = "../multisig-contract" }
+contracts-common = { path = "../contracts-common", package = "nym-contracts-common" }
+multisig-contract-common = { path = "../multisig-contract" }

common/cosmwasm-smart-contracts/coconut-dkg/src/types.rs

@@ -114,6 +114,33 @@ impl Epoch {
             finish_timestamp: current_timestamp.plus_seconds(duration),
         }
     }
+
+    pub fn final_timestamp_secs(&self) -> u64 {
+        let mut finish = self.finish_timestamp.seconds();
+        let time_configuration = self.time_configuration;
+        let mut curr_epoch_state = self.state;
+        while let Some(state) = curr_epoch_state.next() {
+            curr_epoch_state = state;
+            let adding = match curr_epoch_state {
+                EpochState::PublicKeySubmission { .. } => {
+                    time_configuration.public_key_submission_time_secs
+                }
+                EpochState::DealingExchange { .. } => time_configuration.dealing_exchange_time_secs,
+                EpochState::VerificationKeySubmission { .. } => {
+                    time_configuration.verification_key_submission_time_secs
+                }
+                EpochState::VerificationKeyValidation { .. } => {
+                    time_configuration.verification_key_validation_time_secs
+                }
+                EpochState::VerificationKeyFinalization { .. } => {
+                    time_configuration.verification_key_finalization_time_secs
+                }
+                EpochState::InProgress { .. } => 0,
+            };
+            finish += adding;
+        }
+        finish
+    }
 }
 
 // currently (it is still extremely likely to change, we might be able to get rid of verification key-related complaints),
@@ -195,4 +222,8 @@ impl EpochState {
 
         states
     }
+
+    pub fn is_final(&self) -> bool {
+        *self == EpochState::InProgress
+    }
 }

common/cosmwasm-smart-contracts/contracts-common/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "contracts-common"
+name = "nym-contracts-common"
 version = "0.1.0"
 authors = ["Jędrzej Stuczyński <andrew@nymtech.net>"]
 edition = "2021"
@@ -15,4 +15,4 @@ serde = { version = "1.0", features = ["derive"] }
 thiserror = "1"
 
 [dev-dependencies]
-serde_json = "1.0.0"
+serde_json = "1.0.0"

common/cosmwasm-smart-contracts/mixnet-contract/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "mixnet-contract-common"
+name = "nym-mixnet-contract-common"
 version = "0.1.0"
 authors = ["Jędrzej Stuczyński <andrew@nymtech.net>"]
 edition = "2021"
@@ -14,7 +14,7 @@ serde = { version = "1.0", features = ["derive"] }
 serde_repr = "0.1"
 schemars = "0.8"
 thiserror = "1.0"
-contracts-common = { path = "../contracts-common" }
+contracts-common = { path = "../contracts-common", package = "nym-contracts-common" }
 serde_json = "1.0.0"
 humantime-serde = "1.1.1"
 

common/cosmwasm-smart-contracts/vesting-contract/Cargo.toml

@@ -1,12 +1,12 @@
 [package]
-name = "vesting-contract-common"
+name = "nym-vesting-contract-common"
 version = "0.1.0"
 edition = "2021"
 
 [dependencies]
 cosmwasm-std = "1.0.0"
-mixnet-contract-common = { path = "../mixnet-contract" }
-contracts-common = { path = "../contracts-common" }
+mixnet-contract-common = { path = "../mixnet-contract", package = "nym-mixnet-contract-common" }
+contracts-common = { path = "../contracts-common", package = "nym-contracts-common" }
 serde = { version = "1.0", features = ["derive"] }
 schemars = "0.8"
 ts-rs = {version = "6.1.2", optional = true}

common/cosmwasm-smart-contracts/vesting-contract/src/messages.rs

@@ -221,12 +221,25 @@ pub enum QueryMsg {
     GetOriginalVesting {
         vesting_account_address: String,
     },
-    GetDelegatedFree {
-        block_time: Option<Timestamp>,
+    GetHistoricalVestingStakingReward {
         vesting_account_address: String,
     },
-    GetDelegatedVesting {
-        block_time: Option<Timestamp>,
+    GetSpendableVestedCoins {
+        vesting_account_address: String,
+    },
+    GetSpendableRewardCoins {
+        vesting_account_address: String,
+    },
+    GetDelegatedCoins {
+        vesting_account_address: String,
+    },
+    GetPledgedCoins {
+        vesting_account_address: String,
+    },
+    GetStakedCoins {
+        vesting_account_address: String,
+    },
+    GetWithdrawnCoins {
         vesting_account_address: String,
     },
     GetAccount {

common/credentials/Cargo.toml

@@ -12,7 +12,7 @@ thiserror = "1.0"
 
 # I guess temporarily until we get serde support in coconut up and running
 coconut-interface = { path = "../coconut-interface" }
-crypto = { path = "../crypto", features = ["rand", "asymmetric", "symmetric", "hashing"] }
+nym-crypto = { path = "../crypto", features = ["rand", "asymmetric", "symmetric", "hashing"] }
 nym-api-requests = { path = "../../nym-api/nym-api-requests" }
 validator-client = { path = "../client-libs/validator-client" }
 

common/credentials/src/coconut/bandwidth.rs

@@ -10,7 +10,7 @@ use coconut_interface::{
     hash_to_scalar, prepare_blind_sign, Attribute, BlindSignRequest, Credential, Parameters,
     PrivateAttribute, PublicAttribute, Signature, VerificationKey,
 };
-use crypto::asymmetric::{encryption, identity};
+use nym_crypto::asymmetric::{encryption, identity};
 
 use cosmrs::tx::Hash;
 
@@ -42,41 +42,9 @@ pub struct BandwidthVoucher {
     encryption_key: encryption::PrivateKey,
     pedersen_commitments_openings: Vec<Attribute>,
     blind_sign_request: BlindSignRequest,
-    use_request: bool,
 }
 
 impl BandwidthVoucher {
-    pub fn new_with_blind_sign_req(
-        private_attributes: [PrivateAttribute; PRIVATE_ATTRIBUTES as usize],
-        public_attributes_plain: [&str; PUBLIC_ATTRIBUTES as usize],
-        tx_hash: Hash,
-        signing_key: identity::PrivateKey,
-        encryption_key: encryption::PrivateKey,
-        pedersen_commitments_openings: Vec<Attribute>,
-        blind_sign_request: BlindSignRequest,
-    ) -> Self {
-        let voucher_value = public_attributes_plain[0];
-        let voucher_info = public_attributes_plain[1];
-        let voucher_value_plain = voucher_value.to_string();
-        let voucher_info_plain = voucher_info.to_string();
-        let voucher_value = hash_to_scalar(voucher_value.as_bytes());
-        let voucher_info = hash_to_scalar(voucher_info.as_bytes());
-
-        BandwidthVoucher {
-            serial_number: private_attributes[0],
-            binding_number: private_attributes[1],
-            voucher_value,
-            voucher_value_plain,
-            voucher_info,
-            voucher_info_plain,
-            tx_hash,
-            signing_key,
-            encryption_key,
-            pedersen_commitments_openings,
-            blind_sign_request,
-            use_request: false,
-        }
-    }
     pub fn new(
         params: &Parameters,
         voucher_value: String,
@@ -109,10 +77,135 @@ impl BandwidthVoucher {
             encryption_key,
             pedersen_commitments_openings,
             blind_sign_request,
-            use_request: true,
         }
     }
 
+    pub fn to_bytes(&self) -> Vec<u8> {
+        let serial_number_b = self.serial_number.to_bytes();
+        let binding_number_b = self.binding_number.to_bytes();
+        let voucher_value_plain_b = self.voucher_value_plain.as_bytes();
+        let voucher_info_plain_b = self.voucher_info_plain.as_bytes();
+        let tx_hash_b = self.tx_hash.as_bytes();
+        let signing_key_b = self.signing_key.to_bytes();
+        let encryption_key_b = self.encryption_key.to_bytes();
+        let blind_sign_request_b = self.blind_sign_request.to_bytes();
+
+        let mut ret = Vec::new();
+
+        ret.extend_from_slice(&serial_number_b);
+        ret.extend_from_slice(&binding_number_b);
+        ret.extend_from_slice(tx_hash_b);
+        ret.extend_from_slice(&signing_key_b);
+        ret.extend_from_slice(&encryption_key_b);
+        ret.extend_from_slice(&(voucher_value_plain_b.len() as u64).to_be_bytes());
+        ret.extend_from_slice(&(voucher_info_plain_b.len() as u64).to_be_bytes());
+        ret.extend_from_slice(&(blind_sign_request_b.len() as u64).to_be_bytes());
+        ret.extend_from_slice(&(self.pedersen_commitments_openings.len() as u64).to_be_bytes());
+        ret.extend_from_slice(voucher_value_plain_b);
+        ret.extend_from_slice(voucher_info_plain_b);
+        ret.extend_from_slice(&blind_sign_request_b);
+        for commitment in self.pedersen_commitments_openings.iter() {
+            ret.extend_from_slice(&commitment.to_bytes());
+        }
+
+        ret
+    }
+
+    pub fn try_from_bytes(bytes: &[u8]) -> Result<Self, Error> {
+        if bytes.len() < 32 * 5 + 4 * 8 {
+            return Err(Error::BandwidthVoucherDeserializationError(format!(
+                "Less then {} bytes needed",
+                32 * 5 + 4 * 8
+            )));
+        }
+        let mut buff = [0u8; 32];
+        let mut small_buff = [0u8; 8];
+        let scalar_err =
+            || Error::BandwidthVoucherDeserializationError(String::from("Invalid Scalar"));
+        buff.copy_from_slice(&bytes[..32]);
+        let serial_number = Option::<PrivateAttribute>::from(PrivateAttribute::from_bytes(&buff))
+            .ok_or_else(scalar_err)?;
+        buff.copy_from_slice(&bytes[32..2 * 32]);
+        let binding_number = Option::<PrivateAttribute>::from(PrivateAttribute::from_bytes(&buff))
+            .ok_or_else(scalar_err)?;
+        buff.copy_from_slice(&bytes[2 * 32..3 * 32]);
+        let tx_hash = Hash::new(buff);
+        buff.copy_from_slice(&bytes[3 * 32..4 * 32]);
+        let signing_key = identity::PrivateKey::from_bytes(&buff).map_err(|_| {
+            Error::BandwidthVoucherDeserializationError(String::from("Invalid key"))
+        })?;
+        buff.copy_from_slice(&bytes[4 * 32..5 * 32]);
+        let encryption_key = encryption::PrivateKey::from_bytes(&buff).map_err(|_| {
+            Error::BandwidthVoucherDeserializationError(String::from("Invalid key"))
+        })?;
+        small_buff.copy_from_slice(&bytes[5 * 32..5 * 32 + 8]);
+        let voucher_value_plain_no = u64::from_be_bytes(small_buff) as usize;
+        small_buff.copy_from_slice(&bytes[5 * 32 + 8..5 * 32 + 2 * 8]);
+        let voucher_info_plain_no = u64::from_be_bytes(small_buff) as usize;
+        small_buff.copy_from_slice(&bytes[5 * 32 + 2 * 8..5 * 32 + 3 * 8]);
+        let blind_sign_request_no = u64::from_be_bytes(small_buff) as usize;
+        small_buff.copy_from_slice(&bytes[5 * 32 + 3 * 8..5 * 32 + 4 * 8]);
+        let pedersen_commitments_openings_no = u64::from_be_bytes(small_buff) as usize;
+
+        let total_length = 32 * 5
+            + 4 * 8
+            + voucher_value_plain_no
+            + voucher_info_plain_no
+            + blind_sign_request_no
+            + pedersen_commitments_openings_no * 32;
+        if bytes.len() != total_length {
+            return Err(Error::BandwidthVoucherDeserializationError(format!(
+                "Expected {total_length} bytes",
+            )));
+        }
+
+        let utf_err = |_| {
+            Err(Error::BandwidthVoucherDeserializationError(String::from(
+                "Invalid UTF8 string",
+            )))
+        };
+        let mut var_length_pointer = 5 * 32 + 4 * 8;
+        let voucher_value_plain = String::from_utf8(
+            bytes[var_length_pointer..var_length_pointer + voucher_value_plain_no].to_vec(),
+        )
+        .or_else(utf_err)?;
+        let voucher_value = hash_to_scalar(&voucher_value_plain);
+        var_length_pointer += voucher_value_plain_no;
+        let voucher_info_plain = String::from_utf8(
+            bytes[var_length_pointer..var_length_pointer + voucher_info_plain_no].to_vec(),
+        )
+        .or_else(utf_err)?;
+        let voucher_info = hash_to_scalar(&voucher_info_plain);
+        var_length_pointer += voucher_info_plain_no;
+        let blind_sign_request = BlindSignRequest::from_bytes(
+            &bytes[var_length_pointer..var_length_pointer + blind_sign_request_no],
+        )?;
+        var_length_pointer += blind_sign_request_no;
+
+        let mut pedersen_commitments_openings = Vec::new();
+        for _ in 0..pedersen_commitments_openings_no {
+            buff.copy_from_slice(&bytes[var_length_pointer..var_length_pointer + 32]);
+            let commitment =
+                Option::<Attribute>::from(Attribute::from_bytes(&buff)).ok_or_else(scalar_err)?;
+            var_length_pointer += 32;
+            pedersen_commitments_openings.push(commitment);
+        }
+
+        Ok(Self {
+            serial_number,
+            binding_number,
+            voucher_value,
+            voucher_value_plain,
+            voucher_info,
+            voucher_info_plain,
+            tx_hash,
+            signing_key,
+            encryption_key,
+            pedersen_commitments_openings,
+            blind_sign_request,
+        })
+    }
+
     /// Check if the plain values correspond to the PublicAttributes
     pub fn verify_against_plain(values: &[PublicAttribute], plain_values: &[String]) -> bool {
         values.len() == 2
@@ -141,8 +234,8 @@ impl BandwidthVoucher {
         &self.blind_sign_request
     }
 
-    pub fn use_request(&self) -> bool {
-        self.use_request
+    pub fn get_voucher_value(&self) -> String {
+        self.voucher_value_plain.clone()
     }
 
     pub fn get_public_attributes_plain(&self) -> Vec<String> {
@@ -189,13 +282,13 @@ pub fn prepare_for_spending(
 #[cfg(test)]
 mod test {
     use super::*;
+    use coconut_interface::Base58;
     use rand::rngs::OsRng;
 
-    #[test]
-    fn voucher_consistency() {
+    fn voucher_fixture() -> BandwidthVoucher {
         let params = Parameters::new(4).unwrap();
         let mut rng = OsRng;
-        let voucher = BandwidthVoucher::new(
+        BandwidthVoucher::new(
             &params,
             "1234".to_string(),
             "voucher info".to_string(),
@@ -210,7 +303,48 @@ mod test {
                 &encryption::KeyPair::new(&mut rng).private_key().to_bytes(),
             )
             .unwrap(),
+        )
+    }
+
+    #[test]
+    fn serde_voucher() {
+        let voucher = voucher_fixture();
+        let bytes = voucher.to_bytes();
+        let deserialized_voucher = BandwidthVoucher::try_from_bytes(&bytes).unwrap();
+        assert_eq!(voucher.serial_number, deserialized_voucher.serial_number);
+        assert_eq!(voucher.binding_number, deserialized_voucher.binding_number);
+        assert_eq!(voucher.voucher_value, deserialized_voucher.voucher_value);
+        assert_eq!(
+            voucher.voucher_value_plain,
+            deserialized_voucher.voucher_value_plain
         );
+        assert_eq!(voucher.voucher_info, deserialized_voucher.voucher_info);
+        assert_eq!(
+            voucher.voucher_info_plain,
+            deserialized_voucher.voucher_info_plain
+        );
+        assert_eq!(voucher.tx_hash, deserialized_voucher.tx_hash);
+        assert_eq!(
+            voucher.signing_key.to_string(),
+            deserialized_voucher.signing_key.to_string()
+        );
+        assert_eq!(
+            voucher.encryption_key.to_string(),
+            deserialized_voucher.encryption_key.to_string()
+        );
+        assert_eq!(
+            voucher.pedersen_commitments_openings,
+            deserialized_voucher.pedersen_commitments_openings
+        );
+        assert_eq!(
+            voucher.blind_sign_request.to_bs58(),
+            deserialized_voucher.blind_sign_request.to_bs58()
+        );
+    }
+
+    #[test]
+    fn voucher_consistency() {
+        let voucher = voucher_fixture();
         assert!(!BandwidthVoucher::verify_against_plain(
             &[],
             &voucher.get_public_attributes_plain()

common/credentials/src/coconut/params.rs

@@ -1,9 +1,9 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crypto::aes::Aes128;
-use crypto::blake3;
-use crypto::ctr;
+use nym_crypto::aes::Aes128;
+use nym_crypto::blake3;
+use nym_crypto::ctr;
 
 type Aes128Ctr = ctr::Ctr64LE<Aes128>;
 

common/credentials/src/coconut/utils.rs

@@ -5,10 +5,10 @@ use coconut_interface::{
     aggregate_signature_shares, aggregate_verification_keys, prove_bandwidth_credential, Attribute,
     BlindedSignature, Credential, Parameters, Signature, SignatureShare, VerificationKey,
 };
-use crypto::asymmetric::encryption::PublicKey;
-use crypto::shared_key::recompute_shared_key;
-use crypto::symmetric::stream_cipher;
 use nym_api_requests::coconut::BlindSignRequestBody;
+use nym_crypto::asymmetric::encryption::PublicKey;
+use nym_crypto::shared_key::recompute_shared_key;
+use nym_crypto::symmetric::stream_cipher;
 use validator_client::client::CoconutApiClient;
 
 use crate::coconut::bandwidth::{BandwidthVoucher, PRIVATE_ATTRIBUTES, PUBLIC_ATTRIBUTES};
@@ -45,21 +45,15 @@ async fn obtain_partial_credential(
     let private_attributes = attributes.get_private_attributes();
     let blind_sign_request = attributes.blind_sign_request();
 
-    let response = if attributes.use_request() {
-        let blind_sign_request_body = BlindSignRequestBody::new(
-            blind_sign_request,
-            attributes.tx_hash().to_string(),
-            attributes.sign(blind_sign_request).to_base58_string(),
-            &public_attributes,
-            public_attributes_plain,
-            (public_attributes.len() + private_attributes.len()) as u32,
-        );
-        client.blind_sign(&blind_sign_request_body).await?
-    } else {
-        client
-            .partial_bandwidth_credential(&attributes.tx_hash().to_string())
-            .await?
-    };
+    let blind_sign_request_body = BlindSignRequestBody::new(
+        blind_sign_request,
+        attributes.tx_hash().to_string(),
+        attributes.sign(blind_sign_request).to_base58_string(),
+        &public_attributes,
+        public_attributes_plain,
+        (public_attributes.len() + private_attributes.len()) as u32,
+    );
+    let response = client.blind_sign(&blind_sign_request_body).await?;
     let encrypted_signature = response.encrypted_signature;
     let remote_key = PublicKey::from_bytes(&response.remote_key)?;
 
@@ -109,6 +103,8 @@ pub async fn obtain_aggregate_signature(
         .iter()
         .map(|api_client| api_client.node_id)
         .collect();
+    let verification_key =
+        aggregate_verification_keys(&validators_partial_vks, Some(indices.as_ref()))?;
 
     for coconut_api_client in coconut_api_clients.iter() {
         if let Ok(signature) = obtain_partial_credential(
@@ -131,15 +127,8 @@ pub async fn obtain_aggregate_signature(
     attributes.extend_from_slice(&private_attributes);
     attributes.extend_from_slice(&public_attributes);
 
-    let verification_key =
-        aggregate_verification_keys(&validators_partial_vks, Some(indices.as_ref()))?;
-
-    Ok(aggregate_signature_shares(
-        params,
-        &verification_key,
-        &attributes,
-        &shares,
-    )?)
+    aggregate_signature_shares(params, &verification_key, &attributes, &shares)
+        .map_err(Error::SignatureAggregationError)
 }
 
 // TODO: better type flow

common/credentials/src/error.rs

@@ -2,13 +2,16 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use coconut_interface::CoconutError;
-use crypto::asymmetric::encryption::KeyRecoveryError;
+use nym_crypto::asymmetric::encryption::KeyRecoveryError;
 use validator_client::ValidatorClientError;
 
 use thiserror::Error;
 
 #[derive(Debug, Error)]
 pub enum Error {
+    #[error("IO error")]
+    IOError(#[from] std::io::Error),
+
     #[error("The detailed description is yet to be determined")]
     BandwidthCredentialError,
 
@@ -30,6 +33,12 @@ pub enum Error {
     #[error("Could not parse the key - {0}")]
     ParsePublicKey(#[from] KeyRecoveryError),
 
-    #[error("Could not gather enough signature shares")]
+    #[error("Could not gather enough signature shares. Try again using the recovery command")]
     NotEnoughShares,
+
+    #[error("Could not aggregate signature shares - {0}. Try again using the recovery command")]
+    SignatureAggregationError(CoconutError),
+
+    #[error("Could not deserialize bandwidth voucher - {0}")]
+    BandwidthVoucherDeserializationError(String),
 }

common/crypto/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "crypto"
+name = "nym-crypto"
 version = "0.1.0"
 authors = ["Jedrzej Stuczynski <andrew@nymtech.net"]
 edition = "2021"
@@ -26,7 +26,7 @@ thiserror = "1.0.37"
 
 # internal
 nymsphinx-types = { path = "../nymsphinx/types" }
-pemstore = { path = "../../common/pemstore" }
+nym-pemstore = { path = "../../common/pemstore" }
 
 [dev-dependencies]
 rand_chacha = "0.2"

common/crypto/dkg/Cargo.toml

@@ -25,7 +25,7 @@ serde_derive = "1.0"
 thiserror = "1.0"
 zeroize = { version = "1.4", features = ["zeroize_derive"] }
 
-pemstore = { path = "../../pemstore" }
+nym-pemstore = { path = "../../pemstore" }
 
 [dependencies.group]
 version = "0.11"

common/crypto/dkg/src/bte/keys.rs

@@ -8,7 +8,7 @@ use crate::utils::{deserialize_g1, deserialize_g2, deserialize_scalar};
 use bls12_381::{G1Projective, G2Projective, Scalar};
 use ff::Field;
 use group::GroupEncoding;
-use pemstore::traits::{PemStorableKey, PemStorableKeyPair};
+use nym_pemstore::traits::{PemStorableKey, PemStorableKeyPair};
 use rand_core::RngCore;
 use zeroize::Zeroize;
 

common/crypto/src/asymmetric/encryption/mod.rs

@@ -1,7 +1,7 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use pemstore::traits::{PemStorableKey, PemStorableKeyPair};
+use nym_pemstore::traits::{PemStorableKey, PemStorableKeyPair};
 use std::fmt::{self, Display, Formatter};
 use thiserror::Error;
 

common/crypto/src/asymmetric/identity/mod.rs

@@ -4,8 +4,8 @@
 pub use ed25519_dalek::ed25519::signature::Signature as SignatureTrait;
 pub use ed25519_dalek::SignatureError;
 pub use ed25519_dalek::{Verifier, PUBLIC_KEY_LENGTH, SECRET_KEY_LENGTH, SIGNATURE_LENGTH};
+use nym_pemstore::traits::{PemStorableKey, PemStorableKeyPair};
 use nymsphinx_types::{DestinationAddressBytes, DESTINATION_ADDRESS_LENGTH};
-use pemstore::traits::{PemStorableKey, PemStorableKeyPair};
 use std::fmt::{self, Display, Formatter};
 use std::str::FromStr;
 use thiserror::Error;

common/mixnode-common/Cargo.toml

@@ -18,7 +18,7 @@ tokio-util = { version = "0.7.4", features = ["codec"] }
 url = "2.2"
 thiserror = "1.0.37"
 
-crypto =  { path = "../crypto" }
+nym-crypto =  { path = "../crypto" }
 network-defaults = { path = "../network-defaults" }
 nymsphinx-acknowledgements = { path = "../nymsphinx/acknowledgements" }
 nymsphinx-addressing = { path = "../nymsphinx/addressing" }

common/mixnode-common/src/verloc/listener.rs

@@ -4,9 +4,9 @@
 use crate::verloc::error::RttError;
 use crate::verloc::packet::{EchoPacket, ReplyPacket};
 use bytes::{BufMut, BytesMut};
-use crypto::asymmetric::identity;
 use futures::StreamExt;
 use log::*;
+use nym_crypto::asymmetric::identity;
 use std::fmt::{Display, Formatter};
 use std::net::SocketAddr;
 use std::sync::Arc;
@@ -56,7 +56,8 @@ impl PacketListener {
         while !shutdown_listener.is_shutdown() {
             // cloning the arc as each accepted socket is handled in separate task
             let connection_handler = Arc::clone(&self.connection_handler);
-            let handler_shutdown_listener = self.shutdown.clone();
+            let mut handler_shutdown_listener = self.shutdown.clone();
+            handler_shutdown_listener.mark_as_success();
 
             tokio::select! {
                 socket = listener.accept() => {

common/mixnode-common/src/verloc/measurement.rs

@@ -1,7 +1,7 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crypto::asymmetric::identity;
+use nym_crypto::asymmetric::identity;
 use serde::{Serialize, Serializer};
 use std::cmp::Ordering;
 use std::fmt::{self, Display, Formatter};