Use saturating_sub for extra safety (#1258)

* Use saturating_sub for extra safety

* More saturating_sub

* Save some lines

* Add change log

.github/CODEOWNERS

@@ -15,8 +15,8 @@
 * @futurechimp @mmsinclair
 
 # Rust rules:
-*.rs @durch @futurechimp @jstuczyn @neacsu
-Cargo.* @durch @futurechimp @jstuczyn @neacsu
+*.rs @durch @futurechimp @jstuczyn @neacsu @octol
+Cargo.* @durch @futurechimp @jstuczyn @neacsu @octol
 
 # JS rules:
 *.js @mmsinclair @fmtabbara @Aid19801

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,9 @@
+# Description
+
+Closes: #XXXX
+
+<!-- If appropriate, insert relevant description here -->
+
+# Checklist:
+
+- [ ] added a changelog entry to `CHANGELOG.md`

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

@@ -0,0 +1,63 @@
+name: CI for ts-packages
+
+on:
+  push:
+    paths:
+      - 'ts-packages/**'
+
+jobs:
+  build:
+    runs-on: custom-runner-linux
+    steps:
+    - uses: actions/checkout@v2
+    - name: Install rsync
+      run: sudo apt-get install rsync
+    - uses: rlespinasse/github-slug-action@v3.x
+    - uses: actions/setup-node@v2
+      with:
+        node-version: '16'
+    - name: Setup yarn
+      run: npm install -g yarn
+    - name: Build
+      run: yarn && yarn build && yarn build:ci
+    - name: Deploy branch to CI www (storybook)
+      continue-on-error: true
+      uses: easingthemes/ssh-deploy@main
+      env:
+        SSH_PRIVATE_KEY: ${{ secrets.CI_WWW_SSH_PRIVATE_KEY }}
+        ARGS: "-rltgoDzvO --delete"
+        SOURCE: "ts-packages/dist/storybook/"
+        REMOTE_HOST: ${{ secrets.CI_WWW_REMOTE_HOST }}
+        REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
+        TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/ts-${{ env.GITHUB_REF_SLUG }}
+        EXCLUDE: "/dist/, /node_modules/"
+    - name: Deploy branch to CI www (example)
+      continue-on-error: true
+      uses: easingthemes/ssh-deploy@main
+      env:
+        SSH_PRIVATE_KEY: ${{ secrets.CI_WWW_SSH_PRIVATE_KEY }}
+        ARGS: "-rltgoDzvO --delete"
+        SOURCE: "ts-packages/dist/example/"
+        REMOTE_HOST: ${{ secrets.CI_WWW_REMOTE_HOST }}
+        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
+      run: npm install
+      working-directory: .github/workflows/support-files
+    - name: Keybase - Send Notification
+      env:
+        NYM_NOTIFICATION_KIND: ts-packages
+        NYM_PROJECT_NAME: "ts-packages"
+        NYM_CI_WWW_BASE: "${{ secrets.NYM_CI_WWW_BASE }}"
+        NYM_CI_WWW_LOCATION: "ts-${{ env.GITHUB_REF_SLUG }}"
+        GIT_COMMIT_MESSAGE: "${{ github.event.head_commit.message }}"
+        GIT_BRANCH: "${GITHUB_REF##*/}"
+        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' }}"
+      uses: docker://keybaseio/client:stable-node
+      with:
+        args: .github/workflows/support-files/notifications/entry_point.sh

.github/workflows/build.yml

@@ -9,28 +9,14 @@ on:
       - 'explorer/**'
 
 jobs:
-  matrix_prep:
-    runs-on: ubuntu-latest
-    outputs:
-      matrix: ${{ steps.set-matrix.outputs.matrix }}
-    steps:
-      # creates the matrix strategy from build_matrix_includes.json
-      - uses: actions/checkout@v2
-      - id: set-matrix
-        uses: JoshuaTheMiller/conditional-build-matrix@main
-        with:
-          inputFile: '.github/workflows/build_matrix_includes.json'
-          filter: '[?runOnEvent==`${{ github.event_name }}` || runOnEvent==`always`]'
   build:
-    needs: matrix_prep
-    strategy:
-      matrix: ${{fromJson(needs.matrix_prep.outputs.matrix)}}
-    runs-on: ${{ matrix.os }}
-    continue-on-error: ${{ matrix.rust == 'nightly' || matrix.rust == 'beta' || matrix.os == 'windows-latest' }}
+    runs-on: [ self-hosted, custom-linux-exoscale ]
+    # Enable sccache via environment variable
+    env:
+      RUSTC_WRAPPER: /home/ubuntu/.cargo/bin/sccache
     steps:
       - name: Install Dependencies (Linux)
-        run: sudo apt-get update && sudo apt-get install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev squashfs-tools
-        if: matrix.os == 'ubuntu-latest'
+        run: sudo apt-get update && sudo apt-get -y install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev squashfs-tools
 
       - name: Check out repository code
         uses: actions/checkout@v2
@@ -39,7 +25,7 @@ jobs:
         uses: actions-rs/toolchain@v1
         with:
           profile: minimal
-          toolchain: ${{ matrix.rust }}
+          toolchain: stable
           override: true
           components: rustfmt, clippy
 
@@ -47,13 +33,13 @@ jobs:
         uses: actions-rs/cargo@v1
         with:
           command: build
-          args: --all
+          args: --workspace
 
       - name: Run all tests
         uses: actions-rs/cargo@v1
         with:
           command: test
-          args: --all
+          args: --workspace --all-features
 
       - name: Check formatting
         uses: actions-rs/cargo@v1
@@ -63,40 +49,30 @@ jobs:
 
       - uses: actions-rs/clippy-check@v1
         name: Clippy checks
-#        if: matrix.os == 'ubuntu-latest' && matrix.rust == 'stable'
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
           args: --all-features
 
       - name: Run clippy
         uses: actions-rs/cargo@v1
-        if: ${{ matrix.rust != 'nightly' }}
         with:
           command: clippy
-          args: -- -D warnings
-
-#        COCONUT stuff
-      - name: Reclaim some disk space (because Windows is being annoying)
-        uses: actions-rs/cargo@v1
-        if: ${{ matrix.os == 'windows-latest' }}
-        with:
-          command: clean
+          args: --workspace -- -D warnings
 
       - name: Build all binaries with coconut enabled
         uses: actions-rs/cargo@v1
         with:
           command: build
-          args: --all --features=coconut
+          args: --workspace --features=coconut
 
       - name: Run all tests with coconut enabled
         uses: actions-rs/cargo@v1
         with:
           command: test
-          args: --all --features=coconut
+          args: --workspace --features=coconut
 
       - name: Run clippy with coconut enabled
         uses: actions-rs/cargo@v1
-        if: ${{ matrix.rust != 'nightly' }}
         with:
           command: clippy
-          args: --features=coconut -- -D warnings
+          args: --features=coconut -- -D warnings

.github/workflows/build_matrix_includes.json

@@ -10,41 +10,10 @@
     "rust":"stable",
     "runOnEvent":"pull_request"
   },
+
   {
     "os":"macos-latest",
     "rust":"stable",
     "runOnEvent":"pull_request"
-  },
-
-  {
-    "os":"ubuntu-latest",
-    "rust":"beta",
-    "runOnEvent":"pull_request"
-  },
-  {
-    "os":"windows-latest",
-    "rust":"beta",
-    "runOnEvent":"pull_request"
-  },
-  {
-    "os":"macos-latest",
-    "rust":"beta",
-    "runOnEvent":"pull_request"
-  },
-
-  {
-    "os":"ubuntu-latest",
-    "rust":"nightly",
-    "runOnEvent":"pull_request"
-  },
-  {
-    "os":"windows-latest",
-    "rust":"nightly",
-    "runOnEvent":"pull_request"
-  },
-  {
-    "os":"macos-latest",
-    "rust":"nightly",
-    "runOnEvent":"pull_request"
   }
-]
+]

.github/workflows/contracts.yml

@@ -1,4 +1,4 @@
-name: Mixnet Contract
+name: Contracts
 
 on:
   push:
@@ -21,7 +21,7 @@ jobs:
         with:
           inputFile: '.github/workflows/contract_matrix_includes.json'
           filter: '[?runOnEvent==`${{ github.event_name }}` || runOnEvent==`always`]'
-  mixnet-contract:
+  contracts:
     # since it's going to be compiled into wasm, there's absolutely
     # no point in running CI on different OS-es
     runs-on: ubuntu-latest
@@ -45,20 +45,20 @@ jobs:
           RUSTFLAGS: '-C link-arg=-s'
         with:
           command: build
-          args: --manifest-path contracts/mixnet/Cargo.toml --target wasm32-unknown-unknown
+          args: --manifest-path contracts/Cargo.toml --workspace --target wasm32-unknown-unknown
 
       - uses: actions-rs/cargo@v1
         with:
           command: test
-          args: --manifest-path contracts/mixnet/Cargo.toml
+          args: --manifest-path contracts/Cargo.toml
 
       - uses: actions-rs/cargo@v1
         with:
           command: fmt
-          args: --manifest-path contracts/mixnet/Cargo.toml -- --check
+          args: --manifest-path contracts/Cargo.toml --all -- --check
 
       - uses: actions-rs/cargo@v1
         if: ${{ matrix.rust != 'nightly' }}
         with:
           command: clippy
-          args: --manifest-path contracts/mixnet/Cargo.toml -- -D warnings
+          args: --manifest-path contracts/Cargo.toml --workspace -- -D warnings

.github/workflows/erc20_bridge_contract.yml

@@ -1,58 +0,0 @@
-name: ERC20 Bridge Contract
-
-on: [ push, pull_request ]
-
-jobs:
-  matrix_prep:
-    runs-on: ubuntu-latest
-    outputs:
-      matrix: ${{ steps.set-matrix.outputs.matrix }}
-    steps:
-      # creates the matrix strategy from build_matrix_includes.json
-      - uses: actions/checkout@v2
-      - id: set-matrix
-        uses: JoshuaTheMiller/conditional-build-matrix@main
-        with:
-          inputFile: '.github/workflows/contract_matrix_includes.json'
-          filter: '[?runOnEvent==`${{ github.event_name }}` || runOnEvent==`always`]'
-  erc20-bridge-contract:
-    needs: matrix_prep
-    strategy:
-      matrix: ${{fromJson(needs.matrix_prep.outputs.matrix)}}
-    # since it's going to be compiled into wasm, there's absolutely
-    # no point in running CI on different OS-es
-    runs-on: ubuntu-latest
-    continue-on-error: ${{ matrix.rust == 'nightly' }}
-    steps:
-      - uses: actions/checkout@v2
-
-      - uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: ${{ matrix.rust }}
-          target: wasm32-unknown-unknown
-          override: true
-          components: rustfmt, clippy
-
-      - uses: actions-rs/cargo@v1
-        env:
-          RUSTFLAGS: '-C link-arg=-s'
-        with:
-          command: build
-          args: --manifest-path contracts/erc20-bridge/Cargo.toml --target wasm32-unknown-unknown
-
-      - uses: actions-rs/cargo@v1
-        with:
-          command: test
-          args: --manifest-path contracts/erc20-bridge/Cargo.toml
-
-      - uses: actions-rs/cargo@v1
-        with:
-          command: fmt
-          args: --manifest-path contracts/erc20-bridge/Cargo.toml -- --check
-
-      - uses: actions-rs/cargo@v1
-        if: ${{ matrix.rust != 'nightly' }}
-        with:
-          command: clippy
-          args: --manifest-path contracts/erc20-bridge/Cargo.toml -- -D warnings

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

@@ -16,8 +16,9 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions/setup-node@v2
         with:
-          node-version: '14'
-      - run: npm install
+          node-version: '16'
+      - name: Setup yarn
+        run: npm install -g yarn
       - name: Run ESLint
         # GitHub should automatically annotate the PR
-        run: npm run lint
+        run: yarn && yarn lint

.github/workflows/network-explorer.yml

@@ -19,13 +19,20 @@ jobs:
     - uses: rlespinasse/github-slug-action@v3.x
     - uses: actions/setup-node@v2
       with:
-        node-version: '14'
-    - run: npm install
+        node-version: '16'
+    - name: Setup yarn
+      run: npm install -g yarn
       continue-on-error: true
-    - run: npm run test
-      continue-on-error: true
-    - run: npm run build
+    - name: Build shared packages
+      run: cd .. && yarn && yarn build
+    - name: Set environment from the example
+      run: cp .env.prod .env
+#    - run: yarn test
+#      continue-on-error: true
+    - run: yarn && yarn build
       continue-on-error: true
+    - run: yarn storybook:build
+      name: Build storybook
     - name: Deploy branch to CI www
       continue-on-error: true
       uses: easingthemes/ssh-deploy@main
@@ -37,14 +44,27 @@ jobs:
         REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
         TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/network-explorer-${{ env.GITHUB_REF_SLUG }}
         EXCLUDE: "/dist/, /node_modules/"
+    - name: Deploy storybook to CI www
+      continue-on-error: true
+      uses: easingthemes/ssh-deploy@main
+      env:
+        SSH_PRIVATE_KEY: ${{ secrets.CI_WWW_SSH_PRIVATE_KEY }}
+        ARGS: "-rltgoDzvO --delete"
+        SOURCE: "explorer/storybook-static/"
+        REMOTE_HOST: ${{ secrets.CI_WWW_REMOTE_HOST }}
+        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
       run: npm install
-      working-directory: .github/workflows/support-files/messages
+      working-directory: .github/workflows/support-files
     - name: Keybase - Send Notification
       env:
+        NYM_NOTIFICATION_KIND: network-explorer
         NYM_PROJECT_NAME: "Network Explorer"
         NYM_CI_WWW_BASE: "${{ secrets.NYM_CI_WWW_BASE }}"
         NYM_CI_WWW_LOCATION: "network-explorer-${{ env.GITHUB_REF_SLUG }}"
+        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 }}"
@@ -54,4 +74,4 @@ jobs:
         IS_SUCCESS: "${{ job.status == 'success' }}"
       uses: docker://keybaseio/client:stable-node
       with:
-        args: .github/workflows/support-files/messages/entry_point_notifications.sh
+        args: .github/workflows/support-files/notifications/entry_point.sh

.github/workflows/nightly_build.yml

@@ -0,0 +1,157 @@
+name: Nightly builds
+
+on:
+  schedule:
+    - cron: '14 4 * * *'
+jobs:
+  matrix_prep:
+    runs-on: ubuntu-latest
+    outputs:
+      matrix: ${{ steps.set-matrix.outputs.matrix }}
+    steps:
+      # creates the matrix strategy from nightly_build_matrix_includes.json
+      - uses: actions/checkout@v2
+      - id: set-matrix
+        uses: JoshuaTheMiller/conditional-build-matrix@main
+        with:
+          inputFile: '.github/workflows/nightly_build_matrix_includes.json'
+          filter: '[?runOnEvent==`${{ github.event_name }}` || runOnEvent==`always`]'
+  build:
+    needs: matrix_prep
+    strategy:
+      matrix: ${{fromJson(needs.matrix_prep.outputs.matrix)}}
+    runs-on: ${{ matrix.os }}
+    continue-on-error: ${{ matrix.rust == 'nightly' || matrix.rust == 'beta' || matrix.rust == 'stable' }}
+    steps:
+      - name: Install Dependencies (Linux)
+        run: sudo apt-get update && sudo apt-get install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev squashfs-tools
+        if: matrix.os == 'ubuntu-latest'
+
+      - name: Check out repository code
+        uses: actions/checkout@v2
+
+      - name: Install rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: ${{ matrix.rust }}
+          override: true
+          components: rustfmt, clippy
+
+      - name: Build all binaries
+        uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: --workspace
+
+      - name: Run all tests
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --workspace
+
+      - name: Check formatting
+        uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: --all -- --check
+
+      - name: Reclaim some disk space (because Windows is being annoying)
+        uses: actions-rs/cargo@v1
+        if: ${{ matrix.os == 'windows-latest' }}
+        with:
+          command: clean
+
+      - uses: actions-rs/clippy-check@v1
+        name: Clippy checks
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          args: --all-features
+
+      - name: Run clippy
+        uses: actions-rs/cargo@v1
+        if: ${{ matrix.rust != 'nightly' }}
+        with:
+          command: clippy
+          args: --workspace --all-targets -- -D warnings
+
+      # COCONUT stuff
+      - name: Build all binaries with coconut enabled
+        uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: --workspace --features=coconut
+
+      - name: Run all tests with coconut enabled
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --workspace --features=coconut
+
+      - name: Reclaim some disk space (because Windows is being annoying)
+        uses: actions-rs/cargo@v1
+        if: ${{ matrix.os == 'windows-latest' }}
+        with:
+          command: clean
+
+      - name: Run clippy with coconut enabled
+        uses: actions-rs/cargo@v1
+        if: ${{ matrix.rust != 'nightly' }}
+        with:
+          command: clippy
+          args: --workspace --all-targets --features=coconut -- -D warnings
+
+      # nym-wallet (the rust part)
+      - name: Build nym-wallet rust code
+        uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: --manifest-path nym-wallet/Cargo.toml --workspace
+
+      - name: Run nym-wallet tests
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --manifest-path nym-wallet/Cargo.toml --workspace
+
+      - name: Check nym-wallet formatting
+        uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: --manifest-path nym-wallet/Cargo.toml --all -- --check
+
+      - name: Run clippy for nym-wallet
+        uses: actions-rs/cargo@v1
+        if: ${{ matrix.rust != 'nightly' }}
+        with:
+          command: clippy
+          args: --manifest-path nym-wallet/Cargo.toml --workspace --all-targets -- -D warnings
+
+  notification:
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - name: Collect jobs status
+        uses: technote-space/workflow-conclusion-action@v2
+      - name: Check out repository code
+        uses: actions/checkout@v2
+      - name: Keybase - Node Install
+        if: env.WORKFLOW_CONCLUSION == 'failure'
+        run: npm install
+        working-directory: .github/workflows/support-files
+      - name: Keybase - Send Notification
+        if: env.WORKFLOW_CONCLUSION == 'failure'
+        env:
+          NYM_NOTIFICATION_KIND: nightly
+          NYM_PROJECT_NAME: "Nym nightly build"
+          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' }}"
+        uses: docker://keybaseio/client:stable-node
+        with:
+          args: .github/workflows/support-files/notifications/entry_point.sh

.github/workflows/nightly_build_matrix_includes.json

