Implement base line for tests on the validator ts client

- This will need to be separated and configured accordingly 
- This was a quick spin up, using jest as a library to implement some coverage
- Further things to be refined - mocks, more coverage, better configuration, clean up methods, improve env vars

.github/CODEOWNERS

@@ -1,3 +1,40 @@
-# Global owners. If you want to set more specific (per-directory, per-language) owners, see the write-up at
-# https://docs.github.com/en/github/creating-cloning-and-archiving-repositories/creating-a-repository-on-github/about-code-owners
-* @durch @futurechimp @jstuczyn @neacsu
+# Lines starting with '#' are comments.
+# Each line is a file pattern followed by one or more owners.
+
+# More details are here: https://help.github.com/articles/about-codeowners/
+
+# The '*' pattern is global owners.
+
+# Order is important. The last matching pattern has the most precedence.
+# The folders are ordered as follows:
+
+# In each subsection folders are ordered first by depth, then alphabetically.
+# This should make it easy to add new rules without breaking existing ones.
+
+# Something weird not covered by anything else
+* @futurechimp @mmsinclair
+
+# Rust rules:
+*.rs @durch @futurechimp @jstuczyn @neacsu
+Cargo.* @durch @futurechimp @jstuczyn @neacsu
+
+# JS rules:
+*.js @mmsinclair @fmtabbara @Aid19801
+*.ts @mmsinclair @fmtabbara @Aid19801
+*.tsx @mmsinclair @fmtabbara @Aid19801
+*.jsx @mmsinclair @fmtabbara @Aid19801
+
+# Something looking like possible documentation rules:
+*.md @mfahampshire
+
+# our docker scripts
+/docker/ @neacsu
+
+# if there are any changes in the core crypto, I feel like Ania should take a look:
+/common/crypto/ @aniampio
+/common/nymsphinx/ @aniampio
+
+# Explorer and wallet should probably get looked by the product team
+/explorer/ @nymtech/product 
+/nym-wallet/ @nymtech/product 
+/wallet-web/ @nymtech/product

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,32 @@
+---
+name: Feature request
+about: Suggest an enhancement to the product
+title: "[Feature Request]"
+labels: enhancement
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is...
+
+**Is your request a feature not related to an existing problem? A new feature.**
+For example. 
+- Given I am using the nym wallet
+- When I transfer nym tokens across the network
+- Then I want to have an url link in the wallet which navigates outside the application to the nym-explorer
+
+**Where does the feature fit in the Nym real estate?**
+- Application / UI 
+
+**What is this solving?**
+How will this improve the product...
+
+**Is this an update to packages or libraries?**
+If so, please list them. If not, please ignore this section.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/ISSUE_TEMPLATE/report.md

@@ -0,0 +1,43 @@
+---
+name: Report
+about: To help identify and reproduce issues
+title: "[Issue]"
+labels: bug, bug-needs-triage, qa
+assignees: tommyv1987
+
+---
+
+**Describe the issue**
+A clear and concise description of what the issue is...
+
+**Expected behaviour**
+A clear and concise description of what you expected to happen...
+
+**Stack Traces**
+If there are stack traces or logs, please provide them here...
+
+**Steps to Reproduce**
+Steps to reproduce the behaviour, if you're familiar with BDD syntax, please write it in this style:
+- Given I was doing X
+- And I installed Y
+- When I actioned Y
+- Then I expect Z
+
+*An example:*
+- Given I was setting up a mix-node following the instructions in the docs
+- And I successfully bonded my node via the the wallet
+- When I went to start my mixnode
+- Then I was presented with an error
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem...
+
+**Which area of Nym were you using?**
+ - UI: [e.g. Websites - network-explorer, nym-website]
+ - Application: [e.g Gateway, Client, Wallet]
+ - OS: [e.g. Ubuntu 20.x, MacOs Big Sur, Windows 10]
+ - Browser: [e.g Chrome (if applicable)]
+ - Version: [e.g. nym binary(0.11.0), browser(94.0)]
+
+**Additional context**
+Please provide any other information

.github/workflows/build.yml

@@ -1,72 +1,102 @@
 name: Continuous integration
 
-on: [push, pull_request]
+on:
+  push:
+    paths-ignore:
+      - 'explorer/**'
+  pull_request:
+    paths-ignore:
+      - 'explorer/**'
 
 jobs:
-  ci:
-    runs-on: ${{ matrix.os }}
-    continue-on-error: ${{ matrix.rust == 'nightly' || matrix.rust == 'beta' }}
-    strategy:
-      matrix:
-        rust: [stable, beta, nightly]
-        os: [ubuntu-latest, macos-latest, windows-latest]
-
+  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' }}
+    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'
 
-      - uses: actions-rs/toolchain@v1
+      - 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
 
-      # main repo
-      - uses: actions-rs/cargo@v1
+      - name: Build all binaries
+        uses: actions-rs/cargo@v1
         with:
           command: build
           args: --all
 
-      # validator API
-      - uses: actions-rs/cargo@v1
-        with:
-          command: build
-          args: --manifest-path validator-api/Cargo.toml
-
-      # main repo
-      - uses: actions-rs/cargo@v1
+      - name: Run all tests
+        uses: actions-rs/cargo@v1
         with:
           command: test
           args: --all
 
-      # validator API
-      - uses: actions-rs/cargo@v1
-        with:
-          command: test
-          args: --manifest-path validator-api/Cargo.toml
-
-      # main repo
-      - uses: actions-rs/cargo@v1
+      - name: Check formatting
+        uses: actions-rs/cargo@v1
         with:
           command: fmt
           args: --all -- --check
 
-      # validator API
-      - uses: actions-rs/cargo@v1
+      - uses: actions-rs/clippy-check@v1
+        name: Clippy checks
+#        if: matrix.os == 'ubuntu-latest' && matrix.rust == 'stable'
         with:
-          command: fmt
-          args: --manifest-path validator-api/Cargo.toml  -- --check
+          token: ${{ secrets.GITHUB_TOKEN }}
+          args: --all-features
 
-      # main repo
-      - uses: actions-rs/cargo@v1
+      - name: Run clippy
+        uses: actions-rs/cargo@v1
         if: ${{ matrix.rust != 'nightly' }}
         with:
           command: clippy
           args: -- -D warnings
 
-      # validator API
-      - uses: actions-rs/cargo@v1
+#        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
+
+      - name: Build all binaries with coconut enabled
+        uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: --all --features=coconut
+
+      - name: Run all tests with coconut enabled
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --all --features=coconut
+
+      - name: Run clippy with coconut enabled
+        uses: actions-rs/cargo@v1
         if: ${{ matrix.rust != 'nightly' }}
         with:
           command: clippy
-          args: --manifest-path validator-api/Cargo.toml -- -D warnings
+          args: --features=coconut -- -D warnings

.github/workflows/build_matrix_includes.json