@@ -0,0 +1,50 @@
+[
+  {
+    "os":"ubuntu-latest",
+    "rust":"stable",
+    "runOnEvent":"schedule"
+  },
+
+  {
+    "os":"windows-latest",
+    "rust":"stable",
+    "runOnEvent":"schedule"
+  },
+  {
+    "os":"macos-latest",
+    "rust":"stable",
+    "runOnEvent":"schedule"
+  },
+
+  {
+    "os":"ubuntu-latest",
+    "rust":"beta",
+    "runOnEvent":"schedule"
+  },
+  {
+    "os":"windows-latest",
+    "rust":"beta",
+    "runOnEvent":"schedule"
+  },
+  {
+    "os":"macos-latest",
+    "rust":"beta",
+    "runOnEvent":"schedule"
+  },
+
+  {
+    "os":"ubuntu-latest",
+    "rust":"nightly",
+    "runOnEvent":"schedule"
+  },
+  {
+    "os":"windows-latest",
+    "rust":"nightly",
+    "runOnEvent":"schedule"
+  },
+  {
+    "os":"macos-latest",
+    "rust":"nightly",
+    "runOnEvent":"schedule"
+  }
+]

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

@@ -0,0 +1,47 @@
+name: Publish Nym binaries
+on:
+  release:
+    types: [created]
+    
+env:
+  NETWORK: mainnet    
+
+jobs:
+  publish-nym:
+    strategy:
+      fail-fast: false
+      matrix:
+        platform: [ubuntu-latest]
+
+    runs-on: ${{ matrix.platform }}
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Check the release tag starts with `nym-binaries-`
+        if: startsWith(github.ref, 'refs/tags/nym-binaries-') == false
+        uses: actions/github-script@v3
+        with:
+          script: |
+            core.setFailed('Release tag did not start with nym-binaries-...')
+
+      - name: Install Rust stable
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+
+      - name: Build all binaries
+        uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: --workspace --release
+
+      - name: Upload to release based on tag name
+        uses: softprops/action-gh-release@v1
+        with:
+          files: |
+            target/release/nym-client
+            target/release/nym-gateway
+            target/release/nym-mixnode
+            target/release/nym-socks5-client
+            target/release/nym-validator-api
+            target/release/nym-network-requester

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

@@ -0,0 +1,81 @@
+name: Publish Nym Wallet (MacOS)
+on:
+  release:
+    types: [created]
+
+defaults:
+  run:
+    working-directory: nym-wallet
+
+jobs:
+  publish-tauri:
+    strategy:
+      fail-fast: false
+      matrix:
+        platform: [macos-latest]
+
+    runs-on: ${{ matrix.platform }}
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Check the release tag starts with `nym-wallet-`
+        if: startsWith(github.ref, 'refs/tags/nym-wallet-') == false
+        uses: actions/github-script@v3
+        with:
+          script: |
+            core.setFailed('Release tag did not start with nym-wallet-...')
+
+      - name: Node v16
+        uses: actions/setup-node@v1
+        with:
+          node-version: 16.x
+      - name: Install Rust stable
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+      - name: Install the Apple developer certificate for code signing
+        env:
+          APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
+          APPLE_CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
+          KEYCHAIN_PASSWORD: ${{ secrets.KEYCHAIN_PASSWORD }}
+        run: |
+          # create variables
+          CERTIFICATE_PATH=$RUNNER_TEMP/build_certificate.p12
+          KEYCHAIN_PATH=$RUNNER_TEMP/app-signing.keychain-db
+
+          # import certificate and provisioning profile from secrets
+          echo -n "$APPLE_CERTIFICATE" | base64 --decode --output $CERTIFICATE_PATH
+
+          # create temporary keychain
+          security create-keychain -p "$KEYCHAIN_PASSWORD" $KEYCHAIN_PATH
+          security set-keychain-settings -lut 21600 $KEYCHAIN_PATH
+          security unlock-keychain -p "$KEYCHAIN_PASSWORD" $KEYCHAIN_PATH
+
+          # import certificate to keychain
+          security import $CERTIFICATE_PATH -P "$APPLE_CERTIFICATE_PASSWORD" -A -t cert -f pkcs12 -k $KEYCHAIN_PATH
+          security list-keychain -d user -s $KEYCHAIN_PATH
+
+      - name: Install app dependencies and build it
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          ENABLE_CODE_SIGNING: ${{ secrets.APPLE_CERTIFICATE }}
+          APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
+          APPLE_CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
+          APPLE_SIGNING_IDENTITY: ${{ secrets.APPLE_IDENTITY_ID }}
+          APPLE_ID: ${{ secrets.APPLE_ID }}
+          APPLE_PASSWORD: ${{ secrets.APPLE_PASSWORD }}
+          TAURI_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
+          TAURI_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
+        run: yarn && yarn build
+
+      - name: Upload to release based on tag name
+        uses: softprops/action-gh-release@v1
+        with:
+          files: |
+            nym-wallet/target/release/bundle/dmg/*.dmg
+            nym-wallet/target/release/bundle/macos/*.app.tar.gz*
+
+      - name: Clean up keychain
+        if: ${{ always() }}
+        run: |
+          security delete-keychain $RUNNER_TEMP/app-signing.keychain-db

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

@@ -0,0 +1,52 @@
+name: Publish Nym Wallet (Ubuntu)
+on:
+  release:
+    types: [created]
+
+defaults:
+  run:
+    working-directory: nym-wallet
+
+jobs:
+  publish-tauri:
+    strategy:
+      fail-fast: false
+      matrix:
+        platform: [ubuntu-latest]
+
+    runs-on: ${{ matrix.platform }}
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Tauri dependencies
+        run: >
+          sudo apt-get update &&
+          sudo apt-get install -y webkit2gtk-4.0
+      - name: Check the release tag starts with `nym-wallet-`
+        if: startsWith(github.ref, 'refs/tags/nym-wallet-') == false
+        uses: actions/github-script@v3
+        with:
+          script: |
+            core.setFailed('Release tag did not start with nym-wallet-...')
+
+      - name: Node v16
+        uses: actions/setup-node@v1
+        with:
+          node-version: 16.x
+      - name: Install Rust stable
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+      - name: Install app dependencies
+        run: yarn
+      - name: Build app
+        run: yarn build
+        env:
+          TAURI_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
+          TAURI_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
+      - name: Upload to release based on tag name
+        uses: softprops/action-gh-release@v1
+        with:
+          files: |
+            nym-wallet/target/release/bundle/appimage/*.AppImage
+            nym-wallet/target/release/bundle/appimage/*.AppImage.tar.gz*

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

@@ -0,0 +1,75 @@
+name: Publish Nym Wallet (Windows 10)
+on:
+  release:
+    types: [created]
+
+defaults:
+  run:
+    working-directory: nym-wallet
+
+jobs:
+  publish-tauri:
+    strategy:
+      fail-fast: false
+      matrix:
+        platform: [windows10]
+
+    runs-on: ${{ matrix.platform }}
+    steps:
+      - name: Clean up first
+        continue-on-error: true
+        working-directory: .
+        run: |
+          cd ..
+          del /s /q /A:H nym
+          rmdir /s /q nym
+
+      - uses: actions/checkout@v3
+
+      - name: Check the release tag starts with `nym-wallet-`
+        if: startsWith(github.ref, 'refs/tags/nym-wallet-') == false
+        uses: actions/github-script@v3
+        with:
+          script: |
+            core.setFailed('Release tag did not start with nym-wallet-...')
+
+      - name: Import signing certificate
+        env:
+          WINDOWS_CERTIFICATE: ${{ secrets.WINDOWS_CERTIFICATE }}
+          WINDOWS_CERTIFICATE_PASSWORD: ${{ secrets.WINDOWS_CERTIFICATE_PASSWORD }}
+        run: |
+          New-Item -ItemType directory -Path certificate
+          Set-Content -Path certificate/tempCert.txt -Value $env:WINDOWS_CERTIFICATE
+          certutil -decode certificate/tempCert.txt certificate/certificate.pfx
+          Remove-Item -path certificate -include tempCert.txt
+          Import-PfxCertificate -FilePath certificate/certificate.pfx -CertStoreLocation Cert:\CurrentUser\My -Password (ConvertTo-SecureString -String $env:WINDOWS_CERTIFICATE_PASSWORD -Force -AsPlainText)
+
+      - name: Node v16
+        uses: actions/setup-node@v1
+        with:
+          node-version: 16.x
+
+      - name: Install Rust stable
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+
+      - name: Install app dependencies
+        run: yarn
+
+      - name: Build and sign it
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          ENABLE_CODE_SIGNING: ${{ secrets.WINDOWS_CERTIFICATE }}
+          WINDOWS_CERTIFICATE: ${{ secrets.WINDOWS_CERTIFICATE }}
+          WINDOWS_CERTIFICATE_PASSWORD: ${{ secrets.WINDOWS_CERTIFICATE_PASSWORD }}
+          TAURI_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
+          TAURI_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
+        run: yarn build
+
+      - name: Upload to release based on tag name
+        uses: softprops/action-gh-release@v1
+        with:
+          files: |
+            nym-wallet/target/release/bundle/msi/*.msi
+            nym-wallet/target/release/bundle/msi/*.msi.zip*

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

@@ -0,0 +1,55 @@
+name: Nym Wallet Storybook
+
+on:
+  push:
+    paths:
+      - 'nym-wallet/**'
+
+jobs:
+  build:
+    runs-on: custom-runner-linux
+    steps:
+    - uses: actions/checkout@v2
+    - name: Install rsync
+      run: sudo apt-get install rsync
+    - uses: rlespinasse/github-slug-action@v3.x
+    - uses: actions/setup-node@v2
+      with:
+        node-version: '16'
+    - name: Setup yarn
+      run: npm install -g yarn
+    - name: Build dependencies
+      run: yarn && yarn build
+    - name: Build storybook
+      run: yarn storybook:build
+      working-directory: ./nym-wallet
+    - name: Deploy branch to CI www (storybook)
+      continue-on-error: true
+      uses: easingthemes/ssh-deploy@main
+      env:
+        SSH_PRIVATE_KEY: ${{ secrets.CI_WWW_SSH_PRIVATE_KEY }}
+        ARGS: "-rltgoDzvO --delete"
+        SOURCE: "nym-wallet/storybook-static/"
+        REMOTE_HOST: ${{ secrets.CI_WWW_REMOTE_HOST }}
+        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
+      run: npm install
+      working-directory: .github/workflows/support-files
+    - name: Keybase - Send Notification
+      env:
+        NYM_NOTIFICATION_KIND: nym-wallet
+        NYM_PROJECT_NAME: "nym-wallet"
+        NYM_CI_WWW_BASE: "${{ secrets.NYM_CI_WWW_BASE }}"
+        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' }}"
+      uses: docker://keybaseio/client:stable-node
+      with:
+        args: .github/workflows/support-files/notifications/entry_point.sh

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

@@ -0,0 +1,35 @@
+KEYBASE_NYM_CHANNEL=
+KEYBASE_NYMBOT_USERNAME=
+KEYBASE_NYMBOT_PAPERKEY=
+
+NYM_NOTIFICATION_KIND=nightly
+NYM_PROJECT_NAME=Nightly Build
+
+#----------------------------------------------------------------
+# Custom GitHub Actions mock env vars
+IS_SUCCESS=true
+
+#----------------------------------------------------------------
+# GitHub Actions context mock env vars
+GITHUB_SHA=abcdef
+GITHUB_RUN_ID=123456
+GITHUB_REPOSITORY=nymtech/nym
+GITHUB_SERVER_URL=https://github.com
+GIT_BRANCH_NAME=feature/testing-support-files
+GIT_BRANCH=feature/testing-support-files
+GIT_COMMIT_MESSAGE=This is the commit message
+GITHUB_ACTOR=octocat
+
+# add a Personal Access Token (PAT) generated from GitHub here for use in testing
+GITHUB_TOKEN=
+
+#----------------------------------------------------------------
+# Network Explorer
+NYM_CI_WWW_LOCATION=some-branch
+NYM_CI_WWW_BASE=example.com
+
+#----------------------------------------------------------------
+# Nightly builds
+WORKFLOW_CONCLUSION=success
+
+SHOW_DEBUG=true

.github/workflows/support-files/.gitignore

@@ -0,0 +1,5 @@
+node_modules
+.idea
+
+# don't commit the lock file to avoid cross-platform issues
+package-lock.json

.github/workflows/support-files/.nvmrc

@@ -0,0 +1 @@
+16

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

@@ -0,0 +1,58 @@
+# GitHub Actions Support Files
+
+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.
+
+### Adding notifications to a GitHub Action
+
+```
+jobs:
+  build:
+    ...
+    - name: Notifications - Node Install
+      run: npm install
+      working-directory: .github/workflows/support-files/notifications
+    - name: Notifications - Send
+      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"
+        IS_SUCCESS: "${{ job.status == 'success' }}"
+      uses: docker://keybaseio/client:stable-node
+      with:
+        args: .github/workflows/support-files/notifications/entry_point.sh
+```
+
+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` 
+
+### Running locally
+
+You will need:
+- Node 16 LTS
+- npm
+
+Copy `.github/workflows/support-files/.env.example` to `.github/workflows/support-files/.env` and valid Keybase credentials.
+
+Then run `npm install` to get dependencies.
+
+Start development mode for the notification type you want either by passing the value as an env var called `NYM_NOTIFICATION_KIND` or set the `.env` file values correctly.
+
+```bash
+cd .github/workflows/support-files
+npm install
+cp .env.example .env
+vi .env
+npm run dev
+```

.github/workflows/support-files/dev.js

@@ -0,0 +1 @@
+require('./notifications/send_message');

.github/workflows/support-files/messages/.gitignore

@@ -1,2 +0,0 @@
-node_modules
-.idea

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

@@ -1,69 +0,0 @@
-const Bot = require('keybase-bot');
-const Handlebars = require('handlebars');
-const fs = require('fs');
-
-async function main() {
-  const data = { env: process.env };
-  // const data = { ...PASTE TEST DATA HERE ... }; // -- DEV: uncomment to set test data
-
-  // validation of environment
-  if(!(process.env.NYM_PROJECT_NAME || data.env.NYM_PROJECT_NAME)) {
-    throw new Error('Please set env var NYM_PROJECT_NAME with the project name for displaying in notification messages');
-  }
-  const keybaseChannel = process.env.KEYBASE_NYM_CHANNEL || data.env.KEYBASE_NYM_CHANNEL;
-  if(!keybaseChannel) {
-    throw new Error('Please set env var KEYBASE_NYM_CHANNEL with the channel name for the notification message');
-  }
-
-  // extract the git branch name
-  const GIT_BRANCH_NAME = (process.env.GITHUB_REF || data.env.GITHUB_REF).split('/').slice(2).join('/');
-
-  data.env.GIT_BRANCH_NAME = GIT_BRANCH_NAME;
-  const source = fs
-    .readFileSync(process.env.IS_SUCCESS === 'true' ? 'success' : 'failure')
-    .toString();
-  const template = Handlebars.compile(source);
-  const result = template(data);
-
-  // -- DEV: uncomment to show what is available in the handlebars template / show the result
-  // console.dir({ data }, { depth: null });
-  // console.log(result);
-
-  const bot = new Bot();
-  try {
-    const username = process.env.KEYBASE_NYMBOT_USERNAME;
-    const paperkey = process.env.KEYBASE_NYMBOT_PAPERKEY;
-
-    if(!username) {
-      throw new Error('Username is not defined. Please set env var KEYBASE_NYMBOT_USERNAME');
-    }
-    if(!paperkey) {
-      throw new Error('Paperkey is not defined. Please set env var KEYBASE_NYMBOT_PAPERKEY');
-    }
-
-    console.log(`Initialising keybase with user "${username}" and key: "${'*'.repeat(paperkey.length)}"...`);
-    await bot.init(username, paperkey, { verbose: false });
-
-    const channel = {
-      name: 'nymtech_bot',
-      membersType: 'team',
-      topicName: keybaseChannel,
-      topic_type: 'CHAT',
-    };
-    const message = {
-      body: result,
-    };
-
-    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();
-  }
-}
-
-main();

.github/workflows/support-files/network-explorer/index.js

@@ -0,0 +1,29 @@
+const Handlebars = require('handlebars');
+const fs = require('fs');
+const path = require('path');
+
+async function addToContextAndValidate(context) {
+  if (!context.env.NYM_CI_WWW_LOCATION) {
+    throw new Error('Please ensure the env var NYM_CI_WWW_LOCATION is set');
+  }
+  if (!context.env.NYM_CI_WWW_BASE) {
+    throw new Error('Please ensure the env var NYM_CI_WWW_BASE is set');
+  }
+}
+
+async function getMessageBody(context) {
+  const source = fs
+    .readFileSync(
+      context.env.IS_SUCCESS === 'true'
+        ? path.resolve(__dirname, 'templates', 'success')
+        : path.resolve(__dirname, 'templates', 'failure'),
+    )
+    .toString();
+  const template = Handlebars.compile(source);
+  return template(context);
+}
+
+module.exports = {
+  addToContextAndValidate,
+  getMessageBody,
+};

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

@@ -1,11 +1,12 @@
 🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩
 > :rocket: {{ env.NYM_PROJECT_NAME }}  ➡️➡️➡️➡️➡️ **View output:** https://{{ env.NYM_CI_WWW_LOCATION }}.{{ env.NYM_CI_WWW_BASE }}/
+> `storybook`: https://{{ env.NYM_CI_WWW_LOCATION_STORYBOOK }}.{{ env.NYM_CI_WWW_BASE }}
 > ✅ **SUCCESS**
 > `branch` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/tree/{{ env.GIT_BRANCH_NAME }}
 > `commit` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/commit/{{ env.GITHUB_SHA }}
 > `build ` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/actions/runs/{{ env.GITHUB_RUN_ID }}
 
-Commit message:
+Commit message by `{{ env.GITHUB_ACTOR }}` at {{ timestamp }}:
 ```
 {{ env.GIT_COMMIT_MESSAGE }}
 ```

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

@@ -0,0 +1,162 @@
+const Handlebars = require('handlebars');
+const fs = require('fs');
+const path = require('path');
+const { Octokit, App } = require('octokit');
+
+async function addToContextAndValidate(context) {
+  if (!context.env.WORKFLOW_CONCLUSION) {
+    throw new Error('Please ensure the env var WORKFLOW_CONCLUSION is set');
+  }
+  if (!context.env.GITHUB_TOKEN) {
+    throw new Error('Please ensure the env var GITHUB_TOKEN is set');
+  }
+  if (!context.env.GITHUB_RUN_ID) {
+    throw new Error('Please ensure the env var GITHUB_RUN_ID is set');
+  }
+  if (!context.env.GITHUB_REPOSITORY) {
+    throw new Error('Please ensure the env var GITHUB_REPOSITORY is set');
+  }
+}
+
+async function getMessageBody(context) {
+  const source = fs
+    .readFileSync(
+      context.env.WORKFLOW_CONCLUSION === 'success'
+        ? path.resolve(__dirname, 'templates', 'success')
+        : path.resolve(__dirname, 'templates', 'failure'),
+    )
+    .toString();
+  const template = Handlebars.compile(source);
+
+  // get job details from GitHub API
+  const octokit = new Octokit({ auth: context.env.GITHUB_TOKEN });
+  const [owner, repo] = context.env.GITHUB_REPOSITORY.split('/');
+  const {
+    data: { jobs },
+  } = await octokit.rest.actions.listJobsForWorkflowRun({
+    run_id: context.env.GITHUB_RUN_ID,
+    owner,
+    repo,
+  });
+
+  // uncomment this to see what is available for each job
+  if(process.env.SHOW_DEBUG) {
+    console.dir(jobs, { depth: null });
+  }
+
+  /*
+
+   a sample of the response is:
+
+    {
+      total_count: 10,
+      jobs: [
+        {
+          id: 5182940024,
+          run_id: 1840752095,
+          run_url: 'https://api.github.com/repos/nymtech/nym/actions/runs/1840752095',
+          run_attempt: 1,
+          node_id: 'CR_kwDODdjOis8AAAABNO1jeA',
+          head_sha: 'aa00eb70d57751bfa556bd3602df87c7473367fc',
+          url: 'https://api.github.com/repos/nymtech/nym/actions/jobs/5182940024',
+          html_url: 'https://github.com/nymtech/nym/runs/5182940024?check_suite_focus=true',
+          status: 'completed',
+          conclusion: 'success',
+          started_at: '2022-02-14T11:28:34Z',
+          completed_at: '2022-02-14T11:28:38Z',
+          name: 'matrix_prep',
+          steps: [
+            {
+              name: 'Set up job',
+              status: 'completed',
+              conclusion: 'success',
+              number: 1,
+              started_at: '2022-02-14T13:28:34.000+02:00',
+              completed_at: '2022-02-14T13:28:36.000+02:00'
+            },
+            {
+              name: 'Run actions/checkout@v2',
+              status: 'completed',
+              conclusion: 'success',
+              number: 2,
+              started_at: '2022-02-14T13:28:36.000+02:00',
+              completed_at: '2022-02-14T13:28:37.000+02:00'
+            },
+            ...
+          ],
+          check_run_url: 'https://api.github.com/repos/nymtech/nym/check-runs/5182940024',
+          labels: [ 'ubuntu-latest' ],
+          runner_id: 1,
+          runner_name: 'Hosted Agent',
+          runner_group_id: 2,
+          runner_group_name: 'GitHub Actions'
+        },
+        {
+          id: 5182943473,
+          run_id: 1840752095,
+          run_url: 'https://api.github.com/repos/nymtech/nym/actions/runs/1840752095',
+          run_attempt: 1,
+          node_id: 'CR_kwDODdjOis8AAAABNO1w8Q',
+          head_sha: 'aa00eb70d57751bfa556bd3602df87c7473367fc',
+          url: 'https://api.github.com/repos/nymtech/nym/actions/jobs/5182943473',
+          html_url: 'https://github.com/nymtech/nym/runs/5182943473?check_suite_focus=true',
+          status: 'completed',
+          conclusion: 'failure',
+          started_at: '2022-02-14T11:29:04Z',
+          completed_at: '2022-02-14T11:55:45Z',
+          name: 'build (macos-latest, stable, schedule)',
+          steps: [
+            {
+              name: 'Set up job',
+              status: 'completed',
+              conclusion: 'success',
+              number: 1,
+              started_at: '2022-02-14T13:29:04.000+02:00',
+              completed_at: '2022-02-14T13:29:26.000+02:00'
+            },
+            {
+              name: 'Install Dependencies (Linux)',
+              status: 'completed',
+              conclusion: 'skipped',
+              number: 2,
+              started_at: '2022-02-14T13:29:26.000+02:00',
+              completed_at: '2022-02-14T13:29:26.000+02:00'
+            },
+            {
+              name: 'Keybase - Send Notification',
+              status: 'completed',
+              conclusion: 'failure',
+              number: 15,
+              started_at: '2022-02-14T13:55:44.000+02:00',
+              completed_at: '2022-02-14T13:55:44.000+02:00'
+            },
+          ],
+          check_run_url: 'https://api.github.com/repos/nymtech/nym/check-runs/5182943473',
+          labels: [ 'macos-latest' ],
+          runner_id: 4,
+          runner_name: 'GitHub Actions 4',
+          runner_group_id: 2,
+          runner_group_name: 'GitHub Actions'
+        },
+        ...
+      ]
+    }
+   */
+
+  const jobResults = jobs
+    .map((job) => {
+      const icon = job.conclusion === 'success' ? '🟩' : '🟥';
+
+      // each job is converted into formatted markdown text
+      return `${icon} ${job.conclusion}: ${job.name} - ${job.html_url}`;
+    })
+    // and join with newlines for display in the template
+    .join('\n');
+
+  return template({ ...context, jobResults });
+}
+
+module.exports = {
+  addToContextAndValidate,
+  getMessageBody,
+};

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

@@ -0,0 +1,9 @@
+🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥
+> :rocket: {{ env.NYM_PROJECT_NAME }}
+> 🔴 **FAILURE** :cry:
+> `when` {{ timestamp }}
+> `branch` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/tree/{{ env.GIT_BRANCH_NAME }}
+> `commit` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/commit/{{ env.GITHUB_SHA }}
+> `build ` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/actions/runs/{{ env.GITHUB_RUN_ID }}
+
+{{ jobResults }}

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

@@ -0,0 +1,9 @@
+🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩
+> :rocket: {{ env.NYM_PROJECT_NAME }}
+> ✅ **SUCCESS**
+> `when` {{ timestamp }}
+> `branch` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/tree/{{ env.GIT_BRANCH_NAME }}
+> `commit` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/commit/{{ env.GITHUB_SHA }}
+> `build ` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/actions/runs/{{ env.GITHUB_RUN_ID }}
+
+{{ jobResults }}

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

@@ -0,0 +1,153 @@
+require('dotenv').config();
+
+const Bot = require('keybase-bot');
+
+let context = {
+  kinds: ['nym-wallet', 'ts-packages', 'network-explorer', 'nightly'],
+};
+
+/**
+ * Validate that all required env and context vars are available
+ */
+function validateContext() {
+  if (!context.env.NYM_NOTIFICATION_KIND) {
+    throw new Error(
+      'Please set env var NYM_NOTIFICATION_KIND with the project kind that matches a directory in ".github/workflows/support-files"',
+    );
+  }
+  if (!context.kinds.includes(context.env.NYM_NOTIFICATION_KIND)) {
+    throw new Error(`Env var NYM_NOTIFICATION_KIND is not in ${context.kinds}`);
+  }
+  if (!context.env.NYM_PROJECT_NAME) {
+    throw new Error(
+      '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',
+    );
+  }
+}
+
+/**
+ * Creates a context that will be available in the templates for rendering notifications
+ */
+function createTemplateContext() {
+  const options = { dateStyle: 'full', timeStyle: 'long' };
+  context.timestamp = new Date().toLocaleString(undefined, options);
+
+  // add environment to template context and validate
+  context.env = process.env;
+  try {
+    validateContext();
+  } catch (e) {
+    if(process.env.SHOW_DEBUG) {
+      // recursively print the context for easy debugging and rethrow the error
+      console.dir({ context }, { depth: null });
+    }
+    throw e;
+  }
+
+  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)
+      .join('/');
+  }
+
+  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: '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
+ */
+async function processKindScript() {
+  const script = require(`../${context.kind}`);
+  if (!script.addToContextAndValidate) {
+    throw new Error(
+      `"./${context.kind}/index.js" does not export a method called "async addToContextAndValidate(context)"`,
+    );
+  }
+  if (!script.getMessageBody) {
+    throw new Error(
+      `"./${context.kind}/index.js" does not export a method called "async getMessageBody(context)"`,
+    );
+  }
+
+  // call the script to modify and validate the context
+  await script.addToContextAndValidate(context);
+
+  // let the script create a message body and return the result as a string for sending
+  return await script.getMessageBody(context);
+}
+
+/**
+ * The main function, as async so that await syntax is available
+ */
+async function main() {
+  createTemplateContext();
+  console.log(`Sending notification for kind "${context.kind}"...`);
+  const messageBody = await processKindScript();
+  if(process.env.SHOW_DEBUG) {
+    console.log('-----------------------------------------');
+    console.log(messageBody);
+    console.log('-----------------------------------------');
+  }
+  await sendKeybaseMessage(messageBody);
+}
+
+// call main function and let NodeJS handle the promise
+main();

.github/workflows/support-files/nym-wallet/index.js

@@ -0,0 +1,29 @@
+const Handlebars = require('handlebars');
+const fs = require('fs');
+const path = require('path');
+
+async function addToContextAndValidate(context) {
+  if (!context.env.NYM_CI_WWW_LOCATION) {
+    throw new Error('Please ensure the env var NYM_CI_WWW_LOCATION is set');
+  }
+  if (!context.env.NYM_CI_WWW_BASE) {
+    throw new Error('Please ensure the env var NYM_CI_WWW_BASE is set');
+  }
+}
+
+async function getMessageBody(context) {
+  const source = fs
+    .readFileSync(
+      context.env.IS_SUCCESS === 'true'
+        ? path.resolve(__dirname, 'templates', 'success')
+        : path.resolve(__dirname, 'templates', 'failure'),
+    )
+    .toString();
+  const template = Handlebars.compile(source);
+  return template(context);
+}
+
+module.exports = {
+  addToContextAndValidate,
+  getMessageBody,
+};

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

@@ -0,0 +1,11 @@
+🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥
+> :rocket: {{ env.NYM_PROJECT_NAME }}
+> 🔴 **FAILURE** :cry:
+> `branch` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/tree/{{ env.GIT_BRANCH_NAME }}
+> `commit` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/commit/{{ env.GITHUB_SHA }}
+> `build ` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/actions/runs/{{ env.GITHUB_RUN_ID }}
+
+Commit message:
+```
+{{ env.GIT_COMMIT_MESSAGE }}
+```

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

@@ -0,0 +1,15 @@
+🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩
+> :rocket: {{ env.NYM_PROJECT_NAME }}
+> ✅ **SUCCESS**
+
+> ➡️➡️➡️➡️➡️ **View output:**
+> `storybook`: https://{{ env.NYM_CI_WWW_LOCATION }}.{{ env.NYM_CI_WWW_BASE }}
+
+> `branch` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/tree/{{ env.GIT_BRANCH_NAME }}
+> `commit` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/commit/{{ env.GITHUB_SHA }}
+> `build ` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/actions/runs/{{ env.GITHUB_RUN_ID }}
+
+Commit message by `{{ env.GITHUB_ACTOR }}` at {{ timestamp }}:
+```
+{{ env.GIT_COMMIT_MESSAGE }}
+```

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