@@ -0,0 +1,50 @@
+[
+  {
+    "os":"ubuntu-latest",
+    "rust":"stable",
+    "runOnEvent":"always"
+  },
+
+  {
+    "os":"windows-latest",
+    "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/clippy_check.yml

@@ -1,14 +0,0 @@
-name: Clippy check
-
-on: push
-
-jobs:
-  clippy_check:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v1
-      - run: rustup component add clippy
-      - uses: actions-rs/clippy-check@v1
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          args: --all-features 

.github/workflows/contract_matrix_includes.json

@@ -0,0 +1,14 @@
+[
+  {
+    "rust":"stable",
+    "runOnEvent":"always"
+  },
+  {
+    "rust":"beta",
+    "runOnEvent":"pull_request"
+  },
+  {
+    "rust":"nightly",
+    "runOnEvent":"pull_request"
+  }
+]

.github/workflows/contracts.yml

@@ -0,0 +1,64 @@
+name: Contracts
+
+on:
+  push:
+    paths-ignore:
+      - 'explorer/**'
+  pull_request:
+    paths-ignore:
+      - '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/contract_matrix_includes.json'
+          filter: '[?runOnEvent==`${{ github.event_name }}` || runOnEvent==`always`]'
+  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
+    continue-on-error: ${{ matrix.rust == 'nightly' }}
+    needs: matrix_prep
+    strategy:
+      matrix: ${{fromJson(needs.matrix_prep.outputs.matrix)}}
+    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/Cargo.toml --all --target wasm32-unknown-unknown
+
+      - uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --manifest-path contracts/Cargo.toml
+
+      - uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: --manifest-path contracts/Cargo.toml --all -- --check
+
+      - uses: actions-rs/cargo@v1
+        if: ${{ matrix.rust != 'nightly' }}
+        with:
+          command: clippy
+          args: --manifest-path contracts/Cargo.toml --all -- -D warnings

.github/workflows/mixnet_contract.yml

@@ -1,44 +0,0 @@
-name: Mixnet Contract
-
-on: [push, pull_request]
-
-jobs:
-  ci:
-    # 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' }}
-    strategy:
-      matrix:
-        rust: [ stable, beta, 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
-        with:
-          command: build
-          args: --manifest-path contracts/mixnet/Cargo.toml --target wasm32-unknown-unknown
-
-      - uses: actions-rs/cargo@v1
-        with:
-          command: test
-          args: --manifest-path contracts/mixnet/Cargo.toml
-
-      - uses: actions-rs/cargo@v1
-        with:
-          command: fmt
-          args: --manifest-path contracts/mixnet/Cargo.toml -- --check
-
-      - uses: actions-rs/cargo@v1
-        if: ${{ matrix.rust != 'nightly' }}
-        with:
-          command: clippy
-          args: --manifest-path contracts/mixnet/Cargo.toml -- -D warnings

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

@@ -0,0 +1,23 @@
+name: Linting for Network Explorer (eslint/prettier)
+
+on:
+  pull_request:
+    paths:
+      - 'explorer/**'
+
+defaults:
+  run:
+    working-directory: explorer
+
+jobs:
+  build:
+    runs-on: custom-runner-linux
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: '14'
+      - run: npm install
+      - name: Run ESLint
+        # GitHub should automatically annotate the PR
+        run: npm run lint

.github/workflows/network-explorer.yml

@@ -0,0 +1,59 @@
+name: CI for Network Explorer
+
+on:
+  push:
+    paths:
+      - 'explorer/**'
+
+defaults:
+  run:
+    working-directory: explorer
+
+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: '14'
+    - run: npm install
+      continue-on-error: true
+    - name: Set environment from the example
+      run: cp .env.prod .env
+    - run: npm run test
+      continue-on-error: true
+    - run: npm run build
+      continue-on-error: true
+    - name: Deploy branch to CI www
+      continue-on-error: true
+      uses: easingthemes/ssh-deploy@main
+      env:
+        SSH_PRIVATE_KEY: ${{ secrets.CI_WWW_SSH_PRIVATE_KEY }}
+        ARGS: "-rltgoDzvO --delete"
+        SOURCE: "explorer/dist/"
+        REMOTE_HOST: ${{ secrets.CI_WWW_REMOTE_HOST }}
+        REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
+        TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/network-explorer-${{ env.GITHUB_REF_SLUG }}
+        EXCLUDE: "/dist/, /node_modules/"
+    - name: Keybase - Node Install
+      run: npm install
+      working-directory: .github/workflows/support-files/messages
+    - name: Keybase - Send Notification
+      env:
+        NYM_PROJECT_NAME: "Network Explorer"
+        NYM_CI_WWW_BASE: "${{ secrets.NYM_CI_WWW_BASE }}"
+        NYM_CI_WWW_LOCATION: "network-explorer-${{ env.GITHUB_REF_SLUG }}"
+        GIT_COMMIT_MESSAGE: "${{ github.event.head_commit.message }}"
+        GIT_BRANCH: "${GITHUB_REF##*/}"
+        KEYBASE_NYMBOT_USERNAME: "${{ secrets.KEYBASE_NYMBOT_USERNAME }}"
+        KEYBASE_NYMBOT_PAPERKEY: "${{ secrets.KEYBASE_NYMBOT_PAPERKEY }}"
+        KEYBASE_NYMBOT_TEAM: "${{ secrets.KEYBASE_NYMBOT_TEAM }}"
+        KEYBASE_NYM_CHANNEL: "ci-network-explorer"
+        IS_SUCCESS: "${{ job.status == 'success' }}"
+      uses: docker://keybaseio/client:stable-node
+      with:
+        args: .github/workflows/support-files/messages/entry_point_notifications.sh

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

@@ -0,0 +1,12 @@
+name: Publish Nym 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/nym-wallet-types.yml

@@ -0,0 +1,29 @@
+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/nym_wallet.yml

@@ -0,0 +1,77 @@
+name: Webdriverio tests for nym wallet
+
+on:
+  push:
+    paths:
+      - "nym-wallet/**"
+
+defaults:
+  run:
+    working-directory: nym-wallet
+
+jobs:
+  test:
+    name: wallet tests
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Tauri dependencies
+        run: >
+          sudo apt-get update &&
+          sudo apt-get install -y
+          libgtk-3-dev
+          libgtksourceview-3.0-dev
+          webkit2gtk-4.0
+          libappindicator3-dev
+          webkit2gtk-driver
+          xvfb
+
+      - name: Install minimal stable
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: stable
+
+      - name: Node v16
+        uses: actions/setup-node@v1
+        with:
+          node-version: 16.x
+
+      - name: Install yarn for building application
+        run: yarn install
+
+      - name: Build application
+        run: yarn run webpack:build & yarn run tauri:build
+
+      - name: Check binary exists
+        run: |
+          cd target/release/
+          (test -f nym-wallet && echo nym binary exists) || echo wallet does not exist
+
+      - name: Install dependencies
+        run: yarn install
+        working-directory: nym-wallet/webdriver
+
+      - name: Remove existing user datafile
+        uses: JesseTG/rm@v1.0.2
+        with:
+          path: nym-wallet/webdriver/common/data/user-data.json
+
+      - name: Create user data json file
+        id: create-json
+        uses: jsdaniell/create-json@1.1.2
+        with:
+          name: "user-data.json"
+          json: ${{ secrets.WALLET_USERDATA }}
+          dir: "nym-wallet/webdriver/common/data/"
+
+      - name: Install tauri-driver
+        uses: actions-rs/cargo@v1
+        with:
+          command: install
+          args: tauri-driver
+
+      - name: Launch tests
+        run: xvfb-run yarn test:runall
+        working-directory: nym-wallet/webdriver

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

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

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

@@ -0,0 +1,6 @@
+{
+  "trailingComma": "all",
+  "singleQuote": true,
+  "printWidth": 80,
+  "tabWidth": 2
+}

.github/workflows/support-files/messages/entry_point_notifications.sh

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+
+# pass exit codes out to GitHub Actions
+set -euxo pipefail
+
+# change to the directory that contains this script
+cd "${0%/*}"
+
+# run the node script
+node send_message.js

.github/workflows/support-files/messages/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/messages/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "send-keybase-message",
+  "description": "Sends a notification message with the keybase package that fails when piped into the keybase CLI",
+  "version": "1.0.0",
+  "private": true,
+  "scripts": {
+    "format": "prettier --write send_message.js"
+  },
+  "dependencies": {
+    "handlebars": "^4.7.7",
+    "keybase-bot": "^3.6.1"
+  },
+  "devDependencies": {
+    "prettier": "2.3.2"
+  }
+}

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

@@ -0,0 +1,69 @@
+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/messages/success

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

.github/workflows/wasm_client_build.yml

@@ -1,9 +1,12 @@
 name: Wasm Client
 
-on: [push, pull_request]
+on:
+  pull_request:
+    paths-ignore:
+      - 'explorer/**'
 
 jobs:
-  ci:
+  wasm:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
@@ -16,10 +19,16 @@ 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
+          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
@@ -36,4 +45,4 @@ jobs:
 #      - uses: actions-rs/cargo@v1
 #        with:
 #          command: clippy
-#          args: --manifest-path clients/webassembly/Cargo.toml --target wasm32-unknown-unknown -- -D warnings
+#          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

@@ -11,7 +11,6 @@ target
 /.vscode/settings.json
 validator/.vscode
 sample-configs/validator-config.toml
-.vscode
 scripts/deploy_qa.sh
 scripts/run_gate.sh
 scripts/run_mix.sh
@@ -25,7 +24,15 @@ v6-topology.json
 /explorer/downloads/topology.json
 /explorer/public/downloads/mixmining.json
 /explorer/public/downloads/topology.json
+/nym-wallet/dist/*
 /clients/validator/examples/nym-driver-example/current-contract.txt
 validator-api/v4.json
 validator-api/v6.json
 **/node_modules
+validator-api/keypair
+contracts/mixnet/code_id
+contracts/mixnet/Justfile
+contracts/mixnet/Makefile
+validator-config
+*.patch
+validator-api-config.toml

.ruby-version

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

Cargo.toml

@@ -4,6 +4,7 @@
 [profile.release]
 panic = "abort"
 opt-level = "s"
+overflow-checks = true
 
 [profile.dev]
 panic = "abort"
@@ -11,19 +12,25 @@ panic = "abort"
 [workspace]
 
 members = [
+    "clients/client-core",
     "clients/native",
     "clients/native/websocket-requests",
     "clients/socks5",
+    "clients/tauri-client/src-tauri",
     "clients/webassembly",
-    "clients/client-core",
     "common/client-libs/gateway-client",
     "common/client-libs/mixnet-client",
     "common/client-libs/validator-client",
+    "common/coconut-interface",
     "common/config",
+    "common/credentials",
     "common/crypto",
+    "common/bandwidth-claim-contract",
     "common/mixnet-contract",
     "common/mixnode-common",
+    "common/network-defaults",
     "common/nonexhaustive-delayqueue",
+    "common/nymcoconut",
     "common/nymsphinx",
     "common/nymsphinx/acknowledgements",
     "common/nymsphinx/addressing",
@@ -35,15 +42,16 @@ members = [
     "common/nymsphinx/params",
     "common/nymsphinx/types",
     "common/pemstore",
-    "common/socks5/requests",
     "common/socks5/proxy-helpers",
+    "common/socks5/requests",
     "common/topology",
     "common/wasm-utils",
+    "explorer-api",
     "gateway",
     "gateway/gateway-requests",
     "mixnode",
-#    "validator-api",
     "service-providers/network-requester",
+    "validator-api",
 ]
 
 default-members = [
@@ -53,7 +61,8 @@ default-members = [
     "gateway",
     "service-providers/network-requester",
     "mixnode",
-#    "validator-api",
+    "validator-api",
+    "explorer-api",
 ]
 
-exclude = ["explorer", "contracts", "validator-api"]
+exclude = ["explorer", "contracts", "tokenomics-py"]

Makefile

@@ -0,0 +1,45 @@
+all: clippy-all test fmt
+happy: clippy-happy test fmt
+clippy-all: clippy-all-main clippy-all-contracts clippy-all-wallet
+clippy-happy: clippy-happy-main clippy-happy-contracts clippy-happy-wallet
+test: test-main test-contracts test-wallet
+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 --all-features -- -D warnings 
+
+clippy-all-contracts:
+	cargo clippy --manifest-path contracts/Cargo.toml --all-features --target wasm32-unknown-unknown -- -D warnings
+
+clippy-all-wallet: 
+	cargo clippy --manifest-path nym-wallet/Cargo.toml --all-features -- -D warnings
+
+test-main:
+	cargo test --all-features
+
+test-contracts:
+	cargo test --manifest-path contracts/Cargo.toml --all-features
+
+test-wallet:
+	cargo test --manifest-path nym-wallet/Cargo.toml --all-features
+
+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

@@ -5,8 +5,6 @@ SPDX-License-Identifier: Apache-2.0
 
 ## The Nym Privacy Platform
 
-This repository contains the Nym mixnet.
-
 The platform is composed of multiple Rust crates. Top-level executable binary crates include:
 
 * nym-mixnode - shuffles [Sphinx](https://github.com/nymtech/sphinx) packets together to provide privacy against network-level attackers.
@@ -15,6 +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 - 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)
@@ -22,7 +21,7 @@ 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).
+Platform build instructions are available on [our docs site](https://nymtech.net/docs/0.11.0/overview/index/).
 
 ### Developing
 
@@ -32,6 +31,45 @@ There's a `.env.sample-dev` file provided which you can rename to `.env` if you
 
 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.
 
+### Rewards
+
+Node, node operator and delegator rewards are determined according to the principles laid out in the section 6 of [Nym Whitepaper](https://nymtech.net/nym-whitepaper.pdf). Below is a TLDR of the variables and formulas involved in calculating the epoch rewards. Initial reward pool is set to 250 million Nym, making the circulating supply 750 million Nym.
+
+|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 pledged 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`.
+|<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 `reward set` size, and set to 720 in testnet Sandbox.
+|<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.
+|<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 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)">
+
+where:
+
+<img src="https://render.githubusercontent.com/render/math?math=\sigma^'_{i} = min\{\sigma_{i}, 1/k\}">
+
+and
+
+<img src="https://render.githubusercontent.com/render/math?math=\lambda^'_{i} = min\{\lambda_{i}, 1/k\}">
+
+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})\}">
+
+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})\}">
+
+where `s'` is stake `s` scaled over total token circulating supply.
+
 ### Licensing and copyright information
 
 This program is available as open source under the terms of the Apache 2.0 license. However, some elements are being licensed under CC0-1.0 and MIT. For accurate information, please check individual files.

clients/client-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "client-core"
-version = "0.11.0"
+version = "0.12.0"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
 edition = "2018"
 
@@ -15,6 +15,7 @@ rand = { version = "0.7.3", features = ["wasm-bindgen"] }
 serde = { version = "1.0", features = ["derive"] }
 sled = "0.34"
 tokio = { version = "1.4", features = ["macros"] }
+url = { version ="2.2", features = ["serde"] }
 
 # internal
 config = { path = "../../common/config" }
@@ -29,3 +30,6 @@ validator-client = { path = "../../common/client-libs/validator-client" }
 
 [dev-dependencies]
 tempfile = "3.1.0"
+
+[features]
+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

@@ -61,8 +61,8 @@ impl KeyManager {
     // I have absolutely no idea why the compiler insists it's unused. The call happens during client::init::execute
     #[allow(dead_code)]
     /// After shared key with the gateway is derived, puts its ownership to this instance of a [`KeyManager`].
-    pub fn insert_gateway_shared_key(&mut self, gateway_shared_key: SharedKeys) {
-        self.gateway_shared_key = Some(Arc::new(gateway_shared_key))
+    pub fn insert_gateway_shared_key(&mut self, gateway_shared_key: Arc<SharedKeys>) {
+        self.gateway_shared_key = Some(gateway_shared_key)
     }
 
     /// Loads previously stored keys from the disk.

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>>;
@@ -40,7 +39,7 @@ impl MixTrafficController {
     async fn on_messages(&mut self, mut mix_packets: Vec<MixPacket>) {
         debug_assert!(!mix_packets.is_empty());
 
-        let success = if mix_packets.len() == 1 {
+        let result = if mix_packets.len() == 1 {
             let mix_packet = mix_packets.pop().unwrap();
             self.gateway_client.send_mix_packet(mix_packet).await
         } else {
@@ -49,7 +48,7 @@ impl MixTrafficController {
                 .await
         };
 
-        match success {
+        match result {
             Err(e) => {
                 error!("Failed to send sphinx packet(s) to the gateway! - {:?}", e);
                 self.consecutive_gateway_failure_count += 1;
@@ -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/acknowledgement_control/mod.rs

@@ -13,7 +13,6 @@ use crate::client::{inbound_messages::InputMessageReceiver, topology_control::To
 use futures::channel::mpsc;
 use gateway_client::AcknowledgementReceiver;
 use log::*;
-use nymsphinx::params::PacketMode;
 use nymsphinx::{
     acknowledgements::AckKey,
     addressing::clients::Recipient,
@@ -120,14 +119,6 @@ pub(super) struct Config {
 
     /// Average delay a data packet is going to get delayed at a single mixnode.
     average_packet_delay: Duration,
-
-    /// Mode of all mix packets created - VPN or Mix. They indicate whether packets should get delayed
-    /// and keys reused.
-    packet_mode: PacketMode,
-
-    /// If the mode of the client is set to VPN it specifies number of packets created with the
-    /// same initial secret until it gets rotated.
-    vpn_key_reuse_limit: Option<usize>,
 }
 
 impl Config {
@@ -136,16 +127,12 @@ impl Config {
         ack_wait_multiplier: f64,
         average_ack_delay: Duration,
         average_packet_delay: Duration,
-        packet_mode: PacketMode,
-        vpn_key_reuse_limit: Option<usize>,
     ) -> Self {
         Config {
             ack_wait_addition,
             ack_wait_multiplier,
             average_ack_delay,
             average_packet_delay,
-            packet_mode,
-            vpn_key_reuse_limit,
         }
     }
 }
@@ -186,8 +173,6 @@ where
             ack_recipient,
             config.average_packet_delay,
             config.average_ack_delay,
-            config.packet_mode,
-            config.vpn_key_reuse_limit,
         );
 
         // will listen for any acks coming from the network

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

@@ -19,11 +19,9 @@ use gateway_client::AcknowledgementReceiver;
 use log::*;
 use nymsphinx::acknowledgements::AckKey;
 use nymsphinx::addressing::clients::Recipient;
-use nymsphinx::params::PacketMode;
 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;
@@ -51,20 +49,9 @@ pub struct Config {
 
     /// Average delay an acknowledgement packet is going to get delayed at a single mixnode.
     average_ack_delay_duration: Duration,
-
-    /// Mode of all mix packets created - VPN or Mix. They indicate whether packets should get delayed
-    /// and keys reused.
-    packet_mode: PacketMode,
-
-    /// If the mode of the client is set to VPN it specifies number of packets created with the
-    /// same initial secret until it gets rotated.
-    vpn_key_reuse_limit: Option<usize>,
 }
 
 impl Config {
-    // at this point I'm not entirely sure how to deal with this warning without
-    // some considerable refactoring
-    #[allow(clippy::too_many_arguments)]
     pub fn new(
         ack_key: Arc<AckKey>,
         ack_wait_multiplier: f64,
@@ -73,8 +60,6 @@ impl Config {
         average_message_sending_delay: Duration,
         average_packet_delay_duration: Duration,
         self_recipient: Recipient,
-        packet_mode: PacketMode,
-        vpn_key_reuse_limit: Option<usize>,
     ) -> Self {
         Config {
             ack_key,
@@ -84,8 +69,6 @@ impl Config {
             average_message_sending_delay,
             average_packet_delay_duration,
             average_ack_delay_duration,
-            packet_mode,
-            vpn_key_reuse_limit,
         }
     }
 }
@@ -126,8 +109,6 @@ impl RealMessagesController<OsRng> {
             config.ack_wait_multiplier,
             config.average_ack_delay_duration,
             config.average_packet_delay_duration,
-            config.packet_mode,
-            config.vpn_key_reuse_limit,
         );
 
         let ack_control = AcknowledgementController::new(
@@ -163,7 +144,7 @@ impl RealMessagesController<OsRng> {
         }
     }
 
-    pub(super) async fn run(&mut self, vpn_mode: bool) {
+    pub(super) async fn run(&mut self) {
         let mut out_queue_control = self.out_queue_control.take().unwrap();
         let mut ack_control = self.ack_control.take().unwrap();
 
@@ -171,7 +152,7 @@ impl RealMessagesController<OsRng> {
         // the task to ever finish. This will of course change once we introduce
         // graceful shutdowns.
         let out_queue_control_fut = tokio::spawn(async move {
-            out_queue_control.run_out_queue_control(vpn_mode).await;
+            out_queue_control.run_out_queue_control().await;
             error!("The out queue controller has finished execution!");
             out_queue_control
         });
@@ -188,11 +169,9 @@ 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, vpn_mode: bool) -> JoinHandle<Self> {
-        handle.spawn(async move {
-            self.run(vpn_mode).await;
+    pub fn start(mut self) -> JoinHandle<Self> {
+        tokio::spawn(async move {
+            self.run().await;
             self
         })
     }

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

@@ -249,15 +249,6 @@ where
         tokio::task::yield_now().await;
     }
 
-    async fn on_batch_received(&mut self, real_messages: Vec<RealMessage>) {
-        let mut mix_packets = Vec::with_capacity(real_messages.len());
-        for real_message in real_messages.into_iter() {
-            self.sent_notify(real_message.fragment_id);
-            mix_packets.push(real_message.mix_packet);
-        }
-        self.mix_tx.unbounded_send(mix_packets).unwrap();
-    }
-
     // Send messages at certain rate and if no real traffic is available, send cover message.
     async fn run_normal_out_queue(&mut self) {
         // we should set initial delay only when we actually start the stream
@@ -271,20 +262,8 @@ where
         }
     }
 
-    // Send real message as soon as it's available and don't inject ANY cover traffic.
-    async fn run_vpn_out_queue(&mut self) {
-        while let Some(next_messages) = self.real_receiver.next().await {
-            self.on_batch_received(next_messages).await
-        }
-    }
-
-    pub(crate) async fn run_out_queue_control(&mut self, vpn_mode: bool) {
-        if vpn_mode {
-            debug!("Starting out queue controller in vpn mode...");
-            self.run_vpn_out_queue().await
-        } else {
-            debug!("Starting out queue controller...");
-            self.run_normal_out_queue().await
-        }
+    pub(crate) async fn run_out_queue_control(&mut self) {
+        debug!("Starting out queue controller...");
+        self.run_normal_out_queue().await
     }
 }

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

@@ -18,7 +18,7 @@ pub enum ReplyKeyStorageError {
 /// Permanent storage for keys in all sent [`ReplySURB`]
 ///
 /// Each sent out [`ReplySURB`] has a new key associated with it that is going to be used for
-/// payload encryption. In order to decrypt whatever reply we receive, we need to know which
+/// payload encryption. In order to -decrypt whatever reply we receive, we need to know which
 /// key to use for that purpose. We do it based on received `H(t)` which has to be included
 /// with each reply.
 /// Moreover, there is no restriction when the [`ReplySURB`] might get used so we need to

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

@@ -4,14 +4,16 @@
 use log::*;
 use nymsphinx::addressing::clients::Recipient;
 use nymsphinx::params::DEFAULT_NUM_MIX_HOPS;
+use rand::seq::SliceRandom;
+use rand::thread_rng;
 use std::ops::Deref;
 use std::sync::Arc;
 use std::time;
 use std::time::Duration;
-use tokio::runtime::Handle;
 use tokio::sync::{RwLock, RwLockReadGuard};
 use tokio::task::JoinHandle;
 use topology::{nym_topology_from_bonds, NymTopology};
+use url::Url;
 
 // I'm extremely curious why compiler NEVER complained about lack of Debug here before
 #[derive(Debug)]
@@ -104,7 +106,7 @@ impl TopologyAccessor {
         self.inner.read().await.into()
     }
 
-    async fn update_global_topology(&mut self, new_topology: Option<NymTopology>) {
+    async fn update_global_topology(&self, new_topology: Option<NymTopology>) {
         self.inner.write().await.update(new_topology);
     }
 
@@ -125,54 +127,128 @@ impl Default for TopologyAccessor {
 }
 
 pub struct TopologyRefresherConfig {
-    available_validators: Vec<String>,
-    mixnet_contract_address: String,
+    validator_api_urls: Vec<Url>,
     refresh_rate: time::Duration,
+    client_version: String,
 }
 
 impl TopologyRefresherConfig {
     pub fn new(
-        available_validators: Vec<String>,
-        mixnet_contract_address: String,
+        validator_api_urls: Vec<Url>,
         refresh_rate: time::Duration,
+        client_version: String,
     ) -> Self {
         TopologyRefresherConfig {
-            available_validators,
-            mixnet_contract_address,
+            validator_api_urls,
             refresh_rate,
+            client_version,
         }
     }
 }
 
 pub struct TopologyRefresher {
-    validator_client: validator_client::Client,
+    validator_client: validator_client::ApiClient,
+    client_version: String,
 
+    validator_api_urls: Vec<Url>,
     topology_accessor: TopologyAccessor,
     refresh_rate: Duration,
 
+    currently_used_api: usize,
     was_latest_valid: bool,
 }
 
 impl TopologyRefresher {
-    pub fn new(cfg: TopologyRefresherConfig, topology_accessor: TopologyAccessor) -> Self {
-        let validator_client_config =
-            validator_client::Config::new(cfg.available_validators, cfg.mixnet_contract_address);
-        let validator_client = validator_client::Client::new(validator_client_config);
+    pub fn new(mut cfg: TopologyRefresherConfig, topology_accessor: TopologyAccessor) -> Self {
+        cfg.validator_api_urls.shuffle(&mut thread_rng());
 
         TopologyRefresher {
-            validator_client,
+            validator_client: validator_client::ApiClient::new(cfg.validator_api_urls[0].clone()),
+            client_version: cfg.client_version,
+            validator_api_urls: cfg.validator_api_urls,
             topology_accessor,
             refresh_rate: cfg.refresh_rate,
+            currently_used_api: 0,
             was_latest_valid: true,
         }
     }
 
-    async fn get_current_compatible_topology(&mut self) -> Option<NymTopology> {
+    fn use_next_validator_api(&mut self) {
+        if self.validator_api_urls.len() == 1 {
+            warn!("There's only a single validator API available - it won't be possible to use a different one");
+            return;
+        }
+
+        self.currently_used_api = (self.currently_used_api + 1) % self.validator_api_urls.len();
+        self.validator_client
+            .change_validator_api(self.validator_api_urls[self.currently_used_api].clone())
+    }
+
+    /// Verifies whether nodes a reasonably distributed among all mix layers.
+    ///
+    /// In ideal world we would have 33% nodes on layer 1, 33% on layer 2 and 33% on layer 3.
+    /// However, this is a rather unrealistic expectation, instead we check whether there exists
+    /// a layer with more than 66% of nodes or with fewer than 15% and if so, we trigger a failure.
+    ///
+    /// # Arguments
+    ///
+    /// * `topology`: active topology constructed from validator api data
+    /// * `mixnodes_count`: total number of active mixnodes
+    fn check_layer_distribution(
+        &self,
+        active_topology: &NymTopology,
+        mixnodes_count: usize,
+    ) -> bool {
+        let mixes = active_topology.mixes();
+        if active_topology.gateways().is_empty() {
+            return false;
+        }
+
+        // trivial check to see if have at least a single node on each layer (regardless of active set size)
+        if mixes.get(&1).is_none() || mixes.get(&2).is_none() || mixes.get(&3).is_none() {
+            return false;
+        }
+
+        let upper_bound = (mixnodes_count as f32 * 0.66) as usize;
+        let lower_bound = (mixnodes_count as f32 * 0.15) as usize;
+
+        let layer1 = mixes.get(&1).unwrap().len();
+        let layer2 = mixes.get(&2).unwrap().len();
+        let layer3 = mixes.get(&3).unwrap().len();
+
+        if layer1 < lower_bound || layer1 > upper_bound {
+            warn!(
+                "nodes: {}, layer1: {}, layer2: {}, layer3: {}",
+                mixnodes_count, layer1, layer2, layer3
+            );
+            return false;
+        }
+
+        if layer2 < lower_bound || layer2 > upper_bound {
+            warn!(
+                "nodes: {}, layer1: {}, layer2: {}, layer3: {}",
+                mixnodes_count, layer1, layer2, layer3
+            );
+            return false;
+        }
+
+        if layer3 < lower_bound || layer3 > upper_bound {
+            warn!(
+                "nodes: {}, layer1: {}, layer2: {}, layer3: {}",
+                mixnodes_count, layer1, layer2, layer3
+            );
+            return false;
+        }
+
+        true
+    }
+
+    async fn get_current_compatible_topology(&self) -> Option<NymTopology> {
         // TODO: optimization for the future:
         // only refresh mixnodes on timer and refresh gateways only when
         // we have to send to a new, unknown, gateway
 
-        let mixnodes = match self.validator_client.get_cached_mix_nodes().await {
+        let mixnodes = match self.validator_client.get_cached_active_mixnodes().await {
             Err(err) => {
                 error!("failed to get network mixnodes - {}", err);
                 return None;
@@ -188,17 +264,26 @@ impl TopologyRefresher {
             Ok(gateways) => gateways,
         };
 
-        let topology = nym_topology_from_bonds(mixnodes, gateways);
+        let mixnodes_count = mixnodes.len();
+        let topology =
+            nym_topology_from_bonds(mixnodes, gateways).filter_system_version(&self.client_version);
 
-        // TODO: I didn't want to change it now, but the expected system version should rather be put in config
-        // rather than pulled from package version of `client_core`
-        Some(topology.filter_system_version(env!("CARGO_PKG_VERSION")))
+        if !self.check_layer_distribution(&topology, mixnodes_count) {
+            warn!("The current filtered active topology has extremely skewed layer distribution. It cannot be used.");
+            None
+        } else {
+            Some(topology)
+        }
     }
 
     pub async fn refresh(&mut self) {
         trace!("Refreshing the topology");
         let new_topology = self.get_current_compatible_topology().await;
 
+        if new_topology.is_none() {
+            self.use_next_validator_api();
+        }
+
         if new_topology.is_none() && self.was_latest_valid {
             // if we failed to grab this topology, but the one before it was alright, let's assume
             // validator had a tiny hiccup and use the old data
@@ -218,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

@@ -1,23 +1,18 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use config::{deserialize_duration, deserialize_validators, NymConfig};
+use config::defaults::*;
+use config::NymConfig;
 use serde::{Deserialize, Serialize};
 use std::marker::PhantomData;
 use std::path::PathBuf;
 use std::time::Duration;
+use url::Url;
 
 pub mod persistence;
 
 pub const MISSING_VALUE: &str = "MISSING VALUE";
 
-// 'CLIENT'
-pub const DEFAULT_VALIDATOR_REST_ENDPOINTS: &[&str] = &[
-    "http://testnet-milhon-validator1.nymtech.net:1317",
-    "http://testnet-milhon-validator2.nymtech.net:1317",
-];
-pub const DEFAULT_MIXNET_CONTRACT_ADDRESS: &str = "punk10pyejy66429refv3g35g2t7am0was7yalwrzen";
-
 // 'DEBUG'
 const DEFAULT_ACK_WAIT_MULTIPLIER: f64 = 1.5;
 
@@ -27,27 +22,15 @@ const DEFAULT_MESSAGE_STREAM_AVERAGE_DELAY: Duration = Duration::from_millis(20)
 const DEFAULT_AVERAGE_PACKET_DELAY: Duration = Duration::from_millis(50);
 const DEFAULT_TOPOLOGY_REFRESH_RATE: Duration = Duration::from_secs(5 * 60); // every 5min
 const DEFAULT_TOPOLOGY_RESOLUTION_TIMEOUT: Duration = Duration::from_millis(5_000);
-const DEFAULT_GATEWAY_RESPONSE_TIMEOUT: Duration = Duration::from_millis(1_500);
-const DEFAULT_VPN_KEY_REUSE_LIMIT: usize = 1000;
-
-const ZERO_DELAY: Duration = Duration::from_nanos(0);
-
-// helper function to get default validators as a Vec<String>
-pub fn default_validator_rest_endpoints() -> Vec<String> {
-    DEFAULT_VALIDATOR_REST_ENDPOINTS
-        .iter()
-        .map(|&endpoint| endpoint.to_string())
-        .collect()
-}
+// Set this to a high value for now, so that we don't risk sporadic timeouts that might cause
+// bought bandwidth tokens to not have time to be spent; Once we remove the gateway from the
+// bandwidth bridging protocol, we can come back to a smaller timeout value
+const DEFAULT_GATEWAY_RESPONSE_TIMEOUT: Duration = Duration::from_secs(5 * 60);
 
 pub fn missing_string_value() -> String {
     MISSING_VALUE.to_string()
 }
 
-pub fn missing_vec_string_value() -> Vec<String> {
-    vec![missing_string_value()]
-}
-
 #[derive(Debug, Deserialize, PartialEq, Serialize)]
 #[serde(deny_unknown_fields)]
 pub struct Config<T> {
@@ -120,9 +103,24 @@ 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);
+        }
+
         self.client.id = id;
     }
 
+    pub fn with_testnet_mode(&mut self, testnet_mode: bool) {
+        self.client.testnet_mode = testnet_mode;
+    }
+
     pub fn with_gateway_id<S: Into<String>>(&mut self, id: S) {
         self.client.gateway_id = id.into();
     }
@@ -131,12 +129,18 @@ impl<T: NymConfig> Config<T> {
         self.client.gateway_listener = gateway_listener.into();
     }
 
-    pub fn set_custom_validators(&mut self, validators: Vec<String>) {
-        self.client.validator_rest_urls = validators;
+    #[cfg(not(feature = "coconut"))]
+    pub fn with_eth_private_key<S: Into<String>>(&mut self, eth_private_key: S) {
+        self.client.eth_private_key = eth_private_key.into();
     }
 
-    pub fn set_mixnet_contract<S: Into<String>>(&mut self, contract_address: S) {
-        self.client.mixnet_contract_address = contract_address.into();
+    #[cfg(not(feature = "coconut"))]
+    pub fn with_eth_endpoint<S: Into<String>>(&mut self, eth_endpoint: S) {
+        self.client.eth_endpoint = eth_endpoint.into();
+    }
+
+    pub fn set_custom_validator_apis(&mut self, validator_api_urls: Vec<Url>) {
+        self.client.validator_api_urls = validator_api_urls;
     }
 
     pub fn set_high_default_traffic_volume(&mut self) {
@@ -145,14 +149,6 @@ impl<T: NymConfig> Config<T> {
         self.debug.message_sending_average_delay = Duration::from_millis(4); // 250 "real" messages / s
     }
 
-    pub fn set_vpn_mode(&mut self, vpn_mode: bool) {
-        self.client.vpn_mode = vpn_mode;
-    }
-
-    pub fn set_vpn_key_reuse_limit(&mut self, reuse_limit: usize) {
-        self.debug.vpn_key_reuse_limit = Some(reuse_limit)
-    }
-
     pub fn set_custom_version(&mut self, version: &str) {
         self.client.version = version.to_string();
     }
@@ -161,6 +157,10 @@ impl<T: NymConfig> Config<T> {
         self.client.id.clone()
     }
 
+    pub fn get_testnet_mode(&self) -> bool {
+        self.client.testnet_mode
+    }
+
     pub fn get_nym_root_directory(&self) -> PathBuf {
         self.client.nym_root_directory.clone()
     }
@@ -193,12 +193,8 @@ impl<T: NymConfig> Config<T> {
         self.client.ack_key_file.clone()
     }
 
-    pub fn get_validator_rest_endpoints(&self) -> Vec<String> {
-        self.client.validator_rest_urls.clone()
-    }
-
-    pub fn get_validator_mixnet_contract_address(&self) -> String {
-        self.client.mixnet_contract_address.clone()
+    pub fn get_validator_api_endpoints(&self) -> Vec<Url> {
+        self.client.validator_api_urls.clone()
     }
 
     pub fn get_gateway_id(&self) -> String {
@@ -209,21 +205,28 @@ impl<T: NymConfig> Config<T> {
         self.client.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()
+    }
+
+    #[cfg(not(feature = "coconut"))]
+    pub fn get_eth_endpoint(&self) -> String {
+        self.client.eth_endpoint.clone()
+    }
+
+    #[cfg(not(feature = "coconut"))]
+    pub fn get_eth_private_key(&self) -> String {
+        self.client.eth_private_key.clone()
+    }
+
     // Debug getters
     pub fn get_average_packet_delay(&self) -> Duration {
-        if self.client.vpn_mode {
-            ZERO_DELAY
-        } else {
-            self.debug.average_packet_delay
-        }
+        self.debug.average_packet_delay
     }
 
     pub fn get_average_ack_delay(&self) -> Duration {
-        if self.client.vpn_mode {
-            ZERO_DELAY
-        } else {
-            self.debug.average_ack_delay
-        }
+        self.debug.average_ack_delay
     }
 
     pub fn get_ack_wait_multiplier(&self) -> f64 {
@@ -239,11 +242,7 @@ impl<T: NymConfig> Config<T> {
     }
 
     pub fn get_message_sending_average_delay(&self) -> Duration {
-        if self.client.vpn_mode {
-            ZERO_DELAY
-        } else {
-            self.debug.message_sending_average_delay
-        }
+        self.debug.message_sending_average_delay
     }
 
     pub fn get_gateway_response_timeout(&self) -> Duration {
@@ -258,21 +257,6 @@ impl<T: NymConfig> Config<T> {
         self.debug.topology_resolution_timeout
     }
 
-    pub fn get_vpn_mode(&self) -> bool {
-        self.client.vpn_mode
-    }
-
-    pub fn get_vpn_key_reuse_limit(&self) -> Option<usize> {
-        match self.get_vpn_mode() {
-            false => None,
-            true => Some(
-                self.debug
-                    .vpn_key_reuse_limit
-                    .unwrap_or(DEFAULT_VPN_KEY_REUSE_LIMIT),
-            ),
-        }
-    }
-
     pub fn get_version(&self) -> &str {
         &self.client.version
     }
@@ -297,23 +281,13 @@ pub struct Client<T> {
     /// ID specifies the human readable ID of this particular client.
     id: String,
 
-    /// URL to the validator server for obtaining network topology.
-    #[serde(
-        deserialize_with = "deserialize_validators",
-        default = "missing_vec_string_value",
-        alias = "validator_rest_url"
-    )]
-    validator_rest_urls: Vec<String>,
-
-    /// Address of the validator contract managing the network.
-    #[serde(default = "missing_string_value")]
-    mixnet_contract_address: String,
-
-    /// Special mode of the system such that all messages are sent as soon as they are received
-    /// and no cover traffic is generated. If set all message delays are set to 0 and overwriting
-    /// 'Debug' values will have no effect.
+    /// Indicates whether this client is running in a testnet mode, thus attempting
+    /// to claim bandwidth without presenting bandwidth credentials.
     #[serde(default)]
-    vpn_mode: bool,
+    testnet_mode: bool,
+
+    /// Addresses to APIs running on validator from which the client gets the view of the network.
+    validator_api_urls: Vec<Url>,
 
     /// Path to file containing private identity key.
     private_identity_key_file: PathBuf,
@@ -346,6 +320,20 @@ pub struct Client<T> {
     /// 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,
+
+    /// Ethereum private key.
+    #[cfg(not(feature = "coconut"))]
+    eth_private_key: String,
+
+    /// Address to an Ethereum full node.
+    #[cfg(not(feature = "coconut"))]
+    eth_endpoint: String,
+
     /// nym_home_directory specifies absolute path to the home nym Clients directory.
     /// It is expected to use default value and hence .toml file should not redefine this field.
     nym_root_directory: PathBuf,
@@ -360,9 +348,8 @@ impl<T: NymConfig> Default for Client<T> {
         Client {
             version: env!("CARGO_PKG_VERSION").to_string(),
             id: "".to_string(),
-            validator_rest_urls: default_validator_rest_endpoints(),
-            mixnet_contract_address: DEFAULT_MIXNET_CONTRACT_ADDRESS.to_string(),
-            vpn_mode: false,
+            testnet_mode: false,
+            validator_api_urls: default_api_endpoints(),
             private_identity_key_file: Default::default(),
             public_identity_key_file: Default::default(),
             private_encryption_key_file: Default::default(),
@@ -372,6 +359,12 @@ impl<T: NymConfig> Default for Client<T> {
             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(),
+            #[cfg(not(feature = "coconut"))]
+            eth_private_key: "".to_string(),
+            #[cfg(not(feature = "coconut"))]
+            eth_endpoint: "".to_string(),
             nym_root_directory: T::default_root_directory(),
             super_struct: Default::default(),
         }
@@ -406,18 +399,17 @@ 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")
     }
-}
 
-#[derive(Debug, Deserialize, PartialEq, Serialize)]
-#[serde(deny_unknown_fields)]
-pub struct Logging {}
-
-impl Default for Logging {
-    fn default() -> Self {
-        Logging {}
+    #[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")
     }
 }
 
+#[derive(Debug, Default, Deserialize, PartialEq, Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct Logging {}
+
 #[derive(Debug, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
 pub struct Debug {
@@ -425,20 +417,14 @@ pub struct Debug {
     /// sent packet is going to be delayed at any given mix node.
     /// So for a packet going through three mix nodes, on average, it will take three times this value
     /// until the packet reaches its destination.
-    #[serde(
-        deserialize_with = "deserialize_duration",
-        serialize_with = "humantime_serde::serialize"
-    )]
+    #[serde(with = "humantime_serde")]
     average_packet_delay: Duration,
 
     /// The parameter of Poisson distribution determining how long, on average,
     /// sent acknowledgement is going to be delayed at any given mix node.
     /// So for an ack going through three mix nodes, on average, it will take three times this value
     /// until the packet reaches its destination.
-    #[serde(
-        deserialize_with = "deserialize_duration",
-        serialize_with = "humantime_serde::serialize"
-    )]
+    #[serde(with = "humantime_serde")]
     average_ack_delay: Duration,
 
     /// Value multiplied with the expected round trip time of an acknowledgement packet before
@@ -449,58 +435,36 @@ pub struct Debug {
     /// Value added to the expected round trip time of an acknowledgement packet before
     /// it is assumed it was lost and retransmission of the data packet happens.
     /// In an ideal network with 0 latency, this value would have been 0.
-    #[serde(
-        deserialize_with = "deserialize_duration",
-        serialize_with = "humantime_serde::serialize"
-    )]
+    #[serde(with = "humantime_serde")]
     ack_wait_addition: Duration,
 
     /// The parameter of Poisson distribution determining how long, on average,
     /// it is going to take for another loop cover traffic message to be sent.
-    #[serde(
-        deserialize_with = "deserialize_duration",
-        serialize_with = "humantime_serde::serialize"
-    )]
+    #[serde(with = "humantime_serde")]
     loop_cover_traffic_average_delay: Duration,
 
     /// The parameter of Poisson distribution determining how long, on average,
     /// it is going to take another 'real traffic stream' message to be sent.
     /// If no real packets are available and cover traffic is enabled,
     /// a loop cover message is sent instead in order to preserve the rate.
-    #[serde(
-        deserialize_with = "deserialize_duration",
-        serialize_with = "humantime_serde::serialize"
-    )]
+    #[serde(with = "humantime_serde")]
     message_sending_average_delay: Duration,
 
     /// How long we're willing to wait for a response to a message sent to the gateway,
     /// before giving up on it.
-    #[serde(
-        deserialize_with = "deserialize_duration",
-        serialize_with = "humantime_serde::serialize"
-    )]
+    #[serde(with = "humantime_serde")]
     gateway_response_timeout: Duration,
 
     /// The uniform delay every which clients are querying the directory server
     /// to try to obtain a compatible network topology to send sphinx packets through.
-    #[serde(
-        deserialize_with = "deserialize_duration",
-        serialize_with = "humantime_serde::serialize"
-    )]
+    #[serde(with = "humantime_serde")]
     topology_refresh_rate: Duration,
 
     /// During topology refresh, test packets are sent through every single possible network
     /// path. This timeout determines waiting period until it is decided that the packet
     /// did not reach its destination.
-    #[serde(
-        deserialize_with = "deserialize_duration",
-        serialize_with = "humantime_serde::serialize"
-    )]
+    #[serde(with = "humantime_serde")]
     topology_resolution_timeout: Duration,
-
-    /// If the mode of the client is set to VPN it specifies number of packets created with the
-    /// same initial secret until it gets rotated.
-    vpn_key_reuse_limit: Option<usize>,
 }
 
 impl Default for Debug {
@@ -515,7 +479,6 @@ impl Default for Debug {
             gateway_response_timeout: DEFAULT_GATEWAY_RESPONSE_TIMEOUT,
             topology_refresh_rate: DEFAULT_TOPOLOGY_REFRESH_RATE,
             topology_resolution_timeout: DEFAULT_TOPOLOGY_RESOLUTION_TIMEOUT,
-            vpn_key_reuse_limit: None,
         }
     }
 }

clients/native/Cargo.toml

@@ -1,8 +1,9 @@
 [package]
 name = "nym-client"
-version = "0.11.0"
+version = "0.12.1"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>", "Jędrzej Stuczyński <andrew@nymtech.net>"]
 edition = "2018"
+rust-version = "1.56"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -16,14 +17,14 @@ futures = "0.3" # bunch of futures stuff, however, now that I think about it, it
 # the AsyncRead, AsyncWrite, Stream, Sink, etc. traits could be used from tokio
 # channels should really be replaced with crossbeam due to that implementation being more efficient
 # and the single instance of abortable we have should really be refactored anyway
-url = "2.1" # I think we should just replace it with String
+url = "2.2"
 
 clap = "2.33.0" # for the command line arguments
 dirs = "3.0" # for determining default store directories in config
 dotenv = "0.15.0" # for obtaining environmental variables (only used for RUST_LOG for time being)
 log = "0.4" # self explanatory
 pretty_env_logger = "0.4" # for formatting log messages
-rand = {version = "0.7.3", features = ["wasm-bindgen"]} # rng-related traits + some rng implementation to use
+rand = { version = "0.7.3", features = ["wasm-bindgen"] } # rng-related traits + some rng implementation to use
 serde = { version = "1.0.104", features = ["derive"] } # for config serialization/deserialization
 sled = "0.34" # for storage of replySURB decryption keys
 tokio = { version = "1.4", features = ["rt-multi-thread", "net", "signal"] } # async runtime
@@ -31,6 +32,8 @@ tokio-tungstenite = "0.14" # websocket
 
 ## internal
 client-core = { path = "../client-core" }
+coconut-interface = { path = "../../common/coconut-interface", optional = true }
+credentials = { path = "../../common/credentials", optional = true }
 config = { path = "../../common/config" }
 crypto = { path = "../../common/crypto" }
 gateway-client = { path = "../../common/client-libs/gateway-client" }
@@ -41,6 +44,14 @@ topology = { path = "../../common/topology" }
 websocket-requests = { path = "websocket-requests" }
 validator-client = { path = "../../common/client-libs/validator-client" }
 version-checker = { path = "../../common/version-checker" }
+network-defaults = { path = "../../common/network-defaults" }
+
+[features]
+coconut = ["coconut-interface", "credentials", "gateway-requests/coconut", "gateway-client/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/src/client/config/mod.rs

@@ -4,14 +4,13 @@
 use crate::client::config::template::config_template;
 use client_core::config::Config as BaseConfig;
 pub use client_core::config::MISSING_VALUE;
+use config::defaults::DEFAULT_WEBSOCKET_LISTENING_PORT;
 use config::NymConfig;
 use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
 
 mod template;
 
-const DEFAULT_LISTENING_PORT: u16 = 1977;
-
 #[derive(Debug, Deserialize, PartialEq, Serialize, Clone, Copy)]
 #[serde(deny_unknown_fields)]
 pub enum SocketType {
@@ -117,7 +116,7 @@ impl Default for Socket {
     fn default() -> Self {
         Socket {
             socket_type: SocketType::WebSocket,
-            listening_port: DEFAULT_LISTENING_PORT,
+            listening_port: DEFAULT_WEBSOCKET_LISTENING_PORT,
         }
     }
 }

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,21 +19,17 @@ version = '{{ client.version }}'
 # Human readable ID of this particular client.
 id = '{{ client.id }}'
 
-# URL to the validator server for obtaining network topology.
-validator_rest_urls = [
-    {{#each client.validator_rest_urls }}
+# Indicates whether this client is running in a testnet mode, thus attempting
+# to claim bandwidth without presenting bandwidth credentials.
+testnet_mode = {{ client.testnet_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 }}
         '{{this}}',
     {{/each}}
 ]
 
-# Address of the validator contract managing the network.
-mixnet_contract_address = '{{ client.mixnet_contract_address }}'
-
-# Special mode of the system such that all messages are sent as soon as they are received
-# and no cover traffic is generated. If set all message delays are set to 0 and overwriting
-# 'Debug' values will have no effect.
-vpn_mode = {{ client.vpn_mode }}
-
 # Path to file containing private identity key.
 private_identity_key_file = '{{ client.private_identity_key_file }}'
 
@@ -50,6 +46,17 @@ 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 }}'
+
+# Ethereum private key.
+eth_private_key = '{{ client.eth_private_key }}'
+
+# Addess to an Ethereum full node.
+eth_endpoint = '{{ client.eth_endpoint }}'
+
 ##### additional client config options #####
 
 # ID of the gateway from which the client should be fetching messages.

clients/native/src/client/mod.rs

@@ -1,8 +1,6 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::client::config::{Config, SocketType};
-use crate::websocket;
 use client_core::client::cover_traffic_stream::LoopCoverTrafficStream;
 use client_core::client::inbound_messages::{
     InputMessage, InputMessageReceiver, InputMessageSender,
@@ -24,6 +22,7 @@ use client_core::client::topology_control::{
 use client_core::config::persistence::key_pathfinder::ClientKeyPathfinder;
 use crypto::asymmetric::identity;
 use futures::channel::mpsc;
+use gateway_client::bandwidth::BandwidthController;
 use gateway_client::{
     AcknowledgementReceiver, AcknowledgementSender, GatewayClient, MixnetMessageReceiver,
     MixnetMessageSender,
@@ -32,9 +31,10 @@ use log::*;
 use nymsphinx::addressing::clients::Recipient;
 use nymsphinx::addressing::nodes::NodeIdentity;
 use nymsphinx::anonymous_replies::ReplySurb;
-use nymsphinx::params::PacketMode;
 use nymsphinx::receiver::ReconstructedMessage;
-use tokio::runtime::Runtime;
+
+use crate::client::config::{Config, SocketType};
+use crate::websocket;
 
 pub(crate) mod config;
 
@@ -43,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,
 
@@ -67,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,
@@ -93,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(),
@@ -108,7 +99,7 @@ impl NymClient {
             self.as_mix_recipient(),
             topology_accessor,
         )
-        .start(self.runtime.handle());
+        .start();
     }
 
     fn start_real_traffic_controller(
@@ -119,12 +110,6 @@ impl NymClient {
         input_receiver: InputMessageReceiver,
         mix_sender: BatchMixMessageSender,
     ) {
-        let packet_mode = if self.config.get_base().get_vpn_mode() {
-            PacketMode::Vpn
-        } else {
-            PacketMode::Mix
-        };
-
         let controller_config = real_messages_control::Config::new(
             self.key_manager.ack_key(),
             self.config.get_base().get_ack_wait_multiplier(),
@@ -133,15 +118,9 @@ impl NymClient {
             self.config.get_base().get_message_sending_average_delay(),
             self.config.get_base().get_average_packet_delay(),
             self.as_mix_recipient(),
-            packet_mode,
-            self.config.get_base().get_vpn_key_reuse_limit(),
         );
 
         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,
@@ -151,7 +130,7 @@ impl NymClient {
             topology_accessor,
             reply_key_storage,
         )
-        .start(self.runtime.handle(), self.config.get_base().get_vpn_mode());
+        .start();
     }
 
     // buffer controlling all messages fetched from provider
@@ -169,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,
@@ -189,6 +168,19 @@ impl NymClient {
         let gateway_identity = identity::PublicKey::from_base58_string(gateway_id)
             .expect("provided gateway id is invalid!");
 
+        #[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");
+
         let mut gateway_client = GatewayClient::new(
             gateway_address,
             self.key_manager.identity_keypair(),
@@ -197,40 +189,37 @@ impl NymClient {
             mixnet_message_sender,
             ack_sender,
             self.config.get_base().get_gateway_response_timeout(),
+            Some(bandwidth_controller),
         );
 
-        self.runtime.block_on(async {
-            gateway_client
-                .authenticate_and_start()
-                .await
-                .expect("could not authenticate and start up the gateway connection")
-        });
+        if self.config.get_base().get_testnet_mode() {
+            gateway_client.set_testnet_mode(true)
+        }
+        gateway_client
+            .authenticate_and_start()
+            .await
+            .expect("could not authenticate and start up the gateway connection");
 
         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_rest_endpoints(),
-            self.config
-                .get_base()
-                .get_validator_mixnet_contract_address(),
+            self.config.get_base().get_validator_api_endpoints(),
             self.config.get_base().get_topology_refresh_rate(),
+            env!("CARGO_PKG_VERSION").to_string(),
         );
         let mut topology_refresher =
             TopologyRefresher::new(topology_refresher_config, topology_accessor);
         // before returning, block entire runtime to refresh the current network view so that any
         // components depending on topology would see a non-empty view
         info!("Obtaining initial network topology");
-        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"
@@ -238,7 +227,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)
@@ -251,7 +240,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(
@@ -264,8 +253,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
@@ -312,9 +300,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
@@ -326,7 +314,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
@@ -358,14 +346,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(
@@ -376,9 +367,7 @@ impl NymClient {
             sphinx_message_sender.clone(),
         );
 
-        if !self.config.get_base().get_vpn_mode() {
-            self.start_cover_traffic_stream(shared_topology_accessor, sphinx_message_sender);
-        }
+        self.start_cover_traffic_stream(shared_topology_accessor, sphinx_message_sender);
 
         match self.config.get_socket_type() {
             SocketType::WebSocket => {

clients/native/src/commands/init.rs

@@ -1,26 +1,45 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::client::config::Config;
-use crate::commands::override_config;
 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;
 use rand::seq::SliceRandom;
+use rand::thread_rng;
 use std::convert::TryInto;
 use std::sync::Arc;
 use std::time::Duration;
 use topology::{filter::VersionFilterable, gateway};
+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, ETH_ENDPOINT_ARG_NAME, ETH_PRIVATE_KEY_ARG_NAME,
+    TESTNET_MODE_ARG_NAME,
+};
 
 pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
-    App::new("init")
+    let app = App::new("init")
         .about("Initialise a Nym client. Do this first!")
         .arg(Arg::with_name("id")
             .long("id")
@@ -34,13 +53,8 @@ pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
             .takes_value(true)
         )
         .arg(Arg::with_name("validators")
-                .long("validators")
-                .help("Comma separated list of rest endpoints of the validators")
-                .takes_value(true),
-        )
-        .arg(Arg::with_name("mixnet-contract")
-                 .long("mixnet-contract")
-                 .help("Address of the validator contract managing the network")
+                 .long("validators")
+                 .help("Comma separated list of rest endpoints of the validators")
                  .takes_value(true),
         )
         .arg(Arg::with_name("disable-socket")
@@ -53,28 +67,71 @@ pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
             .help("Port for the socket (if applicable) to listen on in all subsequent runs")
             .takes_value(true)
         )
-        .arg(Arg::with_name("vpn-mode")
-            .long("vpn-mode")
-            .help("Set the vpn mode of the client")
-            .long_help(
-                r#" 
-                    Special mode of the system such that all messages are sent as soon as they are received
-                    and no cover traffic is generated. If set all message delays are set to 0 and overwriting
-                    'Debug' values will have no effect.
-                "#
-            )
-        )
         .arg(Arg::with_name("fastmode")
             .long("fastmode")
             .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(TESTNET_MODE_ARG_NAME)
+                .long(TESTNET_MODE_ARG_NAME)
+                .help("Set this client to work in a testnet 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(TESTNET_MODE_ARG_NAME, None, DEFAULT_ETH_ENDPOINT)
+            .required(true))
+        .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)
+            .default_value_if(TESTNET_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>,
-) -> SharedKeys {
+) -> Arc<SharedKeys> {
     let timeout = Duration::from_millis(1500);
     let mut gateway_client = GatewayClient::new_init(
         gateway.clients_address(),
@@ -87,18 +144,19 @@ async fn register_with_gateway(
         .await
         .expect("failed to establish connection with the gateway!");
     gateway_client
-        .register()
+        .perform_initial_authentication()
         .await
         .expect("failed to register with the gateway!")
 }
 
 async fn gateway_details(
-    validator_servers: Vec<String>,
-    mixnet_contract: &str,
+    validator_servers: Vec<Url>,
     chosen_gateway_id: Option<&str>,
 ) -> gateway::Node {
-    let validator_client_config = validator_client::Config::new(validator_servers, mixnet_contract);
-    let validator_client = validator_client::Client::new(validator_client_config);
+    let validator_api = validator_servers
+        .choose(&mut thread_rng())
+        .expect("The list of validator apis is empty");
+    let validator_client = validator_client::ApiClient::new(validator_api.clone());
 
     let gateways = validator_client.get_cached_gateways().await.unwrap();
     let valid_gateways = gateways
@@ -161,7 +219,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
@@ -179,7 +237,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();
     }
@@ -192,27 +250,20 @@ 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_rest_endpoints(),
-                &config.get_base().get_validator_mixnet_contract_address(),
-                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())
-        };
-
-        // 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);
+        let gateway_details = gateway_details(
+            config.get_base().get_validator_api_endpoints(),
+            chosen_gateway_id,
+        )
+        .await;
         config
             .get_base_mut()
-            .with_gateway_listener(gateway_listener);
+            .with_gateway_id(gateway_details.identity_key.to_base58_string());
+        let shared_keys =
+            register_with_gateway(&gateway_details, key_manager.identity_keypair()).await;
+
+        config
+            .get_base_mut()
+            .with_gateway_listener(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

@@ -3,14 +3,32 @@
 
 use crate::client::config::{Config, SocketType};
 use clap::ArgMatches;
+use url::Url;
+
+pub(crate) const TESTNET_MODE_ARG_NAME: &str = "testnet-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;
 
-fn parse_validators(raw: &str) -> Vec<String> {
+fn parse_validators(raw: &str) -> Vec<Url> {
     raw.split(',')
-        .map(|raw_validator| raw_validator.trim().into())
+        .map(|raw_validator| {
+            raw_validator
+                .trim()
+                .parse()
+                .expect("one of the provided validator api urls is invalid")
+        })
         .collect()
 }
 
@@ -18,11 +36,7 @@ pub(crate) fn override_config(mut config: Config, matches: &ArgMatches) -> Confi
     if let Some(raw_validators) = matches.value_of("validators") {
         config
             .get_base_mut()
-            .set_custom_validators(parse_validators(raw_validators));
-    }
-
-    if let Some(contract_address) = matches.value_of("mixnet-contract") {
-        config.get_base_mut().set_mixnet_contract(contract_address)
+            .set_custom_validator_apis(parse_validators(raw_validators));
     }
 
     if let Some(gateway_id) = matches.value_of("gateway") {
@@ -33,10 +47,6 @@ pub(crate) fn override_config(mut config: Config, matches: &ArgMatches) -> Confi
         config = config.with_socket(SocketType::None);
     }
 
-    if matches.is_present("vpn-mode") {
-        config.get_base_mut().set_vpn_mode(true);
-    }
-
     if let Some(port) = matches.value_of("port").map(|port| port.parse::<u16>()) {
         if let Err(err) = port {
             // if port was overridden, it must be parsable
@@ -45,5 +55,26 @@ pub(crate) fn override_config(mut config: Config, matches: &ArgMatches) -> Confi
         config = config.with_port(port.unwrap());
     }
 
+    #[cfg(not(feature = "coconut"))]
+    if let Some(eth_endpoint) = matches.value_of(ETH_ENDPOINT_ARG_NAME) {
+        config.get_base_mut().with_eth_endpoint(eth_endpoint);
+    } else {
+        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_ARG_NAME) {
+        config.get_base_mut().with_eth_private_key(eth_private_key);
+    } else {
+        config
+            .get_base_mut()
+            .with_eth_private_key(DEFAULT_ETH_PRIVATE_KEY);
+    }
+
+    if !cfg!(feature = "eth") || matches.is_present(TESTNET_MODE_ARG_NAME) {
+        config.get_base_mut().with_testnet_mode(true)
+    }
+
     config
 }

clients/native/src/commands/run.rs

@@ -4,13 +4,16 @@
 use crate::client::config::Config;
 use crate::client::NymClient;
 use crate::commands::override_config;
+#[cfg(feature = "eth")]
+#[cfg(not(feature = "coconut"))]
+use crate::commands::{ETH_ENDPOINT_ARG_NAME, ETH_PRIVATE_KEY_ARG_NAME, TESTNET_MODE_ARG_NAME};
 use clap::{App, Arg, ArgMatches};
 use config::NymConfig;
 use log::*;
 use version_checker::is_minor_version_compatible;
 
 pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
-    App::new("run")
+    let app = App::new("run")
         .about("Run the Nym client with provided configuration client optionally overriding set parameters")
         .arg(Arg::with_name("id")
             .long("id")
@@ -24,11 +27,6 @@ pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
                 .help("Comma separated list rest rest endpoints of the validators")
                 .takes_value(true),
         )
-        .arg(Arg::with_name("mixnet-contract")
-                 .long("mixnet-contract")
-                 .help("Address of the validator contract managing the network")
-                 .takes_value(true),
-        )
         .arg(Arg::with_name("gateway")
             .long("gateway")
             .help("Id of the gateway we want to connect to. If overridden, it is user's responsibility to ensure prior registration happened")
@@ -38,23 +36,31 @@ pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
             .long("disable-socket")
             .help("Whether to not start the websocket")
         )
-        .arg(Arg::with_name("vpn-mode")
-            .long("vpn-mode")
-            .help("Set the vpn mode of the client")
-            .long_help(
-                r#" 
-                    Special mode of the system such that all messages are sent as soon as they are received
-                    and no cover traffic is generated. If set all message delays are set to 0 and overwriting
-                    'Debug' values will have no effect.
-                "#
-            )
-        )
         .arg(Arg::with_name("port")
             .short("p")
             .long("port")
             .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(TESTNET_MODE_ARG_NAME)
+                .long(TESTNET_MODE_ARG_NAME)
+                .help("Set this client to work in a testnet 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))
+        .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
 }
 
 // this only checks compatibility between config the binary. It does not take into consideration
@@ -76,7 +82,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)) {
@@ -87,12 +93,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

@@ -3,11 +3,17 @@
 
 use crate::client::config::{Config, MISSING_VALUE};
 use clap::{App, Arg, ArgMatches};
-use client_core::config::{default_validator_rest_endpoints, DEFAULT_MIXNET_CONTRACT_ADDRESS};
+use config::defaults::default_api_endpoints;
 use config::NymConfig;
 use std::fmt::Display;
 use std::process;
-use version_checker::{parse_version, Version};
+use version_checker::Version;
+
+#[allow(dead_code)]
+fn fail_upgrade<D1: Display, D2: Display>(from_version: D1, to_version: D2) -> ! {
+    print_failed_upgrade(from_version, to_version);
+    process::exit(1)
+}
 
 fn print_start_upgrade<D1: Display, D2: Display>(from: D1, to: D2) {
     println!(
@@ -30,28 +36,29 @@ fn print_successful_upgrade<D1: Display, D2: Display>(from: D1, to: D2) {
     );
 }
 
-pub fn command_args<'a, 'b>() -> App<'a, 'b> {
-    App::new("upgrade").about("Try to upgrade the client")
-        .arg(
-            Arg::with_name("id")
-                .long("id")
-                .help("Id of the nym-client we want to upgrade")
-                .takes_value(true)
-                .required(true),
-        )
-        // the rest of arguments depend on the upgrade path
-        .arg(Arg::with_name("current version")
-            .long("current-version")
-            .help("REQUIRED FOR PRE-0.9.0 UPGRADES. Specifies current version of the configuration file to help to determine a valid upgrade path. Valid formats include '0.8.1', 'v0.8.1' or 'V0.8.1'")
-            .takes_value(true)
-        )
+fn outdated_upgrade(config_version: &Version, package_version: &Version) -> ! {
+    eprintln!(
+        "Cannot perform upgrade from {} to {}. Your version is too old to perform the upgrade.!",
+        config_version, package_version
+    );
+    process::exit(1)
 }
 
-fn unsupported_upgrade(config_version: Version, package_version: Version) -> ! {
-    eprintln!("Cannot perform upgrade from {} to {}. Please let the developers know about this issue if you expected it to work!", config_version, package_version);
+fn unsupported_upgrade(current_version: &Version, config_version: &Version) -> ! {
+    eprintln!("Cannot perform upgrade from {} to {}. Please let the developers know about this issue if you expected it to work!", config_version, current_version);
     process::exit(1)
 }
 
+pub fn command_args<'a, 'b>() -> App<'a, 'b> {
+    App::new("upgrade").about("Try to upgrade the client").arg(
+        Arg::with_name("id")
+            .long("id")
+            .help("Id of the nym-client we want to upgrade")
+            .takes_value(true)
+            .required(true),
+    )
+}
+
 fn parse_config_version(config: &Config) -> Version {
     let version = Version::parse(config.get_base().get_version()).unwrap_or_else(|err| {
         eprintln!("failed to parse client version! - {:?}", err);
@@ -86,190 +93,28 @@ fn parse_package_version() -> Version {
     version
 }
 
-fn pre_090_upgrade(from: &str, mut config: Config) -> Config {
-    // this is not extracted to separate function as you only have to manually pass version
-    // if upgrading from pre090 version
-    let from = match from.strip_prefix('v') {
-        Some(stripped) => stripped,
-        None => from,
-    };
-
-    let from = match from.strip_prefix('V') {
-        Some(stripped) => stripped,
-        None => from,
-    };
-
-    let from_version = parse_version(from).expect("invalid version provided!");
-    if from_version.major == 0 && from_version.minor < 8 {
-        // technically this could be implemented, but is there any point in that?
-        eprintln!("upgrading client from before v0.8.0 is not supported. Please run `init` with new binary instead");
-        process::exit(1)
-    }
-
-    if (from_version.major == 0 && from_version.minor >= 9) || from_version.major >= 1 {
-        eprintln!("self reported version is higher than 0.9.0. Those releases should have already contained version numbers in config! Make sure you provided correct version");
-        process::exit(1)
-    }
-
-    // note: current is guaranteed to not have any `build` information suffix (nor pre-release
-    // information), as this was asserted at the beginning of this command)
-    //
-    // upgrade to current (if it's a 0.9.X) or try to upgrade to 0.9.0 as an intermediate
-    // step in future upgrades (so, for example, we might go 0.8.0 -> 0.9.0 -> 0.10.0)
-    // this way we don't need to have all the crazy paths on how to upgrade from any version to any
-    // other version. We just upgrade one minor version at a time.
-    let current = Version::parse(env!("CARGO_PKG_VERSION")).unwrap();
-    let to_version = if current.major == 0 && current.minor == 9 {
-        current
-    } else {
-        Version::new(0, 9, 0)
-    };
-
-    if config.get_base().get_validator_rest_endpoints()[0] != MISSING_VALUE {
-        eprintln!("existing config seems to have specified new validator rest endpoint which was only introduced in 0.9.0! Can't perform upgrade.");
-        print_failed_upgrade(&from_version, &to_version);
-        process::exit(1);
-    }
-
-    print_start_upgrade(&from_version, &to_version);
-
-    config
-        .get_base_mut()
-        .set_custom_version(to_version.to_string().as_ref());
-
-    println!(
-        "Setting validator REST endpoint to to {:?}",
-        default_validator_rest_endpoints()
-    );
-
-    config
-        .get_base_mut()
-        .set_custom_validators(default_validator_rest_endpoints());
-
-    config.save_to_file(None).unwrap_or_else(|err| {
-        eprintln!("failed to overwrite config file! - {:?}", err);
-        print_failed_upgrade(&from_version, &to_version);
-        process::exit(1);
-    });
-
-    print_successful_upgrade(from_version, to_version);
-
-    config
-}
-
-/*
-changes:
-- introduction of mixnet contract address field
-- change to default validator rest endpoint
- */
-fn minor_010_upgrade(
+fn minor_0_12_upgrade(
     mut config: Config,
     _matches: &ArgMatches,
     config_version: &Version,
     package_version: &Version,
 ) -> Config {
-    let to_version = if package_version.major == 0 && package_version.minor == 10 {
+    let to_version = if package_version.major == 0 && package_version.minor == 12 {
         package_version.clone()
     } else {
-        Version::new(0, 10, 0)
+        Version::new(0, 12, 0)
     };
 
     print_start_upgrade(&config_version, &to_version);
 
-    config
-        .get_base_mut()
-        .set_custom_version(to_version.to_string().as_ref());
-
-    if config.get_base().get_validator_mixnet_contract_address() != MISSING_VALUE {
-        eprintln!("existing config seems to have specified mixnet contract address which was only introduced in 0.10.0! Can't perform upgrade.");
-        print_failed_upgrade(&config_version, &to_version);
-        process::exit(1);
-    }
-
     println!(
-        "Setting mixnet contract address to {}",
-        DEFAULT_MIXNET_CONTRACT_ADDRESS
+        "Setting validator API endpoints to {:?}",
+        default_api_endpoints()
     );
 
     config
         .get_base_mut()
-        .set_mixnet_contract(DEFAULT_MIXNET_CONTRACT_ADDRESS);
-
-    // The default validator endpoint changed
-    println!(
-        "Setting validator REST endpoint to to {:?}",
-        default_validator_rest_endpoints()
-    );
-
-    config
-        .get_base_mut()
-        .set_custom_validators(default_validator_rest_endpoints());
-
-    config.save_to_file(None).unwrap_or_else(|err| {
-        eprintln!("failed to overwrite config file! - {:?}", err);
-        print_failed_upgrade(&config_version, &to_version);
-        process::exit(1);
-    });
-
-    print_successful_upgrade(config_version, to_version);
-
-    config
-}
-
-// no changes but version number
-fn patch_010_upgrade(
-    mut config: Config,
-    _matches: &ArgMatches,
-    config_version: &Version,
-    package_version: &Version,
-) -> Config {
-    let to_version = package_version;
-
-    print_start_upgrade(&config_version, &to_version);
-
-    config
-        .get_base_mut()
-        .set_custom_version(to_version.to_string().as_ref());
-
-    config.save_to_file(None).unwrap_or_else(|err| {
-        eprintln!("failed to overwrite config file! - {:?}", err);
-        print_failed_upgrade(&config_version, &to_version);
-        process::exit(1);
-    });
-
-    print_successful_upgrade(config_version, to_version);
-
-    config
-}
-
-fn minor_011_upgrade(
-    mut config: Config,
-    _matches: &ArgMatches,
-    config_version: &Version,
-    package_version: &Version,
-) -> Config {
-    let to_version = package_version;
-
-    print_start_upgrade(&config_version, &to_version);
-
-    println!(
-        "Setting mixnet contract address to {}",
-        DEFAULT_MIXNET_CONTRACT_ADDRESS
-    );
-
-    config
-        .get_base_mut()
-        .set_mixnet_contract(DEFAULT_MIXNET_CONTRACT_ADDRESS);
-
-    // The default validator endpoint changed
-    println!(
-        "Setting validator REST endpoint to {:?}",
-        default_validator_rest_endpoints()
-    );
-
-    config
-        .get_base_mut()
-        .set_custom_validators(default_validator_rest_endpoints());
+        .set_custom_validator_apis(default_api_endpoints());
 
     config
         .get_base_mut()
@@ -297,18 +142,11 @@ fn do_upgrade(mut config: Config, matches: &ArgMatches, package_version: Version
 
         config = match config_version.major {
             0 => match config_version.minor {
-                9 => minor_010_upgrade(config, matches, &config_version, &Version::new(0, 10, 0)),
-                10 => match config_version.patch {
-                    0 => {
-                        patch_010_upgrade(config, matches, &config_version, &Version::new(0, 10, 1))
-                    }
-                    _ => {
-                        minor_011_upgrade(config, matches, &config_version, &Version::new(0, 11, 0))
-                    }
-                },
-                _ => unsupported_upgrade(config_version, package_version),
+                9 | 10 => outdated_upgrade(&config_version, &package_version),
+                11 => minor_0_12_upgrade(config, matches, &config_version, &package_version),
+                _ => unsupported_upgrade(&config_version, &package_version),
             },
-            _ => unsupported_upgrade(config_version, package_version),
+            _ => unsupported_upgrade(&config_version, &package_version),
         }
     }
 }
@@ -318,22 +156,14 @@ pub fn execute(matches: &ArgMatches) {
 
     let id = matches.value_of("id").unwrap();
 
-    let mut existing_config = Config::load_from_file(Some(id)).unwrap_or_else(|err| {
+    let existing_config = Config::load_from_file(Some(id)).unwrap_or_else(|err| {
         eprintln!("failed to load existing config file! - {:?}", err);
         process::exit(1)
     });
 
-    // versions fields were added in 0.9.0
     if existing_config.get_base().get_version() == MISSING_VALUE {
-        let self_reported_version = matches.value_of("current version").unwrap_or_else(|| {
-            eprintln!(
-                "trying to upgrade from pre v0.9.0 without providing current system version!"
-            );
-            process::exit(1)
-        });
-
-        // upgrades up to 0.9.0
-        existing_config = pre_090_upgrade(self_reported_version, existing_config);
+        eprintln!("the existing configuration file does not seem to contain version number.");
+        process::exit(1);
     }
 
     // here be upgrade path to 0.9.X and beyond based on version number from config

clients/native/src/main.rs

@@ -1,19 +1,21 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use clap::{App, ArgMatches};
+use clap::{crate_version, App, ArgMatches};
 
 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 +23,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 +52,38 @@ 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}{}
+"#,
+        "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"),
     )
 }
 

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/src/websocket/mod.rs

@@ -1,8 +1,8 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-pub(crate) mod handler;
-pub(crate) mod listener;
-
 pub(crate) use handler::Handler;
 pub(crate) use listener::Listener;
+
+pub(crate) mod handler;
+pub(crate) mod listener;

clients/socks5/Cargo.toml

@@ -1,8 +1,9 @@
 [package]
 name = "nym-socks5-client"
-version = "0.11.0"
+version = "0.12.1"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
 edition = "2018"
+rust-version = "1.56"
 
 [lib]
 name = "nym_socks5"
@@ -20,18 +21,29 @@ rand = { version = "0.7.3", features = ["wasm-bindgen"] }
 serde = { version = "1.0", features = ["derive"] } # for config serialization/deserialization
 snafu = "0.6"
 tokio = { version = "1.4", features = ["rt-multi-thread", "net", "signal"] }
+url = "2.2"
 
 # internal
 client-core = { path = "../client-core" }
+coconut-interface = { path = "../../common/coconut-interface", optional = true }
+credentials = { path = "../../common/credentials", optional = true }
 config = { path = "../../common/config" }
 crypto = { path = "../../common/crypto" }
 gateway-client = { path = "../../common/client-libs/gateway-client" }
 gateway-requests = { path = "../../gateway/gateway-requests" }
 nymsphinx = { path = "../../common/nymsphinx" }
-ordered-buffer = {path = "../../common/socks5/ordered-buffer"}
+ordered-buffer = { path = "../../common/socks5/ordered-buffer" }
 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" }
 version-checker = { path = "../../common/version-checker" }
+network-defaults = { path = "../../common/network-defaults" }
+
+[features]
+coconut = ["coconut-interface", "credentials", "gateway-requests/coconut", "gateway-client/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")
+}

clients/socks5/src/client/config/mod.rs

@@ -4,6 +4,7 @@
 use crate::client::config::template::config_template;
 use client_core::config::Config as BaseConfig;
 pub use client_core::config::MISSING_VALUE;
+use config::defaults::DEFAULT_SOCKS5_LISTENING_PORT;
 use config::NymConfig;
 use nymsphinx::addressing::clients::Recipient;
 use serde::{Deserialize, Serialize};
@@ -11,8 +12,6 @@ use std::path::PathBuf;
 
 mod template;
 
-const DEFAULT_LISTENING_PORT: u16 = 1080;
-
 #[derive(Debug, Default, Deserialize, PartialEq, Serialize)]
 #[serde(deny_unknown_fields)]
 pub struct Config {
@@ -103,7 +102,7 @@ pub struct Socks5 {
 impl Socks5 {
     pub fn new<S: Into<String>>(provider_mix_address: S) -> Self {
         Socks5 {
-            listening_port: DEFAULT_LISTENING_PORT,
+            listening_port: DEFAULT_SOCKS5_LISTENING_PORT,
             provider_mix_address: provider_mix_address.into(),
         }
     }
@@ -112,7 +111,7 @@ impl Socks5 {
 impl Default for Socks5 {
     fn default() -> Self {
         Socks5 {
-            listening_port: DEFAULT_LISTENING_PORT,
+            listening_port: DEFAULT_SOCKS5_LISTENING_PORT,
             provider_mix_address: "".into(),
         }
     }

clients/socks5/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,21 +19,17 @@ version = '{{ client.version }}'
 # Human readable ID of this particular client.
 id = '{{ client.id }}'
 
-# URL to the validator server for obtaining network topology.
-validator_rest_urls = [
-    {{#each client.validator_rest_urls }}
+# Indicates whether this client is running in a testnet mode, thus attempting
+# to claim bandwidth without presenting bandwidth credentials.
+testnet_mode = {{ client.testnet_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 }}
         '{{this}}',
     {{/each}}
 ]
 
-# Address of the validator contract managing the network.
-mixnet_contract_address = '{{ client.mixnet_contract_address }}'
-
-# Special mode of the system such that all messages are sent as soon as they are received
-# and no cover traffic is generated. If set all message delays are set to 0 and overwriting
-# 'Debug' values will have no effect.
-vpn_mode = {{ client.vpn_mode }}
-
 # Path to file containing private identity key.
 private_identity_key_file = '{{ client.private_identity_key_file }}'
 
@@ -50,6 +46,17 @@ 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 }}'
+
+# Ethereum private key.
+eth_private_key = '{{ client.eth_private_key }}'
+
+# Addess to an Ethereum full node.
+eth_endpoint = '{{ client.eth_endpoint }}'
+
 ##### additional client config options #####
 
 # ID of the gateway from which the client should be fetching messages.

clients/socks5/src/client/mod.rs

@@ -1,11 +1,6 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::client::config::Config;
-use crate::socks::{
-    authentication::{AuthenticationMethods, Authenticator, User},
-    server::SphinxSocksServer,
-};
 use client_core::client::cover_traffic_stream::LoopCoverTrafficStream;
 use client_core::client::inbound_messages::{
     InputMessage, InputMessageReceiver, InputMessageSender,
@@ -25,6 +20,7 @@ use client_core::client::topology_control::{
 use client_core::config::persistence::key_pathfinder::ClientKeyPathfinder;
 use crypto::asymmetric::identity;
 use futures::channel::mpsc;
+use gateway_client::bandwidth::BandwidthController;
 use gateway_client::{
     AcknowledgementReceiver, AcknowledgementSender, GatewayClient, MixnetMessageReceiver,
     MixnetMessageSender,
@@ -32,8 +28,12 @@ use gateway_client::{
 use log::*;
 use nymsphinx::addressing::clients::Recipient;
 use nymsphinx::addressing::nodes::NodeIdentity;
-use nymsphinx::params::PacketMode;
-use tokio::runtime::Runtime;
+
+use crate::client::config::Config;
+use crate::socks::{
+    authentication::{AuthenticationMethods, Authenticator, User},
+    server::SphinxSocksServer,
+};
 
 pub(crate) mod config;
 
@@ -42,11 +42,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,
 }
@@ -57,7 +52,6 @@ impl NymClient {
         let key_manager = KeyManager::load_keys(&pathfinder).expect("failed to load stored keys");
 
         NymClient {
-            runtime: Runtime::new().unwrap(),
             config,
             key_manager,
         }
@@ -81,9 +75,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(),
@@ -96,7 +87,7 @@ impl NymClient {
             self.as_mix_recipient(),
             topology_accessor,
         )
-        .start(self.runtime.handle());
+        .start();
     }
 
     fn start_real_traffic_controller(
@@ -107,12 +98,6 @@ impl NymClient {
         input_receiver: InputMessageReceiver,
         mix_sender: BatchMixMessageSender,
     ) {
-        let packet_mode = if self.config.get_base().get_vpn_mode() {
-            PacketMode::Vpn
-        } else {
-            PacketMode::Mix
-        };
-
         let controller_config = client_core::client::real_messages_control::Config::new(
             self.key_manager.ack_key(),
             self.config.get_base().get_ack_wait_multiplier(),
@@ -121,15 +106,9 @@ impl NymClient {
             self.config.get_base().get_message_sending_average_delay(),
             self.config.get_base().get_average_packet_delay(),
             self.as_mix_recipient(),
-            packet_mode,
-            self.config.get_base().get_vpn_key_reuse_limit(),
         );
 
         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,
@@ -139,7 +118,7 @@ impl NymClient {
             topology_accessor,
             reply_key_storage,
         )
-        .start(self.runtime.handle(), self.config.get_base().get_vpn_mode());
+        .start();
     }
 
     // buffer controlling all messages fetched from provider
@@ -157,10 +136,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,
@@ -177,6 +156,19 @@ impl NymClient {
         let gateway_identity = identity::PublicKey::from_base58_string(gateway_id)
             .expect("provided gateway id is invalid!");
 
+        #[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");
+
         let mut gateway_client = GatewayClient::new(
             gateway_address,
             self.key_manager.identity_keypair(),
@@ -185,43 +177,37 @@ impl NymClient {
             mixnet_message_sender,
             ack_sender,
             self.config.get_base().get_gateway_response_timeout(),
+            Some(bandwidth_controller),
         );
 
-        self.runtime.block_on(async {
-            gateway_client
-                .authenticate_and_start()
-                .await
-                .expect("could not authenticate and start up the gateway connection")
-        });
+        if self.config.get_base().get_testnet_mode() {
+            gateway_client.set_testnet_mode(true)
+        }
+        gateway_client
+            .authenticate_and_start()
+            .await
+            .expect("could not authenticate and start up the gateway connection");
 
         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_rest_endpoints(),
-            self.config
-                .get_base()
-                .get_validator_mixnet_contract_address(),
+            self.config.get_base().get_validator_api_endpoints(),
             self.config.get_base().get_topology_refresh_rate(),
+            env!("CARGO_PKG_VERSION").to_string(),
         );
         let mut topology_refresher =
             TopologyRefresher::new(topology_refresher_config, topology_accessor);
         // before returning, block entire runtime to refresh the current network view so that any
         // components depending on topology would see a non-empty view
-        info!(
-            "Obtaining initial network topology from {}",
-            self.config.get_base().get_validator_rest_endpoints()[0]
-        );
-        self.runtime.block_on(topology_refresher.refresh());
+        info!("Obtaining initial network topology");
+        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"
@@ -229,7 +215,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)
@@ -242,7 +228,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_socks5_listener(
@@ -261,14 +247,13 @@ impl NymClient {
             self.config.get_provider_mix_address(),
             self.as_mix_recipient(),
         );
-        self.runtime
-            .spawn(async move { sphinx_socks.serve(msg_input, buffer_requester).await });
+        tokio::spawn(async move { sphinx_socks.serve(msg_input, buffer_requester).await });
     }
 
     /// 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
@@ -280,7 +265,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
@@ -312,14 +297,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(
@@ -329,9 +317,8 @@ impl NymClient {
             input_receiver,
             sphinx_message_sender.clone(),
         );
-        if !self.config.get_base().get_vpn_mode() {
-            self.start_cover_traffic_stream(shared_topology_accessor, sphinx_message_sender);
-        }
+
+        self.start_cover_traffic_stream(shared_topology_accessor, sphinx_message_sender);
         self.start_socks5_listener(received_buffer_request_sender, input_sender);
 
         info!("Client startup finished!");

clients/socks5/src/commands/init.rs

@@ -1,25 +1,43 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::client::config::Config;
-use crate::commands::override_config;
 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::{prelude::SliceRandom, rngs::OsRng};
+use rand::{prelude::SliceRandom, rngs::OsRng, thread_rng};
 use std::convert::TryInto;
 use std::sync::Arc;
 use std::time::Duration;
 use topology::{filter::VersionFilterable, gateway};
+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, ETH_ENDPOINT_ARG_NAME, ETH_PRIVATE_KEY_ARG_NAME,
+    TESTNET_MODE_ARG_NAME,
+};
 
 pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
-    App::new("init")
+    let app = App::new("init")
         .about("Initialise a Nym client. Do this first!")
         .arg(Arg::with_name("id")
             .long("id")
@@ -39,13 +57,8 @@ pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
             .takes_value(true)
         )
         .arg(Arg::with_name("validators")
-                .long("validators")
-                .help("Comma separated list of rest endpoints of the validators")
-                .takes_value(true),
-        )
-        .arg(Arg::with_name("mixnet-contract")
-                 .long("mixnet-contract")
-                 .help("Address of the validator contract managing the network")
+                 .long("validators")
+                 .help("Comma separated list of rest endpoints of the validators")
                  .takes_value(true),
         )
         .arg(Arg::with_name("port")
@@ -54,28 +67,71 @@ pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
             .help("Port for the socket to listen on in all subsequent runs")
             .takes_value(true)
         )
-        .arg(Arg::with_name("vpn-mode")
-            .long("vpn-mode")
-            .help("Set the vpn mode of the client")
-            .long_help(
-                r#" 
-                    Special mode of the system such that all messages are sent as soon as they are received
-                    and no cover traffic is generated. If set all message delays are set to 0 and overwriting
-                    'Debug' values will have no effect.
-                "#
-            )
-        )
         .arg(Arg::with_name("fastmode")
             .long("fastmode")
             .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(TESTNET_MODE_ARG_NAME)
+                .long(TESTNET_MODE_ARG_NAME)
+                .help("Set this client to work in a testnet 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(TESTNET_MODE_ARG_NAME, None, DEFAULT_ETH_ENDPOINT)
+            .required(true))
+        .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)
+            .default_value_if(TESTNET_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("BandwidthVoucher"),
+    };
+
+    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>,
-) -> SharedKeys {
+) -> Arc<SharedKeys> {
     let timeout = Duration::from_millis(1500);
     let mut gateway_client = GatewayClient::new_init(
         gateway.clients_address(),
@@ -88,18 +144,19 @@ async fn register_with_gateway(
         .await
         .expect("failed to establish connection with the gateway!");
     gateway_client
-        .register()
+        .perform_initial_authentication()
         .await
         .expect("failed to register with the gateway!")
 }
 
 async fn gateway_details(
-    validator_servers: Vec<String>,
-    mixnet_contract: &str,
+    validator_servers: Vec<Url>,
     chosen_gateway_id: Option<&str>,
 ) -> gateway::Node {
-    let validator_client_config = validator_client::Config::new(validator_servers, mixnet_contract);
-    let validator_client = validator_client::Client::new(validator_client_config);
+    let validator_api = validator_servers
+        .choose(&mut thread_rng())
+        .expect("The list of validator apis is empty");
+    let validator_client = validator_client::ApiClient::new(validator_api.clone());
 
     let gateways = validator_client.get_cached_gateways().await.unwrap();
     let valid_gateways = gateways
@@ -162,7 +219,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
@@ -181,7 +238,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();
     }
@@ -194,27 +251,20 @@ 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_rest_endpoints(),
-                &config.get_base().get_validator_mixnet_contract_address(),
-                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())
-        };
-
-        // 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);
+        let gateway_details = gateway_details(
+            config.get_base().get_validator_api_endpoints(),
+            chosen_gateway_id,
+        )
+        .await;
         config
             .get_base_mut()
-            .with_gateway_listener(gateway_listener);
+            .with_gateway_id(gateway_details.identity_key.to_base58_string());
+        let shared_keys =
+            register_with_gateway(&gateway_details, key_manager.identity_keypair()).await;
+
+        config
+            .get_base_mut()
+            .with_gateway_listener(gateway_details.clients_address());
         key_manager.insert_gateway_shared_key(shared_keys);
 
         let pathfinder = ClientKeyPathfinder::new_from_config(config.get_base());

clients/socks5/src/commands/mod.rs

@@ -3,14 +3,32 @@
 
 use crate::client::config::Config;
 use clap::ArgMatches;
+use url::Url;
 
 pub(crate) mod init;
 pub(crate) mod run;
 pub(crate) mod upgrade;
 
-fn parse_validators(raw: &str) -> Vec<String> {
+pub(crate) const TESTNET_MODE_ARG_NAME: &str = "testnet-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";
+
+fn parse_validators(raw: &str) -> Vec<Url> {
     raw.split(',')
-        .map(|raw_validator| raw_validator.trim().into())
+        .map(|raw_validator| {
+            raw_validator
+                .trim()
+                .parse()
+                .expect("one of the provided validator api urls is invalid")
+        })
         .collect()
 }
 
@@ -18,21 +36,13 @@ pub(crate) fn override_config(mut config: Config, matches: &ArgMatches) -> Confi
     if let Some(raw_validators) = matches.value_of("validators") {
         config
             .get_base_mut()
-            .set_custom_validators(parse_validators(raw_validators));
-    }
-
-    if let Some(contract_address) = matches.value_of("mixnet-contract") {
-        config.get_base_mut().set_mixnet_contract(contract_address)
+            .set_custom_validator_apis(parse_validators(raw_validators));
     }
 
     if let Some(gateway_id) = matches.value_of("gateway") {
         config.get_base_mut().with_gateway_id(gateway_id);
     }
 
-    if matches.is_present("vpn-mode") {
-        config.get_base_mut().set_vpn_mode(true);
-    }
-
     if let Some(port) = matches.value_of("port").map(|port| port.parse::<u16>()) {
         if let Err(err) = port {
             // if port was overridden, it must be parsable
@@ -41,5 +51,26 @@ pub(crate) fn override_config(mut config: Config, matches: &ArgMatches) -> Confi
         config = config.with_port(port.unwrap());
     }
 
+    #[cfg(not(feature = "coconut"))]
+    if let Some(eth_endpoint) = matches.value_of(ETH_ENDPOINT_ARG_NAME) {
+        config.get_base_mut().with_eth_endpoint(eth_endpoint);
+    } else {
+        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_ARG_NAME) {
+        config.get_base_mut().with_eth_private_key(eth_private_key);
+    } else {
+        config
+            .get_base_mut()
+            .with_eth_private_key(DEFAULT_ETH_PRIVATE_KEY);
+    }
+
+    if !cfg!(feature = "eth") || matches.is_present(TESTNET_MODE_ARG_NAME) {
+        config.get_base_mut().with_testnet_mode(true)
+    }
+
     config
 }

clients/socks5/src/commands/run.rs

@@ -4,13 +4,16 @@
 use crate::client::config::Config;
 use crate::client::NymClient;
 use crate::commands::override_config;
+#[cfg(feature = "eth")]
+#[cfg(not(feature = "coconut"))]
+use crate::commands::{ETH_ENDPOINT_ARG_NAME, ETH_PRIVATE_KEY_ARG_NAME, TESTNET_MODE_ARG_NAME};
 use clap::{App, Arg, ArgMatches};
 use config::NymConfig;
 use log::*;
 use version_checker::is_minor_version_compatible;
 
 pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
-    App::new("run")
+    let app = App::new("run")
         .about("Run the Nym client with provided configuration client optionally overriding set parameters")
         .arg(Arg::with_name("id")
             .long("id")
@@ -34,33 +37,36 @@ pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
                 .help("Comma separated list of rest endpoints of the validators")
                 .takes_value(true),
         )
-        .arg(Arg::with_name("mixnet-contract")
-                 .long("mixnet-contract")
-                 .help("Address of the validator contract managing the network")
-                 .takes_value(true),
-        )
         .arg(Arg::with_name("gateway")
             .long("gateway")
             .help("Id of the gateway we want to connect to. If overridden, it is user's responsibility to ensure prior registration happened")
             .takes_value(true)
         )
-        .arg(Arg::with_name("vpn-mode")
-            .long("vpn-mode")
-            .help("Set the vpn mode of the client")
-            .long_help(
-                r#" 
-                    Special mode of the system such that all messages are sent as soon as they are received
-                    and no cover traffic is generated. If set all message delays are set to 0 and overwriting
-                    'Debug' values will have no effect.
-                "#
-            )
-        )
         .arg(Arg::with_name("port")
             .short("p")
             .long("port")
             .help("Port for the socket to listen on")
             .takes_value(true)
+        );
+    #[cfg(feature = "eth")]
+    #[cfg(not(feature = "coconut"))]
+    let app = app
+        .arg(
+            Arg::with_name(TESTNET_MODE_ARG_NAME)
+                .long(TESTNET_MODE_ARG_NAME)
+                .help("Set this client to work in a testnet 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))
+        .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
 }
 
 // this only checks compatibility between config the binary. It does not take into consideration
@@ -82,7 +88,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)) {
@@ -93,12 +99,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/socks5/src/commands/upgrade.rs

@@ -3,11 +3,17 @@
 
 use crate::client::config::{Config, MISSING_VALUE};
 use clap::{App, Arg, ArgMatches};
-use client_core::config::{default_validator_rest_endpoints, DEFAULT_MIXNET_CONTRACT_ADDRESS};
+use config::defaults::default_api_endpoints;
 use config::NymConfig;
 use std::fmt::Display;
 use std::process;
-use version_checker::{parse_version, Version};
+use version_checker::Version;
+
+#[allow(dead_code)]
+fn fail_upgrade<D1: Display, D2: Display>(from_version: D1, to_version: D2) -> ! {
+    print_failed_upgrade(from_version, to_version);
+    process::exit(1)
+}
 
 fn print_start_upgrade<D1: Display, D2: Display>(from: D1, to: D2) {
     println!(
@@ -30,28 +36,29 @@ fn print_successful_upgrade<D1: Display, D2: Display>(from: D1, to: D2) {
     );
 }
 
-pub fn command_args<'a, 'b>() -> App<'a, 'b> {
-    App::new("upgrade").about("Try to upgrade the client")
-        .arg(
-            Arg::with_name("id")
-                .long("id")
-                .help("Id of the nym-socks5-client we want to upgrade")
-                .takes_value(true)
-                .required(true),
-        )
-        // the rest of arguments depend on the upgrade path
-        .arg(Arg::with_name("current version")
-            .long("current-version")
-            .help("REQUIRED FOR PRE-0.9.0 UPGRADES. Specifies current version of the configuration file to help to determine a valid upgrade path. Valid formats include '0.8.1', 'v0.8.1' or 'V0.8.1'")
-            .takes_value(true)
-        )
+fn outdated_upgrade(config_version: &Version, package_version: &Version) -> ! {
+    eprintln!(
+        "Cannot perform upgrade from {} to {}. Your version is too old to perform the upgrade.!",
+        config_version, package_version
+    );
+    process::exit(1)
 }
 
-fn unsupported_upgrade(config_version: Version, package_version: Version) -> ! {
-    eprintln!("Cannot perform upgrade from {} to {}. Please let the developers know about this issue if you expected it to work!", config_version, package_version);
+fn unsupported_upgrade(current_version: &Version, config_version: &Version) -> ! {
+    eprintln!("Cannot perform upgrade from {} to {}. Please let the developers know about this issue if you expected it to work!", config_version, current_version);
     process::exit(1)
 }
 
+pub fn command_args<'a, 'b>() -> App<'a, 'b> {
+    App::new("upgrade").about("Try to upgrade the client").arg(
+        Arg::with_name("id")
+            .long("id")
+            .help("Id of the nym-client we want to upgrade")
+            .takes_value(true)
+            .required(true),
+    )
+}
+
 fn parse_config_version(config: &Config) -> Version {
     let version = Version::parse(config.get_base().get_version()).unwrap_or_else(|err| {
         eprintln!("failed to parse client version! - {:?}", err);
@@ -86,190 +93,28 @@ fn parse_package_version() -> Version {
     version
 }
 
-fn pre_090_upgrade(from: &str, mut config: Config) -> Config {
-    // this is not extracted to separate function as you only have to manually pass version
-    // if upgrading from pre090 version
-    let from = match from.strip_prefix('v') {
-        Some(stripped) => stripped,
-        None => from,
-    };
-
-    let from = match from.strip_prefix('V') {
-        Some(stripped) => stripped,
-        None => from,
-    };
-
-    let from_version = parse_version(from).expect("invalid version provided!");
-    if from_version.major == 0 && from_version.minor < 8 {
-        // technically this could be implemented, but is there any point in that?
-        eprintln!("upgrading client from before v0.8.0 is not supported. Please run `init` with new binary instead");
-        process::exit(1)
-    }
-
-    if (from_version.major == 0 && from_version.minor >= 9) || from_version.major >= 1 {
-        eprintln!("self reported version is higher than 0.9.0. Those releases should have already contained version numbers in config! Make sure you provided correct version");
-        process::exit(1)
-    }
-
-    // note: current is guaranteed to not have any `build` information suffix (nor pre-release
-    // information), as this was asserted at the beginning of this command)
-    //
-    // upgrade to current (if it's a 0.9.X) or try to upgrade to 0.9.0 as an intermediate
-    // step in future upgrades (so, for example, we might go 0.8.0 -> 0.9.0 -> 0.10.0)
-    // this way we don't need to have all the crazy paths on how to upgrade from any version to any
-    // other version. We just upgrade one minor version at a time.
-    let current = Version::parse(env!("CARGO_PKG_VERSION")).unwrap();
-    let to_version = if current.major == 0 && current.minor == 9 {
-        current
-    } else {
-        Version::new(0, 9, 0)
-    };
-
-    if config.get_base().get_validator_rest_endpoints()[0] != MISSING_VALUE {
-        eprintln!("existing config seems to have specified new validator rest endpoint which was only introduced in 0.9.0! Can't perform upgrade.");
-        print_failed_upgrade(&from_version, &to_version);
-        process::exit(1);
-    }
-
-    print_start_upgrade(&from_version, &to_version);
-
-    config
-        .get_base_mut()
-        .set_custom_version(to_version.to_string().as_ref());
-
-    println!(
-        "Setting validator REST endpoint to {:?}",
-        default_validator_rest_endpoints()
-    );
-
-    config
-        .get_base_mut()
-        .set_custom_validators(default_validator_rest_endpoints());
-
-    config.save_to_file(None).unwrap_or_else(|err| {
-        eprintln!("failed to overwrite config file! - {:?}", err);
-        print_failed_upgrade(&from_version, &to_version);
-        process::exit(1);
-    });
-
-    print_successful_upgrade(from_version, to_version);
-
-    config
-}
-
-/*
-changes:
-- introduction of mixnet contract address field
-- change to default validator rest endpoint
- */
-fn minor_010_upgrade(
+fn minor_0_12_upgrade(
     mut config: Config,
     _matches: &ArgMatches,
     config_version: &Version,
     package_version: &Version,
 ) -> Config {
-    let to_version = if package_version.major == 0 && package_version.minor == 10 {
+    let to_version = if package_version.major == 0 && package_version.minor == 12 {
         package_version.clone()
     } else {
-        Version::new(0, 10, 0)
+        Version::new(0, 12, 0)
     };
 
     print_start_upgrade(&config_version, &to_version);
 
-    config
-        .get_base_mut()
-        .set_custom_version(to_version.to_string().as_ref());
-
-    if config.get_base().get_validator_mixnet_contract_address() != MISSING_VALUE {
-        eprintln!("existing config seems to have specified mixnet contract address which was only introduced in 0.10.0! Can't perform upgrade.");
-        print_failed_upgrade(&config_version, &to_version);
-        process::exit(1);
-    }
-
     println!(
-        "Setting mixnet contract address to {}",
-        DEFAULT_MIXNET_CONTRACT_ADDRESS
+        "Setting validator API endpoints to {:?}",
+        default_api_endpoints()
     );
 
     config
         .get_base_mut()
-        .set_mixnet_contract(DEFAULT_MIXNET_CONTRACT_ADDRESS);
-
-    // The default validator endpoint changed
-    println!(
-        "Setting validator REST endpoint to to {:?}",
-        default_validator_rest_endpoints()
-    );
-
-    config
-        .get_base_mut()
-        .set_custom_validators(default_validator_rest_endpoints());
-
-    config.save_to_file(None).unwrap_or_else(|err| {
-        eprintln!("failed to overwrite config file! - {:?}", err);
-        print_failed_upgrade(&config_version, &to_version);
-        process::exit(1);
-    });
-
-    print_successful_upgrade(config_version, to_version);
-
-    config
-}
-
-// no changes but version number
-fn patch_010_upgrade(
-    mut config: Config,
-    _matches: &ArgMatches,
-    config_version: &Version,
-    package_version: &Version,
-) -> Config {
-    let to_version = package_version;
-
-    print_start_upgrade(&config_version, &to_version);
-
-    config
-        .get_base_mut()
-        .set_custom_version(to_version.to_string().as_ref());
-
-    config.save_to_file(None).unwrap_or_else(|err| {
-        eprintln!("failed to overwrite config file! - {:?}", err);
-        print_failed_upgrade(&config_version, &to_version);
-        process::exit(1);
-    });
-
-    print_successful_upgrade(config_version, to_version);
-
-    config
-}
-
-fn minor_011_upgrade(
-    mut config: Config,
-    _matches: &ArgMatches,
-    config_version: &Version,
-    package_version: &Version,
-) -> Config {
-    let to_version = package_version;
-
-    print_start_upgrade(&config_version, &to_version);
-
-    println!(
-        "Setting mixnet contract address to {}",
-        DEFAULT_MIXNET_CONTRACT_ADDRESS
-    );
-
-    config
-        .get_base_mut()
-        .set_mixnet_contract(DEFAULT_MIXNET_CONTRACT_ADDRESS);
-
-    // The default validator endpoint changed
-    println!(
-        "Setting validator REST endpoint to {:?}",
-        default_validator_rest_endpoints()
-    );
-
-    config
-        .get_base_mut()
-        .set_custom_validators(default_validator_rest_endpoints());
+        .set_custom_validator_apis(default_api_endpoints());
 
     config
         .get_base_mut()
@@ -297,18 +142,11 @@ fn do_upgrade(mut config: Config, matches: &ArgMatches, package_version: Version
 
         config = match config_version.major {
             0 => match config_version.minor {
-                9 => minor_010_upgrade(config, matches, &config_version, &Version::new(0, 10, 0)),
-                10 => match config_version.patch {
-                    0 => {
-                        patch_010_upgrade(config, matches, &config_version, &Version::new(0, 10, 1))
-                    }
-                    _ => {
-                        minor_011_upgrade(config, matches, &config_version, &Version::new(0, 11, 0))
-                    }
-                },
-                _ => unsupported_upgrade(config_version, package_version),
+                9 | 10 => outdated_upgrade(&config_version, &package_version),
+                11 => minor_0_12_upgrade(config, matches, &config_version, &package_version),
+                _ => unsupported_upgrade(&config_version, &package_version),
             },
-            _ => unsupported_upgrade(config_version, package_version),
+            _ => unsupported_upgrade(&config_version, &package_version),
         }
     }
 }
@@ -318,22 +156,14 @@ pub fn execute(matches: &ArgMatches) {
 
     let id = matches.value_of("id").unwrap();
 
-    let mut existing_config = Config::load_from_file(Some(id)).unwrap_or_else(|err| {
+    let existing_config = Config::load_from_file(Some(id)).unwrap_or_else(|err| {
         eprintln!("failed to load existing config file! - {:?}", err);
         process::exit(1)
     });
 
-    // versions fields were added in 0.9.0
     if existing_config.get_base().get_version() == MISSING_VALUE {
-        let self_reported_version = matches.value_of("current version").unwrap_or_else(|| {
-            eprintln!(
-                "trying to upgrade from pre v0.9.0 without providing current system version!"
-            );
-            process::exit(1)
-        });
-
-        // upgrades up to 0.9.0
-        existing_config = pre_090_upgrade(self_reported_version, existing_config);
+        eprintln!("the existing configuration file does not seem to contain version number.");
+        process::exit(1);
     }
 
     // here be upgrade path to 0.9.X and beyond based on version number from config

clients/socks5/src/main.rs

@@ -1,13 +1,14 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use clap::{App, ArgMatches};
+use clap::{crate_version, App, ArgMatches};
 
 pub mod client;
 mod commands;
 pub mod socks;
 
-fn main() {
+#[tokio::main]
+async fn main() {
     dotenv::dotenv().ok();
     setup_logging();
     println!("{}", banner());
@@ -15,19 +16,20 @@ fn main() {
     let arg_matches = App::new("Nym Socks5 Proxy")
         .version(env!("CARGO_PKG_VERSION"))
         .author("Nymtech")
+        .long_version(&*long_version())
         .about("A Socks5 localhost proxy that converts incoming messages to Sphinx and sends them to a Nym address")
         .subcommand(commands::init::command_args())
         .subcommand(commands::run::command_args())
         .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 +52,38 @@ fn banner() -> String {
              (socks5 proxy - version {:})
 
     "#,
-        env!("CARGO_PKG_VERSION")
+        crate_version!()
+    )
+}
+
+fn long_version() -> String {
+    format!(
+        r#"
+{:<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"),
     )
 }
 

clients/tauri-client/.gitignore

@@ -0,0 +1,5 @@
+.DS_Store
+/node_modules/
+/src/node_modules/@sapper/
+yarn-error.log
+/__sapper__/

clients/tauri-client/README.md

@@ -0,0 +1,33 @@
+## Prerequisites
+
+On Ubuntu-ish systems (not tested on Debian but may work):
+
+```
+sudo apt update && sudo apt install libwebkit2gtk-4.0-dev \
+    build-essential \
+    curl \
+    wget \
+    libssl-dev \
+    libgtk-3-dev \
+    libappindicator3-dev \
+    patchelf \
+    librsvg2-dev```
+
+
+
+## Getting started
+
+1. Start Sapper([docs](https://sapper.svelte.dev/docs/)) -> `yarn run dev`
+2. Start Tauri([docs](https://tauri.studio/en/)) in another terminal -> `yarn tauri dev`
+3. Start validator-api locally, or override `validator-urls` in `index.svelte`
+
+## Getting around
+
++ Frontend -> `tauri-client/`
+  + logic -> `tauri-client/src/routes/index.svelte`
+  + assets -> `tauri-client/static`
++ Backend -> `tauri-client/src/src-tauri`
+
+## Build standalone app
+
++ yarn tauri build [--debug]

clients/tauri-client/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "TODO",
+  "description": "TODO",
+  "version": "0.0.1",
+  "scripts": {
+    "dev": "sapper dev",
+    "build": "sapper build --legacy",
+    "export": "sapper export --legacy",
+    "start": "node __sapper__/build"
+  },
+  "dependencies": {
+    "@tauri-apps/api": "^1.0.0-beta.4",
+    "compression": "^1.7.1",
+    "polka": "next",
+    "qrious": "^4.0.2",
+    "sirv": "^1.0.0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.0.0",
+    "@babel/plugin-syntax-dynamic-import": "^7.0.0",
+    "@babel/plugin-transform-runtime": "^7.0.0",
+    "@babel/preset-env": "^7.0.0",
+    "@babel/runtime": "^7.0.0",
+    "@rollup/plugin-babel": "^5.0.0",
+    "@rollup/plugin-commonjs": "^14.0.0",
+    "@rollup/plugin-node-resolve": "^8.0.0",
+    "@rollup/plugin-replace": "^2.4.0",
+    "@rollup/plugin-url": "^5.0.0",
+    "@tauri-apps/cli": "^1.0.0-beta.5",
+    "rollup": "^2.3.4",
+    "rollup-plugin-svelte": "^7.0.0",
+    "rollup-plugin-terser": "^7.0.0",
+    "sapper": "^0.28.0",
+    "sass": "^1.35.2",
+    "svelte": "^3.17.3",
+    "svelte-preprocess": "^4.7.4"
+  }
+}

clients/tauri-client/rollup.config.js

@@ -0,0 +1,140 @@
+import path from "path";
+import resolve from "@rollup/plugin-node-resolve";
+import replace from "@rollup/plugin-replace";
+import commonjs from "@rollup/plugin-commonjs";
+import url from "@rollup/plugin-url";
+import svelte from "rollup-plugin-svelte";
+import babel from "@rollup/plugin-babel";
+import { terser } from "rollup-plugin-terser";
+import config from "sapper/config/rollup.js";
+import pkg from "./package.json";
+import sveltePreprocess from "svelte-preprocess";
+
+const mode = process.env.NODE_ENV;
+const dev = mode === "development";
+const legacy = !!process.env.SAPPER_LEGACY_BUILD;
+
+const onwarn = (warning, onwarn) =>
+  (warning.code === "MISSING_EXPORT" && /'preload'/.test(warning.message)) ||
+  (warning.code === "CIRCULAR_DEPENDENCY" &&
+    /[/\\]@sapper[/\\]/.test(warning.message)) ||
+  onwarn(warning);
+
+export default {
+  client: {
+    input: config.client.input(),
+    output: config.client.output(),
+    plugins: [
+      replace({
+        preventAssignment: true,
+        values: {
+          "process.browser": true,
+          "process.env.NODE_ENV": JSON.stringify(mode),
+        },
+      }),
+      svelte({
+        compilerOptions: {
+          dev,
+          hydratable: true,
+        },
+        preprocess: sveltePreprocess(),
+      }),
+      url({
+        sourceDir: path.resolve(__dirname, "src/node_modules/images"),
+        publicPath: "/client/",
+      }),
+      resolve({
+        browser: true,
+        dedupe: ["svelte"],
+      }),
+      commonjs(),
+
+      legacy &&
+        babel({
+          extensions: [".js", ".mjs", ".html", ".svelte"],
+          babelHelpers: "runtime",
+          exclude: ["node_modules/@babel/**"],
+          presets: [
+            [
+              "@babel/preset-env",
+              {
+                targets: "> 0.25%, not dead",
+              },
+            ],
+          ],
+          plugins: [
+            "@babel/plugin-syntax-dynamic-import",
+            [
+              "@babel/plugin-transform-runtime",
+              {
+                useESModules: true,
+              },
+            ],
+          ],
+        }),
+
+      !dev &&
+        terser({
+          module: true,
+        }),
+    ],
+
+    preserveEntrySignatures: false,
+    onwarn,
+  },
+
+  server: {
+    input: config.server.input(),
+    output: config.server.output(),
+    plugins: [
+      replace({
+        preventAssignment: true,
+        values: {
+          "process.browser": false,
+          "process.env.NODE_ENV": JSON.stringify(mode),
+        },
+      }),
+      svelte({
+        compilerOptions: {
+          dev,
+          generate: "ssr",
+          hydratable: true,
+        },
+        emitCss: false,
+      }),
+      url({
+        sourceDir: path.resolve(__dirname, "src/node_modules/images"),
+        publicPath: "/client/",
+        emitFiles: false, // already emitted by client build
+      }),
+      resolve({
+        dedupe: ["svelte"],
+      }),
+      commonjs(),
+    ],
+    external: Object.keys(pkg.dependencies).concat(
+      require("module").builtinModules
+    ),
+    preserveEntrySignatures: "strict",
+    onwarn,
+  },
+
+  serviceworker: {
+    input: config.serviceworker.input(),
+    output: config.serviceworker.output(),
+    plugins: [
+      resolve(),
+      replace({
+        preventAssignment: true,
+        values: {
+          "process.browser": true,
+          "process.env.NODE_ENV": JSON.stringify(mode),
+        },
+      }),
+      commonjs(),
+      !dev && terser(),
+    ],
+    preserveEntrySignatures: false,
+    onwarn,
+  },
+};

clients/tauri-client/scripts/setupTypeScript.js

@@ -0,0 +1,304 @@
+/**
+ * Run this script to convert the project to TypeScript. This is only guaranteed to work
+ * on the unmodified default template; if you have done code changes you are likely need
+ * to touch up the generated project manually.
+ */
+
+// @ts-check
+const fs = require('fs');
+const path = require('path');
+const { argv } = require('process');
+
+const projectRoot = argv[2] || path.join(__dirname, '..');
+
+const isRollup = fs.existsSync(path.join(projectRoot, "rollup.config.js"));
+
+function warn(message) {
+	console.warn('Warning: ' + message);
+}
+
+function replaceInFile(fileName, replacements) {
+	if (fs.existsSync(fileName)) {
+		let contents = fs.readFileSync(fileName, 'utf8');
+		let hadUpdates = false;
+
+		replacements.forEach(([from, to]) => {
+			const newContents = contents.replace(from, to);
+
+			const isAlreadyApplied = typeof to !== 'string' || contents.includes(to);
+
+			if (newContents !== contents) {
+				contents = newContents;
+				hadUpdates = true;
+			} else if (!isAlreadyApplied) {
+				warn(`Wanted to update "${from}" in ${fileName}, but did not find it.`);
+			}
+		});
+
+		if (hadUpdates) {
+			fs.writeFileSync(fileName, contents);
+		} else {
+			console.log(`${fileName} had already been updated.`);
+		}
+	} else {
+		warn(`Wanted to update ${fileName} but the file did not exist.`);
+	}
+}
+
+function createFile(fileName, contents) {
+	if (fs.existsSync(fileName)) {
+		warn(`Wanted to create ${fileName}, but it already existed. Leaving existing file.`);
+	} else {
+		fs.writeFileSync(fileName, contents);
+	}
+}
+
+function addDepsToPackageJson() {
+	const pkgJSONPath = path.join(projectRoot, 'package.json');
+	const packageJSON = JSON.parse(fs.readFileSync(pkgJSONPath, 'utf8'));
+	packageJSON.devDependencies = Object.assign(packageJSON.devDependencies, {
+		...(isRollup ? { '@rollup/plugin-typescript': '^6.0.0' } : { 'ts-loader': '^8.0.4' }),
+		'@tsconfig/svelte': '^1.0.10',
+		'@types/compression': '^1.7.0',
+		'@types/node': '^14.11.1',
+		'@types/polka': '^0.5.1',
+		'svelte-check': '^1.0.46',
+		'svelte-preprocess': '^4.3.0',
+		tslib: '^2.0.1',
+		typescript: '^4.0.3'
+	});
+
+	// Add script for checking
+	packageJSON.scripts = Object.assign(packageJSON.scripts, {
+		validate: 'svelte-check --ignore src/node_modules/@sapper'
+	});
+
+	// Write the package JSON
+	fs.writeFileSync(pkgJSONPath, JSON.stringify(packageJSON, null, '  '));
+}
+
+function changeJsExtensionToTs(dir) {
+	const elements = fs.readdirSync(dir, { withFileTypes: true });
+
+	for (let i = 0; i < elements.length; i++) {
+		if (elements[i].isDirectory()) {
+			changeJsExtensionToTs(path.join(dir, elements[i].name));
+		} else if (elements[i].name.match(/^[^_]((?!json).)*js$/)) {
+			fs.renameSync(path.join(dir, elements[i].name), path.join(dir, elements[i].name).replace('.js', '.ts'));
+		}
+	}
+}
+
+function updateSingleSvelteFile({ view, vars, contextModule }) {
+	replaceInFile(path.join(projectRoot, 'src', `${view}.svelte`), [
+		[/(?:<script)(( .*?)*?)>/gm, (m, attrs) => `<script${attrs}${!attrs.includes('lang="ts"') ? ' lang="ts"' : ''}>`],
+		...(vars ? vars.map(({ name, type }) => [`export let ${name};`, `export let ${name}: ${type};`]) : []),
+		...(contextModule ? contextModule.map(({ js, ts }) => [js, ts]) : [])
+	]);
+}
+
+// Switch the *.svelte file to use TS
+function updateSvelteFiles() {
+	[
+		{
+			view: 'components/Nav',
+			vars: [{ name: 'segment', type: 'string' }]
+		},
+		{
+			view: 'routes/_layout',
+			vars: [{ name: 'segment', type: 'string' }]
+		},
+		{
+			view: 'routes/_error',
+			vars: [
+				{ name: 'status', type: 'number' },
+				{ name: 'error', type: 'Error' }
+			]
+		},
+		{
+			view: 'routes/blog/index',
+			vars: [{ name: 'posts', type: '{ slug: string; title: string, html: any }[]' }],
+			contextModule: [
+				{
+					js: '.then(r => r.json())',
+					ts: '.then((r: { json: () => any; }) => r.json())'
+				},
+				{
+					js: '.then(posts => {',
+					ts: '.then((posts: { slug: string; title: string, html: any }[]) => {'
+				}
+			]
+		},
+		{
+			view: 'routes/blog/[slug]',
+			vars: [{ name: 'post', type: '{ slug: string; title: string, html: any }' }]
+		}
+	].forEach(updateSingleSvelteFile);
+}
+
+function updateRollupConfig() {
+	// Edit rollup config
+	replaceInFile(path.join(projectRoot, 'rollup.config.js'), [
+		// Edit imports
+		[
+			/'rollup-plugin-terser';\n(?!import sveltePreprocess)/,
+			`'rollup-plugin-terser';
+import sveltePreprocess from 'svelte-preprocess';
+import typescript from '@rollup/plugin-typescript';
+`
+		],
+		// Edit inputs
+		[
+			/(?<!THIS_IS_UNDEFINED[^\n]*\n\s*)onwarn\(warning\);/,
+			`(warning.code === 'THIS_IS_UNDEFINED') ||\n\tonwarn(warning);`
+		],
+		[/input: config.client.input\(\)(?!\.replace)/, `input: config.client.input().replace(/\\.js$/, '.ts')`],
+		[
+			/input: config.server.input\(\)(?!\.replace)/,
+			`input: { server: config.server.input().server.replace(/\\.js$/, ".ts") }`
+		],
+		[
+			/input: config.serviceworker.input\(\)(?!\.replace)/,
+			`input: config.serviceworker.input().replace(/\\.js$/, '.ts')`
+		],
+		// Add preprocess
+		[/compilerOptions/g, 'preprocess: sveltePreprocess({ sourceMap: dev }),\n\t\t\t\tcompilerOptions'],
+		// Add TypeScript
+		[/commonjs\(\)(?!,\n\s*typescript)/g, 'commonjs(),\n\t\t\ttypescript({ sourceMap: dev })']
+	]);
+}
+
+function updateWebpackConfig() {
+	// Edit webpack config
+	replaceInFile(path.join(projectRoot, 'webpack.config.js'), [
+		// Edit imports
+		[
+			/require\('webpack-modules'\);\n(?!const sveltePreprocess)/,
+			`require('webpack-modules');\nconst sveltePreprocess = require('svelte-preprocess');\n`
+		],
+		// Edit extensions
+		[
+			/\['\.mjs', '\.js', '\.json', '\.svelte', '\.html'\]/,
+			`['.mjs', '.js', '.ts', '.json', '.svelte', '.html']`
+		],
+		// Edit entries
+		[
+			/entry: config\.client\.entry\(\)/,
+			`entry: { main: config.client.entry().main.replace(/\\.js$/, '.ts') }`
+		],
+		[
+			/entry: config\.server\.entry\(\)/,
+			`entry: { server: config.server.entry().server.replace(/\\.js$/, '.ts') }`
+		],
+		[
+			/entry: config\.serviceworker\.entry\(\)/,
+			`entry: { 'service-worker': config.serviceworker.entry()['service-worker'].replace(/\\.js$/, '.ts') }`
+		],
+		[
+      /loader: 'svelte-loader',\n\t\t\t\t\t\toptions: {/g,
+      'loader: \'svelte-loader\',\n\t\t\t\t\t\toptions: {\n\t\t\t\t\t\t\tpreprocess: sveltePreprocess({ sourceMap: dev }),'
+    ],
+		// Add TypeScript rules for client and server
+		[
+			/module: {\n\s*rules: \[\n\s*(?!{\n\s*test: \/\\\.ts\$\/)/g,
+			`module: {\n\t\t\trules: [\n\t\t\t\t{\n\t\t\t\t\ttest: /\\.ts$/,\n\t\t\t\t\tloader: 'ts-loader'\n\t\t\t\t},\n\t\t\t\t`
+		],
+		// Add TypeScript rules for serviceworker
+		[
+			/output: config\.serviceworker\.output\(\),\n\s*(?!module)/,
+			`output: config.serviceworker.output(),\n\t\tmodule: {\n\t\t\trules: [\n\t\t\t\t{\n\t\t\t\t\ttest: /\\.ts$/,\n\t\t\t\t\tloader: 'ts-loader'\n\t\t\t\t}\n\t\t\t]\n\t\t},\n\t\t`
+		],
+		// Edit outputs
+		[
+			/output: config\.serviceworker\.output\(\),\n\s*(?!resolve)/,
+			`output: config.serviceworker.output(),\n\t\tresolve: { extensions: ['.mjs', '.js', '.ts', '.json'] },\n\t\t`
+		]
+	]);
+}
+
+function updateServiceWorker() {
+	replaceInFile(path.join(projectRoot, 'src', 'service-worker.ts'), [
+		[`shell.concat(files);`, `(shell as string[]).concat(files as string[]);`],
+		[`self.skipWaiting();`, `((self as any) as ServiceWorkerGlobalScope).skipWaiting();`],
+		[`self.clients.claim();`, `((self as any) as ServiceWorkerGlobalScope).clients.claim();`],
+		[`fetchAndCache(request)`, `fetchAndCache(request: Request)`],
+		[`self.addEventListener('activate', event =>`, `self.addEventListener('activate', (event: ExtendableEvent) =>`],
+		[`self.addEventListener('install', event =>`, `self.addEventListener('install', (event: ExtendableEvent) =>`],
+		[`addEventListener('fetch', event =>`, `addEventListener('fetch', (event: FetchEvent) =>`],
+	]);
+}
+
+function createTsConfig() {
+	const tsconfig = `{
+		"extends": "@tsconfig/svelte/tsconfig.json",
+		"compilerOptions": {
+			"lib": ["DOM", "ES2017", "WebWorker"]
+		},
+		"include": ["src/**/*", "src/node_modules/**/*"],
+		"exclude": ["node_modules/*", "__sapper__/*", "static/*"]
+	}`;
+
+	createFile(path.join(projectRoot, 'tsconfig.json'), tsconfig);
+}
+
+// Adds the extension recommendation
+function configureVsCode() {
+	const dir = path.join(projectRoot, '.vscode');
+
+	if (!fs.existsSync(dir)) {
+		fs.mkdirSync(dir);
+	}
+
+	createFile(path.join(projectRoot, '.vscode', 'extensions.json'), `{"recommendations": ["svelte.svelte-vscode"]}`);
+}
+
+function deleteThisScript() {
+	fs.unlinkSync(path.join(__filename));
+
+	// Check for Mac's DS_store file, and if it's the only one left remove it
+	const remainingFiles = fs.readdirSync(path.join(__dirname));
+	if (remainingFiles.length === 1 && remainingFiles[0] === '.DS_store') {
+		fs.unlinkSync(path.join(__dirname, '.DS_store'));
+	}
+
+	// Check if the scripts folder is empty
+	if (fs.readdirSync(path.join(__dirname)).length === 0) {
+		// Remove the scripts folder
+		fs.rmdirSync(path.join(__dirname));
+	}
+}
+
+console.log(`Adding TypeScript with ${isRollup ? "Rollup" : "webpack" }...`);
+
+addDepsToPackageJson();
+
+changeJsExtensionToTs(path.join(projectRoot, 'src'));
+
+updateSvelteFiles();
+
+if (isRollup) {
+	updateRollupConfig();
+} else {
+	updateWebpackConfig();
+}
+
+updateServiceWorker();
+
+createTsConfig();
+
+configureVsCode();
+
+// Delete this script, but not during testing
+if (!argv[2]) {
+	deleteThisScript();
+}
+
+console.log('Converted to TypeScript.');
+
+if (fs.existsSync(path.join(projectRoot, 'node_modules'))) {
+	console.log(`
+Next:
+1. run 'npm install' again to install TypeScript dependencies
+2. run 'npm run build' for the @sapper imports in your project to work
+`);
+}

clients/tauri-client/src-tauri/.gitignore

@@ -0,0 +1,4 @@
+# Generated by Cargo
+# will have compiled files and executables
+/target/
+WixTools

clients/tauri-client/src-tauri/Cargo.toml

@@ -0,0 +1,30 @@
+[package]
+name = "app"
+version = "0.1.0"
+description = "A Tauri App"
+authors = ["you"]
+license = ""
+repository = ""
+default-run = "app"
+edition = "2018"
+build = "src/build.rs"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[build-dependencies]
+tauri-build = { version = "1.0.0-beta.2" }
+
+[dependencies]
+serde_json = "1.0"
+serde = { version = "1.0", features = ["derive"] }
+tauri = { version = "1.0.0-beta.4", features = [] }
+tokio = "1.4"
+url = "2.2"
+
+coconut-interface = { path = "../../../common/coconut-interface" }
+credentials = { path = "../../../common/credentials" }
+validator-client = {path = "../../../common/client-libs/validator-client"}
+
+[features]
+default = ["custom-protocol"]
+custom-protocol = ["tauri/custom-protocol"]

clients/tauri-client/src-tauri/rustfmt.toml

@@ -0,0 +1,13 @@
+max_width = 100
+hard_tabs = false
+tab_spaces = 2
+newline_style = "Auto"
+use_small_heuristics = "Default"
+reorder_imports = true
+reorder_modules = true
+remove_nested_parens = true
+edition = "2018"
+merge_derives = true
+use_try_shorthand = false
+use_field_init_shorthand = false
+force_explicit_abi = true

clients/tauri-client/src-tauri/src/build.rs

@@ -0,0 +1,3 @@
+fn main() {
+  tauri_build::build()
+}

clients/tauri-client/src-tauri/src/main.rs

@@ -0,0 +1,211 @@
+#![cfg_attr(
+  all(not(debug_assertions), target_os = "windows"),
+  windows_subsystem = "windows"
+)]
+
+use std::sync::Arc;
+
+use tokio::sync::RwLock;
+use url::Url;
+
+use coconut_interface::{
+  self, hash_to_scalar, Attribute, Credential, Parameters, Signature, Theta, VerificationKey,
+};
+use credentials::{obtain_aggregate_signature, obtain_aggregate_verification_key};
+
+struct State {
+  signatures: Vec<Signature>,
+  n_attributes: u32,
+  params: Parameters,
+  serial_number: Attribute,
+  binding_number: Attribute,
+  voucher_value: Attribute,
+  voucher_info: Attribute,
+  aggregated_verification_key: Option<VerificationKey>,
+}
+
+impl State {
+  fn init(public_attributes_bytes: Vec<Vec<u8>>, private_attributes_bytes: Vec<Vec<u8>>) -> State {
+    let n_attributes = (public_attributes_bytes.len() + private_attributes_bytes.len()) as u32;
+    let params = Parameters::new(n_attributes).unwrap();
+    let public_attributes = public_attributes_bytes
+      .iter()
+      .map(hash_to_scalar)
+      .collect::<Vec<Attribute>>();
+    let private_attributes = private_attributes_bytes
+      .iter()
+      .map(hash_to_scalar)
+      .collect::<Vec<Attribute>>();
+    State {
+      signatures: Vec::new(),
+      n_attributes,
+      params,
+      serial_number: private_attributes[0],
+      binding_number: private_attributes[1],
+      voucher_value: public_attributes[0],
+      voucher_info: public_attributes[1],
+      aggregated_verification_key: None,
+    }
+  }
+}
+
+fn parse_url_validators(raw: &[String]) -> Result<Vec<Url>, String> {
+  let mut parsed_urls = Vec::with_capacity(raw.len());
+  for url in raw {
+    let parsed_url: Url = url
+      .parse()
+      .map_err(|err| format!("one of validator urls is malformed - {}", err))?;
+    parsed_urls.push(parsed_url)
+  }
+  Ok(parsed_urls)
+}
+
+#[tauri::command]
+async fn randomise_credential(
+  idx: usize,
+  state: tauri::State<'_, Arc<RwLock<State>>>,
+) -> Result<Vec<Signature>, String> {
+  let mut state = state.write().await;
+  let signature = state.signatures.remove(idx);
+  let (new_signature, _) = signature.randomise(&state.params);
+  state.signatures.insert(idx, new_signature);
+  Ok(state.signatures.clone())
+}
+
+#[tauri::command]
+async fn delete_credential(
+  idx: usize,
+  state: tauri::State<'_, Arc<RwLock<State>>>,
+) -> Result<Vec<Signature>, String> {
+  let mut state = state.write().await;
+  state.signatures.remove(idx);
+  Ok(state.signatures.clone())
+}
+
+#[tauri::command]
+async fn list_credentials(
+  state: tauri::State<'_, Arc<RwLock<State>>>,
+) -> Result<Vec<Signature>, String> {
+  let state = state.read().await;
+  Ok(state.signatures.clone())
+}
+
+async fn get_aggregated_verification_key(
+  validator_urls: Vec<String>,
+  state: tauri::State<'_, Arc<RwLock<State>>>,
+) -> Result<VerificationKey, String> {
+  if let Some(verification_key) = &state.read().await.aggregated_verification_key {
+    return Ok(verification_key.clone());
+  }
+
+  let parsed_urls = parse_url_validators(&validator_urls)?;
+  let key = obtain_aggregate_verification_key(&parsed_urls)
+    .await
+    .map_err(|err| format!("failed to obtain aggregate verification key - {:?}", err))?;
+
+  state
+    .write()
+    .await
+    .aggregated_verification_key
+    .replace(key.clone());
+
+  Ok(key)
+}
+
+async fn prove_credential(
+  idx: usize,
+  validator_urls: Vec<String>,
+  state: tauri::State<'_, Arc<RwLock<State>>>,
+) -> Result<Theta, String> {
+  let verification_key = get_aggregated_verification_key(validator_urls, state.clone()).await?;
+  let state = state.read().await;
+
+  if let Some(signature) = state.signatures.get(idx) {
+    match coconut_interface::prove_bandwidth_credential(
+      &state.params,
+      &verification_key,
+      signature,
+      state.serial_number,
+      state.binding_number,
+    ) {
+      Ok(theta) => Ok(theta),
+      Err(e) => Err(format!("{:?}", e)),
+    }
+  } else {
+    Err("Got invalid Signature idx".to_string())
+  }
+}
+
+#[tauri::command]
+async fn verify_credential(
+  idx: usize,
+  validator_urls: Vec<String>,
+  state: tauri::State<'_, Arc<RwLock<State>>>,
+) -> Result<bool, String> {
+  // the API needs to be improved but at least it should compile (in theory)
+  let verification_key =
+    get_aggregated_verification_key(validator_urls.clone(), state.clone()).await?;
+  let theta = prove_credential(idx, validator_urls, state.clone()).await?;
+
+  let state = state.read().await;
+
+  let public_attributes_bytes = vec![
+    state.voucher_value.to_bytes().to_vec(),
+    state.voucher_info.to_bytes().to_vec(),
+  ];
+
+  let credential = Credential::new(
+    state.n_attributes,
+    theta,
+    public_attributes_bytes,
+    state
+      .signatures
+      .get(idx)
+      .ok_or("Got invalid signature idx")?,
+  );
+
+  Ok(credential.verify(&verification_key))
+}
+
+#[tauri::command]
+async fn get_credential(
+  validator_urls: Vec<String>,
+  state: tauri::State<'_, Arc<RwLock<State>>>,
+) -> Result<Vec<Signature>, String> {
+  let guard = state.read().await;
+  let parsed_urls = parse_url_validators(&validator_urls)?;
+  let public_attributes = vec![guard.voucher_value, guard.voucher_info];
+  let private_attributes = vec![guard.serial_number, guard.binding_number];
+
+  let signature = obtain_aggregate_signature(
+    &guard.params,
+    &public_attributes,
+    &private_attributes,
+    &parsed_urls,
+  )
+  .await
+  .map_err(|err| format!("failed to obtain aggregate signature - {:?}", err))?;
+
+  let mut state = state.write().await;
+  state.signatures.push(signature);
+  Ok(state.signatures.clone())
+}
+
+fn main() {
+  let public_attributes = vec![b"public_key".to_vec()];
+  let private_attributes = vec![b"private_key".to_vec()];
+  tauri::Builder::default()
+    .manage(Arc::new(RwLock::new(State::init(
+      public_attributes,
+      private_attributes,
+    ))))
+    .invoke_handler(tauri::generate_handler![
+      get_credential,
+      randomise_credential,
+      delete_credential,
+      list_credentials,
+      verify_credential
+    ])
+    .run(tauri::generate_context!())
+    .expect("error while running tauri application");
+}

clients/tauri-client/src-tauri/tauri.conf.json

@@ -0,0 +1,65 @@
+{
+  "package": {
+    "productName": "nym-tauri-client",
+    "version": "0.1.0"
+  },
+  "build": {
+    "distDir": "../__sapper__/export",
+    "devPath": "http://localhost:3000",
+    "beforeDevCommand": "",
+    "beforeBuildCommand": "yarn run export"
+  },
+  "tauri": {
+    "bundle": {
+      "active": true,
+      "targets": "all",
+      "identifier": "com.tauri.dev",
+      "icon": [
+        "icons/32x32.png",
+        "icons/128x128.png",
+        "icons/128x128@2x.png",
+        "icons/icon.icns",
+        "icons/icon.ico"
+      ],
+      "resources": [],
+      "externalBin": [],
+      "copyright": "",
+      "category": "DeveloperTool",
+      "shortDescription": "",
+      "longDescription": "",
+      "deb": {
+        "depends": [],
+        "useBootstrapper": false
+      },
+      "macOS": {
+        "frameworks": [],
+        "minimumSystemVersion": "",
+        "useBootstrapper": false,
+        "exceptionDomain": "",
+        "signingIdentity": null,
+        "entitlements": null
+      },
+      "windows": {
+        "certificateThumbprint": null,
+        "digestAlgorithm": "sha256",
+        "timestampUrl": ""
+      }
+    },
+    "updater": {
+      "active": false
+    },
+    "allowlist": {},
+    "windows": [
+      {
+        "title": "Nym Client",
+        "width": 800,
+        "height": 1000,
+        "resizable": true,
+        "fullscreen": false
+      }
+    ],
+    "security": {
+      "csp": "default-src blob: data: filesystem: ws: wss: http: https: tauri: 'unsafe-eval' 'unsafe-inline' 'self' img-src: 'self'"
+    }
+  }
+}

clients/tauri-client/src/ambient.d.ts

@@ -0,0 +1,39 @@
+/**
+ * These declarations tell TypeScript that we allow import of images, e.g.
+ * ```
+		<script lang='ts'>
+			import successkid from 'images/successkid.jpg';
+		</script>
+
+		<img src="{successkid}">
+	 ```
+ */
+declare module "*.gif" {
+	const value: string;
+	export default value;
+}
+
+declare module "*.jpg" {
+	const value: string;
+	export default value;
+}
+
+declare module "*.jpeg" {
+	const value: string;
+	export default value;
+}
+
+declare module "*.png" {
+	const value: string;
+	export default value;
+}
+
+declare module "*.svg" {
+	const value: string;
+	export default value;
+}
+
+declare module "*.webp" {
+	const value: string;
+	export default value;
+}

clients/tauri-client/src/client.js

@@ -0,0 +1,5 @@
+import * as sapper from '@sapper/app';
+
+sapper.start({
+	target: document.querySelector('#sapper')
+});

clients/tauri-client/src/components/Nav.svelte

@@ -0,0 +1,3 @@
+<nav>
+	<img src="coconut-120.png" style="width: 120px" alt=""/>
+</nav>