@@ -4,11 +4,14 @@
   "version": "1.0.0",
   "private": true,
   "scripts": {
-    "format": "prettier --write send_message.js"
+    "dev": "node dev.js",
+    "format": "prettier --write **/*.js"
   },
   "dependencies": {
+    "dotenv": "^16.0.0",
     "handlebars": "^4.7.7",
-    "keybase-bot": "^3.6.1"
+    "keybase-bot": "^3.6.1",
+    "octokit": "^1.7.1"
   },
   "devDependencies": {
     "prettier": "2.3.2"

.github/workflows/support-files/ts-packages/index.js

@@ -0,0 +1,29 @@
+const Handlebars = require('handlebars');
+const fs = require('fs');
+const path = require('path');
+
+async function addToContextAndValidate(context) {
+  if (!context.env.NYM_CI_WWW_LOCATION) {
+    throw new Error('Please ensure the env var NYM_CI_WWW_LOCATION is set');
+  }
+  if (!context.env.NYM_CI_WWW_BASE) {
+    throw new Error('Please ensure the env var NYM_CI_WWW_BASE is set');
+  }
+}
+
+async function getMessageBody(context) {
+  const source = fs
+    .readFileSync(
+      context.env.IS_SUCCESS === 'true'
+        ? path.resolve(__dirname, 'templates', 'success')
+        : path.resolve(__dirname, 'templates', 'failure'),
+    )
+    .toString();
+  const template = Handlebars.compile(source);
+  return template(context);
+}
+
+module.exports = {
+  addToContextAndValidate,
+  getMessageBody,
+};

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

@@ -0,0 +1,11 @@
+🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥
+> :rocket: {{ env.NYM_PROJECT_NAME }}
+> 🔴 **FAILURE** :cry:
+> `branch` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/tree/{{ env.GIT_BRANCH_NAME }}
+> `commit` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/commit/{{ env.GITHUB_SHA }}
+> `build ` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/actions/runs/{{ env.GITHUB_RUN_ID }}
+
+Commit message:
+```
+{{ env.GIT_COMMIT_MESSAGE }}
+```

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

@@ -0,0 +1,16 @@
+🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩
+> :rocket: {{ env.NYM_PROJECT_NAME }}
+> ✅ **SUCCESS**
+
+> ➡️➡️➡️➡️➡️ **View output:**
+> `storybook`: https://{{ env.NYM_CI_WWW_LOCATION }}.{{ env.NYM_CI_WWW_BASE }}
+> `example`: https://{{ env.NYM_CI_WWW_LOCATION }}-example.{{ env.NYM_CI_WWW_BASE }}
+
+> `branch` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/tree/{{ env.GIT_BRANCH_NAME }}
+> `commit` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/commit/{{ env.GITHUB_SHA }}
+> `build ` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/actions/runs/{{ env.GITHUB_RUN_ID }}
+
+Commit message by `{{ env.GITHUB_ACTOR }}` at {{ timestamp }}:
+```
+{{ env.GIT_COMMIT_MESSAGE }}
+```

.github/workflows/tauri-wallet-publish.yml

@@ -1,12 +0,0 @@
-name: Publish Tauri Wallet
-on:
-  push:
-    tags:
-      - nym-wallet-*
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Run a one-line script
-        run: echo Hello, world!

.github/workflows/tauri-wallet-types.yml

@@ -1,29 +0,0 @@
-name: Generate TS types
-
-on:
-  push:
-    paths-ignore:
-      - "explorer/**"
-  pull_request:
-    paths-ignore:
-      - "explorer/**"
-
-jobs:
-  nym-wallet-types:
-    runs-on: ubuntu-latest
-    if: ${{ github.event_name != 'pull_request' }}
-    steps:
-      - name: Prepare
-        run: sudo apt-get update && sudo apt-get install -y libpango1.0-dev libatk1.0-dev libgdk-pixbuf2.0-dev libsoup2.4-dev librust-gdk-dev libwebkit2gtk-4.0-dev
-      - uses: actions/checkout@v2
-      - uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-      - name: Generate TS
-        run: cd nym-wallet/src-tauri && cargo test
-      - uses: EndBug/add-and-commit@v7.2.1 # https://github.com/marketplace/actions/add-commit
-        with:
-          add: '["nym-wallet"]'
-          message: "[ci skip] Generate TS types"
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/wallet.yml

@@ -0,0 +1,57 @@
+name: Nym Wallet (rust)
+
+on:
+  push:
+    paths-ignore:
+      - 'explorer/**'
+  pull_request:
+    paths-ignore:
+      - 'explorer/**'
+
+jobs:
+  build:
+    runs-on: [ self-hosted, custom-linux-exoscale ]
+    steps:
+      - name: Install Dependencies (Linux)
+        run: sudo apt-get update && sudo apt-get -y install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev squashfs-tools
+
+      - name: Check out repository code
+        uses: actions/checkout@v2
+
+      - name: Install rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: stable
+          override: true
+          components: rustfmt, clippy
+
+      - name: Build all binaries
+        uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: --manifest-path nym-wallet/Cargo.toml --workspace
+
+      - name: Run all tests
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --manifest-path nym-wallet/Cargo.toml --workspace
+
+      - name: Check formatting
+        uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: --manifest-path nym-wallet/Cargo.toml --all -- --check
+
+      - uses: actions-rs/clippy-check@v1
+        name: Clippy checks
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          args: --manifest-path nym-wallet/Cargo.toml --workspace --all-features
+
+      - name: Run clippy
+        uses: actions-rs/cargo@v1
+        with:
+          command: clippy
+          args: --manifest-path nym-wallet/Cargo.toml --workspace --all-features -- -D warnings

.github/workflows/wasm_client_build.yml

@@ -19,30 +19,27 @@ jobs:
           override: true
           components: rustfmt, clippy
 
-# token credentials (non-coconut) don't work for wasm right now
-#      - uses: actions-rs/cargo@v1
-#        with:
-#          command: build
-#          args: --manifest-path clients/webassembly/Cargo.toml --target wasm32-unknown-unknown
+      - uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: --manifest-path clients/webassembly/Cargo.toml --target wasm32-unknown-unknown
 
       - uses: actions-rs/cargo@v1
         with:
           command: build
           args: --manifest-path clients/webassembly/Cargo.toml --target wasm32-unknown-unknown --features=coconut
 
-# for some reason this does not seem to work correctly, leave it for later, building is good enough for now
-#      - uses: actions-rs/cargo@v1
-#        with:
-#          command: test
-#          args: --manifest-path clients/webassembly/Cargo.toml --target wasm32-unknown-unknown
+      - uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --manifest-path clients/webassembly/Cargo.toml
 
       - uses: actions-rs/cargo@v1
         with:
           command: fmt
           args: --manifest-path clients/webassembly/Cargo.toml -- --check
 
-# for some reason this does not seem to work correctly, leave it for later, building is good enough for now
-#      - uses: actions-rs/cargo@v1
-#        with:
-#          command: clippy
-#          args: --manifest-path clients/webassembly/Cargo.toml --target wasm32-unknown-unknown -- -D warnings
+      - uses: actions-rs/cargo@v1
+        with:
+          command: clippy
+          args: --manifest-path clients/webassembly/Cargo.toml --target wasm32-unknown-unknown -- -D warnings

.github_changelog_generator

@@ -0,0 +1,3 @@
+unreleased=true
+future-release=v0.12.0
+since-tag=v0.11.0

.gitignore

@@ -34,4 +34,7 @@ contracts/mixnet/code_id
 contracts/mixnet/Justfile
 contracts/mixnet/Makefile
 validator-config
-*.patch
+*.patch
+validator-api-config.toml
+dist
+storybook-static

.ruby-version

@@ -0,0 +1 @@
+2.7.5

.wellknown/wallet/validators.json

@@ -0,0 +1,6 @@
+{
+  "mainnet":[{
+    "nymd_url":"https://rpc.nyx.nodes.guru/",
+    "api_url":"https://api.nyx.nodes.guru/"
+  }]
+}

Cargo.toml

@@ -9,24 +9,33 @@ overflow-checks = true
 [profile.dev]
 panic = "abort"
 
+[profile.test]
+# equivalent of running in `--release` (but since we're in test profile we're keeping overflow checks and all of those by default)
+opt-level = 3
+
 [workspace]
 
+resolver = "2"
 members = [
     "clients/client-core",
+    "clients/credential",
     "clients/native",
     "clients/native/websocket-requests",
     "clients/socks5",
-    "clients/tauri-client/src-tauri",
-    "clients/webassembly",
     "common/client-libs/gateway-client",
     "common/client-libs/mixnet-client",
     "common/client-libs/validator-client",
+    "common/credential-storage",
     "common/coconut-interface",
     "common/config",
     "common/credentials",
     "common/crypto",
-    "common/erc20-bridge-contract",
-    "common/mixnet-contract",
+    "common/crypto/dkg",
+    "common/bandwidth-claim-contract",
+    "common/cosmwasm-smart-contracts/coconut-bandwidth-contract",
+    "common/cosmwasm-smart-contracts/contracts-common",
+    "common/cosmwasm-smart-contracts/mixnet-contract",
+    "common/cosmwasm-smart-contracts/vesting-contract",
     "common/mixnode-common",
     "common/network-defaults",
     "common/nonexhaustive-delayqueue",
@@ -52,16 +61,17 @@ members = [
     "mixnode",
     "service-providers/network-requester",
     "validator-api",
+    "validator-api/validator-api-requests",
 ]
 
 default-members = [
     "clients/native",
     "clients/socks5",
-#    "clients/webassembly",
     "gateway",
     "service-providers/network-requester",
     "mixnode",
     "validator-api",
+    "explorer-api",
 ]
 
-exclude = ["explorer", "contracts", "tokenomics-py"]
+exclude = ["explorer", "contracts", "tokenomics-py", "clients/webassembly"]

Makefile

@@ -0,0 +1,56 @@
+test: build clippy-all cargo-test wasm fmt
+no-clippy: build cargo-test wasm fmt
+happy: fmt clippy-happy test
+clippy-all: clippy-all-main clippy-all-contracts clippy-all-wallet
+clippy-happy: clippy-happy-main clippy-happy-contracts clippy-happy-wallet
+cargo-test: test-main test-contracts test-wallet
+build: build-contracts build-wallet build-main
+fmt: fmt-main fmt-contracts fmt-wallet
+
+clippy-happy-main:
+	cargo clippy
+
+clippy-happy-contracts:
+	cargo clippy --manifest-path contracts/Cargo.toml --target wasm32-unknown-unknown
+
+clippy-happy-wallet:
+	cargo clippy --manifest-path nym-wallet/Cargo.toml
+
+clippy-all-main:
+	cargo clippy --workspace --all-features -- -D warnings
+
+clippy-all-contracts:
+	cargo clippy --workspace --manifest-path contracts/Cargo.toml --all-features --target wasm32-unknown-unknown -- -D warnings
+
+clippy-all-wallet:
+	cargo clippy --workspace --manifest-path nym-wallet/Cargo.toml --all-features -- -D warnings
+
+test-main:
+	cargo test --all-features --workspace
+
+test-contracts:
+	cargo test --manifest-path contracts/Cargo.toml --all-features
+
+test-wallet:
+	cargo test --manifest-path nym-wallet/Cargo.toml --all-features
+
+build-main:
+	cargo build --workspace
+
+build-contracts:
+	cargo build --manifest-path contracts/Cargo.toml --workspace
+
+build-wallet:
+	cargo build --manifest-path nym-wallet/Cargo.toml --workspace
+
+fmt-main:
+	cargo fmt --all
+
+fmt-contracts:
+	cargo fmt --manifest-path contracts/Cargo.toml --all
+
+fmt-wallet:
+	cargo fmt --manifest-path nym-wallet/Cargo.toml --all
+
+wasm:
+	RUSTFLAGS='-C link-arg=-s' cargo build --manifest-path contracts/Cargo.toml --release --target wasm32-unknown-unknown

README.md

@@ -13,7 +13,7 @@ The platform is composed of multiple Rust crates. Top-level executable binary cr
 * nym-gateway - acts sort of like a mailbox for mixnet messages, removing the need for directly delivery to potentially offline or firewalled devices.
 * nym-network-monitor - sends packets through the full system to check that they are working as expected, and stores node uptime histories as the basis of a rewards system ("mixmining" or "proof-of-mixing").
 * nym-explorer - a (projected) block explorer and (existing) mixnet viewer.
-* nym-wallet (currently in development)- a desktop wallet implemented using the [Tauri](https://tauri.studio/en/docs/about/intro) framework. 
+* nym-wallet - a desktop wallet implemented using the [Tauri](https://tauri.studio/en/docs/about/intro) framework. 
 
 [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg?style=for-the-badge)](https://opensource.org/licenses/Apache-2.0)
 [![Build Status](https://img.shields.io/github/workflow/status/nymtech/nym/Continuous%20integration/develop?style=for-the-badge&logo=github-actions)](https://github.com/nymtech/nym/actions?query=branch%3Adevelop)
@@ -21,12 +21,15 @@ The platform is composed of multiple Rust crates. Top-level executable binary cr
 
 ### Building
 
-Platform build instructions are available on [our docs site](https://nymtech.net/docs/0.11.0/overview/index/).
+Platform build instructions are available on [our docs site](https://nymtech.net/docs/stable/run-nym-nodes/build-nym).
+Wallet build instructions are also available on [our docs site](https://nymtech.net/docs/stable/nym-apps/wallet#for-developers).
 
 ### Developing
 
 There's a `.env.sample-dev` file provided which you can rename to `.env` if you want convenient logging, backtrace, or other environment variables pre-set. The `.env` file is ignored so you don't need to worry about checking it in.
 
+For Typescript components, please see [ts-packages](./ts-packages).
+
 ### Developer chat
 
 You can chat to us in [Keybase](https://keybase.io). Download their chat app, then click **Teams -> Join a team**. Type **nymtech.friends** into the team name and hit **continue**. For general chat, hang out in the **#general** channel. Our development takes places in the **#dev** channel. Node operators should be in the **#node-operators** channel.
@@ -37,36 +40,40 @@ Node, node operator and delegator rewards are determined according to the princi
 
 |Symbol|Definition|
 |---|---|
-|<img src="https://render.githubusercontent.com/render/math?math=R">|global share of rewards available, starts at 2% of the reward pool. 
-|<img src="https://render.githubusercontent.com/render/math?math=R_{i}">|node reward for mixnode `i`.
-|<img src="https://render.githubusercontent.com/render/math?math=\sigma_{i}">|ratio of total node stake (node bond + all delegations) to the token circulating supply.
-|<img src="https://render.githubusercontent.com/render/math?math=\lambda_{i}">|ratio of stake operator has plaged to their node to the token circulating supply.
-|<img src="https://render.githubusercontent.com/render/math?math=\omega_{i}">|fraction of total effort undertaken by node `i`, set to `1/k` in testnet Milhon.
-|<img src="https://render.githubusercontent.com/render/math?math=k">|number of nodes stakeholders are incentivised to create, set by the validators, a matter of governance. Currently determined by the `active set` size, and set to 5000 in testnet Milhon.
-|<img src="https://render.githubusercontent.com/render/math?math=\alpha">|Sybil attack resistance parameter - the higher this parameter is set the stronger the reduction in competitivness gets for a Sybil attacker.
-|<img src="https://render.githubusercontent.com/render/math?math=PM_{i}">|declared profit margin of operator `i`, defaults to 10% in testnet Milhon.
-|<img src="https://render.githubusercontent.com/render/math?math=PF_{i}">|uptime of node `i`, scaled to 0 - 1, for the rewarding epoch
-|<img src="https://render.githubusercontent.com/render/math?math=PP_{i}">|cost of operating node `i` for the duration of the rewarding eopoch, set to 40 Nym for testnet Milhon.
+|<img src="https://render.githubusercontent.com/render/math?math=R#gh-light-mode-only"><img src="https://render.githubusercontent.com/render/math?math=\color{white}R#gh-dark-mode-only">|global share of rewards available, starts at 2% of the reward pool.
+|<img src="https://render.githubusercontent.com/render/math?math=R_{i}#gh-light-mode-only"><img src="https://render.githubusercontent.com/render/math?math=\color{white}R_{i}#gh-dark-mode-only">|node reward for mixnode `i`.
+|<img src="https://render.githubusercontent.com/render/math?math=\sigma_{i}#gh-light-mode-only"><img src="https://render.githubusercontent.com/render/math?math=\color{white}\sigma_{i}#gh-dark-mode-only">|ratio of total node stake (node bond + all delegations) to the token circulating supply.
+|<img src="https://render.githubusercontent.com/render/math?math=\lambda_{i}#gh-light-mode-only"><img src="https://render.githubusercontent.com/render/math?math=\color{white}\lambda_{i}#gh-dark-mode-only">|ratio of stake operator has pledged to their node to the token circulating supply.
+|<img src="https://render.githubusercontent.com/render/math?math=\omega_{i}#gh-light-mode-only"><img src="https://render.githubusercontent.com/render/math?math=\color{white}\omega_{i}#gh-dark-mode-only">|fraction of total effort undertaken by node `i`, set to `1/k`.
+|<img src="https://render.githubusercontent.com/render/math?math=k#gh-light-mode-only"><img src="https://render.githubusercontent.com/render/math?math=\color{white}k#gh-dark-mode-only">|number of nodes stakeholders are incentivised to create, set by the validators, a matter of governance. Currently determined by the `reward set` size, and set to 720 in testnet Sandbox.
+|<img src="https://render.githubusercontent.com/render/math?math=\alpha#gh-light-mode-only"><img src="https://render.githubusercontent.com/render/math?math=\color{white}\alpha#gh-dark-mode-only">|Sybil attack resistance parameter - the higher this parameter is set the stronger the reduction in competitivness gets for a Sybil attacker.
+|<img src="https://render.githubusercontent.com/render/math?math=PM_{i}#gh-light-mode-only"><img src="https://render.githubusercontent.com/render/math?math=\color{white}PM_{i}#gh-dark-mode-only">|declared profit margin of operator `i`, defaults to 10% in.
+|<img src="https://render.githubusercontent.com/render/math?math=PF_{i}#gh-light-mode-only"><img src="https://render.githubusercontent.com/render/math?math=\color{white}PF_{i}#gh-dark-mode-only">|uptime of node `i`, scaled to 0 - 1, for the rewarding epoch
+|<img src="https://render.githubusercontent.com/render/math?math=PP_{i}#gh-light-mode-only"><img src="https://render.githubusercontent.com/render/math?math=\color{white}PP_{i}#gh-dark-mode-only">|cost of operating node `i` for the duration of the rewarding epoch, set to 40 NYMT.
 
 Node reward for node `i` is determined as:
 
-<img src="https://render.githubusercontent.com/render/math?math=R_{i}=PF_{i} \cdot R \cdot (\sigma^'_{i} \cdot \omega_{i} \cdot k %2b \alpha \cdot \lambda^'_{i} \cdot \sigma^'_{i} \cdot k)/(1 %2b \alpha)">
-
+<img src="https://render.githubusercontent.com/render/math?math=R_{i}=PF_{i} \cdot R \cdot (\sigma^'_{i} \cdot \omega_{i} \cdot k %2b \alpha \cdot \lambda^'_{i} \cdot \sigma^'_{i} \cdot k)/(1 %2b \alpha)#gh-light-mode-only">
+<img src="https://render.githubusercontent.com/render/math?math=\color{white}R_{i}=PF_{i} \cdot R \cdot (\sigma^'_{i} \cdot \omega_{i} \cdot k %2b \alpha \cdot \lambda^'_{i} \cdot \sigma^'_{i} \cdot k)/(1 %2b \alpha)#gh-dark-mode-only">
 where:
 
-<img src="https://render.githubusercontent.com/render/math?math=\sigma^'_{i} = min\{\sigma_{i}, 1/k\}">
+<img src="https://render.githubusercontent.com/render/math?math=\sigma^'_{i} = min\{\sigma_{i}, 1/k\}#gh-light-mode-only">
+<img src="https://render.githubusercontent.com/render/math?math=\color{white}\sigma^'_{i} = min\{\sigma_{i}, 1/k\}#gh-dark-mode-only">
 
 and
 
-<img src="https://render.githubusercontent.com/render/math?math=\lambda^'_{i} = min\{\lambda_{i}, 1/k\}">
+<img src="https://render.githubusercontent.com/render/math?math=\lambda^'_{i} = min\{\lambda_{i}, 1/k\}#gh-light-mode-only">
+<img src="https://render.githubusercontent.com/render/math?math=\color{white}\lambda^'_{i} = min\{\lambda_{i}, 1/k\}#gh-dark-mode-only">
 
 Operator of node `i` is credited with the following amount:
 
-<img src="https://render.githubusercontent.com/render/math?math=min\{PP_{i},R_{i})\} %2b max\{0, (PM_{i} %2b (1 - PM_{i}) \cdot \lambda_{i}/\delta_{i}) \cdot (R_{i} - PP_{i})\}">
+<img src="https://render.githubusercontent.com/render/math?math=min\{PP_{i},R_{i})\} %2b max\{0, (PM_{i} %2b (1 - PM_{i}) \cdot \lambda_{i}/\delta_{i}) \cdot (R_{i} - PP_{i})\}#gh-light-mode-only">
+<img src="https://render.githubusercontent.com/render/math?math=\color{white}min\{PP_{i},R_{i})\} %2b max\{0, (PM_{i} %2b (1 - PM_{i}) \cdot \lambda_{i}/\delta_{i}) \cdot (R_{i} - PP_{i})\}#gh-dark-mode-only">
 
 Delegate with stake `s` recieves:
 
-<img src="https://render.githubusercontent.com/render/math?math=max\{0, (1-PM_{i}) \cdot (s^'/\sigma_{i}) \cdot (R_{i} - PP_{i})\}">
+<img src="https://render.githubusercontent.com/render/math?math=max\{0, (1-PM_{i}) \cdot (s^'/\sigma_{i}) \cdot (R_{i} - PP_{i})\}#gh-light-mode-only">
+<img src="https://render.githubusercontent.com/render/math?math=\color{white}max\{0, (1-PM_{i}) \cdot (s^'/\sigma_{i}) \cdot (R_{i} - PP_{i})\}#gh-dark-mode-only">
 
 where `s'` is stake `s` scaled over total token circulating supply.
 

SECURITY.md

@@ -0,0 +1,10 @@
+Critical bug or security issue 💥
+
+If you're here because you're trying to figure out how to notify us of a security issue, go to Discord, and alert the core engineers:
+
+    Dave Hrycyszyn futurechimp#5430
+    Drazen Urch drazen#4873
+    Jedrzej Stuczynski "Jedrzej | Nym#5666"
+
+
+Please avoid opening public issues on GitHub that contain information about a potential security vulnerability as this makes it difficult to reduce the impact and harm of valid security issues.

assets/README.md

@@ -0,0 +1,12 @@
+# Shared assets
+
+This directory contains asset files shared by many projects in this repo.
+
+You will find:
+
+- favicons
+- logos
+- shared fonts
+- shared icon SVGs
+
+See [ts-packages/react-webpack-with-theme-example](../ts-packages/react-webpack-with-theme-example) for examples of usage.

assets/favicon/favicon.svg

@@ -0,0 +1,10 @@
+<svg width="64" height="64" viewBox="0 0 80 80" fill="none" xmlns="http://www.w3.org/2000/svg">
+	<path d="M40 78.5C61.263 78.5 78.5 61.263 78.5 40C78.5 18.737 61.263 1.5 40 1.5C18.737 1.5 1.5 18.737 1.5 40C1.5 61.263 18.737 78.5 40 78.5Z" fill="#070B15" stroke="url(#paint0_linear_0_1)" stroke-width="3"/>
+	<path d="M31.4894 27.56L41.8623 56H48.5106H56V24H48.5106V52.4L38.1777 24H31.4894H24V56H31.4894V27.56Z" fill="white"/>
+	<defs>
+		<linearGradient id="paint0_linear_0_1" x1="0.839161" y1="80" x2="80" y2="80" gradientUnits="userSpaceOnUse">
+			<stop offset="0.09375" stop-color="#FB6E4E"/>
+			<stop offset="1" stop-color="#F51473"/>
+		</linearGradient>
+	</defs>
+</svg>

assets/fonts/fonts.css

@@ -0,0 +1,6 @@
+@font-face {
+    font-family: 'Open Sans';
+    src: url('./OpenSans-VariableFont_wdth,wght.ttf') format('truetype-variations'),
+    url('./OpenSans-Italic-VariableFont_wdth,wght.ttf') format('truetype-variations');
+    font-weight: 100 1000;
+}

assets/logo/logo-circle-small.svg

@@ -0,0 +1,10 @@
+<svg width="64" height="64" viewBox="0 0 80 80" fill="none" xmlns="http://www.w3.org/2000/svg">
+    <path d="M40 78.5C61.263 78.5 78.5 61.263 78.5 40C78.5 18.737 61.263 1.5 40 1.5C18.737 1.5 1.5 18.737 1.5 40C1.5 61.263 18.737 78.5 40 78.5Z" fill="#070B15" stroke="url(#paint0_linear_0_1)" stroke-width="3"/>
+    <path d="M31.4894 27.56L41.8623 56H48.5106H56V24H48.5106V52.4L38.1777 24H31.4894H24V56H31.4894V27.56Z" fill="white"/>
+    <defs>
+        <linearGradient id="paint0_linear_0_1" x1="0.839161" y1="80" x2="80" y2="80" gradientUnits="userSpaceOnUse">
+            <stop offset="0.09375" stop-color="#FB6E4E"/>
+            <stop offset="1" stop-color="#F51473"/>
+        </linearGradient>
+    </defs>
+</svg>

assets/logo/logo-circle.svg

@@ -0,0 +1,13 @@
+<svg width="300" height="300" viewBox="0 0 296 296" fill="none" xmlns="http://www.w3.org/2000/svg">
+    <path d="M148 296C229.738 296 296 229.738 296 148C296 66.2619 229.738 0 148 0C66.2619 0 0 66.2619 0 148C0 229.738 66.2619 296 148 296Z" fill="url(#paint0_linear_113_1244)"/>
+    <path d="M148 285.875C224.147 285.875 285.875 224.146 285.875 148C285.875 71.8536 224.147 10.1248 148 10.1248C71.8538 10.1248 10.125 71.8536 10.125 148C10.125 224.146 71.8538 285.875 148 285.875Z" fill="#121725"/>
+    <path d="M88.8829 120.143H88.7169V120.281V168.637L68.3289 120.226L68.3012 120.143H68.1905H56.6272H43.653H43.5146V120.281V175.719V175.857H43.653H56.6272H56.7655V175.719V127.28L77.2365 175.774L77.2642 175.857H77.3748H88.8829H101.829H101.968V175.719V120.281V120.143H101.829H88.8829Z" fill="white"/>
+    <path d="M252.347 120.143H227.616H227.477L227.45 120.253L214.78 168.858L202.082 120.253L202.054 120.143H201.944H177.157H176.991V120.281V175.719V175.857H177.157H190.104H190.242V175.719V127.667L202.774 175.747L202.801 175.857H202.94H226.564H226.675L226.703 175.747L239.234 127.667V175.719V175.857H239.373H252.347H252.485V175.719V120.281V120.143H252.347Z" fill="white"/>
+    <path d="M155.663 120.143H155.58L155.552 120.198L139.812 147.557L123.988 120.198L123.96 120.143H123.877H108.911H108.635L108.773 120.364L133.145 162.579V175.719V175.857H133.283H146.257H146.396V175.719V162.579L170.767 120.364L170.905 120.143H170.629H155.663Z" fill="white"/>
+    <defs>
+        <linearGradient id="paint0_linear_113_1244" x1="0" y1="148" x2="296" y2="148" gradientUnits="userSpaceOnUse">
+            <stop offset="0.09375" stop-color="#FB6E4E"/>
+            <stop offset="1" stop-color="#FC1D60"/>
+        </linearGradient>
+    </defs>
+</svg>

assets/logo/logo-wordmark.svg

@@ -0,0 +1,5 @@
+<svg viewBox="0 0 210 56" fill="none" xmlns="http://www.w3.org/2000/svg">
+    <path d="M45.8829 0.142822H45.7169V0.28114V48.637L25.3289 0.225818L25.3012 0.142822H25.1905H13.6272H0.652966H0.514648V0.28114V55.7189V55.8572H0.652966H13.6272H13.7655V55.7189V7.28002L34.2365 55.7742L34.2642 55.8572H34.3748H45.8829H58.8294H58.9677V55.7189V0.28114V0.142822H58.8294H45.8829Z"/>
+    <path d="M209.347 0.142822H184.616H184.477L184.45 0.253483L171.78 48.8583L159.082 0.253483L159.054 0.142822H158.944H134.157H133.991V0.28114V55.7189V55.8572H134.157H147.104H147.242V55.7189V7.66731L159.774 55.7466L159.801 55.8572H159.94H183.564H183.675L183.703 55.7466L196.234 7.66731V55.7189V55.8572H196.373H209.347H209.485V55.7189V0.28114V0.142822H209.347Z"/>
+    <path d="M112.663 0.142822H112.58L112.552 0.198153L96.8116 27.5574L80.988 0.198153L80.9604 0.142822H80.8774H65.9114H65.6348L65.7731 0.364136L90.1447 42.5787V55.7189V55.8572H90.283H103.257H103.396V55.7189V42.5787L127.767 0.364136L127.905 0.142822H127.629H112.663Z"/>
+</svg>

assets/token/token-dark.svg

@@ -0,0 +1,5 @@
+<svg width="200" height="200" viewBox="0 0 200 200" fill="none" xmlns="http://www.w3.org/2000/svg">
+    <path d="M170.7 29.3001C131.7 -9.7999 68.3001 -9.7999 29.3001 29.3001C-9.7999 68.4001 -9.7999 131.7 29.3001 170.7C68.4001 209.8 131.7 209.8 170.7 170.7C209.8 131.7 209.8 68.3001 170.7 29.3001ZM162.1 162.1C127.8 196.4 72.1001 196.4 37.8001 162.1C3.5001 127.8 3.5001 72.1001 37.8001 37.8001C72.1001 3.5001 127.8 3.5001 162.1 37.8001C196.5 72.2001 196.5 127.8 162.1 162.1Z" fill="white"/>
+    <path d="M162.1 37.9C127.8 3.60005 72.1002 3.60005 37.8002 37.9C3.50019 72.2 3.50019 127.9 37.8002 162.2C72.1002 196.5 127.8 196.5 162.1 162.2C196.5 127.8 196.5 72.2 162.1 37.9ZM63.0002 170.7C56.8002 167.4 51.1002 163.2 46.1002 158.4V41.7C51.3002 36.7 57.2002 32.5 63.6002 29.1L137 140.9V29.3C143.2 32.6 148.9 36.8 153.9 41.6V158.3C148.7 163.3 142.8 167.5 136.4 170.9L63.0002 59.1V170.7Z" fill="#070B15"/>
+    <path d="M154 158.3V41.7C148.9 36.9 143.2 32.7 137.1 29.4V140.9L63.5 29C57.1 32.4 51.2 36.6 46 41.6V158.3C51.1 163.1 56.8 167.3 62.9 170.6V59.1L136.5 171C142.9 167.6 148.8 163.3 154 158.3Z" fill="white"/>
+</svg>

assets/token/token-light.svg

@@ -0,0 +1,5 @@
+<svg width="200" height="200" viewBox="0 0 200 200" fill="none" xmlns="http://www.w3.org/2000/svg">
+    <path d="M170.7 29.3001C131.7 -9.7999 68.3001 -9.7999 29.3001 29.3001C-9.7999 68.4001 -9.7999 131.7 29.3001 170.7C68.4001 209.8 131.7 209.8 170.7 170.7C209.8 131.7 209.8 68.3001 170.7 29.3001ZM162.1 162.1C127.8 196.4 72.1001 196.4 37.8001 162.1C3.5001 127.8 3.5001 72.1001 37.8001 37.8001C72.1001 3.5001 127.8 3.5001 162.1 37.8001C196.5 72.2001 196.5 127.8 162.1 162.1Z" fill="#141521"/>
+    <path d="M162.1 37.9C127.8 3.60005 72.1002 3.60005 37.8002 37.9C3.50019 72.2 3.50019 127.9 37.8002 162.2C72.1002 196.5 127.8 196.5 162.1 162.2C196.5 127.8 196.5 72.2 162.1 37.9ZM63.0002 170.7C56.8002 167.4 51.1002 163.2 46.1002 158.4V41.7C51.3002 36.7 57.2002 32.5 63.6002 29.1L137 140.9V29.3C143.2 32.6 148.9 36.8 153.9 41.6V158.3C148.7 163.3 142.8 167.5 136.4 170.9L63.0002 59.1V170.7Z" fill="white"/>
+    <path d="M154 158.3V41.7C148.9 36.9 143.2 32.7 137.1 29.4V140.9L63.5 29C57.1 32.4 51.2 36.6 46 41.6V158.3C51.1 163.1 56.8 167.3 62.9 170.6V59.1L136.5 171C142.9 167.6 148.8 163.3 154 158.3Z" fill="#141521"/>
+</svg>

clients/client-core/Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "client-core"
-version = "0.11.0"
+version = "1.0.1"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
-edition = "2018"
+edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -32,4 +32,4 @@ validator-client = { path = "../../common/client-libs/validator-client" }
 tempfile = "3.1.0"
 
 [features]
-coconut = []
+coconut = ["gateway-client/coconut", "gateway-requests/coconut"]

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

@@ -13,7 +13,6 @@ use nymsphinx::utils::sample_poisson_duration;
 use rand::{rngs::OsRng, CryptoRng, Rng};
 use std::pin::Pin;
 use std::sync::Arc;
-use tokio::runtime::Handle;
 use tokio::task::JoinHandle;
 use tokio::time;
 
@@ -165,8 +164,8 @@ impl LoopCoverTrafficStream<OsRng> {
         }
     }
 
-    pub fn start(mut self, handle: &Handle) -> JoinHandle<()> {
-        handle.spawn(async move {
+    pub fn start(mut self) -> JoinHandle<()> {
+        tokio::spawn(async move {
             self.run().await;
         })
     }

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

@@ -79,9 +79,9 @@ impl KeyManager {
             ))?;
 
         let gateway_shared_key: SharedKeys =
-            pemstore::load_key(&client_pathfinder.gateway_shared_key().to_owned())?;
+            pemstore::load_key(client_pathfinder.gateway_shared_key())?;
 
-        let ack_key: AckKey = pemstore::load_key(&client_pathfinder.ack_key().to_owned())?;
+        let ack_key: AckKey = pemstore::load_key(client_pathfinder.ack_key())?;
 
         // TODO: ack key is never stored so it is generated now. But perhaps it should be stored
         // after all for consistency sake?

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

@@ -6,7 +6,6 @@ use futures::StreamExt;
 use gateway_client::GatewayClient;
 use log::*;
 use nymsphinx::forwarding::packet::MixPacket;
-use tokio::runtime::Handle;
 use tokio::task::JoinHandle;
 
 pub type BatchMixMessageSender = mpsc::UnboundedSender<Vec<MixPacket>>;
@@ -72,8 +71,8 @@ impl MixTrafficController {
         }
     }
 
-    pub fn start(mut self, handle: &Handle) -> JoinHandle<()> {
-        handle.spawn(async move {
+    pub fn start(mut self) -> JoinHandle<()> {
+        tokio::spawn(async move {
             self.run().await;
         })
     }

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

@@ -22,7 +22,6 @@ use nymsphinx::addressing::clients::Recipient;
 use rand::{rngs::OsRng, CryptoRng, Rng};
 use std::sync::Arc;
 use std::time::Duration;
-use tokio::runtime::Handle;
 use tokio::task::JoinHandle;
 
 mod acknowledgement_control;
@@ -170,10 +169,8 @@ impl RealMessagesController<OsRng> {
         self.ack_control = Some(ack_control_fut.await.unwrap());
     }
 
-    // &Handle is only passed for consistency sake with other client modules, but I think
-    // when we get to refactoring, we should apply gateway approach and make it implicit
-    pub fn start(mut self, handle: &Handle) -> JoinHandle<Self> {
-        handle.spawn(async move {
+    pub fn start(mut self) -> JoinHandle<Self> {
+        tokio::spawn(async move {
             self.run().await;
             self
         })

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

@@ -15,7 +15,6 @@ use nymsphinx::params::{ReplySurbEncryptionAlgorithm, ReplySurbKeyDigestAlgorith
 use nymsphinx::receiver::{MessageReceiver, MessageRecoveryError, ReconstructedMessage};
 use std::collections::HashSet;
 use std::sync::Arc;
-use tokio::runtime::Handle;
 use tokio::task::JoinHandle;
 
 // Buffer Requests to say "hey, send any reconstructed messages to this channel"
@@ -291,8 +290,8 @@ impl RequestReceiver {
         }
     }
 
-    fn start(mut self, handle: &Handle) -> JoinHandle<()> {
-        handle.spawn(async move {
+    fn start(mut self) -> JoinHandle<()> {
+        tokio::spawn(async move {
             while let Some(request) = self.query_receiver.next().await {
                 match request {
                     ReceivedBufferMessage::ReceiverAnnounce(sender) => {
@@ -322,8 +321,8 @@ impl FragmentedMessageReceiver {
             mixnet_packet_receiver,
         }
     }
-    fn start(mut self, handle: &Handle) -> JoinHandle<()> {
-        handle.spawn(async move {
+    fn start(mut self) -> JoinHandle<()> {
+        tokio::spawn(async move {
             while let Some(new_messages) = self.mixnet_packet_receiver.next().await {
                 self.received_buffer.handle_new_received(new_messages).await;
             }
@@ -355,9 +354,9 @@ impl ReceivedMessagesBufferController {
         }
     }
 
-    pub fn start(self, handle: &Handle) {
+    pub fn start(self) {
         // TODO: should we do anything with JoinHandle(s) returned by start methods?
-        self.fragmented_message_receiver.start(handle);
-        self.request_receiver.start(handle);
+        self.fragmented_message_receiver.start();
+        self.request_receiver.start();
     }
 }

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

@@ -1,10 +1,10 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
+use crypto::generic_array::typenum::Unsigned;
 use log::*;
 use nymsphinx::anonymous_replies::{
-    encryption_key::EncryptionKeyDigest, encryption_key::Unsigned, SurbEncryptionKey,
-    SurbEncryptionKeySize,
+    encryption_key::EncryptionKeyDigest, SurbEncryptionKey, SurbEncryptionKeySize,
 };
 use std::path::Path;
 
@@ -43,7 +43,7 @@ impl ReplyKeyStorage {
         // if this fails it means we have some database corruption and we
         // absolutely can't continue
 
-        if key_bytes_ref.len() != SurbEncryptionKeySize::to_usize() {
+        if key_bytes_ref.len() != SurbEncryptionKeySize::USIZE {
             error!("REPLY KEY STORAGE DATA CORRUPTION - ENCRYPTION KEY HAS INVALID LENGTH");
             panic!("REPLY KEY STORAGE DATA CORRUPTION - ENCRYPTION KEY HAS INVALID LENGTH");
         }
@@ -59,7 +59,7 @@ impl ReplyKeyStorage {
     ) -> Result<(), ReplyKeyStorageError> {
         let digest = encryption_key.compute_digest();
 
-        let insertion_result = match self.db.insert(digest.to_vec(), encryption_key.to_bytes()) {
+        let insertion_result = match self.db.insert(digest, encryption_key.to_bytes()) {
             Err(e) => Err(ReplyKeyStorageError::DbWriteError(e)),
             Ok(existing_key) => {
                 if existing_key.is_some() {
@@ -79,7 +79,7 @@ impl ReplyKeyStorage {
         &self,
         key_digest: EncryptionKeyDigest,
     ) -> Result<Option<SurbEncryptionKey>, ReplyKeyStorageError> {
-        let removal_result = match self.db.remove(&key_digest.to_vec()) {
+        let removal_result = match self.db.remove(key_digest) {
             Err(e) => Err(ReplyKeyStorageError::DbReadError(e)),
             Ok(existing_key) => {
                 Ok(existing_key.map(|existing_key| self.read_encryption_key(existing_key)))

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

@@ -10,7 +10,6 @@ use std::ops::Deref;
 use std::sync::Arc;
 use std::time;
 use std::time::Duration;
-use tokio::runtime::Handle;
 use tokio::sync::{RwLock, RwLockReadGuard};
 use tokio::task::JoinHandle;
 use topology::{nym_topology_from_bonds, NymTopology};
@@ -304,8 +303,8 @@ impl TopologyRefresher {
         self.topology_accessor.is_routable().await
     }
 
-    pub fn start(mut self, handle: &Handle) -> JoinHandle<()> {
-        handle.spawn(async move {
+    pub fn start(mut self) -> JoinHandle<()> {
+        tokio::spawn(async move {
             loop {
                 tokio::time::sleep(self.refresh_rate).await;
                 self.refresh().await;

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

@@ -103,26 +103,27 @@ impl<T: NymConfig> Config<T> {
                 self::Client::<T>::default_reply_encryption_key_store_path(&id);
         }
 
-        #[cfg(not(feature = "coconut"))]
-        if self
-            .client
-            .backup_bandwidth_token_keys_dir
-            .as_os_str()
-            .is_empty()
-        {
-            self.client.backup_bandwidth_token_keys_dir =
-                self::Client::<T>::default_backup_bandwidth_token_keys_dir(&id);
+        if self.client.database_path.as_os_str().is_empty() {
+            self.client.database_path = self::Client::<T>::default_database_path(&id);
         }
 
         self.client.id = id;
     }
 
-    pub fn with_gateway_id<S: Into<String>>(&mut self, id: S) {
-        self.client.gateway_id = id.into();
+    pub fn with_disabled_credentials(&mut self, disabled_credentials_mode: bool) {
+        self.client.disabled_credentials_mode = disabled_credentials_mode;
     }
 
-    pub fn with_gateway_listener<S: Into<String>>(&mut self, gateway_listener: S) {
-        self.client.gateway_listener = gateway_listener.into();
+    pub fn with_gateway_endpoint<S: Into<String>>(&mut self, id: S, owner: S, listener: S) {
+        self.client.gateway_endpoint = GatewayEndpoint {
+            gateway_id: id.into(),
+            gateway_owner: owner.into(),
+            gateway_listener: listener.into(),
+        };
+    }
+
+    pub fn with_gateway_id<S: Into<String>>(&mut self, id: S) {
+        self.client.gateway_endpoint.gateway_id = id.into();
     }
 
     #[cfg(not(feature = "coconut"))]
@@ -153,6 +154,10 @@ impl<T: NymConfig> Config<T> {
         self.client.id.clone()
     }
 
+    pub fn get_disabled_credentials_mode(&self) -> bool {
+        self.client.disabled_credentials_mode
+    }
+
     pub fn get_nym_root_directory(&self) -> PathBuf {
         self.client.nym_root_directory.clone()
     }
@@ -190,16 +195,19 @@ impl<T: NymConfig> Config<T> {
     }
 
     pub fn get_gateway_id(&self) -> String {
-        self.client.gateway_id.clone()
+        self.client.gateway_endpoint.gateway_id.clone()
+    }
+
+    pub fn get_gateway_owner(&self) -> String {
+        self.client.gateway_endpoint.gateway_owner.clone()
     }
 
     pub fn get_gateway_listener(&self) -> String {
-        self.client.gateway_listener.clone()
+        self.client.gateway_endpoint.gateway_listener.clone()
     }
 
-    #[cfg(not(feature = "coconut"))]
-    pub fn get_backup_bandwidth_token_keys_dir(&self) -> PathBuf {
-        self.client.backup_bandwidth_token_keys_dir.clone()
+    pub fn get_database_path(&self) -> PathBuf {
+        self.client.database_path.clone()
     }
 
     #[cfg(not(feature = "coconut"))]
@@ -264,6 +272,19 @@ impl<T: NymConfig> Default for Config<T> {
     }
 }
 
+#[derive(Debug, Default, Deserialize, PartialEq, Serialize)]
+struct GatewayEndpoint {
+    /// gateway_id specifies ID of the gateway to which the client should send messages.
+    /// If initially omitted, a random gateway will be chosen from the available topology.
+    gateway_id: String,
+
+    /// Address of the gateway owner to which the client should send messages.
+    gateway_owner: String,
+
+    /// Address of the gateway listener to which all client requests should be sent.
+    gateway_listener: String,
+}
+
 #[derive(Debug, Deserialize, PartialEq, Serialize)]
 pub struct Client<T> {
     /// Version of the client for which this configuration was created.
@@ -273,6 +294,11 @@ pub struct Client<T> {
     /// ID specifies the human readable ID of this particular client.
     id: String,
 
+    /// Indicates whether this client is running in a disabled credentials mode, thus attempting
+    /// to claim bandwidth without presenting bandwidth credentials.
+    #[serde(default)]
+    disabled_credentials_mode: bool,
+
     /// Addresses to APIs running on validator from which the client gets the view of the network.
     validator_api_urls: Vec<Url>,
 
@@ -300,18 +326,11 @@ pub struct Client<T> {
     /// sent but not received back.
     reply_encryption_key_store_path: PathBuf,
 
-    /// gateway_id specifies ID of the gateway to which the client should send messages.
-    /// If initially omitted, a random gateway will be chosen from the available topology.
-    gateway_id: String,
+    /// Information regarding how the client should send data to gateway.
+    gateway_endpoint: GatewayEndpoint,
 
-    /// Address of the gateway listener to which all client requests should be sent.
-    gateway_listener: String,
-
-    /// Path to directory containing public/private keys used for bandwidth token purchase.
-    /// Those are saved in case of emergency, to be able to reclaim bandwidth tokens.
-    /// The public key is the name of the file, while the private key is the content.
-    #[cfg(not(feature = "coconut"))]
-    backup_bandwidth_token_keys_dir: PathBuf,
+    /// Path to the database containing bandwidth credentials of this client.
+    database_path: PathBuf,
 
     /// Ethereum private key.
     #[cfg(not(feature = "coconut"))]
@@ -335,6 +354,7 @@ impl<T: NymConfig> Default for Client<T> {
         Client {
             version: env!("CARGO_PKG_VERSION").to_string(),
             id: "".to_string(),
+            disabled_credentials_mode: true,
             validator_api_urls: default_api_endpoints(),
             private_identity_key_file: Default::default(),
             public_identity_key_file: Default::default(),
@@ -343,10 +363,8 @@ impl<T: NymConfig> Default for Client<T> {
             gateway_shared_key_file: Default::default(),
             ack_key_file: Default::default(),
             reply_encryption_key_store_path: Default::default(),
-            gateway_id: "".to_string(),
-            gateway_listener: "".to_string(),
-            #[cfg(not(feature = "coconut"))]
-            backup_bandwidth_token_keys_dir: Default::default(),
+            gateway_endpoint: Default::default(),
+            database_path: Default::default(),
             #[cfg(not(feature = "coconut"))]
             eth_private_key: "".to_string(),
             #[cfg(not(feature = "coconut"))]
@@ -385,10 +403,8 @@ impl<T: NymConfig> Client<T> {
     fn default_reply_encryption_key_store_path(id: &str) -> PathBuf {
         T::default_data_directory(Some(id)).join("reply_key_store")
     }
-
-    #[cfg(not(feature = "coconut"))]
-    fn default_backup_bandwidth_token_keys_dir(id: &str) -> PathBuf {
-        T::default_data_directory(Some(id)).join("backup_bandwidth_token_keys")
+    fn default_database_path(id: &str) -> PathBuf {
+        T::default_data_directory(Some(id)).join("db.sqlite")
     }
 }
 

clients/credential/Cargo.toml

@@ -0,0 +1,30 @@
+[package]
+name = "credential"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+async-trait = "0.1.52"
+bip39 = "1.0.1"
+cfg-if = "0.1"
+clap = { version = "3.0.10", features = ["cargo", "derive"] }
+pickledb = "0.4.1"
+rand = "0.7.3"
+serde = { version = "1.0", features = ["derive"] }
+thiserror = "1.0"
+url = "2.2"
+tokio = { version = "1.4", features = ["rt-multi-thread", "net", "signal", "macros"] } # async runtime
+
+coconut-bandwidth-contract-common = { path = "../../common/cosmwasm-smart-contracts/coconut-bandwidth-contract" }
+coconut-interface = { path = "../../common/coconut-interface" }
+credentials = { path = "../../common/credentials" }
+credential-storage = { path = "../../common/credential-storage" }
+crypto = { path = "../../common/crypto", features = ["rand", "asymmetric", "symmetric", "aes", "hashing"] }
+network-defaults = { path = "../../common/network-defaults" }
+pemstore = { path = "../../common/pemstore" }
+validator-client = { path = "../../common/client-libs/validator-client", features = ["nymd-client"] }
+
+[features]
+coconut = ["credentials/coconut"]

clients/credential/src/client.rs

@@ -0,0 +1,69 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use bip39::Mnemonic;
+use coconut_bandwidth_contract_common::deposit::DepositData;
+use std::str::FromStr;
+use url::Url;
+
+use crate::error::Result;
+use crate::{CONTRACT_ADDRESS, MNEMONIC, NYMD_URL};
+
+use coconut_bandwidth_contract_common::msg::ExecuteMsg;
+use network_defaults::DEFAULT_NETWORK;
+use validator_client::nymd::{
+    AccountId, CosmosCoin, Decimal, Denom, NymdClient, SigningNymdClient,
+};
+
+pub(crate) struct Client {
+    nymd_client: NymdClient<SigningNymdClient>,
+    denom: Denom,
+    contract_address: AccountId,
+}
+
+impl Client {
+    pub fn new() -> Self {
+        let nymd_url = Url::from_str(NYMD_URL).unwrap();
+        let mnemonic = Mnemonic::from_str(MNEMONIC).unwrap();
+        let nymd_client = NymdClient::connect_with_mnemonic(
+            DEFAULT_NETWORK,
+            nymd_url.as_ref(),
+            None,
+            None,
+            None,
+            mnemonic,
+            None,
+        )
+        .unwrap();
+        let denom = Denom::from_str(network_defaults::DENOM).unwrap();
+        let contract_address = AccountId::from_str(CONTRACT_ADDRESS).unwrap();
+
+        Client {
+            nymd_client,
+            denom,
+            contract_address,
+        }
+    }
+
+    pub async fn deposit(
+        &self,
+        amount: u64,
+        info: &str,
+        verification_key: String,
+        encryption_key: String,
+    ) -> Result<String> {
+        let req = ExecuteMsg::DepositFunds {
+            data: DepositData::new(info.to_string(), verification_key, encryption_key),
+        };
+        let funds = vec![CosmosCoin {
+            denom: self.denom.clone(),
+            amount: Decimal::from(amount),
+        }];
+        Ok(self
+            .nymd_client
+            .execute(&self.contract_address, &req, Default::default(), "", funds)
+            .await?
+            .transaction_hash
+            .to_string())
+    }
+}

clients/credential/src/commands.rs

@@ -0,0 +1,183 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use async_trait::async_trait;
+use clap::{Args, Subcommand};
+use pickledb::PickleDb;
+use rand::rngs::OsRng;
+use std::str::FromStr;
+use url::Url;
+
+use coconut_interface::{Attribute, Base58, BlindSignRequest, Bytable, Parameters};
+use credential_storage::storage::Storage;
+use credential_storage::PersistentStorage;
+use credentials::coconut::bandwidth::{BandwidthVoucher, TOTAL_ATTRIBUTES};
+use credentials::coconut::utils::obtain_aggregate_signature;
+use crypto::asymmetric::{encryption, identity};
+use network_defaults::VOUCHER_INFO;
+use validator_client::nymd::tx::Hash;
+
+use crate::client::Client;
+use crate::error::{CredentialClientError, Result};
+use crate::state::{KeyPair, RequestData, State};
+use crate::SIGNER_AUTHORITIES;
+
+#[derive(Subcommand)]
+pub(crate) enum Commands {
+    /// Deposit funds for buying coconut credential
+    Deposit(Deposit),
+    /// Lists the tx hashes of previous deposits
+    ListDeposits(ListDeposits),
+    /// Get a credential for a given deposit
+    GetCredential(GetCredential),
+}
+
+#[async_trait]
+pub(crate) trait Execute {
+    async fn execute(&self, db: &mut PickleDb, shared_storage: PersistentStorage) -> Result<()>;
+}
+
+#[derive(Args, Clone)]
+pub(crate) struct Deposit {
+    /// The amount that needs to be deposited
+    #[clap(long)]
+    amount: u64,
+}
+
+#[async_trait]
+impl Execute for Deposit {
+    async fn execute(&self, db: &mut PickleDb, _shared_storage: PersistentStorage) -> Result<()> {
+        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 client = Client::new();
+        let tx_hash = client
+            .deposit(
+                self.amount,
+                VOUCHER_INFO,
+                signing_keypair.public_key.clone(),
+                encryption_keypair.public_key.clone(),
+            )
+            .await?;
+
+        let state = State {
+            amount: self.amount,
+            tx_hash: tx_hash.clone(),
+            signing_keypair,
+            encryption_keypair,
+            blind_request_data: None,
+            signature: None,
+        };
+        db.set(&tx_hash, &state).unwrap();
+
+        println!("{:?}", state);
+
+        Ok(())
+    }
+}
+
+#[derive(Args, Clone)]
+pub(crate) struct ListDeposits {}
+
+#[async_trait]
+impl Execute for ListDeposits {
+    async fn execute(&self, db: &mut PickleDb, _shared_storage: PersistentStorage) -> Result<()> {
+        for kv in db.iter() {
+            println!("{:?}", kv.get_value::<State>());
+        }
+
+        Ok(())
+    }
+}
+
+#[derive(Args, Clone)]
+pub(crate) struct GetCredential {
+    /// The hash of a successful deposit transaction
+    #[clap(long)]
+    tx_hash: String,
+    /// If we want to get the signature without attaching a blind sign request; it is expected that
+    /// there is already a signature stored on the signer
+    #[clap(long, parse(from_flag))]
+    __no_request: bool,
+}
+
+#[async_trait]
+impl Execute for GetCredential {
+    async fn execute(&self, db: &mut PickleDb, shared_storage: PersistentStorage) -> Result<()> {
+        let mut state = db
+            .get::<State>(&self.tx_hash)
+            .ok_or(CredentialClientError::NoDeposit)?;
+        let urls = SIGNER_AUTHORITIES.map(|addr| Url::from_str(addr).unwrap());
+
+        let params = Parameters::new(TOTAL_ATTRIBUTES).unwrap();
+        let bandwidth_credential_attributes = if self.__no_request {
+            if let Some(blind_request_data) = state.blind_request_data {
+                let serial_number =
+                    Attribute::try_from_byte_slice(&blind_request_data.serial_number)
+                        .map_err(|_| CredentialClientError::CorruptedBlindSignRequest)?;
+                let binding_number =
+                    Attribute::try_from_byte_slice(&blind_request_data.binding_number)
+                        .map_err(|_| CredentialClientError::CorruptedBlindSignRequest)?;
+                let pedersen_commitments_openings = vec![
+                    Attribute::try_from_byte_slice(&blind_request_data.first_attribute)
+                        .map_err(|_| CredentialClientError::CorruptedBlindSignRequest)?,
+                    Attribute::try_from_byte_slice(&blind_request_data.second_attribute)
+                        .map_err(|_| CredentialClientError::CorruptedBlindSignRequest)?,
+                ];
+                let blind_sign_request =
+                    BlindSignRequest::from_bytes(blind_request_data.blind_sign_req.as_slice())
+                        .map_err(|_| CredentialClientError::CorruptedBlindSignRequest)?;
+                BandwidthVoucher::new_with_blind_sign_req(
+                    [serial_number, binding_number],
+                    [&state.amount.to_string(), VOUCHER_INFO],
+                    Hash::from_str(&self.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,
+                    )?,
+                    pedersen_commitments_openings,
+                    blind_sign_request,
+                )
+            } else {
+                return Err(CredentialClientError::NoLocalBlindSignRequest);
+            }
+        } else {
+            BandwidthVoucher::new(
+                &params,
+                state.amount.to_string(),
+                VOUCHER_INFO.to_string(),
+                Hash::from_str(&self.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)?,
+            )
+        };
+
+        // Back up the blind sign req data, in case of sporadic failures
+        state.blind_request_data = Some(RequestData::new(
+            bandwidth_credential_attributes.get_private_attributes(),
+            bandwidth_credential_attributes.pedersen_commitments_openings(),
+            bandwidth_credential_attributes.blind_sign_request(),
+        )?);
+        db.set(&self.tx_hash, &state).unwrap();
+
+        let signature =
+            obtain_aggregate_signature(&params, &bandwidth_credential_attributes, &urls).await?;
+        shared_storage
+            .insert_coconut_credential(
+                state.amount.to_string(),
+                VOUCHER_INFO.to_string(),
+                bandwidth_credential_attributes.get_private_attributes()[0].to_bs58(),
+                bandwidth_credential_attributes.get_private_attributes()[1].to_bs58(),
+                signature.to_bs58(),
+            )
+            .await?;
+        state.signature = Some(signature.to_bs58());
+        db.set(&self.tx_hash, &state).unwrap();
+
+        println!("Signature: {:?}", state.signature);
+
+        Ok(())
+    }
+}

clients/credential/src/error.rs

@@ -0,0 +1,45 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+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 validator_client::nymd::error::NymdError;
+
+pub type Result<T> = std::result::Result<T, CredentialClientError>;
+
+#[derive(Error, Debug)]
+pub enum CredentialClientError {
+    #[error("Nymd error: {0}")]
+    Nymd(#[from] NymdError),
+
+    #[error("Credential error: {0}")]
+    Credential(#[from] CredentialError),
+
+    #[error("No previous deposit with that tx hash")]
+    NoDeposit,
+
+    #[error("Wrong number of attributes")]
+    WrongAttributeNumber,
+
+    #[error("Could not find any backed up blind sign request data")]
+    NoLocalBlindSignRequest,
+
+    #[error("The local blind sign request data is corrupted")]
+    CorruptedBlindSignRequest,
+
+    #[error("The tx hash provided is not valid")]
+    InvalidTxHash,
+
+    #[error("Could not parse Ed25519 data")]
+    Ed25519ParseError(#[from] Ed25519RecoveryError),
+
+    #[error("Could not parse X25519 data")]
+    X25519ParseError(#[from] KeyRecoveryError),
+
+    #[error("Could not use shared storage")]
+    SharedStorageError(#[from] StorageError),
+}

clients/credential/src/main.rs

@@ -0,0 +1,63 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+cfg_if::cfg_if! {
+    if #[cfg(feature = "coconut")] {
+
+        mod client;
+        mod commands;
+        mod error;
+        mod state;
+
+        use commands::{Commands, Execute};
+        use error::Result;
+
+        use clap::Parser;
+        use pickledb::{PickleDb, PickleDbDumpPolicy, SerializationMethod};
+
+        pub const MNEMONIC: &str = "jazz fatigue diagram account outer wrist slide cherry mother grid network pause wolf pig round answer mail junior better hair dismiss toward access end";
+        pub const NYMD_URL: &str = "http://127.0.0.1:26657";
+        pub const CONTRACT_ADDRESS: &str = "nymt1nc5tatafv6eyq7llkr2gv50ff9e22mnfp9pc5s";
+        pub const SIGNER_AUTHORITIES: [&str; 1] = [
+            "http://127.0.0.1:8080",
+        ];
+
+        #[derive(Parser)]
+        #[clap(author = "Nymtech", version, about)]
+        struct Cli {
+            #[clap(subcommand)]
+            command: Commands,
+        }
+
+        #[tokio::main]
+        async fn main() -> Result<()> {
+            let args = Cli::parse();
+
+            let shared_storage = credential_storage::initialise_storage(std::path::PathBuf::from("/tmp/credential.db")).await;
+            let mut db = match PickleDb::load(
+                "credential.db",
+                PickleDbDumpPolicy::AutoDump,
+                SerializationMethod::Json,
+            ) {
+                Ok(db) => db,
+                Err(_) => PickleDb::new(
+                    "credential.db",
+                    PickleDbDumpPolicy::AutoDump,
+                    SerializationMethod::Json,
+                ),
+            };
+
+            match &args.command {
+                Commands::Deposit(m) => m.execute(&mut db, shared_storage).await?,
+                Commands::ListDeposits(m) => m.execute(&mut db, shared_storage).await?,
+                Commands::GetCredential(m) => m.execute(&mut db, shared_storage).await?,
+            }
+
+            Ok(())
+        }
+    } else {
+        fn main() {
+            println!("Crate only designed for coconut feature");
+        }
+    }
+}

clients/credential/src/state.rs

@@ -0,0 +1,72 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use coconut_interface::{Attribute, BlindSignRequest, Bytable, PrivateAttribute};
+use serde::{Deserialize, Serialize};
+
+use crypto::asymmetric::{encryption, identity};
+
+use crate::error::{CredentialClientError, Result};
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub(crate) struct KeyPair {
+    pub public_key: String,
+    pub private_key: String,
+}
+
+impl From<identity::KeyPair> for KeyPair {
+    fn from(kp: identity::KeyPair) -> Self {
+        Self {
+            public_key: kp.public_key().to_base58_string(),
+            private_key: kp.private_key().to_base58_string(),
+        }
+    }
+}
+
+impl From<encryption::KeyPair> for KeyPair {
+    fn from(kp: encryption::KeyPair) -> Self {
+        Self {
+            public_key: kp.public_key().to_base58_string(),
+            private_key: kp.private_key().to_base58_string(),
+        }
+    }
+}
+
+#[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 blind_request_data: Option<RequestData>,
+    pub signature: Option<String>,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub(crate) struct RequestData {
+    pub serial_number: Vec<u8>,
+    pub binding_number: Vec<u8>,
+    pub first_attribute: Vec<u8>,
+    pub second_attribute: Vec<u8>,
+    pub blind_sign_req: Vec<u8>,
+}
+
+impl RequestData {
+    pub fn new(
+        private_attributes: Vec<PrivateAttribute>,
+        attributes: &[Attribute],
+        blind_sign_request: &BlindSignRequest,
+    ) -> Result<Self> {
+        if private_attributes.len() != 2 || attributes.len() != 2 {
+            Err(CredentialClientError::WrongAttributeNumber)
+        } else {
+            Ok(RequestData {
+                serial_number: private_attributes[0].to_byte_vec(),
+                binding_number: private_attributes[1].to_byte_vec(),
+                first_attribute: attributes[0].to_byte_vec(),
+                second_attribute: attributes[1].to_byte_vec(),
+                blind_sign_req: blind_sign_request.to_bytes(),
+            })
+        }
+    }
+}

clients/native/Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "nym-client"
-version = "0.11.0"
+version = "1.0.1"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>", "Jędrzej Stuczyński <andrew@nymtech.net>"]
-edition = "2018"
+edition = "2021"
 rust-version = "1.56"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -34,6 +34,7 @@ tokio-tungstenite = "0.14" # websocket
 client-core = { path = "../client-core" }
 coconut-interface = { path = "../../common/coconut-interface", optional = true }
 credentials = { path = "../../common/credentials", optional = true }
+credential-storage = { path = "../../common/credential-storage" }
 config = { path = "../../common/config" }
 crypto = { path = "../../common/crypto" }
 gateway-client = { path = "../../common/client-libs/gateway-client" }
@@ -42,12 +43,16 @@ nymsphinx = { path = "../../common/nymsphinx" }
 pemstore = { path = "../../common/pemstore" }
 topology = { path = "../../common/topology" }
 websocket-requests = { path = "websocket-requests" }
-validator-client = { path = "../../common/client-libs/validator-client" }
+validator-client = { path = "../../common/client-libs/validator-client", features = ["nymd-client"] }
 version-checker = { path = "../../common/version-checker" }
 network-defaults = { path = "../../common/network-defaults" }
 
 [features]
-coconut = ["coconut-interface", "credentials", "gateway-requests/coconut", "gateway-client/coconut"]
+coconut = ["coconut-interface", "credentials", "credentials/coconut", "gateway-requests/coconut", "gateway-client/coconut", "client-core/coconut"]
+eth = []
 
 [dev-dependencies]
 serde_json = "1.0" # for the "textsend" example
+
+[build-dependencies]
+vergen = { version = "5", default-features = false, features = ["build", "git", "rustc", "cargo"] }

clients/native/build.rs

@@ -0,0 +1,8 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use vergen::{vergen, Config};
+
+fn main() {
+    vergen(Config::default()).expect("failed to extract build metadata")
+}

clients/native/examples/go-examples/websocket/go.mod

@@ -3,6 +3,5 @@ module github.com/nymtech/nym/clients/native/examples/go
 go 1.14
 
 require (
-	github.com/btcsuite/btcutil v1.0.2 // indirect
 	github.com/gorilla/websocket v1.4.2
 )

clients/native/examples/js-examples/websocket/package.json

@@ -18,14 +18,12 @@
   "author": "Dave Hrycyszyn",
   "license": "Apache-2.0",
   "devDependencies": {
-    "autoprefixer": "^10.2.6",
-    "clean-webpack-plugin": "^3.0.0",
-    "webpack": "^4.42.1",
-    "webpack-cli": "^3.3.11",
-    "webpack-dev-server": "^3.11.0"
+    "clean-webpack-plugin": "^4.0.0",
+    "webpack": "^5.70.0",
+    "webpack-cli": "^4.9.2",
+    "webpack-dev-server": "^4.7.4"
   },
   "dependencies": {
-    "core-js": "^3.6.5",
-    "html-webpack-plugin": "^4.2.0"
+    "html-webpack-plugin": "^5.5.0"
   }
 }

clients/native/examples/js-examples/websocket/webpack.config.js

@@ -1,9 +1,9 @@
-const autoprefixer = require('autoprefixer');
 const path = require('path');
 const HtmlWebpackPlugin = require('html-webpack-plugin');
 const { CleanWebpackPlugin } = require('clean-webpack-plugin');
 
 module.exports = {
+    mode: 'production',
     entry: './src/index.js',
     output: {
         filename: 'bundle.js',
@@ -18,7 +18,7 @@ module.exports = {
         })
     ],
     devServer: {
-        contentBase: path.join(__dirname, 'dist'),
+        static: path.join(__dirname, 'dist'),
         compress: true,
         port: 8888
     }

clients/native/examples/websocket_binarysend.rs

@@ -35,7 +35,7 @@ async fn send_file_with_reply() {
     let (mut ws_stream, _) = connect_async(uri).await.unwrap();
 
     let recipient = get_self_address(&mut ws_stream).await;
-    println!("our full address is: {}", recipient.to_string());
+    println!("our full address is: {}", recipient);
 
     let read_data = std::fs::read("examples/dummy_file").unwrap();
 
@@ -83,7 +83,7 @@ async fn send_file_without_reply() {
     let (mut ws_stream, _) = connect_async(uri).await.unwrap();
 
     let recipient = get_self_address(&mut ws_stream).await;
-    println!("our full address is: {}", recipient.to_string());
+    println!("our full address is: {}", recipient);
 
     let read_data = std::fs::read("examples/dummy_file").unwrap();
 

clients/native/examples/websocket_textsend.rs

@@ -36,7 +36,7 @@ async fn send_text_with_reply() {
     let (mut ws_stream, _) = connect_async(uri).await.unwrap();
 
     let recipient = get_self_address(&mut ws_stream).await;
-    println!("our full address is: {}", recipient.to_string());
+    println!("our full address is: {}", recipient);
 
     let send_request = json!({
         "type" : "send",
@@ -76,7 +76,7 @@ async fn send_text_without_reply() {
     let (mut ws_stream, _) = connect_async(uri).await.unwrap();
 
     let recipient = get_self_address(&mut ws_stream).await;
-    println!("our full address is: {}", recipient.to_string());
+    println!("our full address is: {}", recipient);
 
     let send_request = json!({
         "type" : "send",

clients/native/src/client/config/template.rs

@@ -5,7 +5,7 @@ pub(crate) fn config_template() -> &'static str {
     // While using normal toml marshalling would have been way simpler with less overhead,
     // I think it's useful to have comments attached to the saved config file to explain behaviour of
     // particular fields.
-    // Note: any changes to the template must be reflected in the appropriate structs in verloc.
+    // Note: any changes to the template must be reflected in the appropriate structs.
     r#"
 # This is a TOML config file.
 # For more information, see https://github.com/toml-lang/toml
@@ -19,6 +19,10 @@ version = '{{ client.version }}'
 # Human readable ID of this particular client.
 id = '{{ client.id }}'
 
+# Indicates whether this client is running in a disabled credentials mode, thus attempting
+# to claim bandwidth without presenting bandwidth credentials.
+disabled_credentials_mode = {{ client.disabled_credentials_mode }}
+
 # Addresses to APIs running on validator from which the client gets the view of the network.
 validator_api_urls = [
     {{#each client.validator_api_urls }}
@@ -42,10 +46,8 @@ public_encryption_key_file = '{{ client.public_encryption_key_file }}'
 # sent but not received back.
 reply_encryption_key_store_path = '{{ client.reply_encryption_key_store_path }}'
 
-# Path to directory containing public/private keys used for bandwidth token purchase.
-# Those are saved in case of emergency, to be able to reclaim bandwidth tokens.
-# The public key is the name of the file, while the private key is the content.
-backup_bandwidth_token_keys_dir = '{{ client.backup_bandwidth_token_keys_dir }}'
+# Path to the database containing bandwidth credentials
+database_path = '{{ client.database_path }}'
 
 # Ethereum private key.
 eth_private_key = '{{ client.eth_private_key }}'
@@ -55,12 +57,6 @@ eth_endpoint = '{{ client.eth_endpoint }}'
 
 ##### additional client config options #####
 
-# ID of the gateway from which the client should be fetching messages.
-gateway_id = '{{ client.gateway_id }}'
-
-# Address of the gateway listener to which all client requests should be sent.
-gateway_listener = '{{ client.gateway_listener }}'
-
 # A gateway specific, optional, base58 stringified shared key used for
 # communication with particular gateway.
 gateway_shared_key_file = '{{ client.gateway_shared_key_file }}'
@@ -74,6 +70,17 @@ ack_key_file = '{{ client.ack_key_file }}'
 # Absolute path to the home Nym Clients directory.
 nym_root_directory = '{{ client.nym_root_directory }}'
 
+[client.gateway_endpoint]
+# ID of the gateway from which the client should be fetching messages.
+gateway_id = '{{ client.gateway_endpoint.gateway_id }}'
+
+# Address of the gateway owner to which the client should send messages.
+gateway_owner = '{{ client.gateway_endpoint.gateway_owner }}'
+
+# Address of the gateway listener to which all client requests should be sent.
+gateway_listener = '{{ client.gateway_endpoint.gateway_listener }}'
+
+
 
 ##### socket config options #####
 

clients/native/src/client/mod.rs

@@ -32,7 +32,6 @@ use nymsphinx::addressing::clients::Recipient;
 use nymsphinx::addressing::nodes::NodeIdentity;
 use nymsphinx::anonymous_replies::ReplySurb;
 use nymsphinx::receiver::ReconstructedMessage;
-use tokio::runtime::Runtime;
 
 use crate::client::config::{Config, SocketType};
 use crate::websocket;
@@ -44,11 +43,6 @@ pub struct NymClient {
     /// key filepaths, etc.
     config: Config,
 
-    /// Tokio runtime used for futures execution.
-    // TODO: JS: Personally I think I prefer the implicit way of using it that we've done with the
-    // gateway.
-    runtime: Runtime,
-
     /// KeyManager object containing smart pointers to all relevant keys used by the client.
     key_manager: KeyManager,
 
@@ -68,7 +62,6 @@ impl NymClient {
         let key_manager = KeyManager::load_keys(&pathfinder).expect("failed to load stored keys");
 
         NymClient {
-            runtime: Runtime::new().unwrap(),
             config,
             key_manager,
             input_tx: None,
@@ -94,9 +87,6 @@ impl NymClient {
         mix_tx: BatchMixMessageSender,
     ) {
         info!("Starting loop cover traffic stream...");
-        // we need to explicitly enter runtime due to "next_delay: time::delay_for(Default::default())"
-        // set in the constructor which HAS TO be called within context of a tokio runtime
-        let _guard = self.runtime.enter();
 
         LoopCoverTrafficStream::new(
             self.key_manager.ack_key(),
@@ -109,7 +99,7 @@ impl NymClient {
             self.as_mix_recipient(),
             topology_accessor,
         )
-        .start(self.runtime.handle());
+        .start();
     }
 
     fn start_real_traffic_controller(
@@ -131,10 +121,6 @@ impl NymClient {
         );
 
         info!("Starting real traffic stream...");
-        // we need to explicitly enter runtime due to "next_delay: time::delay_for(Default::default())"
-        // set in the constructor [of OutQueueControl] which HAS TO be called within context of a tokio runtime
-        // When refactoring this restriction should definitely be removed.
-        let _guard = self.runtime.enter();
 
         RealMessagesController::new(
             controller_config,
@@ -144,7 +130,7 @@ impl NymClient {
             topology_accessor,
             reply_key_storage,
         )
-        .start(self.runtime.handle());
+        .start();
     }
 
     // buffer controlling all messages fetched from provider
@@ -162,10 +148,10 @@ impl NymClient {
             mixnet_receiver,
             reply_key_storage,
         )
-        .start(self.runtime.handle())
+        .start()
     }
 
-    fn start_gateway_client(
+    async fn start_gateway_client(
         &mut self,
         mixnet_message_sender: MixnetMessageSender,
         ack_sender: AcknowledgementSender,
@@ -174,6 +160,10 @@ impl NymClient {
         if gateway_id.is_empty() {
             panic!("The identity of the gateway is unknown - did you run `nym-client` init?")
         }
+        let gateway_owner = self.config.get_base().get_gateway_owner();
+        if gateway_owner.is_empty() {
+            panic!("The owner of the gateway is unknown - did you run `nym-client` init?")
+        }
         let gateway_address = self.config.get_base().get_gateway_listener();
         if gateway_address.is_empty() {
             panic!("The address of the gateway is unknown - did you run `nym-client` init?")
@@ -182,43 +172,47 @@ impl NymClient {
         let gateway_identity = identity::PublicKey::from_base58_string(gateway_id)
             .expect("provided gateway id is invalid!");
 
-        self.runtime.block_on(async {
-            #[cfg(feature = "coconut")]
-            let bandwidth_controller = BandwidthController::new(
-                self.config.get_base().get_validator_api_endpoints(),
-                *self.key_manager.identity_keypair().public_key(),
-            );
-            #[cfg(not(feature = "coconut"))]
-            let bandwidth_controller = BandwidthController::new(
-                self.config.get_base().get_eth_endpoint(),
-                self.config.get_base().get_eth_private_key(),
-                self.config.get_base().get_backup_bandwidth_token_keys_dir(),
-            )
-            .expect("Could not create bandwidth controller");
+        #[cfg(feature = "coconut")]
+        let bandwidth_controller = BandwidthController::new(
+            credential_storage::initialise_storage(self.config.get_base().get_database_path())
+                .await,
+            self.config.get_base().get_validator_api_endpoints(),
+        );
+        #[cfg(not(feature = "coconut"))]
+        let bandwidth_controller = BandwidthController::new(
+            credential_storage::initialise_storage(self.config.get_base().get_database_path())
+                .await,
+            self.config.get_base().get_eth_endpoint(),
+            self.config.get_base().get_eth_private_key(),
+        )
+        .expect("Could not create bandwidth controller");
 
-            let mut gateway_client = GatewayClient::new(
-                gateway_address,
-                self.key_manager.identity_keypair(),
-                gateway_identity,
-                Some(self.key_manager.gateway_shared_key()),
-                mixnet_message_sender,
-                ack_sender,
-                self.config.get_base().get_gateway_response_timeout(),
-                Some(bandwidth_controller),
-            );
+        let mut gateway_client = GatewayClient::new(
+            gateway_address,
+            self.key_manager.identity_keypair(),
+            gateway_identity,
+            gateway_owner,
+            Some(self.key_manager.gateway_shared_key()),
+            mixnet_message_sender,
+            ack_sender,
+            self.config.get_base().get_gateway_response_timeout(),
+            Some(bandwidth_controller),
+        );
 
-            gateway_client
-                .authenticate_and_start()
-                .await
-                .expect("could not authenticate and start up the gateway connection");
+        if self.config.get_base().get_disabled_credentials_mode() {
+            gateway_client.set_disabled_credentials_mode(true)
+        }
+        gateway_client
+            .authenticate_and_start()
+            .await
+            .expect("could not authenticate and start up the gateway connection");
 
-            gateway_client
-        })
+        gateway_client
     }
 
     // future responsible for periodically polling directory server and updating
     // the current global view of topology
-    fn start_topology_refresher(&mut self, topology_accessor: TopologyAccessor) {
+    async fn start_topology_refresher(&mut self, topology_accessor: TopologyAccessor) {
         let topology_refresher_config = TopologyRefresherConfig::new(
             self.config.get_base().get_validator_api_endpoints(),
             self.config.get_base().get_topology_refresh_rate(),
@@ -229,13 +223,10 @@ impl NymClient {
         // before returning, block entire runtime to refresh the current network view so that any
         // components depending on topology would see a non-empty view
         info!("Obtaining initial network topology");
-        self.runtime.block_on(topology_refresher.refresh());
+        topology_refresher.refresh().await;
 
         // TODO: a slightly more graceful termination here
-        if !self
-            .runtime
-            .block_on(topology_refresher.is_topology_routable())
-        {
+        if !topology_refresher.is_topology_routable().await {
             panic!(
                 "The current network topology seem to be insufficient to route any packets through\
                 - check if enough nodes and a gateway are online"
@@ -243,7 +234,7 @@ impl NymClient {
         }
 
         info!("Starting topology refresher...");
-        topology_refresher.start(self.runtime.handle());
+        topology_refresher.start();
     }
 
     // controller for sending sphinx packets to mixnet (either real traffic or cover traffic)
@@ -256,7 +247,7 @@ impl NymClient {
         gateway_client: GatewayClient,
     ) {
         info!("Starting mix traffic controller...");
-        MixTrafficController::new(mix_rx, gateway_client).start(self.runtime.handle());
+        MixTrafficController::new(mix_rx, gateway_client).start();
     }
 
     fn start_websocket_listener(
@@ -269,8 +260,7 @@ impl NymClient {
         let websocket_handler =
             websocket::Handler::new(msg_input, buffer_requester, self.as_mix_recipient());
 
-        websocket::Listener::new(self.config.get_listening_port())
-            .start(self.runtime.handle(), websocket_handler);
+        websocket::Listener::new(self.config.get_listening_port()).start(websocket_handler);
     }
 
     /// EXPERIMENTAL DIRECT RUST API
@@ -317,9 +307,9 @@ impl NymClient {
     }
 
     /// blocking version of `start` method. Will run forever (or until SIGINT is sent)
-    pub fn run_forever(&mut self) {
-        self.start();
-        if let Err(e) = self.runtime.block_on(tokio::signal::ctrl_c()) {
+    pub async fn run_forever(&mut self) {
+        self.start().await;
+        if let Err(e) = tokio::signal::ctrl_c().await {
             error!(
                 "There was an error while capturing SIGINT - {:?}. We will terminate regardless",
                 e
@@ -331,7 +321,7 @@ impl NymClient {
         );
     }
 
-    pub fn start(&mut self) {
+    pub async fn start(&mut self) {
         info!("Starting nym client");
         // channels for inter-component communication
         // TODO: make the channels be internally created by the relevant components
@@ -363,14 +353,17 @@ impl NymClient {
 
         // the components are started in very specific order. Unless you know what you are doing,
         // do not change that.
-        self.start_topology_refresher(shared_topology_accessor.clone());
+        self.start_topology_refresher(shared_topology_accessor.clone())
+            .await;
         self.start_received_messages_buffer_controller(
             received_buffer_request_receiver,
             mixnet_messages_receiver,
             reply_key_storage.clone(),
         );
 
-        let gateway_client = self.start_gateway_client(mixnet_messages_sender, ack_sender);
+        let gateway_client = self
+            .start_gateway_client(mixnet_messages_sender, ack_sender)
+            .await;
 
         self.start_mix_traffic_controller(sphinx_message_receiver, gateway_client);
         self.start_real_traffic_controller(

clients/native/src/commands/init.rs

@@ -4,20 +4,10 @@
 use clap::{App, Arg, ArgMatches};
 use client_core::client::key_manager::KeyManager;
 use client_core::config::persistence::key_pathfinder::ClientKeyPathfinder;
-#[cfg(feature = "coconut")]
-use coconut_interface::{hash_to_scalar, Credential, Parameters};
 use config::NymConfig;
-#[cfg(feature = "coconut")]
-use credentials::coconut::bandwidth::{
-    obtain_signature, prepare_for_spending, BandwidthVoucherAttributes, TOTAL_ATTRIBUTES,
-};
-#[cfg(feature = "coconut")]
-use credentials::obtain_aggregate_verification_key;
 use crypto::asymmetric::{encryption, identity};
 use gateway_client::GatewayClient;
 use gateway_requests::registration::handshake::SharedKeys;
-#[cfg(feature = "coconut")]
-use network_defaults::BANDWIDTH_VALUE;
 use nymsphinx::addressing::clients::Recipient;
 use nymsphinx::addressing::nodes::NodeIdentity;
 use rand::rngs::OsRng;
@@ -31,6 +21,12 @@ use url::Url;
 
 use crate::client::config::Config;
 use crate::commands::override_config;
+#[cfg(feature = "eth")]
+#[cfg(not(feature = "coconut"))]
+use crate::commands::{
+    DEFAULT_ETH_ENDPOINT, DEFAULT_ETH_PRIVATE_KEY, ENABLED_CREDENTIALS_MODE_ARG_NAME,
+    ETH_ENDPOINT_ARG_NAME, ETH_PRIVATE_KEY_ARG_NAME,
+};
 
 pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
     let app = App::new("init")
@@ -66,52 +62,32 @@ pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
             .hidden(true) // this will prevent this flag from being displayed in `--help`
             .help("Mostly debug-related option to increase default traffic rate so that you would not need to modify config post init")
         );
+    #[cfg(feature = "eth")]
     #[cfg(not(feature = "coconut"))]
         let app = app
-        .arg(Arg::with_name("eth_endpoint")
-            .long("eth_endpoint")
-            .help("URL of an Ethereum full node that we want to use for getting bandwidth tokens from ERC20 tokens")
+        .arg(
+            Arg::with_name(ENABLED_CREDENTIALS_MODE_ARG_NAME)
+                .long(ENABLED_CREDENTIALS_MODE_ARG_NAME)
+                .help("Set this client to work in a disabled credentials mode that would attempt to use gateway without bandwidth credential requirement. If this value is set, --eth_endpoint and --eth_private_key don't need to be set.")
+                .conflicts_with_all(&[ETH_ENDPOINT_ARG_NAME, ETH_PRIVATE_KEY_ARG_NAME])
+        )
+        .arg(Arg::with_name(ETH_ENDPOINT_ARG_NAME)
+            .long(ETH_ENDPOINT_ARG_NAME)
+            .help("URL of an Ethereum full node that we want to use for getting bandwidth tokens from ERC20 tokens. If you don't want to set this value, use --testnet-mode instead")
             .takes_value(true)
+            .default_value_if(ENABLED_CREDENTIALS_MODE_ARG_NAME, None, DEFAULT_ETH_ENDPOINT)
             .required(true))
-        .arg(Arg::with_name("eth_private_key")
-            .long("eth_private_key")
-            .help("Ethereum private key used for obtaining bandwidth tokens from ERC20 tokens")
+        .arg(Arg::with_name(ETH_PRIVATE_KEY_ARG_NAME)
+            .long(ETH_PRIVATE_KEY_ARG_NAME)
+            .help("Ethereum private key used for obtaining bandwidth tokens from ERC20 tokens. If you don't want to set this value, use --testnet-mode instead")
             .takes_value(true)
-            .required(true));
+            .default_value_if(ENABLED_CREDENTIALS_MODE_ARG_NAME, None, DEFAULT_ETH_PRIVATE_KEY)
+            .required(true)
+        );
 
     app
 }
 
-// this behaviour should definitely be changed, we shouldn't
-// need to get bandwidth credential for registration
-#[cfg(feature = "coconut")]
-async fn _prepare_temporary_credential(validators: &[Url], raw_identity: &[u8]) -> Credential {
-    let verification_key = obtain_aggregate_verification_key(validators)
-        .await
-        .expect("could not obtain aggregate verification key of validators");
-
-    let params = Parameters::new(TOTAL_ATTRIBUTES).unwrap();
-    let bandwidth_credential_attributes = BandwidthVoucherAttributes {
-        serial_number: params.random_scalar(),
-        binding_number: params.random_scalar(),
-        voucher_value: hash_to_scalar(BANDWIDTH_VALUE.to_be_bytes()),
-        voucher_info: hash_to_scalar(String::from("BandwidthVoucher").as_bytes()),
-    };
-
-    let bandwidth_credential =
-        obtain_signature(&params, &bandwidth_credential_attributes, validators)
-            .await
-            .expect("could not obtain bandwidth credential");
-
-    prepare_for_spending(
-        raw_identity,
-        &bandwidth_credential,
-        &bandwidth_credential_attributes,
-        &verification_key,
-    )
-    .expect("could not prepare out bandwidth credential for spending")
-}
-
 async fn register_with_gateway(
     gateway: &gateway::Node,
     our_identity: Arc<identity::KeyPair>,
@@ -120,6 +96,7 @@ async fn register_with_gateway(
     let mut gateway_client = GatewayClient::new_init(
         gateway.clients_address(),
         gateway.identity_key,
+        gateway.owner.clone(),
         our_identity.clone(),
         timeout,
     );
@@ -203,7 +180,7 @@ fn show_address(config: &Config) {
     println!("\nThe address of this client is: {}", client_recipient);
 }
 
-pub fn execute(matches: &ArgMatches) {
+pub async fn execute(matches: ArgMatches<'static>) {
     println!("Initialising client...");
 
     let id = matches.value_of("id").unwrap(); // required for now
@@ -221,7 +198,7 @@ pub fn execute(matches: &ArgMatches) {
 
     // TODO: ideally that should be the last thing that's being done to config.
     // However, we are later further overriding it with gateway id
-    config = override_config(config, matches);
+    config = override_config(config, &matches);
     if matches.is_present("fastmode") {
         config.get_base_mut().set_high_default_traffic_volume();
     }
@@ -234,26 +211,19 @@ pub fn execute(matches: &ArgMatches) {
 
         let chosen_gateway_id = matches.value_of("gateway");
 
-        let registration_fut = async {
-            let gate_details = gateway_details(
-                config.get_base().get_validator_api_endpoints(),
-                chosen_gateway_id,
-            )
-            .await;
-            config
-                .get_base_mut()
-                .with_gateway_id(gate_details.identity_key.to_base58_string());
-            let shared_keys =
-                register_with_gateway(&gate_details, key_manager.identity_keypair()).await;
-            (shared_keys, gate_details.clients_address())
-        };
+        let gateway_details = gateway_details(
+            config.get_base().get_validator_api_endpoints(),
+            chosen_gateway_id,
+        )
+        .await;
+        let shared_keys =
+            register_with_gateway(&gateway_details, key_manager.identity_keypair()).await;
 
-        // TODO: is there perhaps a way to make it work without having to spawn entire runtime?
-        let rt = tokio::runtime::Runtime::new().unwrap();
-        let (shared_keys, gateway_listener) = rt.block_on(registration_fut);
-        config
-            .get_base_mut()
-            .with_gateway_listener(gateway_listener);
+        config.get_base_mut().with_gateway_endpoint(
+            gateway_details.identity_key.to_base58_string(),
+            gateway_details.owner.clone(),
+            gateway_details.clients_address(),
+        );
         key_manager.insert_gateway_shared_key(shared_keys);
 
         let pathfinder = ClientKeyPathfinder::new_from_config(config.get_base());

clients/native/src/commands/mod.rs

@@ -5,6 +5,18 @@ use crate::client::config::{Config, SocketType};
 use clap::ArgMatches;
 use url::Url;
 
+pub(crate) const ENABLED_CREDENTIALS_MODE_ARG_NAME: &str = "enabled-credentials-mode";
+#[cfg(not(feature = "coconut"))]
+pub(crate) const ETH_ENDPOINT_ARG_NAME: &str = "eth_endpoint";
+#[cfg(not(feature = "coconut"))]
+pub(crate) const ETH_PRIVATE_KEY_ARG_NAME: &str = "eth_private_key";
+#[cfg(not(feature = "coconut"))]
+pub(crate) const DEFAULT_ETH_ENDPOINT: &str =
+    "https://rinkeby.infura.io/v3/00000000000000000000000000000000";
+#[cfg(not(feature = "coconut"))]
+pub(crate) const DEFAULT_ETH_PRIVATE_KEY: &str =
+    "0000000000000000000000000000000000000000000000000000000000000001";
+
 pub(crate) mod init;
 pub(crate) mod run;
 pub(crate) mod upgrade;
@@ -20,7 +32,7 @@ fn parse_validators(raw: &str) -> Vec<Url> {
         .collect()
 }
 
-pub(crate) fn override_config(mut config: Config, matches: &ArgMatches) -> Config {
+pub(crate) fn override_config(mut config: Config, matches: &ArgMatches<'_>) -> Config {
     if let Some(raw_validators) = matches.value_of("validators") {
         config
             .get_base_mut()
@@ -44,12 +56,24 @@ pub(crate) fn override_config(mut config: Config, matches: &ArgMatches) -> Confi
     }
 
     #[cfg(not(feature = "coconut"))]
-    if let Some(eth_endpoint) = matches.value_of("eth_endpoint") {
+    if let Some(eth_endpoint) = matches.value_of(ETH_ENDPOINT_ARG_NAME) {
         config.get_base_mut().with_eth_endpoint(eth_endpoint);
+    } else if !cfg!(feature = "eth") {
+        config
+            .get_base_mut()
+            .with_eth_endpoint(DEFAULT_ETH_ENDPOINT);
     }
     #[cfg(not(feature = "coconut"))]
-    if let Some(eth_private_key) = matches.value_of("eth_private_key") {
+    if let Some(eth_private_key) = matches.value_of(ETH_PRIVATE_KEY_ARG_NAME) {
         config.get_base_mut().with_eth_private_key(eth_private_key);
+    } else if !cfg!(feature = "eth") {
+        config
+            .get_base_mut()
+            .with_eth_private_key(DEFAULT_ETH_PRIVATE_KEY);
+    }
+
+    if matches.is_present(ENABLED_CREDENTIALS_MODE_ARG_NAME) {
+        config.get_base_mut().with_disabled_credentials(false)
     }
 
     config

clients/native/src/commands/run.rs

@@ -4,6 +4,11 @@
 use crate::client::config::Config;
 use crate::client::NymClient;
 use crate::commands::override_config;
+#[cfg(feature = "eth")]
+#[cfg(not(feature = "coconut"))]
+use crate::commands::{
+    ENABLED_CREDENTIALS_MODE_ARG_NAME, ETH_ENDPOINT_ARG_NAME, ETH_PRIVATE_KEY_ARG_NAME,
+};
 use clap::{App, Arg, ArgMatches};
 use config::NymConfig;
 use log::*;
@@ -39,15 +44,22 @@ pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
             .help("Port for the socket (if applicable) to listen on")
             .takes_value(true)
         );
+    #[cfg(feature = "eth")]
     #[cfg(not(feature = "coconut"))]
         let app = app
-        .arg(Arg::with_name("eth_endpoint")
-            .long("eth_endpoint")
-            .help("URL of an Ethereum full node that we want to use for getting bandwidth tokens from ERC20 tokens")
+        .arg(
+            Arg::with_name(ENABLED_CREDENTIALS_MODE_ARG_NAME)
+                .long(ENABLED_CREDENTIALS_MODE_ARG_NAME)
+                .help("Set this client to work in a enabled credentials mode that would attempt to use gateway with bandwidth credential requirement. If this value is set, --eth_endpoint and --eth_private_key don't need to be set.")
+                .conflicts_with_all(&[ETH_ENDPOINT_ARG_NAME, ETH_PRIVATE_KEY_ARG_NAME])
+        )
+        .arg(Arg::with_name(ETH_ENDPOINT_ARG_NAME)
+            .long(ETH_ENDPOINT_ARG_NAME)
+            .help("URL of an Ethereum full node that we want to use for getting bandwidth tokens from ERC20 tokens. If you don't want to set this value, use --testnet-mode instead")
             .takes_value(true))
-        .arg(Arg::with_name("eth_private_key")
-            .long("eth_private_key")
-            .help("Ethereum private key used for obtaining bandwidth tokens from ERC20 tokens")
+        .arg(Arg::with_name(ETH_PRIVATE_KEY_ARG_NAME)
+            .long(ETH_PRIVATE_KEY_ARG_NAME)
+            .help("Ethereum private key used for obtaining bandwidth tokens from ERC20 tokens. If you don't want to set this value, use --testnet-mode instead")
             .takes_value(true));
 
     app
@@ -72,7 +84,7 @@ fn version_check(cfg: &Config) -> bool {
     }
 }
 
-pub fn execute(matches: &ArgMatches) {
+pub async fn execute(matches: ArgMatches<'static>) {
     let id = matches.value_of("id").unwrap();
 
     let mut config = match Config::load_from_file(Some(id)) {
@@ -83,12 +95,12 @@ pub fn execute(matches: &ArgMatches) {
         }
     };
 
-    config = override_config(config, matches);
+    config = override_config(config, &matches);
 
     if !version_check(&config) {
         error!("failed the local version check");
         return;
     }
 
-    NymClient::new(config).run_forever();
+    NymClient::new(config).run_forever().await;
 }

clients/native/src/commands/upgrade.rs

@@ -95,7 +95,7 @@ fn parse_package_version() -> Version {
 
 fn minor_0_12_upgrade(
     mut config: Config,
-    _matches: &ArgMatches,
+    _matches: &ArgMatches<'_>,
     config_version: &Version,
     package_version: &Version,
 ) -> Config {
@@ -131,7 +131,7 @@ fn minor_0_12_upgrade(
     config
 }
 
-fn do_upgrade(mut config: Config, matches: &ArgMatches, package_version: Version) {
+fn do_upgrade(mut config: Config, matches: &ArgMatches<'_>, package_version: Version) {
     loop {
         let config_version = parse_config_version(&config);
 
@@ -151,7 +151,7 @@ fn do_upgrade(mut config: Config, matches: &ArgMatches, package_version: Version
     }
 }
 
-pub fn execute(matches: &ArgMatches) {
+pub fn execute(matches: &ArgMatches<'_>) {
     let package_version = parse_package_version();
 
     let id = matches.value_of("id").unwrap();

clients/native/src/main.rs

@@ -1,19 +1,22 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use clap::{App, ArgMatches};
+use clap::{crate_version, App, ArgMatches};
+use network_defaults::DEFAULT_NETWORK;
 
 pub mod client;
 pub mod commands;
 pub mod websocket;
 
-fn main() {
+#[tokio::main]
+async fn main() {
     dotenv::dotenv().ok();
     setup_logging();
     println!("{}", banner());
 
     let arg_matches = App::new("Nym Client")
-        .version(env!("CARGO_PKG_VERSION"))
+        .version(crate_version!())
+        .long_version(&*long_version())
         .author("Nymtech")
         .about("Implementation of the Nym Client")
         .subcommand(commands::init::command_args())
@@ -21,13 +24,13 @@ fn main() {
         .subcommand(commands::upgrade::command_args())
         .get_matches();
 
-    execute(arg_matches);
+    execute(arg_matches).await;
 }
 
-fn execute(matches: ArgMatches) {
+async fn execute(matches: ArgMatches<'static>) {
     match matches.subcommand() {
-        ("init", Some(m)) => commands::init::execute(m),
-        ("run", Some(m)) => commands::run::execute(m),
+        ("init", Some(m)) => commands::init::execute(m.clone()).await,
+        ("run", Some(m)) => commands::run::execute(m.clone()).await,
         ("upgrade", Some(m)) => commands::upgrade::execute(m),
         _ => println!("{}", usage()),
     }
@@ -50,7 +53,41 @@ fn banner() -> String {
              (client - version {:})
 
     "#,
-        env!("CARGO_PKG_VERSION")
+        crate_version!()
+    )
+}
+
+fn long_version() -> String {
+    format!(
+        r#"
+{:<20}{}
+{:<20}{}
+{:<20}{}
+{:<20}{}
+{:<20}{}
+{:<20}{}
+{:<20}{}
+{:<20}{}
+{:<20}{}
+"#,
+        "Build Timestamp:",
+        env!("VERGEN_BUILD_TIMESTAMP"),
+        "Build Version:",
+        env!("VERGEN_BUILD_SEMVER"),
+        "Commit SHA:",
+        env!("VERGEN_GIT_SHA"),
+        "Commit Date:",
+        env!("VERGEN_GIT_COMMIT_TIMESTAMP"),
+        "Commit Branch:",
+        env!("VERGEN_GIT_BRANCH"),
+        "rustc Version:",
+        env!("VERGEN_RUSTC_SEMVER"),
+        "rustc Channel:",
+        env!("VERGEN_RUSTC_CHANNEL"),
+        "cargo Profile:",
+        env!("VERGEN_CARGO_PROFILE"),
+        "Network:",
+        DEFAULT_NETWORK
     )
 }
 

clients/native/src/websocket/listener.rs

@@ -5,7 +5,6 @@ use super::handler::Handler;
 use log::*;
 use std::{net::SocketAddr, process, sync::Arc};
 use tokio::io::AsyncWriteExt;
-use tokio::runtime;
 use tokio::{sync::Notify, task::JoinHandle};
 
 enum State {
@@ -87,9 +86,9 @@ impl Listener {
         }
     }
 
-    pub(crate) fn start(mut self, rt_handle: &runtime::Handle, handler: Handler) -> JoinHandle<()> {
+    pub(crate) fn start(mut self, handler: Handler) -> JoinHandle<()> {
         info!("Running websocket on {:?}", self.address.to_string());
 
-        rt_handle.spawn(async move { self.run(handler).await })
+        tokio::spawn(async move { self.run(handler).await })
     }
 }

clients/native/websocket-requests/Cargo.toml

@@ -2,7 +2,7 @@
 name = "websocket-requests"
 version = "0.1.0"
 authors = ["Jędrzej Stuczyński <andrew@nymtech.net>"]
-edition = "2018"
+edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 

clients/socks5/Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "nym-socks5-client"
-version = "0.11.0"
+version = "1.0.1"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
-edition = "2018"
+edition = "2021"
 rust-version = "1.56"
 
 [lib]
@@ -27,6 +27,7 @@ url = "2.2"
 client-core = { path = "../client-core" }
 coconut-interface = { path = "../../common/coconut-interface", optional = true }
 credentials = { path = "../../common/credentials", optional = true }
+credential-storage = { path = "../../common/credential-storage" }
 config = { path = "../../common/config" }
 crypto = { path = "../../common/crypto" }
 gateway-client = { path = "../../common/client-libs/gateway-client" }
@@ -37,9 +38,13 @@ socks5-requests = { path = "../../common/socks5/requests" }
 topology = { path = "../../common/topology" }
 pemstore = { path = "../../common/pemstore" }
 proxy-helpers = { path = "../../common/socks5/proxy-helpers" }
-validator-client = { path = "../../common/client-libs/validator-client" }
+validator-client = { path = "../../common/client-libs/validator-client", features = ["nymd-client"] }
 version-checker = { path = "../../common/version-checker" }
 network-defaults = { path = "../../common/network-defaults" }
 
 [features]
-coconut = ["coconut-interface", "credentials", "gateway-requests/coconut", "gateway-client/coconut"]
+coconut = ["coconut-interface", "credentials", "gateway-requests/coconut", "gateway-client/coconut", "credentials/coconut", "client-core/coconut"]
+eth = []
+
+[build-dependencies]
+vergen = { version = "5", default-features = false, features = ["build", "git", "rustc", "cargo"] }

clients/socks5/build.rs

@@ -0,0 +1,8 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use vergen::{vergen, Config};
+
+fn main() {
+    vergen(Config::default()).expect("failed to extract build metadata")
+}