Network Explorer: change prod env to round robin DNS

- fix up API urls after Network Explorer API changes
- set currency denominations in `.env` file
- set API endpoints in `.env` file

.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,70 +1,102 @@
 name: Continuous integration
 
-on: [push, pull_request]
+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/build_matrix_includes.json'
+          filter: '[?runOnEvent==`${{ github.event_name }}` || runOnEvent==`always`]'
   build:
-    runs-on: ${{ matrix.os }}
-    continue-on-error: ${{ matrix.rust == 'nightly' || matrix.rust == 'beta' }}
+    needs: matrix_prep
     strategy:
-      matrix:
-        rust: [stable, beta, nightly]
-        os: [ubuntu-latest, macos-latest, windows-latest]
-
+      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/checkout@v2
+      - name: Check out repository code
+        uses: actions/checkout@v2
 
-      - uses: actions-rs/toolchain@v1
+      - name: Install rust toolchain
+        uses: actions-rs/toolchain@v1
         with:
           profile: minimal
           toolchain: ${{ matrix.rust }}
           override: true
           components: rustfmt, clippy
 
-      # Exclude validator API on Windows
-      - uses: actions-rs/cargo@v1
-        if: ${{ matrix.os == 'windows-latest' }}
-        with:
-          command: build
-          args: --all --exclude nym-validator-api
-
-      - uses: actions-rs/cargo@v1
-        if: ${{ matrix.os != 'windows-latest' }}
+      - name: Build all binaries
+        uses: actions-rs/cargo@v1
         with:
           command: build
           args: --all
 
-      # Exclude validator API on Windows
-      - uses: actions-rs/cargo@v1
-        if: ${{ matrix.os == 'windows-latest' }}
-        with:
-          command: test
-          args: --all --exclude nym-validator-api
-
-      - uses: actions-rs/cargo@v1
-        if: ${{ matrix.os != 'windows-latest' }}
+      - name: Run all tests
+        uses: actions-rs/cargo@v1
         with:
           command: test
           args: --all
 
-      - uses: actions-rs/cargo@v1
+      - name: Check formatting
+        uses: actions-rs/cargo@v1
         with:
           command: fmt
           args: --all -- --check
 
-      # Exclude validator API on Windows
-      - uses: actions-rs/cargo@v1
-        if: ${{ matrix.rust != 'nightly' && matrix.os == 'windows-latest' }}
+      - uses: actions-rs/clippy-check@v1
+        name: Clippy checks
+#        if: matrix.os == 'ubuntu-latest' && matrix.rust == 'stable'
         with:
-          command: clippy
-          args: --all --exclude nym-validator-api -- -D warnings
+          token: ${{ secrets.GITHUB_TOKEN }}
+          args: --all-features
 
-      - uses: actions-rs/cargo@v1
-        if: ${{ matrix.rust != 'nightly' && matrix.os != 'windows-latest' }}
+      - name: Run clippy
+        uses: actions-rs/cargo@v1
+        if: ${{ matrix.rust != 'nightly' }}
         with:
           command: clippy
           args: -- -D warnings
+
+#        COCONUT stuff
+      - name: Reclaim some disk space (because Windows is being annoying)
+        uses: actions-rs/cargo@v1
+        if: ${{ matrix.os == 'windows-latest' }}
+        with:
+          command: clean
+
+      - 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: --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:
-  mixnet-contract:
-    # 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

@@ -1,10 +1,17 @@
 name: Generate TS types
 
-on: push
+on:
+  push:
+    paths-ignore:
+      - "explorer/**"
+  pull_request:
+    paths-ignore:
+      - "explorer/**"
 
 jobs:
-  tauri-wallet-types:
+  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
@@ -13,10 +20,10 @@ jobs:
         with:
           toolchain: stable
       - name: Generate TS
-        run: cd tauri-wallet/src-tauri && cargo test
+        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: '["tauri-wallet"]'
-          message: '[ci skip] Generate TS types'
+          add: '["nym-wallet"]'
+          message: "[ci skip] Generate TS types"
         env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          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,6 +1,9 @@
 name: Wasm Client
 
-on: [push, pull_request]
+on:
+  pull_request:
+    paths-ignore:
+      - 'explorer/**'
 
 jobs:
   wasm:
@@ -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

.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,8 +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

Cargo.toml

@@ -4,6 +4,7 @@
 [profile.release]
 panic = "abort"
 opt-level = "s"
+overflow-checks = true
 
 [profile.dev]
 panic = "abort"
@@ -24,10 +25,12 @@ members = [
     "common/config",
     "common/credentials",
     "common/crypto",
+    "common/erc20-bridge-contract",
     "common/mixnet-contract",
     "common/mixnode-common",
     "common/network-defaults",
     "common/nonexhaustive-delayqueue",
+    "common/nymcoconut",
     "common/nymsphinx",
     "common/nymsphinx/acknowledgements",
     "common/nymsphinx/addressing",
@@ -59,6 +62,7 @@ default-members = [
     "service-providers/network-requester",
     "mixnode",
     "validator-api",
+    "explorer-api",
 ]
 
-exclude = ["explorer", "contracts"]
+exclude = ["explorer", "contracts", "tokenomics-py"]

Makefile

@@ -0,0 +1,31 @@
+all: clippy test fmt
+clippy: clippy-main clippy-contracts clippy-wallet
+test: test-main test-contracts test-wallet
+fmt: fmt-main fmt-contracts fmt-wallet
+
+clippy-main:
+	cargo clippy
+
+clippy-contracts:
+	cargo clippy --manifest-path contracts/Cargo.toml
+
+clippy-wallet: 
+	cargo clippy --manifest-path nym-wallet/Cargo.toml
+
+test-main:
+	cargo test
+
+test-contracts:
+	cargo test --manifest-path contracts/Cargo.toml
+
+test-wallet:
+	cargo test --manifest-path nym-wallet/Cargo.toml
+
+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

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,7 +13,7 @@ The platform is composed of multiple Rust crates. Top-level executable binary cr
 * nym-gateway - acts sort of like a mailbox for mixnet messages, removing the need for directly delivery to potentially offline or firewalled devices.
 * nym-network-monitor - sends packets through the full system to check that they are working as expected, and stores node uptime histories as the basis of a rewards system ("mixmining" or "proof-of-mixing").
 * nym-explorer - a (projected) block explorer and (existing) mixnet viewer.
-* nym-wallet (currently in development)- a desktop wallet implemented using the [Tauri](https://tauri.studio/en/docs/about/intro) framework. 
+* nym-wallet - a desktop wallet implemented using the [Tauri](https://tauri.studio/en/docs/about/intro) framework. 
 
 [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg?style=for-the-badge)](https://opensource.org/licenses/Apache-2.0)
 [![Build Status](https://img.shields.io/github/workflow/status/nymtech/nym/Continuous%20integration/develop?style=for-the-badge&logo=github-actions)](https://github.com/nymtech/nym/actions?query=branch%3Adevelop)
@@ -23,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
 
@@ -33,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 plaged to their node to the token circulating supply.
+|<img src="https://render.githubusercontent.com/render/math?math=\omega_{i}">|fraction of total effort undertaken by node `i`, set to `1/k` in testnet Milhon.
+|<img src="https://render.githubusercontent.com/render/math?math=k">|number of nodes stakeholders are incentivised to create, set by the validators, a matter of governance. Currently determined by the `active set` size, and set to 5000 in testnet Milhon.
+|<img src="https://render.githubusercontent.com/render/math?math=\alpha">|Sybil attack resistance parameter - the higher this parameter is set the stronger the reduction in competitivness gets for a Sybil attacker.
+|<img src="https://render.githubusercontent.com/render/math?math=PM_{i}">|declared profit margin of operator `i`, defaults to 10% in testnet Milhon.
+|<img src="https://render.githubusercontent.com/render/math?math=PF_{i}">|uptime of node `i`, scaled to 0 - 1, for the rewarding epoch
+|<img src="https://render.githubusercontent.com/render/math?math=PP_{i}">|cost of operating node `i` for the duration of the rewarding eopoch, set to 40 Nym for testnet Milhon.
+
+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

@@ -30,3 +30,6 @@ validator-client = { path = "../../common/client-libs/validator-client" }
 
 [dev-dependencies]
 tempfile = "3.1.0"
+
+[features]
+coconut = []

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

@@ -40,7 +40,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 +49,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;

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

@@ -107,7 +107,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);
     }
 
@@ -130,19 +130,26 @@ impl Default for TopologyAccessor {
 pub struct TopologyRefresherConfig {
     validator_api_urls: Vec<Url>,
     refresh_rate: time::Duration,
+    client_version: String,
 }
 
 impl TopologyRefresherConfig {
-    pub fn new(validator_api_urls: Vec<Url>, refresh_rate: time::Duration) -> Self {
+    pub fn new(
+        validator_api_urls: Vec<Url>,
+        refresh_rate: time::Duration,
+        client_version: String,
+    ) -> Self {
         TopologyRefresherConfig {
             validator_api_urls,
             refresh_rate,
+            client_version,
         }
     }
 }
 
 pub struct TopologyRefresher {
     validator_client: validator_client::ApiClient,
+    client_version: String,
 
     validator_api_urls: Vec<Url>,
     topology_accessor: TopologyAccessor,
@@ -158,6 +165,7 @@ impl TopologyRefresher {
 
         TopologyRefresher {
             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,
@@ -177,12 +185,71 @@ impl TopologyRefresher {
             .change_validator_api(self.validator_api_urls[self.currently_used_api].clone())
     }
 
-    async fn get_current_compatible_topology(&mut self) -> Option<NymTopology> {
+    /// 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_mixnodes().await {
+        let mixnodes = match self.validator_client.get_cached_active_mixnodes().await {
             Err(err) => {
                 error!("failed to get network mixnodes - {}", err);
                 return None;
@@ -198,11 +265,16 @@ 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) {

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

@@ -22,7 +22,10 @@ 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);
+// 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()
@@ -100,6 +103,17 @@ 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;
     }
 
@@ -111,6 +125,16 @@ impl<T: NymConfig> Config<T> {
         self.client.gateway_listener = gateway_listener.into();
     }
 
+    #[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();
+    }
+
+    #[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;
     }
@@ -173,6 +197,21 @@ 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 {
         self.debug.average_packet_delay
@@ -268,6 +307,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,
@@ -292,6 +345,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(),
         }
@@ -326,18 +385,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 {

clients/native/Cargo.toml

@@ -3,6 +3,7 @@ name = "nym-client"
 version = "0.11.0"
 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
 
@@ -23,7 +24,7 @@ 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,8 +32,8 @@ tokio-tungstenite = "0.14" # websocket
 
 ## internal
 client-core = { path = "../client-core" }
-coconut-interface = { path = "../../common/coconut-interface" }
-credentials = { path = "../../common/credentials" }
+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" }
@@ -43,6 +44,13 @@ 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"]
 
 [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/template.rs

@@ -42,6 +42,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,
@@ -22,11 +20,9 @@ use client_core::client::topology_control::{
     TopologyAccessor, TopologyRefresher, TopologyRefresherConfig,
 };
 use client_core::config::persistence::key_pathfinder::ClientKeyPathfinder;
-use coconut_interface::Credential;
-use credentials::bandwidth::prepare_for_spending;
-use credentials::obtain_aggregate_verification_key;
 use crypto::asymmetric::identity;
 use futures::channel::mpsc;
+use gateway_client::bandwidth::BandwidthController;
 use gateway_client::{
     AcknowledgementReceiver, AcknowledgementSender, GatewayClient, MixnetMessageReceiver,
     MixnetMessageSender,
@@ -38,6 +34,9 @@ use nymsphinx::anonymous_replies::ReplySurb;
 use nymsphinx::receiver::ReconstructedMessage;
 use tokio::runtime::Runtime;
 
+use crate::client::config::{Config, SocketType};
+use crate::websocket;
+
 pub(crate) mod config;
 
 pub struct NymClient {
@@ -166,30 +165,6 @@ impl NymClient {
         .start(self.runtime.handle())
     }
 
-    async fn prepare_credential(&self) -> Credential {
-        let verification_key = obtain_aggregate_verification_key(
-            &self.config.get_base().get_validator_api_endpoints(),
-        )
-        .await
-        .expect("could not obtain aggregate verification key of validators");
-
-        let bandwidth_credential = credentials::bandwidth::obtain_signature(
-            &self.key_manager.identity_keypair().public_key().to_bytes(),
-            &self.config.get_base().get_validator_api_endpoints(),
-        )
-        .await
-        .expect("could not obtain bandwidth credential");
-        // the above would presumably be loaded from a file
-
-        // the below would only be executed once we know where we want to spend it (i.e. which gateway and stuff)
-        prepare_for_spending(
-            &self.key_manager.identity_keypair().public_key().to_bytes(),
-            &bandwidth_credential,
-            &verification_key,
-        )
-        .expect("could not prepare out bandwidth credential for spending")
-    }
-
     fn start_gateway_client(
         &mut self,
         mixnet_message_sender: MixnetMessageSender,
@@ -208,7 +183,18 @@ impl NymClient {
             .expect("provided gateway id is invalid!");
 
         self.runtime.block_on(async {
-            let coconut_credential = self.prepare_credential().await;
+            #[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,
@@ -218,7 +204,7 @@ impl NymClient {
                 mixnet_message_sender,
                 ack_sender,
                 self.config.get_base().get_gateway_response_timeout(),
-                coconut_credential,
+                Some(bandwidth_controller),
             );
 
             gateway_client
@@ -236,6 +222,7 @@ impl NymClient {
         let topology_refresher_config = TopologyRefresherConfig::new(
             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);

clients/native/src/commands/init.rs

@@ -1,18 +1,23 @@
 // 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;
-use coconut_interface::Credential;
+#[cfg(feature = "coconut")]
+use coconut_interface::{hash_to_scalar, Credential, Parameters};
 use config::NymConfig;
-use credentials::bandwidth::prepare_for_spending;
+#[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;
@@ -24,8 +29,11 @@ use std::time::Duration;
 use topology::{filter::VersionFilterable, gateway};
 use url::Url;
 
+use crate::client::config::Config;
+use crate::commands::override_config;
+
 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,9 +47,9 @@ 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),
+                 .long("validators")
+                 .help("Comma separated list of rest endpoints of the validators")
+                 .takes_value(true),
         )
         .arg(Arg::with_name("disable-socket")
             .long("disable-socket")
@@ -57,37 +65,62 @@ pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
             .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(not(feature = "coconut"))]
+        let app = app
+        .arg(Arg::with_name("eth_endpoint")
+            .long("eth_endpoint")
+            .help("URL of an Ethereum full node that we want to use for getting bandwidth tokens from ERC20 tokens")
+            .takes_value(true)
+            .required(true))
+        .arg(Arg::with_name("eth_private_key")
+            .long("eth_private_key")
+            .help("Ethereum private key used for obtaining bandwidth tokens from ERC20 tokens")
+            .takes_value(true)
+            .required(true));
+
+    app
 }
 
 // this behaviour should definitely be changed, we shouldn't
 // need to get bandwidth credential for registration
-async fn prepare_temporary_credential(validators: &[Url], raw_identity: &[u8]) -> Credential {
+#[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 bandwidth_credential = credentials::bandwidth::obtain_signature(raw_identity, validators)
-        .await
-        .expect("could not obtain bandwidth credential");
+    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()),
+    };
 
-    prepare_for_spending(raw_identity, &bandwidth_credential, &verification_key)
-        .expect("could not prepare out bandwidth credential for spending")
+    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>,
-    validator_urls: Vec<Url>,
 ) -> Arc<SharedKeys> {
     let timeout = Duration::from_millis(1500);
-    let coconut_credential =
-        prepare_temporary_credential(&validator_urls, &our_identity.public_key().to_bytes()).await;
     let mut gateway_client = GatewayClient::new_init(
         gateway.clients_address(),
         gateway.identity_key,
         our_identity.clone(),
-        coconut_credential,
         timeout,
     );
     gateway_client
@@ -210,13 +243,8 @@ pub fn execute(matches: &ArgMatches) {
             config
                 .get_base_mut()
                 .with_gateway_id(gate_details.identity_key.to_base58_string());
-            let validator_urls = config.get_base().get_validator_api_endpoints();
-            let shared_keys = register_with_gateway(
-                &gate_details,
-                key_manager.identity_keypair(),
-                validator_urls,
-            )
-            .await;
+            let shared_keys =
+                register_with_gateway(&gate_details, key_manager.identity_keypair()).await;
             (shared_keys, gate_details.clients_address())
         };
 

clients/native/src/commands/mod.rs

@@ -43,5 +43,14 @@ 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") {
+        config.get_base_mut().with_eth_endpoint(eth_endpoint);
+    }
+    #[cfg(not(feature = "coconut"))]
+    if let Some(eth_private_key) = matches.value_of("eth_private_key") {
+        config.get_base_mut().with_eth_private_key(eth_private_key);
+    }
+
     config
 }

clients/native/src/commands/run.rs

@@ -10,7 +10,7 @@ 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")
@@ -38,7 +38,19 @@ pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
             .long("port")
             .help("Port for the socket (if applicable) to listen on")
             .takes_value(true)
-        )
+        );
+    #[cfg(not(feature = "coconut"))]
+        let app = app
+        .arg(Arg::with_name("eth_endpoint")
+            .long("eth_endpoint")
+            .help("URL of an Ethereum full node that we want to use for getting bandwidth tokens from ERC20 tokens")
+            .takes_value(true))
+        .arg(Arg::with_name("eth_private_key")
+            .long("eth_private_key")
+            .help("Ethereum private key used for obtaining bandwidth tokens from ERC20 tokens")
+            .takes_value(true));
+
+    app
 }
 
 // this only checks compatibility between config the binary. It does not take into consideration

clients/native/src/main.rs

@@ -1,7 +1,7 @@
 // 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;
@@ -13,7 +13,8 @@ fn main() {
     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())
@@ -50,7 +51,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/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

@@ -3,6 +3,7 @@ name = "nym-socks5-client"
 version = "0.11.0"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
 edition = "2018"
+rust-version = "1.56"
 
 [lib]
 name = "nym_socks5"
@@ -24,17 +25,24 @@ url = "2.2"
 
 # internal
 client-core = { path = "../client-core" }
-coconut-interface = { path = "../../common/coconut-interface" }
-credentials = { path = "../../common/credentials" }
+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"]
+
+[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/template.rs

@@ -42,6 +42,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,
@@ -23,11 +18,9 @@ use client_core::client::topology_control::{
     TopologyAccessor, TopologyRefresher, TopologyRefresherConfig,
 };
 use client_core::config::persistence::key_pathfinder::ClientKeyPathfinder;
-use coconut_interface::Credential;
-use credentials::bandwidth::prepare_for_spending;
-use credentials::obtain_aggregate_verification_key;
 use crypto::asymmetric::identity;
 use futures::channel::mpsc;
+use gateway_client::bandwidth::BandwidthController;
 use gateway_client::{
     AcknowledgementReceiver, AcknowledgementSender, GatewayClient, MixnetMessageReceiver,
     MixnetMessageSender,
@@ -37,6 +30,12 @@ use nymsphinx::addressing::clients::Recipient;
 use nymsphinx::addressing::nodes::NodeIdentity;
 use tokio::runtime::Runtime;
 
+use crate::client::config::Config;
+use crate::socks::{
+    authentication::{AuthenticationMethods, Authenticator, User},
+    server::SphinxSocksServer,
+};
+
 pub(crate) mod config;
 
 pub struct NymClient {
@@ -154,30 +153,6 @@ impl NymClient {
         .start(self.runtime.handle())
     }
 
-    async fn prepare_credential(&self) -> Credential {
-        let verification_key = obtain_aggregate_verification_key(
-            &self.config.get_base().get_validator_api_endpoints(),
-        )
-        .await
-        .expect("could not obtain aggregate verification key of validators");
-
-        let bandwidth_credential = credentials::bandwidth::obtain_signature(
-            &self.key_manager.identity_keypair().public_key().to_bytes(),
-            &self.config.get_base().get_validator_api_endpoints(),
-        )
-        .await
-        .expect("could not obtain bandwidth credential");
-        // the above would presumably be loaded from a file
-
-        // the below would only be executed once we know where we want to spend it (i.e. which gateway and stuff)
-        prepare_for_spending(
-            &self.key_manager.identity_keypair().public_key().to_bytes(),
-            &bandwidth_credential,
-            &verification_key,
-        )
-        .expect("could not prepare out bandwidth credential for spending")
-    }
-
     fn start_gateway_client(
         &mut self,
         mixnet_message_sender: MixnetMessageSender,
@@ -196,7 +171,18 @@ impl NymClient {
             .expect("provided gateway id is invalid!");
 
         self.runtime.block_on(async {
-            let coconut_credential = self.prepare_credential().await;
+            #[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,
@@ -206,7 +192,7 @@ impl NymClient {
                 mixnet_message_sender,
                 ack_sender,
                 self.config.get_base().get_gateway_response_timeout(),
-                coconut_credential,
+                Some(bandwidth_controller),
             );
 
             gateway_client
@@ -224,6 +210,7 @@ impl NymClient {
         let topology_refresher_config = TopologyRefresherConfig::new(
             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);

clients/socks5/src/commands/init.rs

@@ -1,18 +1,23 @@
 // 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;
-use coconut_interface::Credential;
+#[cfg(feature = "coconut")]
+use coconut_interface::{hash_to_scalar, Credential, Parameters};
 use config::NymConfig;
-use credentials::bandwidth::prepare_for_spending;
+#[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, thread_rng};
@@ -22,8 +27,11 @@ use std::time::Duration;
 use topology::{filter::VersionFilterable, gateway};
 use url::Url;
 
+use crate::client::config::Config;
+use crate::commands::override_config;
+
 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")
@@ -43,9 +51,9 @@ 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),
+                 .long("validators")
+                 .help("Comma separated list of rest endpoints of the validators")
+                 .takes_value(true),
         )
         .arg(Arg::with_name("port")
             .short("p")
@@ -57,37 +65,62 @@ pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
             .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(not(feature = "coconut"))]
+        let app = app
+        .arg(Arg::with_name("eth_endpoint")
+            .long("eth_endpoint")
+            .help("URL of an Ethereum full node that we want to use for getting bandwidth tokens from ERC20 tokens")
+            .takes_value(true)
+            .required(true))
+        .arg(Arg::with_name("eth_private_key")
+            .long("eth_private_key")
+            .help("Ethereum private key used for obtaining bandwidth tokens from ERC20 tokens")
+            .takes_value(true)
+            .required(true));
+
+    app
 }
 
 // this behaviour should definitely be changed, we shouldn't
 // need to get bandwidth credential for registration
-async fn prepare_temporary_credential(validators: &[Url], raw_identity: &[u8]) -> Credential {
+#[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 bandwidth_credential = credentials::bandwidth::obtain_signature(raw_identity, validators)
-        .await
-        .expect("could not obtain bandwidth credential");
+    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"),
+    };
 
-    prepare_for_spending(raw_identity, &bandwidth_credential, &verification_key)
-        .expect("could not prepare out bandwidth credential for spending")
+    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>,
-    validator_urls: Vec<Url>,
 ) -> Arc<SharedKeys> {
     let timeout = Duration::from_millis(1500);
-    let coconut_credential =
-        prepare_temporary_credential(&validator_urls, &our_identity.public_key().to_bytes()).await;
     let mut gateway_client = GatewayClient::new_init(
         gateway.clients_address(),
         gateway.identity_key,
         our_identity.clone(),
-        coconut_credential,
         timeout,
     );
     gateway_client
@@ -211,13 +244,8 @@ pub fn execute(matches: &ArgMatches) {
             config
                 .get_base_mut()
                 .with_gateway_id(gate_details.identity_key.to_base58_string());
-            let validator_urls = config.get_base().get_validator_api_endpoints();
-            let shared_keys = register_with_gateway(
-                &gate_details,
-                key_manager.identity_keypair(),
-                validator_urls,
-            )
-            .await;
+            let shared_keys =
+                register_with_gateway(&gate_details, key_manager.identity_keypair()).await;
             (shared_keys, gate_details.clients_address())
         };
 

clients/socks5/src/commands/mod.rs

@@ -39,5 +39,14 @@ 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") {
+        config.get_base_mut().with_eth_endpoint(eth_endpoint);
+    }
+    #[cfg(not(feature = "coconut"))]
+    if let Some(eth_private_key) = matches.value_of("eth_private_key") {
+        config.get_base_mut().with_eth_private_key(eth_private_key);
+    }
+
     config
 }

clients/socks5/src/commands/run.rs

@@ -10,7 +10,7 @@ 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")
@@ -44,7 +44,19 @@ pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
             .long("port")
             .help("Port for the socket to listen on")
             .takes_value(true)
-        )
+        );
+    #[cfg(not(feature = "coconut"))]
+    let app = app
+        .arg(Arg::with_name("eth_endpoint")
+            .long("eth_endpoint")
+            .help("URL of an Ethereum full node that we want to use for getting bandwidth tokens from ERC20 tokens")
+            .takes_value(true))
+        .arg(Arg::with_name("eth_private_key")
+            .long("eth_private_key")
+            .help("Ethereum private key used for obtaining bandwidth tokens from ERC20 tokens")
+            .takes_value(true));
+
+    app
 }
 
 // this only checks compatibility between config the binary. It does not take into consideration

clients/socks5/src/main.rs

@@ -1,7 +1,7 @@
 // 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;
@@ -15,6 +15,7 @@ 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())
@@ -50,7 +51,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/src-tauri/src/main.rs

@@ -3,21 +3,24 @@
   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};
-use std::sync::Arc;
-use tokio::sync::RwLock;
-use url::Url;
 
 struct State {
   signatures: Vec<Signature>,
   n_attributes: u32,
   params: Parameters,
-  public_attributes_bytes: Vec<Vec<u8>>,
-  public_attributes: Vec<Attribute>,
-  private_attributes: Vec<Attribute>,
+  serial_number: Attribute,
+  binding_number: Attribute,
+  voucher_value: Attribute,
+  voucher_info: Attribute,
   aggregated_verification_key: Option<VerificationKey>,
 }
 
@@ -37,9 +40,10 @@ impl State {
       signatures: Vec::new(),
       n_attributes,
       params,
-      public_attributes_bytes,
-      public_attributes,
-      private_attributes,
+      serial_number: private_attributes[0],
+      binding_number: private_attributes[1],
+      voucher_value: public_attributes[0],
+      voucher_info: public_attributes[1],
       aggregated_verification_key: None,
     }
   }
@@ -63,8 +67,8 @@ async fn randomise_credential(
 ) -> Result<Vec<Signature>, String> {
   let mut state = state.write().await;
   let signature = state.signatures.remove(idx);
-  let new = signature.randomise(&state.params);
-  state.signatures.insert(idx, new);
+  let (new_signature, _) = signature.randomise(&state.params);
+  state.signatures.insert(idx, new_signature);
   Ok(state.signatures.clone())
 }
 
@@ -117,14 +121,15 @@ async fn prove_credential(
   let state = state.read().await;
 
   if let Some(signature) = state.signatures.get(idx) {
-    match coconut_interface::prove_credential(
+    match coconut_interface::prove_bandwidth_credential(
       &state.params,
       &verification_key,
       signature,
-      &state.private_attributes,
+      state.serial_number,
+      state.binding_number,
     ) {
       Ok(theta) => Ok(theta),
-      Err(e) => Err(format!("{}", e)),
+      Err(e) => Err(format!("{:?}", e)),
     }
   } else {
     Err("Got invalid Signature idx".to_string())
@@ -144,10 +149,15 @@ async fn verify_credential(
 
   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,
-    state.public_attributes_bytes.clone(),
+    public_attributes_bytes,
     state
       .signatures
       .get(idx)
@@ -164,11 +174,13 @@ async fn get_credential(
 ) -> 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,
-    &guard.public_attributes,
-    &guard.private_attributes,
+    &public_attributes,
+    &private_attributes,
     &parsed_urls,
   )
   .await

clients/validator/.eslintrc.json

@@ -1,41 +1,83 @@
 {
     "root": true,
-    "parser": "@typescript-eslint/parser",
-    "plugins": [
-        "@typescript-eslint"
-    ],
     "env": {
+        "browser": true,
         "es6": true,
-        "node": true,
-        "mocha": true
+        "node": true
     },
-    "extends": [
-        "eslint:recommended",
-        "plugin:@typescript-eslint/eslint-recommended",
-        "plugin:@typescript-eslint/recommended"
-    ],
     "parserOptions": {
-        "ecmaVersion": 2018,
+        "ecmaVersion": 2019,
         "sourceType": "module"
     },
+    "globals": {
+        "Atomics": "readonly",
+        "SharedArrayBuffer": "readonly"
+    },
+    "plugins": ["prettier", "mocha"],
+    "extends": [
+        "airbnb-base",
+        "airbnb-typescript/base",
+        "prettier"],
     "rules": {
-        "no-console": "off",
-        "linebreak-style": "off",
-        "quotes": [
-            "error",
-            "double",
-            {
-                "allowTemplateLiterals": true
-            }
-        ],
-        "keyword-spacing": [
+        "prettier/prettier": "error",
+        "import/prefer-default-export": "off",
+        "import/no-extraneous-dependencies": [
             "error",
             {
-                "before": true
+                "devDependencies": [
+                    "**/*.test.[jt]s",
+                    "**/*.spec.[jt]s"
+                ]
             }
         ],
-        "space-before-blocks": [
-            "error"
+        "import/extensions": [
+            "error",
+            "ignorePackages",
+            {
+                "ts": "never",
+                "js": "never"
+            }
         ]
-    }
-}
+    },
+    "overrides": [
+        {
+            "files": "**/*.ts",
+            "parser": "@typescript-eslint/parser",
+            "parserOptions": {
+                "project": "./tsconfig.json"
+            },
+            "plugins": ["@typescript-eslint/eslint-plugin"],
+            "extends": [
+                "plugin:@typescript-eslint/eslint-recommended",
+                "plugin:@typescript-eslint/recommended",
+                "prettier"
+            ],
+            "rules": {
+                "@typescript-eslint/explicit-function-return-type": "off",
+                "@typescript-eslint/no-explicit-any": "off",
+                "@typescript-eslint/no-var-requires": "off",
+                "no-use-before-define": [0],
+                "@typescript-eslint/no-use-before-define": [1],
+                "import/no-unresolved": 0,
+                "import/no-extraneous-dependencies": [
+                    "error",
+                    {
+                        "devDependencies": [
+                            "**/*.test.ts",
+                            "**/*.spec.ts"
+                        ]
+                    }
+                ],
+                "quotes": "off",
+                "@typescript-eslint/quotes": [
+                    2,
+                    "single",
+                    {
+                        "avoidEscape": true
+                    }
+                ],
+                "@typescript-eslint/no-unused-vars": [2, { "argsIgnorePattern": "^_" }]
+            }
+        }
+    ]
+}

clients/validator/.prettierrc

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

clients/validator/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nymproject/nym-validator-client",
-  "version": "0.17.0",
+  "version": "0.19.0",
   "description": "A TypeScript client for interacting with smart contracts in Nym validators",
   "repository": "https://github.com/nymtech/nym",
   "main": "./dist/index.js",
@@ -9,7 +9,8 @@
     "build": "tsc",
     "test": "ts-mocha tests/**/*.test.ts",
     "coverage": "nyc npm test",
-    "lint": "eslint \"**/*.ts\"",
+    "lint": "eslint src",
+    "lint:fix": "eslint src --fix",
     "docs": "typedoc --out docs src/index.ts"
   },
   "keywords": [],
@@ -23,22 +24,33 @@
     "@types/chai": "^4.2.15",
     "@types/expect": "^24.3.0",
     "@types/mocha": "^8.2.1",
-    "@typescript-eslint/eslint-plugin": "^4.14.0",
-    "@typescript-eslint/parser": "^4.14.0",
+    "@typescript-eslint/eslint-plugin": "^5.7.0",
+    "@typescript-eslint/parser": "^5.7.0",
     "chai": "^4.2.0",
     "eslint": "^7.18.0",
+    "eslint-config-airbnb": "^19.0.2",
+    "eslint-config-airbnb-typescript": "^16.1.0",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-import-resolver-root-import": "^1.0.4",
+    "eslint-plugin-import": "^2.25.3",
+    "eslint-plugin-mocha": "^10.0.3",
+    "eslint-plugin-prettier": "^4.0.0",
     "mocha": "^8.2.1",
     "moq.ts": "^7.2.0",
     "nyc": "^15.1.0",
+    "prettier": "^2.5.1",
     "ts-mocha": "^8.0.0",
     "typedoc": "^0.20.27",
     "typescript": "^4.1.3"
   },
   "dependencies": {
+    "@cosmjs/cosmwasm-stargate": "^0.27.0-rc2",
+    "@cosmjs/crypto": "^0.27.0-rc2",
+    "@cosmjs/math": "^0.27.0-rc2",
+    "@cosmjs/proto-signing": "^0.27.0-rc2",
+    "@cosmjs/stargate": "^0.27.0-rc2",
+    "@cosmjs/tendermint-rpc": "^0.27.0-rc2",
     "axios": "^0.21.1",
-    "@cosmjs/cosmwasm-stargate": "^0.25.5",
-    "@cosmjs/stargate": "^0.25.5",
-    "@cosmjs/math": "^0.25.5",
-    "@cosmjs/proto-signing": "^0.25.5"
+    "cosmjs-types": "^0.4.0"
   }
-}
+}

clients/validator/src/.eslintrc.json

@@ -1,41 +0,0 @@
-{
-    "root": true,
-    "parser": "@typescript-eslint/parser",
-    "plugins": [
-        "@typescript-eslint"
-    ],
-    "env": {
-        "es6": true,
-        "node": true,
-        "mocha": true
-    },
-    "extends": [
-        "eslint:recommended",
-        "plugin:@typescript-eslint/eslint-recommended",
-        "plugin:@typescript-eslint/recommended"
-    ],
-    "parserOptions": {
-        "ecmaVersion": 2018,
-        "sourceType": "module"
-    },
-    "rules": {
-        "no-console": "off",
-        "linebreak-style": "off",
-        "quotes": [
-            "error",
-            "double",
-            {
-                "allowTemplateLiterals": true
-            }
-        ],
-        "keyword-spacing": [
-            "error",
-            {
-                "before": true
-            }
-        ],
-        "space-before-blocks": [
-            "error"
-        ]
-    }
-}

clients/validator/src/.nvmrc

@@ -1 +0,0 @@
-15.0.1

clients/validator/src/caches/gateways.ts

@@ -1,59 +0,0 @@
-import { GatewayBond } from "../types";
-import {INetClient} from "../net-client"
-import {IQueryClient} from "../query-client";
-import {PagedGatewayResponse, VALIDATOR_API_GATEWAYS, VALIDATOR_API_PORT} from "../index";
-import axios from "axios";
-
-
-/**
- * There are serious limits in smart contract systems, but we need to keep track of
- * potentially thousands of nodes. GatewaysCache instances repeatedly make requests for
- * paged data about what gateways exist, and keep them locally in memory so that they're
- * available for querying.
- **/
-export default class GatewaysCache {
-    gateways: GatewayBond[]
-    client: INetClient | IQueryClient
-    perPage: number
-
-    constructor(client: INetClient | IQueryClient, perPage: number) {
-        this.client = client;
-        this.gateways = [];
-        this.perPage = perPage;
-    }
-
-    /// Makes repeated requests to assemble a full list of gateways.
-    /// Requests continue to be make as long as `shouldMakeAnotherRequest()`
-    /// returns true.
-    async refreshGateways(contractAddress: string): Promise<GatewayBond[]> {
-        let newGateways: GatewayBond[] = [];
-        let response: PagedGatewayResponse;
-        let next: string | undefined = undefined;
-        for (;;) {
-            response = await this.client.getGateways(contractAddress, this.perPage, next);
-            newGateways = newGateways.concat(response.nodes)
-            next = response.start_next_after;
-            // if `start_next_after` is not set, we're done
-            if (!next) {
-                break
-            }
-        }
-
-        this.gateways = newGateways
-        return newGateways;
-    }
-
-    /// Makes requests to assemble a full list of gateways from validator-api
-    async refreshValidatorAPIGateways(urls: string[]): Promise<GatewayBond[]> {
-        for (const url of urls) {
-            const validator_api_url = new URL(url);
-            validator_api_url.port = VALIDATOR_API_PORT;
-            validator_api_url.pathname += VALIDATOR_API_GATEWAYS;
-            const response = await axios.get(validator_api_url.toString());
-            if (response.status == 200) {
-                return response.data;
-            }
-        }
-        throw new Error("None of the provided validators seem to be alive")
-    }
-}

clients/validator/src/caches/mixnodes.ts

@@ -1,60 +0,0 @@
-import { MixNodeBond } from "../types";
-import { INetClient } from "../net-client"
-import {IQueryClient} from "../query-client";
-import {PagedMixnodeResponse, VALIDATOR_API_MIXNODES, VALIDATOR_API_PORT} from "../index";
-import axios from "axios";
-
-export { MixnodesCache };
-
-/**
- * There are serious limits in smart contract systems, but we need to keep track of 
- * potentially thousands of nodes. MixnodeCache instances repeatedly make requests for
- *  paged data about what mixnodes exist, and keep them locally in memory so that they're
- *  available for querying.
- *  */
-export default class MixnodesCache {
-    mixNodes: MixNodeBond[]
-    client: INetClient | IQueryClient
-    perPage: number
-
-    constructor(client: INetClient | IQueryClient, perPage: number) {
-        this.client = client;
-        this.mixNodes = [];
-        this.perPage = perPage;
-    }
-
-    /// Makes repeated requests to assemble a full list of nodes. 
-    /// Requests continue to be make as long as `shouldMakeAnotherRequest()`
-    // returns true. 
-    async refreshMixNodes(contractAddress: string): Promise<MixNodeBond[]> {
-        let newMixnodes: MixNodeBond[] = [];
-        let response: PagedMixnodeResponse;
-        let next: string | undefined = undefined;
-        for (;;) {
-            response = await this.client.getMixNodes(contractAddress, this.perPage, next);
-            newMixnodes = newMixnodes.concat(response.nodes)
-            next = response.start_next_after;
-            // if `start_next_after` is not set, we're done
-            if (!next) {
-                break
-            }
-        }
-
-        this.mixNodes = newMixnodes
-        return this.mixNodes;
-    }
-
-    /// Makes  requests to assemble a full list of mixnodes from validator-api
-    async refreshValidatorAPIMixNodes(urls: string[]): Promise<MixNodeBond[]> {
-        for (const url of urls) {
-            const validator_api_url = new URL(url);
-            validator_api_url.port = VALIDATOR_API_PORT;
-            validator_api_url.pathname += VALIDATOR_API_MIXNODES;
-            const response = await axios.get(validator_api_url.toString());
-            if (response.status == 200) {
-                return response.data;
-            }
-        }
-        throw new Error("None of the provided validators seem to be alive")
-    }
-}

clients/validator/src/currency.ts

@@ -1,73 +1,68 @@
-import { Decimal } from "@cosmjs/math";
-import { Coin } from ".";
+import { Decimal } from '@cosmjs/math';
+import { Coin } from '@cosmjs/stargate';
 
 // NARROW NO-BREAK SPACE (U+202F)
-const thinSpace = "\u202F";
+const thinSpace = '\u202F';
 
 export function printableCoin(coin?: Coin): string {
-    if (!coin) {
-        return "0";
-    }
-    if (coin.denom.startsWith("u")) {
-        const ticker = coin.denom.slice(1).toUpperCase();
-        return Decimal.fromAtomics(coin.amount, 6).toString() + thinSpace + ticker;
-    } else {
-        return coin.amount + thinSpace + coin.denom;
-    }
+  if (!coin) {
+    return '0';
+  }
+  if (coin.denom.startsWith('u')) {
+    const ticker = coin.denom.slice(1).toUpperCase();
+    return Decimal.fromAtomics(coin.amount, 6).toString() + thinSpace + ticker;
+  }
+  return coin.amount + thinSpace + coin.denom;
 }
 
 export function printableBalance(balance?: readonly Coin[]): string {
-    if (!balance || balance.length === 0) return "–";
-    return balance.map(printableCoin).join(", ");
+  if (!balance || balance.length === 0) return '–';
+  return balance.map(printableCoin).join(', ');
 }
 
 // converts display amount, such as "12.0346" to its native token representation,
 // with 6 fractional digits. So in that case it would result in "12034600"
 // Basically does the same job as `displayAmountToNative` but without the requirement
 // of having the coinMap
-export function printableBalanceToNative(amountToDisplay: string): string  {
-    const decimalAmount = Decimal.fromUserInput(amountToDisplay, 6);
-    return decimalAmount.atomics;
+export function printableBalanceToNative(amountToDisplay: string): string {
+  const decimalAmount = Decimal.fromUserInput(amountToDisplay, 6);
+  return decimalAmount.atomics;
 }
 
 // reciprocal of `printableBalanceToNative`, takes, for example 10000000 and returns 10
 export function nativeToPrintable(nativeValue: string): string {
-    return Decimal.fromAtomics(nativeValue, 6).toString()
+  return Decimal.fromAtomics(nativeValue, 6).toString();
 }
 
 export interface MappedCoin {
-    readonly denom: string;
-    readonly fractionalDigits: number;
+  readonly denom: string;
+  readonly fractionalDigits: number;
 }
 
 export interface CoinMap {
-    readonly [key: string]: MappedCoin;
+  readonly [key: string]: MappedCoin;
 }
 
 export function nativeCoinToDisplay(coin: Coin, coinMap: CoinMap): Coin {
-    if (!coinMap) return coin;
+  if (!coinMap) return coin;
 
-    const coinToDisplay = coinMap[coin.denom];
-    if (!coinToDisplay) return coin;
+  const coinToDisplay = coinMap[coin.denom];
+  if (!coinToDisplay) return coin;
 
-    const amountToDisplay = Decimal.fromAtomics(coin.amount, coinToDisplay.fractionalDigits).toString();
+  const amountToDisplay = Decimal.fromAtomics(coin.amount, coinToDisplay.fractionalDigits).toString();
 
-    return { denom: coinToDisplay.denom, amount: amountToDisplay };
+  return { denom: coinToDisplay.denom, amount: amountToDisplay };
 }
 
 // display amount is eg "12.0346", return is in native tokens
 // with 6 fractional digits, this would be eg. "12034600"
-export function displayAmountToNative(
-    amountToDisplay: string,
-    coinMap: CoinMap,
-    nativeDenom: string,
-): string {
-    const fractionalDigits = coinMap[nativeDenom]?.fractionalDigits;
-    if (fractionalDigits) {
-        // use https://github.com/CosmWasm/cosmjs/blob/v0.22.2/packages/math/src/decimal.ts
-        const decimalAmount = Decimal.fromUserInput(amountToDisplay, fractionalDigits);
-        return decimalAmount.atomics;
-    }
+export function displayAmountToNative(amountToDisplay: string, coinMap: CoinMap, nativeDenom: string): string {
+  const fractionalDigits = coinMap[nativeDenom]?.fractionalDigits;
+  if (fractionalDigits) {
+    // use https://github.com/CosmWasm/cosmjs/blob/v0.22.2/packages/math/src/decimal.ts
+    const decimalAmount = Decimal.fromUserInput(amountToDisplay, fractionalDigits);
+    return decimalAmount.atomics;
+  }
 
-    return amountToDisplay;
+  return amountToDisplay;
 }

clients/validator/src/net-client.ts

@@ -1,207 +0,0 @@
-import { SigningCosmWasmClient, SigningCosmWasmClientOptions } from "@cosmjs/cosmwasm-stargate";
-import {
-    Delegation,
-    GatewayOwnershipResponse,
-    MixOwnershipResponse, PagedGatewayDelegationsResponse,
-    PagedGatewayResponse, PagedMixDelegationsResponse,
-    PagedMixnodeResponse,
-    StateParams
-} from "./index";
-import { DirectSecp256k1HdWallet, EncodeObject } from "@cosmjs/proto-signing";
-import { Coin, StdFee } from "@cosmjs/stargate";
-import { BroadcastTxResponse } from "@cosmjs/stargate"
-import { nymGasLimits, nymGasPrice } from "./stargate-helper"
-import {
-    ExecuteResult,
-    InstantiateOptions,
-    InstantiateResult,
-    MigrateResult,
-    UploadMeta,
-    UploadResult
-} from "@cosmjs/cosmwasm-stargate";
-
-export interface INetClient {
-    clientAddress: string;
-
-    getBalance(address: string, denom: string): Promise<Coin | null>;
-
-    getMixNodes(contractAddress: string, limit: number, start_after?: string): Promise<PagedMixnodeResponse>;
-
-    getGateways(contractAddress: string, limit: number, start_after?: string): Promise<PagedGatewayResponse>;
-
-    getMixDelegations(contractAddress: string, mixIdentity: string, limit: number, start_after?: string): Promise<PagedMixDelegationsResponse>
-
-    getMixDelegation(contractAddress: string, mixIdentity: string, delegatorAddress: string): Promise<Delegation>
-
-    getGatewayDelegations(contractAddress: string, gatewayIdentity: string, limit: number, start_after?: string): Promise<PagedGatewayDelegationsResponse>
-
-    getGatewayDelegation(contractAddress: string, gatewayIdentity: string, delegatorAddress: string): Promise<Delegation>
-
-    ownsMixNode(contractAddress: string, address: string): Promise<MixOwnershipResponse>;
-
-    ownsGateway(contractAddress: string, address: string): Promise<GatewayOwnershipResponse>;
-
-    getStateParams(contractAddress: string): Promise<StateParams>;
-
-    signAndBroadcast(signerAddress: string, messages: readonly EncodeObject[], fee: StdFee, memo?: string): Promise<BroadcastTxResponse>;
-
-    executeContract(senderAddress: string, contractAddress: string, handleMsg: Record<string, unknown>, memo?: string, transferAmount?: readonly Coin[]): Promise<ExecuteResult>;
-
-    instantiate(senderAddress: string, codeId: number, initMsg: Record<string, unknown>, label: string, options?: InstantiateOptions): Promise<InstantiateResult>;
-
-    sendTokens(senderAddress: string, recipientAddress: string, transferAmount: readonly Coin[], memo?: string): Promise<BroadcastTxResponse>;
-
-    upload(senderAddress: string, wasmCode: Uint8Array, meta?: UploadMeta, memo?: string): Promise<UploadResult>;
-
-    changeValidator(newUrl: string): Promise<void>
-}
-
-/**
- * Takes care of network communication between this code and the validator.
- * Depends on `SigningCosmWasClient`, which signs all requests using keypairs
- * derived from on bech32 mnemonics.
- *
- * Wraps several methods from CosmWasmSigningClient so we can mock them for
- * unit testing.
- */
-export default class NetClient implements INetClient {
-    clientAddress: string;
-    private cosmClient: SigningCosmWasmClient;
-
-    // helpers for changing validators without having to remake the wallet
-    private readonly wallet: DirectSecp256k1HdWallet;
-    private readonly signerOptions: SigningCosmWasmClientOptions;
-
-    private constructor(clientAddress: string, cosmClient: SigningCosmWasmClient, wallet: DirectSecp256k1HdWallet, signerOptions: SigningCosmWasmClientOptions) {
-        this.clientAddress = clientAddress;
-        this.cosmClient = cosmClient;
-        this.wallet = wallet;
-        this.signerOptions = signerOptions;
-    }
-
-    public static async connect(wallet: DirectSecp256k1HdWallet, url: string, prefix: string): Promise<INetClient> {
-        const [{address}] = await wallet.getAccounts();
-        const signerOptions: SigningCosmWasmClientOptions = {
-            gasPrice: nymGasPrice(prefix),
-            gasLimits: nymGasLimits,
-        };
-        const client = await SigningCosmWasmClient.connectWithSigner(url, wallet, signerOptions);
-        return new NetClient(address, client, wallet, signerOptions);
-    }
-
-    async changeValidator(url: string): Promise<void> {
-        this.cosmClient = await SigningCosmWasmClient.connectWithSigner(url, this.wallet, this.signerOptions);
-    }
-
-    public getMixNodes(contractAddress: string, limit: number, start_after?: string): Promise<PagedMixnodeResponse> {
-        if (start_after == undefined) { // TODO: check if we can take this out, I'm not sure what will happen if we send an "undefined" so I'm playing it safe here.
-            return this.cosmClient.queryContractSmart(contractAddress, {get_mix_nodes: {limit}});
-        } else {
-            return this.cosmClient.queryContractSmart(contractAddress, {get_mix_nodes: {limit, start_after}});
-        }
-    }
-
-    public getGateways(contractAddress: string, limit: number, start_after?: string): Promise<PagedGatewayResponse> {
-        if (start_after == undefined) { // TODO: check if we can take this out, I'm not sure what will happen if we send an "undefined" so I'm playing it safe here.
-            return this.cosmClient.queryContractSmart(contractAddress, {get_gateways: {limit}});
-        } else {
-            return this.cosmClient.queryContractSmart(contractAddress, {get_gateways: {limit, start_after}});
-        }
-    }
-
-    public getMixDelegations(contractAddress: string, mixIdentity: string, limit: number, start_after?: string): Promise<PagedMixDelegationsResponse> {
-        if (start_after == undefined) { // TODO: check if we can take this out, I'm not sure what will happen if we send an "undefined" so I'm playing it safe here.
-            return this.cosmClient.queryContractSmart(contractAddress, {
-                get_mix_delegations: {
-                    mix_identity: mixIdentity,
-                    limit
-                }
-            });
-        } else {
-            return this.cosmClient.queryContractSmart(contractAddress, {
-                get_mix_delegations: {
-                    mix_identity: mixIdentity,
-                    limit,
-                    start_after
-                }
-            });
-        }
-    }
-
-    public getMixDelegation(contractAddress: string, mixIdentity: string, delegatorAddress: string): Promise<Delegation> {
-        return this.cosmClient.queryContractSmart(contractAddress, {
-            get_mix_delegation: {
-                mix_identity: mixIdentity,
-                address: delegatorAddress
-            }
-        });
-    }
-
-    public getGatewayDelegations(contractAddress: string, gatewayIdentity: string, limit: number, start_after?: string): Promise<PagedGatewayDelegationsResponse> {
-        if (start_after == undefined) { // TODO: check if we can take this out, I'm not sure what will happen if we send an "undefined" so I'm playing it safe here.
-            return this.cosmClient.queryContractSmart(contractAddress, {
-                get_gateway_delegations: {
-                    gateway_identity: gatewayIdentity,
-                    limit
-                }
-            });
-        } else {
-            return this.cosmClient.queryContractSmart(contractAddress, {
-                get_gateway_delegations: {
-                    gateway_identity: gatewayIdentity,
-                    limit,
-                    start_after
-                }
-            });
-        }
-    }
-
-    public getGatewayDelegation(contractAddress: string, gatewayIdentity: string, delegatorAddress: string): Promise<Delegation> {
-        return this.cosmClient.queryContractSmart(contractAddress, {
-            get_gateway_delegation: {
-                gateway_identity: gatewayIdentity,
-                address: delegatorAddress
-            }
-        });
-    }
-
-    public ownsMixNode(contractAddress: string, address: string): Promise<MixOwnershipResponse> {
-        return this.cosmClient.queryContractSmart(contractAddress, {owns_mixnode: {address}});
-    }
-
-    public ownsGateway(contractAddress: string, address: string): Promise<GatewayOwnershipResponse> {
-        return this.cosmClient.queryContractSmart(contractAddress, {owns_gateway: {address}});
-    }
-
-    public getBalance(address: string, denom: string): Promise<Coin | null> {
-        return this.cosmClient.getBalance(address, denom);
-    }
-
-    public getStateParams(contractAddress: string): Promise<StateParams> {
-        return this.cosmClient.queryContractSmart(contractAddress, {state_params: {}});
-    }
-
-    public executeContract(senderAddress: string, contractAddress: string, handleMsg: Record<string, unknown>, memo?: string, transferAmount?: readonly Coin[]): Promise<ExecuteResult> {
-        return this.cosmClient.execute(senderAddress, contractAddress, handleMsg, memo, transferAmount);
-    }
-
-    public signAndBroadcast(signerAddress: string, messages: readonly EncodeObject[], fee: StdFee, memo?: string): Promise<BroadcastTxResponse> {
-        return this.cosmClient.signAndBroadcast(signerAddress, messages, fee, memo)
-    }
-
-    public sendTokens(senderAddress: string, recipientAddress: string, transferAmount: readonly Coin[], memo?: string): Promise<BroadcastTxResponse> {
-        return this.cosmClient.sendTokens(senderAddress, recipientAddress, transferAmount, memo);
-    }
-
-    public upload(senderAddress: string, wasmCode: Uint8Array, meta?: UploadMeta, memo?: string): Promise<UploadResult> {
-        return this.cosmClient.upload(senderAddress, wasmCode, meta, memo);
-    }
-
-    public instantiate(senderAddress: string, codeId: number, initMsg: Record<string, unknown>, label: string, options?: InstantiateOptions): Promise<InstantiateResult> {
-        return this.cosmClient.instantiate(senderAddress, codeId, initMsg, label, options);
-    }
-
-    public migrate(senderAddress: string, contractAddress: string, codeId: number, migrateMsg: Record<string, unknown>, memo?: string): Promise<MigrateResult> {
-        return this.cosmClient.migrate(senderAddress, contractAddress, codeId, migrateMsg, memo)
-    }
-}

clients/validator/src/nymd-querier.ts

@@ -0,0 +1,182 @@
+/*
+ * Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { JsonObject } from '@cosmjs/cosmwasm-stargate/build/queries';
+// eslint-disable-next-line import/no-cycle
+import { INymdQuery } from './query-client';
+import {
+  ContractStateParams,
+  Delegation,
+  GatewayOwnershipResponse,
+  LayerDistribution,
+  MixnetContractVersion,
+  MixOwnershipResponse,
+  PagedAllDelegationsResponse,
+  PagedDelegatorDelegationsResponse,
+  PagedGatewayResponse,
+  PagedMixDelegationsResponse,
+  PagedMixnodeResponse,
+  RewardingIntervalResponse,
+  RewardingStatus,
+} from './types';
+
+interface SmartContractQuery {
+  queryContractSmart(address: string, queryMsg: Record<string, unknown>): Promise<JsonObject>;
+}
+
+export default class NymdQuerier implements INymdQuery {
+  client: SmartContractQuery;
+
+  constructor(client: SmartContractQuery) {
+    this.client = client;
+  }
+
+  getContractVersion(mixnetContractAddress: string): Promise<MixnetContractVersion> {
+    return this.client.queryContractSmart(mixnetContractAddress, {
+      get_contract_version: {},
+    });
+  }
+
+  getMixNodesPaged(mixnetContractAddress: string, limit?: number, startAfter?: string): Promise<PagedMixnodeResponse> {
+    return this.client.queryContractSmart(mixnetContractAddress, {
+      get_mix_nodes: {
+        limit,
+        start_after: startAfter,
+      },
+    });
+  }
+
+  getGatewaysPaged(mixnetContractAddress: string, limit?: number, startAfter?: string): Promise<PagedGatewayResponse> {
+    return this.client.queryContractSmart(mixnetContractAddress, {
+      get_gateways: {
+        limit,
+        start_after: startAfter,
+      },
+    });
+  }
+
+  ownsMixNode(mixnetContractAddress: string, address: string): Promise<MixOwnershipResponse> {
+    return this.client.queryContractSmart(mixnetContractAddress, {
+      owns_mixnode: {
+        address,
+      },
+    });
+  }
+
+  ownsGateway(mixnetContractAddress: string, address: string): Promise<GatewayOwnershipResponse> {
+    return this.client.queryContractSmart(mixnetContractAddress, {
+      owns_gateway: {
+        address,
+      },
+    });
+  }
+
+  getStateParams(mixnetContractAddress: string): Promise<ContractStateParams> {
+    return this.client.queryContractSmart(mixnetContractAddress, {
+      state_params: {},
+    });
+  }
+
+  getCurrentRewardingInterval(mixnetContractAddress: string): Promise<RewardingIntervalResponse> {
+    return this.client.queryContractSmart(mixnetContractAddress, {
+      current_rewarding_interval: {},
+    });
+  }
+
+  getAllNetworkDelegationsPaged(
+    mixnetContractAddress: string,
+    limit?: number,
+    startAfter?: [string, string],
+  ): Promise<PagedAllDelegationsResponse> {
+    return this.client.queryContractSmart(mixnetContractAddress, {
+      get_all_network_delegations: {
+        start_after: startAfter,
+        limit,
+      },
+    });
+  }
+
+  getMixNodeDelegationsPaged(
+    mixnetContractAddress: string,
+    mixIdentity: string,
+    limit?: number,
+    startAfter?: string,
+  ): Promise<PagedMixDelegationsResponse> {
+    return this.client.queryContractSmart(mixnetContractAddress, {
+      get_mixnode_delegations: {
+        mix_identity: mixIdentity,
+        start_after: startAfter,
+        limit,
+      },
+    });
+  }
+
+  getDelegatorDelegationsPaged(
+    mixnetContractAddress: string,
+    delegator: string,
+    limit?: number,
+    startAfter?: string,
+  ): Promise<PagedDelegatorDelegationsResponse> {
+    return this.client.queryContractSmart(mixnetContractAddress, {
+      get_delegator_delegations: {
+        delegator,
+        start_after: startAfter,
+        limit,
+      },
+    });
+  }
+
+  getDelegationDetails(mixnetContractAddress: string, mixIdentity: string, delegator: string): Promise<Delegation> {
+    return this.client.queryContractSmart(mixnetContractAddress, {
+      get_delegation_details: {
+        mix_identity: mixIdentity,
+        delegator,
+      },
+    });
+  }
+
+  getLayerDistribution(mixnetContractAddress: string): Promise<LayerDistribution> {
+    return this.client.queryContractSmart(mixnetContractAddress, {
+      layer_distribution: {},
+    });
+  }
+
+  getRewardPool(mixnetContractAddress: string): Promise<string> {
+    return this.client.queryContractSmart(mixnetContractAddress, {
+      get_reward_pool: {},
+    });
+  }
+
+  getCirculatingSupply(mixnetContractAddress: string): Promise<string> {
+    return this.client.queryContractSmart(mixnetContractAddress, {
+      get_circulating_supply: {},
+    });
+  }
+
+  getEpochRewardPercent(mixnetContractAddress: string): Promise<number> {
+    return this.client.queryContractSmart(mixnetContractAddress, {
+      get_epoch_reward_percent: {},
+    });
+  }
+
+  getSybilResistancePercent(mixnetContractAddress: string): Promise<number> {
+    return this.client.queryContractSmart(mixnetContractAddress, {
+      get_sybil_resistance_percent: {},
+    });
+  }
+
+  getRewardingStatus(
+    mixnetContractAddress: string,
+    mixIdentity: string,
+    rewardingIntervalNonce: number,
+  ): Promise<RewardingStatus> {
+    return this.client.queryContractSmart(mixnetContractAddress, {
+      get_rewarding_status: {
+        mix_identity: mixIdentity,
+        rewarding_interval_nonce: rewardingIntervalNonce,
+      },
+    });
+  }
+}

clients/validator/src/query-client.ts

@@ -1,147 +1,218 @@
-import { Coin } from "@cosmjs/stargate";
-import { CosmWasmClient } from "@cosmjs/cosmwasm-stargate";
+import { CosmWasmClient } from '@cosmjs/cosmwasm-stargate';
+import { Tendermint34Client } from '@cosmjs/tendermint-rpc';
 import {
-    Delegation,
-    GatewayOwnershipResponse,
-    MixOwnershipResponse, PagedGatewayDelegationsResponse,
-    PagedGatewayResponse, PagedMixDelegationsResponse,
-    PagedMixnodeResponse,
-    StateParams
-} from "./index";
+  Account,
+  Block,
+  Coin,
+  DeliverTxResponse,
+  IndexedTx,
+  SearchTxFilter,
+  SearchTxQuery,
+  SequenceResponse,
+} from '@cosmjs/stargate';
+import { JsonObject } from '@cosmjs/cosmwasm-stargate/build/queries';
+import { Code, CodeDetails, Contract, ContractCodeHistoryEntry } from '@cosmjs/cosmwasm-stargate/build/cosmwasmclient';
+// eslint-disable-next-line import/no-cycle
+import NymdQuerier from './nymd-querier';
+import {
+  ContractStateParams,
+  Delegation,
+  GatewayBond,
+  GatewayOwnershipResponse,
+  LayerDistribution,
+  MixnetContractVersion,
+  MixNodeBond,
+  MixOwnershipResponse,
+  PagedAllDelegationsResponse,
+  PagedDelegatorDelegationsResponse,
+  PagedGatewayResponse,
+  PagedMixDelegationsResponse,
+  PagedMixnodeResponse,
+  RewardingIntervalResponse,
+  RewardingStatus,
+} from './types';
+import ValidatorApiQuerier, { IValidatorApiQuery } from './validator-api-querier';
 
-export interface IQueryClient {
-    getBalance(address: string, stakeDenom: string): Promise<Coin | null>;
-
-    getMixNodes(contractAddress: string, limit: number, start_after?: string): Promise<PagedMixnodeResponse>;
-
-    getGateways(contractAddress: string, limit: number, start_after?: string): Promise<PagedGatewayResponse>;
-
-    getMixDelegations(contractAddress: string, mixIdentity: string, limit: number, start_after?: string): Promise<PagedMixDelegationsResponse>
-
-    getMixDelegation(contractAddress: string, mixIdentity: string, delegatorAddress: string): Promise<Delegation>
-
-    getGatewayDelegations(contractAddress: string, gatewayIdentity: string, limit: number, start_after?: string): Promise<PagedGatewayDelegationsResponse>
-
-    getGatewayDelegation(contractAddress: string, gatewayIdentity: string, delegatorAddress: string): Promise<Delegation>
-
-    ownsMixNode(contractAddress: string, address: string): Promise<MixOwnershipResponse>;
-
-    ownsGateway(contractAddress: string, address: string): Promise<GatewayOwnershipResponse>;
-
-    getStateParams(contractAddress: string): Promise<StateParams>;
-
-    changeValidator(newUrl: string): Promise<void>
+export interface ICosmWasmQuery {
+  // methods exposed by `CosmWasmClient`
+  getChainId(): Promise<string>;
+  getHeight(): Promise<number>;
+  getAccount(searchAddress: string): Promise<Account | null>;
+  getSequence(address: string): Promise<SequenceResponse>;
+  getBlock(height?: number): Promise<Block>;
+  getBalance(address: string, searchDenom: string): Promise<Coin>;
+  getTx(id: string): Promise<IndexedTx | null>;
+  searchTx(query: SearchTxQuery, filter?: SearchTxFilter): Promise<readonly IndexedTx[]>;
+  disconnect(): void;
+  broadcastTx(tx: Uint8Array, timeoutMs?: number, pollIntervalMs?: number): Promise<DeliverTxResponse>;
+  getCodes(): Promise<readonly Code[]>;
+  getCodeDetails(codeId: number): Promise<CodeDetails>;
+  getContracts(codeId: number): Promise<readonly string[]>;
+  getContract(address: string): Promise<Contract>;
+  getContractCodeHistory(address: string): Promise<readonly ContractCodeHistoryEntry[]>;
+  queryContractRaw(address: string, key: Uint8Array): Promise<Uint8Array | null>;
+  queryContractSmart(address: string, queryMsg: Record<string, unknown>): Promise<JsonObject>;
 }
 
-/**
- * Takes care of network communication between this code and the validator.
- * Depends on `SigningCosmWasClient`, which signs all requests using keypairs
- * derived from on bech32 mnemonics.
- *
- * Wraps several methods from CosmWasmSigningClient so we can mock them for
- * unit testing.
- */
-export default class QueryClient implements IQueryClient {
-    private cosmClient: CosmWasmClient;
+export interface INymdQuery {
+  // nym-specific implemented inside NymQuerier
+  getContractVersion(mixnetContractAddress: string): Promise<MixnetContractVersion>;
 
-    private constructor(cosmClient: CosmWasmClient) {
-        this.cosmClient = cosmClient;
-    }
+  getMixNodesPaged(mixnetContractAddress: string, limit?: number, startAfter?: string): Promise<PagedMixnodeResponse>;
+  getGatewaysPaged(mixnetContractAddress: string, limit?: number, startAfter?: string): Promise<PagedGatewayResponse>;
+  ownsMixNode(mixnetContractAddress: string, address: string): Promise<MixOwnershipResponse>;
+  ownsGateway(mixnetContractAddress: string, address: string): Promise<GatewayOwnershipResponse>;
+  getStateParams(mixnetContractAddress: string): Promise<ContractStateParams>;
+  getCurrentRewardingInterval(mixnetContractAddress: string): Promise<RewardingIntervalResponse>;
 
-    public static async connect(url: string): Promise<IQueryClient> {
-        const client = await CosmWasmClient.connect(url)
-        return new QueryClient(client)
-    }
+  getAllNetworkDelegationsPaged(
+    mixnetContractAddress: string,
+    limit?: number,
+    startAfter?: [string, string],
+  ): Promise<PagedAllDelegationsResponse>;
+  getMixNodeDelegationsPaged(
+    mixnetContractAddress: string,
+    mixIdentity: string,
+    limit?: number,
+    startAfter?: string,
+  ): Promise<PagedMixDelegationsResponse>;
+  getDelegatorDelegationsPaged(
+    mixnetContractAddress: string,
+    delegator: string,
+    limit?: number,
+    startAfter?: string,
+  ): Promise<PagedDelegatorDelegationsResponse>;
+  getDelegationDetails(mixnetContractAddress: string, mixIdentity: string, delegator: string): Promise<Delegation>;
 
-    async changeValidator(url: string): Promise<void> {
-        this.cosmClient = await CosmWasmClient.connect(url)
-    }
-
-    public getMixNodes(contractAddress: string, limit: number, start_after?: string): Promise<PagedMixnodeResponse> {
-        if (start_after == undefined) { // TODO: check if we can take this out, I'm not sure what will happen if we send an "undefined" so I'm playing it safe here.
-            return this.cosmClient.queryContractSmart(contractAddress, {get_mix_nodes: {limit}});
-        } else {
-            return this.cosmClient.queryContractSmart(contractAddress, {get_mix_nodes: {limit, start_after}});
-        }
-    }
-
-    public getGateways(contractAddress: string, limit: number, start_after?: string): Promise<PagedGatewayResponse> {
-        if (start_after == undefined) { // TODO: check if we can take this out, I'm not sure what will happen if we send an "undefined" so I'm playing it safe here.
-            return this.cosmClient.queryContractSmart(contractAddress, {get_gateways: {limit}});
-        } else {
-            return this.cosmClient.queryContractSmart(contractAddress, {get_gateways: {limit, start_after}});
-        }
-    }
-
-    public getMixDelegations(contractAddress: string, mixIdentity: string, limit: number, start_after?: string): Promise<PagedMixDelegationsResponse> {
-        if (start_after == undefined) { // TODO: check if we can take this out, I'm not sure what will happen if we send an "undefined" so I'm playing it safe here.
-            return this.cosmClient.queryContractSmart(contractAddress, {
-                get_mix_delegations: {
-                    mix_identity: mixIdentity,
-                    limit
-                }
-            });
-        } else {
-            return this.cosmClient.queryContractSmart(contractAddress, {
-                get_mix_delegations: {
-                    mix_identity: mixIdentity,
-                    limit,
-                    start_after
-                }
-            });
-        }
-    }
-
-    public getMixDelegation(contractAddress: string, mixIdentity: string, delegatorAddress: string): Promise<Delegation> {
-        return this.cosmClient.queryContractSmart(contractAddress, {
-            get_mix_delegation: {
-                mix_identity: mixIdentity,
-                address: delegatorAddress
-            }
-        });
-    }
-
-    public getGatewayDelegations(contractAddress: string, gatewayIdentity: string, limit: number, start_after?: string): Promise<PagedGatewayDelegationsResponse> {
-        if (start_after == undefined) { // TODO: check if we can take this out, I'm not sure what will happen if we send an "undefined" so I'm playing it safe here.
-            return this.cosmClient.queryContractSmart(contractAddress, {
-                get_gateway_delegations: {
-                    gateway_identity: gatewayIdentity,
-                    limit
-                }
-            });
-        } else {
-            return this.cosmClient.queryContractSmart(contractAddress, {
-                get_gateway_delegations: {
-                    gateway_identity: gatewayIdentity,
-                    limit,
-                    start_after
-                }
-            });
-        }
-    }
-
-    public getGatewayDelegation(contractAddress: string, gatewayIdentity: string, delegatorAddress: string): Promise<Delegation> {
-        return this.cosmClient.queryContractSmart(contractAddress, {
-            get_gateway_delegation: {
-                gateway_identity: gatewayIdentity,
-                address: delegatorAddress
-            }
-        });
-    }
-
-    public ownsMixNode(contractAddress: string, address: string): Promise<MixOwnershipResponse> {
-        return this.cosmClient.queryContractSmart(contractAddress, {owns_mixnode: {address}});
-    }
-
-    public ownsGateway(contractAddress: string, address: string): Promise<GatewayOwnershipResponse> {
-        return this.cosmClient.queryContractSmart(contractAddress, {owns_gateway: {address}});
-    }
-
-    public getBalance(address: string, stakeDenom: string): Promise<Coin | null> {
-        return this.cosmClient.getBalance(address, stakeDenom);
-    }
-
-    public getStateParams(contractAddress: string): Promise<StateParams> {
-        return this.cosmClient.queryContractSmart(contractAddress, {state_params: {}});
-    }
+  getLayerDistribution(mixnetContractAddress: string): Promise<LayerDistribution>;
+  getRewardPool(mixnetContractAddress: string): Promise<string>;
+  getCirculatingSupply(mixnetContractAddress: string): Promise<string>;
+  getEpochRewardPercent(mixnetContractAddress: string): Promise<number>;
+  getSybilResistancePercent(mixnetContractAddress: string): Promise<number>;
+  getRewardingStatus(
+    mixnetContractAddress: string,
+    mixIdentity: string,
+    rewardingIntervalNonce: number,
+  ): Promise<RewardingStatus>;
+}
+
+export interface IQueryClient extends ICosmWasmQuery, INymdQuery, IValidatorApiQuery {}
+
+export default class QueryClient extends CosmWasmClient implements IQueryClient {
+  private nymdQuerier: NymdQuerier;
+
+  private validatorApiQuerier: ValidatorApiQuerier;
+
+  private constructor(tmClient: Tendermint34Client, validatorApiUrl: string) {
+    super(tmClient);
+    this.nymdQuerier = new NymdQuerier(this);
+    this.validatorApiQuerier = new ValidatorApiQuerier(validatorApiUrl);
+  }
+
+  public static async connectWithNym(nymdUrl: string, validatorApiUrl: string): Promise<QueryClient> {
+    const tmClient = await Tendermint34Client.connect(nymdUrl);
+    return new QueryClient(tmClient, validatorApiUrl);
+  }
+
+  getContractVersion(mixnetContractAddress: string): Promise<MixnetContractVersion> {
+    return this.nymdQuerier.getContractVersion(mixnetContractAddress);
+  }
+
+  getMixNodesPaged(mixnetContractAddress: string, limit?: number, startAfter?: string): Promise<PagedMixnodeResponse> {
+    return this.nymdQuerier.getMixNodesPaged(mixnetContractAddress, limit, startAfter);
+  }
+
+  getGatewaysPaged(mixnetContractAddress: string, limit?: number, startAfter?: string): Promise<PagedGatewayResponse> {
+    return this.nymdQuerier.getGatewaysPaged(mixnetContractAddress, limit, startAfter);
+  }
+
+  ownsMixNode(mixnetContractAddress: string, address: string): Promise<MixOwnershipResponse> {
+    return this.nymdQuerier.ownsMixNode(mixnetContractAddress, address);
+  }
+
+  ownsGateway(mixnetContractAddress: string, address: string): Promise<GatewayOwnershipResponse> {
+    return this.nymdQuerier.ownsGateway(mixnetContractAddress, address);
+  }
+
+  getStateParams(mixnetContractAddress: string): Promise<ContractStateParams> {
+    return this.nymdQuerier.getStateParams(mixnetContractAddress);
+  }
+
+  getCurrentRewardingInterval(mixnetContractAddress: string): Promise<RewardingIntervalResponse> {
+    return this.nymdQuerier.getCurrentRewardingInterval(mixnetContractAddress);
+  }
+
+  getAllNetworkDelegationsPaged(
+    mixnetContractAddress: string,
+    limit?: number,
+    startAfter?: [string, string],
+  ): Promise<PagedAllDelegationsResponse> {
+    return this.nymdQuerier.getAllNetworkDelegationsPaged(mixnetContractAddress, limit, startAfter);
+  }
+
+  getMixNodeDelegationsPaged(
+    mixnetContractAddress: string,
+    mixIdentity: string,
+    limit?: number,
+    startAfter?: string,
+  ): Promise<PagedMixDelegationsResponse> {
+    return this.nymdQuerier.getMixNodeDelegationsPaged(mixnetContractAddress, mixIdentity, limit, startAfter);
+  }
+
+  getDelegatorDelegationsPaged(
+    mixnetContractAddress: string,
+    delegator: string,
+    limit?: number,
+    startAfter?: string,
+  ): Promise<PagedDelegatorDelegationsResponse> {
+    return this.nymdQuerier.getDelegatorDelegationsPaged(mixnetContractAddress, delegator, limit, startAfter);
+  }
+
+  getDelegationDetails(mixnetContractAddress: string, mixIdentity: string, delegator: string): Promise<Delegation> {
+    return this.nymdQuerier.getDelegationDetails(mixnetContractAddress, mixIdentity, delegator);
+  }
+
+  getLayerDistribution(mixnetContractAddress: string): Promise<LayerDistribution> {
+    return this.nymdQuerier.getLayerDistribution(mixnetContractAddress);
+  }
+
+  getRewardPool(mixnetContractAddress: string): Promise<string> {
+    return this.nymdQuerier.getRewardPool(mixnetContractAddress);
+  }
+
+  getCirculatingSupply(mixnetContractAddress: string): Promise<string> {
+    return this.nymdQuerier.getCirculatingSupply(mixnetContractAddress);
+  }
+
+  getEpochRewardPercent(mixnetContractAddress: string): Promise<number> {
+    return this.nymdQuerier.getEpochRewardPercent(mixnetContractAddress);
+  }
+
+  getSybilResistancePercent(mixnetContractAddress: string): Promise<number> {
+    return this.nymdQuerier.getSybilResistancePercent(mixnetContractAddress);
+  }
+
+  getRewardingStatus(
+    mixnetContractAddress: string,
+    mixIdentity: string,
+    rewardingIntervalNonce: number,
+  ): Promise<RewardingStatus> {
+    return this.nymdQuerier.getRewardingStatus(mixnetContractAddress, mixIdentity, rewardingIntervalNonce);
+  }
+
+  getCachedGateways(): Promise<GatewayBond[]> {
+    return this.validatorApiQuerier.getCachedGateways();
+  }
+
+  getCachedMixnodes(): Promise<MixNodeBond[]> {
+    return this.validatorApiQuerier.getCachedMixnodes();
+  }
+
+  getActiveMixnodes(): Promise<MixNodeBond[]> {
+    return this.validatorApiQuerier.getActiveMixnodes();
+  }
+
+  getRewardedMixnodes(): Promise<MixNodeBond[]> {
+    return this.validatorApiQuerier.getRewardedMixnodes();
+  }
 }

clients/validator/src/signing-client.ts

@@ -0,0 +1,467 @@
+import {
+  ExecuteResult,
+  InstantiateOptions,
+  InstantiateResult,
+  MigrateResult,
+  SigningCosmWasmClient,
+  SigningCosmWasmClientOptions,
+  UploadResult,
+} from '@cosmjs/cosmwasm-stargate';
+import { DirectSecp256k1HdWallet, EncodeObject } from '@cosmjs/proto-signing';
+import { Coin, DeliverTxResponse, SignerData, StdFee } from '@cosmjs/stargate';
+import { Tendermint34Client } from '@cosmjs/tendermint-rpc';
+import { ChangeAdminResult } from '@cosmjs/cosmwasm-stargate/build/signingcosmwasmclient';
+import { TxRaw } from 'cosmjs-types/cosmos/tx/v1beta1/tx';
+import { nymGasPrice } from './stargate-helper';
+import { IQueryClient } from './query-client';
+import NymdQuerier from './nymd-querier';
+import {
+  ContractStateParams,
+  Delegation,
+  Gateway,
+  GatewayBond,
+  GatewayOwnershipResponse,
+  LayerDistribution,
+  MixnetContractVersion,
+  MixNode,
+  MixNodeBond,
+  MixOwnershipResponse,
+  PagedAllDelegationsResponse,
+  PagedDelegatorDelegationsResponse,
+  PagedGatewayResponse,
+  PagedMixDelegationsResponse,
+  PagedMixnodeResponse,
+  RewardingIntervalResponse,
+  RewardingStatus,
+} from './types';
+import ValidatorApiQuerier from './validator-api-querier';
+
+// methods exposed by `SigningCosmWasmClient`
+export interface ICosmWasmSigning {
+  simulate(signerAddress: string, messages: readonly EncodeObject[], memo: string | undefined): Promise<number>;
+
+  upload(
+    senderAddress: string,
+    wasmCode: Uint8Array,
+    fee: StdFee | 'auto' | number,
+    memo?: string,
+  ): Promise<UploadResult>;
+
+  instantiate(
+    senderAddress: string,
+    codeId: number,
+    msg: Record<string, unknown>,
+    label: string,
+    fee: StdFee | 'auto' | number,
+    options?: InstantiateOptions,
+  ): Promise<InstantiateResult>;
+
+  updateAdmin(
+    senderAddress: string,
+    contractAddress: string,
+    newAdmin: string,
+    fee: StdFee | 'auto' | number,
+    memo?: string,
+  ): Promise<ChangeAdminResult>;
+
+  clearAdmin(
+    senderAddress: string,
+    contractAddress: string,
+    fee: StdFee | 'auto' | number,
+    memo?: string,
+  ): Promise<ChangeAdminResult>;
+
+  migrate(
+    senderAddress: string,
+    contractAddress: string,
+    codeId: number,
+    migrateMsg: Record<string, unknown>,
+    fee: StdFee | 'auto' | number,
+    memo?: string,
+  ): Promise<MigrateResult>;
+
+  execute(
+    senderAddress: string,
+    contractAddress: string,
+    msg: Record<string, unknown>,
+    fee: StdFee | 'auto' | number,
+    memo?: string,
+    funds?: readonly Coin[],
+  ): Promise<ExecuteResult>;
+
+  sendTokens(
+    senderAddress: string,
+    recipientAddress: string,
+    amount: readonly Coin[],
+    fee: StdFee | 'auto' | number,
+    memo?: string,
+  ): Promise<DeliverTxResponse>;
+
+  delegateTokens(
+    delegatorAddress: string,
+    validatorAddress: string,
+    amount: Coin,
+    fee: StdFee | 'auto' | number,
+    memo?: string,
+  ): Promise<DeliverTxResponse>;
+
+  undelegateTokens(
+    delegatorAddress: string,
+    validatorAddress: string,
+    amount: Coin,
+    fee: StdFee | 'auto' | number,
+    memo?: string,
+  ): Promise<DeliverTxResponse>;
+
+  withdrawRewards(
+    delegatorAddress: string,
+    validatorAddress: string,
+    fee: StdFee | 'auto' | number,
+    memo?: string,
+  ): Promise<DeliverTxResponse>;
+
+  signAndBroadcast(
+    signerAddress: string,
+    messages: readonly EncodeObject[],
+    fee: StdFee | 'auto' | number,
+    memo?: string,
+  ): Promise<DeliverTxResponse>;
+
+  sign(
+    signerAddress: string,
+    messages: readonly EncodeObject[],
+    fee: StdFee,
+    memo: string,
+    explicitSignerData?: SignerData,
+  ): Promise<TxRaw>;
+}
+
+export interface INymSigning {
+  clientAddress: string;
+}
+
+export interface ISigningClient extends IQueryClient, ICosmWasmSigning, INymSigning {
+  bondMixNode(
+    mixnetContractAddress: string,
+    mixNode: MixNode,
+    ownerSignature: string,
+    pledge: Coin,
+    fee?: StdFee | 'auto' | number,
+    memo?: string,
+  ): Promise<ExecuteResult>;
+
+  unbondMixNode(mixnetContractAddress: string, fee?: StdFee | 'auto' | number, memo?: string): Promise<ExecuteResult>;
+
+  bondGateway(
+    mixnetContractAddress: string,
+    gateway: Gateway,
+    ownerSignature: string,
+    pledge: Coin,
+    fee?: StdFee | 'auto' | number,
+    memo?: string,
+  ): Promise<ExecuteResult>;
+
+  unbondGateway(mixnetContractAddress: string, fee?: StdFee | 'auto' | number, memo?: string): Promise<ExecuteResult>;
+
+  delegateToMixNode(
+    mixnetContractAddress: string,
+    mixIdentity: string,
+    amount: Coin,
+    fee?: StdFee | 'auto' | number,
+    memo?: string,
+  ): Promise<ExecuteResult>;
+
+  undelegateFromMixNode(
+    mixnetContractAddress: string,
+    mixIdentity: string,
+    fee?: StdFee | 'auto' | number,
+    memo?: string,
+  ): Promise<ExecuteResult>;
+
+  updateContractStateParams(
+    mixnetContractAddress: string,
+    newParams: ContractStateParams,
+    fee?: StdFee | 'auto' | number,
+    memo?: string,
+  ): Promise<ExecuteResult>;
+
+  // I don't see any point in exposing rewarding / vesting-related (INSIDE mixnet contract, like "BondMixnodeOnBehalf")
+  // functionalities in our typescript client. However, if for some reason, we find we need them
+  // they're rather trivial to add.
+}
+
+export default class SigningClient extends SigningCosmWasmClient implements ISigningClient {
+  private nymdQuerier: NymdQuerier;
+
+  private validatorApiQuerier: ValidatorApiQuerier;
+
+  clientAddress: string;
+
+  private constructor(
+    clientAddress: string,
+    validatorApiUrl: string,
+    tmClient: Tendermint34Client,
+    wallet: DirectSecp256k1HdWallet,
+    signerOptions: SigningCosmWasmClientOptions,
+  ) {
+    super(tmClient, wallet, signerOptions);
+    this.clientAddress = clientAddress;
+    this.nymdQuerier = new NymdQuerier(this);
+    this.validatorApiQuerier = new ValidatorApiQuerier(validatorApiUrl);
+  }
+
+  public static async connectWithNymSigner(
+    wallet: DirectSecp256k1HdWallet,
+    nymdUrl: string,
+    validatorApiUrl: string,
+    prefix: string,
+  ): Promise<SigningClient> {
+    const [{ address }] = await wallet.getAccounts();
+    const signerOptions: SigningCosmWasmClientOptions = {
+      gasPrice: nymGasPrice(prefix),
+    };
+    const tmClient = await Tendermint34Client.connect(nymdUrl);
+    return new SigningClient(address, validatorApiUrl, tmClient, wallet, signerOptions);
+  }
+
+  // query related:
+
+  getContractVersion(mixnetContractAddress: string): Promise<MixnetContractVersion> {
+    return this.nymdQuerier.getContractVersion(mixnetContractAddress);
+  }
+
+  getMixNodesPaged(mixnetContractAddress: string, limit?: number, startAfter?: string): Promise<PagedMixnodeResponse> {
+    return this.nymdQuerier.getMixNodesPaged(mixnetContractAddress, limit, startAfter);
+  }
+
+  getGatewaysPaged(mixnetContractAddress: string, limit?: number, startAfter?: string): Promise<PagedGatewayResponse> {
+    return this.nymdQuerier.getGatewaysPaged(mixnetContractAddress, limit, startAfter);
+  }
+
+  ownsMixNode(mixnetContractAddress: string, address: string): Promise<MixOwnershipResponse> {
+    return this.nymdQuerier.ownsMixNode(mixnetContractAddress, address);
+  }
+
+  ownsGateway(mixnetContractAddress: string, address: string): Promise<GatewayOwnershipResponse> {
+    return this.nymdQuerier.ownsGateway(mixnetContractAddress, address);
+  }
+
+  getStateParams(mixnetContractAddress: string): Promise<ContractStateParams> {
+    return this.nymdQuerier.getStateParams(mixnetContractAddress);
+  }
+
+  getCurrentRewardingInterval(mixnetContractAddress: string): Promise<RewardingIntervalResponse> {
+    return this.nymdQuerier.getCurrentRewardingInterval(mixnetContractAddress);
+  }
+
+  getAllNetworkDelegationsPaged(
+    mixnetContractAddress: string,
+    limit?: number,
+    startAfter?: [string, string],
+  ): Promise<PagedAllDelegationsResponse> {
+    return this.nymdQuerier.getAllNetworkDelegationsPaged(mixnetContractAddress, limit, startAfter);
+  }
+
+  getMixNodeDelegationsPaged(
+    mixnetContractAddress: string,
+    mixIdentity: string,
+    limit?: number,
+    startAfter?: string,
+  ): Promise<PagedMixDelegationsResponse> {
+    return this.nymdQuerier.getMixNodeDelegationsPaged(mixnetContractAddress, mixIdentity, limit, startAfter);
+  }
+
+  getDelegatorDelegationsPaged(
+    mixnetContractAddress: string,
+    delegator: string,
+    limit?: number,
+    startAfter?: string,
+  ): Promise<PagedDelegatorDelegationsResponse> {
+    return this.nymdQuerier.getDelegatorDelegationsPaged(mixnetContractAddress, delegator, limit, startAfter);
+  }
+
+  getDelegationDetails(mixnetContractAddress: string, mixIdentity: string, delegator: string): Promise<Delegation> {
+    return this.nymdQuerier.getDelegationDetails(mixnetContractAddress, mixIdentity, delegator);
+  }
+
+  getLayerDistribution(mixnetContractAddress: string): Promise<LayerDistribution> {
+    return this.nymdQuerier.getLayerDistribution(mixnetContractAddress);
+  }
+
+  getRewardPool(mixnetContractAddress: string): Promise<string> {
+    return this.nymdQuerier.getRewardPool(mixnetContractAddress);
+  }
+
+  getCirculatingSupply(mixnetContractAddress: string): Promise<string> {
+    return this.nymdQuerier.getCirculatingSupply(mixnetContractAddress);
+  }
+
+  getEpochRewardPercent(mixnetContractAddress: string): Promise<number> {
+    return this.nymdQuerier.getEpochRewardPercent(mixnetContractAddress);
+  }
+
+  getSybilResistancePercent(mixnetContractAddress: string): Promise<number> {
+    return this.nymdQuerier.getSybilResistancePercent(mixnetContractAddress);
+  }
+
+  getRewardingStatus(
+    mixnetContractAddress: string,
+    mixIdentity: string,
+    rewardingIntervalNonce: number,
+  ): Promise<RewardingStatus> {
+    return this.nymdQuerier.getRewardingStatus(mixnetContractAddress, mixIdentity, rewardingIntervalNonce);
+  }
+
+  getCachedGateways(): Promise<GatewayBond[]> {
+    return this.validatorApiQuerier.getCachedGateways();
+  }
+
+  getCachedMixnodes(): Promise<MixNodeBond[]> {
+    return this.validatorApiQuerier.getCachedMixnodes();
+  }
+
+  getActiveMixnodes(): Promise<MixNodeBond[]> {
+    return this.validatorApiQuerier.getActiveMixnodes();
+  }
+
+  getRewardedMixnodes(): Promise<MixNodeBond[]> {
+    return this.validatorApiQuerier.getRewardedMixnodes();
+  }
+
+  // signing related:
+
+  bondMixNode(
+    mixnetContractAddress: string,
+    mixNode: MixNode,
+    ownerSignature: string,
+    pledge: Coin,
+    fee: StdFee | 'auto' | number = 'auto',
+    memo = 'Default MixNode Bonding from Typescript',
+  ): Promise<ExecuteResult> {
+    return this.execute(
+      this.clientAddress,
+      mixnetContractAddress,
+      {
+        bond_mixnode: {
+          mix_node: mixNode,
+          owner_signature: ownerSignature,
+        },
+      },
+      fee,
+      memo,
+      [pledge],
+    );
+  }
+
+  unbondMixNode(
+    mixnetContractAddress: string,
+    fee: StdFee | 'auto' | number = 'auto',
+    memo = 'Default MixNode Unbonding from Typescript',
+  ): Promise<ExecuteResult> {
+    return this.execute(
+      this.clientAddress,
+      mixnetContractAddress,
+      {
+        unbond_mixnode: {},
+      },
+      fee,
+      memo,
+    );
+  }
+
+  bondGateway(
+    mixnetContractAddress: string,
+    gateway: Gateway,
+    ownerSignature: string,
+    pledge: Coin,
+    fee: StdFee | 'auto' | number = 'auto',
+    memo = 'Default Gateway Bonding from Typescript',
+  ): Promise<ExecuteResult> {
+    return this.execute(
+      this.clientAddress,
+      mixnetContractAddress,
+      {
+        bond_gateway: {
+          gateway,
+          owner_signature: ownerSignature,
+        },
+      },
+      fee,
+      memo,
+      [pledge],
+    );
+  }
+
+  unbondGateway(
+    mixnetContractAddress: string,
+    fee: StdFee | 'auto' | number = 'auto',
+    memo = 'Default Gateway Unbonding from Typescript',
+  ): Promise<ExecuteResult> {
+    return this.execute(
+      this.clientAddress,
+      mixnetContractAddress,
+      {
+        unbond_gateway: {},
+      },
+      fee,
+      memo,
+    );
+  }
+
+  delegateToMixNode(
+    mixnetContractAddress: string,
+    mixIdentity: string,
+    amount: Coin,
+    fee: StdFee | 'auto' | number = 'auto',
+    memo = 'Default MixNode Delegation from Typescript',
+  ): Promise<ExecuteResult> {
+    return this.execute(
+      this.clientAddress,
+      mixnetContractAddress,
+      {
+        delegate_to_mixnode: {
+          mix_identity: mixIdentity,
+        },
+      },
+      fee,
+      memo,
+      [amount],
+    );
+  }
+
+  undelegateFromMixNode(
+    mixnetContractAddress: string,
+    mixIdentity: string,
+    fee: StdFee | 'auto' | number = 'auto',
+    memo = 'Default MixNode Undelegation from Typescript',
+  ): Promise<ExecuteResult> {
+    return this.execute(
+      this.clientAddress,
+      mixnetContractAddress,
+      {
+        undelegate_from_mixnode: {
+          mix_identity: mixIdentity,
+        },
+      },
+      fee,
+      memo,
+    );
+  }
+
+  updateContractStateParams(
+    mixnetContractAddress: string,
+    newParams: ContractStateParams,
+    fee: StdFee | 'auto' | number = 'auto',
+    memo = 'Default Contract State Params Update from Typescript',
+  ): Promise<ExecuteResult> {
+    return this.execute(
+      this.clientAddress,
+      mixnetContractAddress,
+      {
+        update_contract_state_params: newParams,
+      },
+      fee,
+      memo,
+    );
+  }
+}

clients/validator/src/stargate-helper.ts

@@ -1,26 +1,14 @@
-import axios from "axios";
-import { GasLimits, GasPrice } from "@cosmjs/stargate";
-import { CosmWasmFeeTable, defaultGasLimits } from "@cosmjs/cosmwasm-stargate";
-
-export const nymGasLimits: GasLimits<CosmWasmFeeTable> = {
-    ...defaultGasLimits,
-    upload: 2_500_000,
-    init: 500_000,
-    migrate: 200_000,
-    exec: 250_000,
-    send: 80_000,
-    changeAdmin: 80_000,
-};
+import axios from 'axios';
+import { GasPrice } from '@cosmjs/stargate';
 
 export function nymGasPrice(prefix: string): GasPrice {
-    return GasPrice.fromString(`0.025u${prefix}`); // TODO: ideally this ugly conversion shouldn't be hardcoded here.
+  return GasPrice.fromString(`0.025u${prefix}`); // TODO: ideally this ugly conversion shouldn't be hardcoded here.
 }
 
 export const downloadWasm = async (url: string): Promise<Uint8Array> => {
-    const r = await axios.get(url, {responseType: "arraybuffer"});
-    if (r.status !== 200) {
-        throw new Error(`Download error: ${r.status}`);
-    }
-    return r.data;
+  const r = await axios.get(url, { responseType: 'arraybuffer' });
+  if (r.status !== 200) {
+    throw new Error(`Download error: ${r.status}`);
+  }
+  return r.data;
 };
-

clients/validator/src/types.ts

@@ -1,50 +1,162 @@
-import { Coin } from "@cosmjs/stargate";
+import { Coin } from '@cosmjs/stargate';
+
+// TODO: ideally we'd have re-exported those using that fancy crate that builds ts types from rust
+
+export type MixnetContractVersion = {
+  build_timestamp: string;
+  build_version: string;
+  commit_sha: string;
+  commit_timestamp: string;
+  commit_branch: string;
+  rustc_version: string;
+};
+
+export type PagedMixnodeResponse = {
+  nodes: MixNodeBond[];
+  per_page: number;
+  start_next_after?: string;
+};
+
+export type PagedGatewayResponse = {
+  nodes: GatewayBond[];
+  per_page: number;
+  start_next_after?: string;
+};
+
+export type MixOwnershipResponse = {
+  address: string;
+  mixnode?: MixNodeBond;
+};
+
+export type GatewayOwnershipResponse = {
+  address: string;
+  gateway?: GatewayBond;
+};
+
+export type ContractStateParams = {
+  // ideally I'd want to define those as `number` rather than `string`, but
+  // rust-side they are defined as Uint128 and that don't have
+  // native javascript representations and therefore are interpreted as strings after deserialization
+  minimum_mixnode_pledge: string;
+  minimum_gateway_pledge: string;
+  mixnode_rewarded_set_size: number;
+  mixnode_active_set_size: number;
+};
+
+export type RewardingIntervalResponse = {
+  current_rewarding_interval_starting_block: number;
+  current_rewarding_interval_nonce: number;
+  rewarding_in_progress: boolean;
+};
+
+export type LayerDistribution = {
+  gateways: number;
+  layer1: number;
+  layer2: number;
+  layer3: number;
+};
+
+export type Delegation = {
+  owner: string;
+  node_identity: string;
+  amount: Coin;
+  block_height: number;
+  proxy?: string;
+};
+
+export type PagedMixDelegationsResponse = {
+  delegations: Delegation[];
+  start_next_after?: string;
+};
+
+export type PagedDelegatorDelegationsResponse = {
+  delegations: Delegation[];
+  start_next_after?: string;
+};
+
+export type PagedAllDelegationsResponse = {
+  delegations: Delegation[];
+  start_next_after?: [string, string];
+};
+
+export type RewardingResult = {
+  operator_reward: string;
+  total_delegator_reward: string;
+};
+
+export type NodeRewardParams = {
+  period_reward_pool: string;
+  k: string;
+  reward_blockstamp: number;
+  circulating_supply: string;
+  uptime: string;
+  sybil_resistance_percent: number;
+};
+
+export type DelegatorRewardParams = {
+  node_reward_params: NodeRewardParams;
+  sigma: number;
+  profit_margin: number;
+  node_profit: number;
+};
+
+export type PendingDelegatorRewarding = {
+  running_results: RewardingResult;
+  next_start: string;
+  rewarding_params: DelegatorRewardParams;
+};
+
+export type RewardingStatus = { Complete: RewardingResult } | { PendingNextDelegatorPage: PendingDelegatorRewarding };
+
+export type MixnodeRewardingStatusResponse = {
+  status?: RewardingStatus;
+};
 
 export enum Layer {
-    Gateway,
-    One,
-    Two,
-    Three,
+  Gateway,
+  One,
+  Two,
+  Three,
 }
 
-export type MixNodeBond = { // TODO: change name to MixNodeBond
-    owner: string,
-    mix_node: MixNode,    // TODO: camelCase this later once everything else works
-    layer: Layer,
-    bond_amount: Coin,
-    total_delegation: Coin,
-}
+export type MixNodeBond = {
+  owner: string;
+  mix_node: MixNode;
+  layer: Layer;
+  bond_amount: Coin;
+  total_delegation: Coin;
+};
 
 export type MixNode = {
-    host: string,
-    mix_port: number,
-    verloc_port: number,
-    http_api_port: number,
-    sphinx_key: string, // TODO: camelCase this later once everything else works
-    identity_key: string,
-    version: string,
-}
+  host: string;
+  mix_port: number;
+  verloc_port: number;
+  http_api_port: number;
+  sphinx_key: string;
+  identity_key: string;
+  version: string;
+};
 
 export type GatewayBond = {
-    owner: string
-    gateway: Gateway,
-    
-    bond_amount: Coin,
-    total_delegation: Coin,
-}
+  owner: string;
+  gateway: Gateway;
+
+  bond_amount: Coin;
+  total_delegation: Coin;
+};
 
 export type Gateway = {
-    host: string,
-    mix_port: number,
-    clients_port: number,
-    location: string,
-    sphinx_key: string,
-    identity_key: string,
-    version: string
-}
+  host: string;
+  mix_port: number;
+  clients_port: number;
+  location: string;
+  sphinx_key: string;
+  identity_key: string;
+  version: string;
+};
 
 export type SendRequest = {
-    senderAddress: string,
-    recipientAddress: string,
-    transferAmount: readonly Coin[]
-}
+  senderAddress: string;
+  recipientAddress: string;
+  transferAmount: readonly Coin[];
+};

clients/validator/src/utils.ts

@@ -1,14 +1,18 @@
 // eslint-disable-next-line @typescript-eslint/no-explicit-any,@typescript-eslint/explicit-module-boundary-types
-import { Coin } from "@cosmjs/stargate";
-import { EncodeObject } from "@cosmjs/proto-signing";
+import { Coin } from '@cosmjs/stargate';
+import { EncodeObject } from '@cosmjs/proto-signing';
 
-export function makeBankMsgSend(senderAddress: string, recipientAddress: string, transferAmount: readonly Coin[]): EncodeObject {
-    return {
-        typeUrl: "/cosmos.bank.v1beta1.MsgSend",
-        value: {
-            fromAddress: senderAddress,
-            toAddress: recipientAddress,
-            amount: transferAmount,
-        },
-    };
-}
+export function makeBankMsgSend(
+  senderAddress: string,
+  recipientAddress: string,
+  transferAmount: readonly Coin[],
+): EncodeObject {
+  return {
+    typeUrl: '/cosmos.bank.v1beta1.MsgSend',
+    value: {
+      fromAddress: senderAddress,
+      toAddress: recipientAddress,
+      amount: transferAmount,
+    },
+  };
+}

clients/validator/src/validator-api-querier.ts

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import axios from 'axios';
+import { GatewayBond, MixNodeBond } from './types';
+
+export const VALIDATOR_API_VERSION = '/v1';
+export const VALIDATOR_API_GATEWAYS_PATH = `${VALIDATOR_API_VERSION}/gateways`;
+export const VALIDATOR_API_MIXNODES_PATH = `${VALIDATOR_API_VERSION}/mixnodes`;
+export const VALIDATOR_API_ACTIVE_MIXNODES_PATH = `${VALIDATOR_API_VERSION}/mixnodes/active`;
+export const VALIDATOR_API_REWARDED_MIXNODES_PATH = `${VALIDATOR_API_VERSION}/mixnodes/rewarded`;
+
+export interface IValidatorApiQuery {
+  getCachedMixnodes(): Promise<MixNodeBond[]>;
+
+  getCachedGateways(): Promise<GatewayBond[]>;
+
+  getActiveMixnodes(): Promise<MixNodeBond[]>;
+
+  getRewardedMixnodes(): Promise<MixNodeBond[]>;
+}
+
+export default class ValidatorApiQuerier implements IValidatorApiQuery {
+  validatorApiUrl: string;
+
+  constructor(validatorApiUrl: string) {
+    this.validatorApiUrl = validatorApiUrl;
+  }
+
+  async getCachedMixnodes(): Promise<MixNodeBond[]> {
+    const url = new URL(this.validatorApiUrl);
+    url.pathname += VALIDATOR_API_MIXNODES_PATH;
+
+    const response = await axios.get(url.toString());
+    if (response.status === 200) {
+      return response.data;
+    }
+    throw new Error('None of the provided validator APIs seem to be alive');
+  }
+
+  async getCachedGateways(): Promise<GatewayBond[]> {
+    const url = new URL(this.validatorApiUrl);
+    url.pathname += VALIDATOR_API_GATEWAYS_PATH;
+
+    const response = await axios.get(url.toString());
+    if (response.status === 200) {
+      return response.data;
+    }
+    throw new Error('None of the provided validator APIs seem to be alive');
+  }
+
+  async getActiveMixnodes(): Promise<MixNodeBond[]> {
+    const url = new URL(this.validatorApiUrl);
+    url.pathname += VALIDATOR_API_ACTIVE_MIXNODES_PATH;
+
+    const response = await axios.get(url.toString());
+    if (response.status === 200) {
+      return response.data;
+    }
+    throw new Error('None of the provided validator APIs seem to be alive');
+  }
+
+  async getRewardedMixnodes(): Promise<MixNodeBond[]> {
+    const url = new URL(this.validatorApiUrl);
+    url.pathname += VALIDATOR_API_REWARDED_MIXNODES_PATH;
+
+    const response = await axios.get(url.toString());
+    if (response.status === 200) {
+      return response.data;
+    }
+    throw new Error('None of the provided validator APIs seem to be alive');
+  }
+}

clients/validator/tests/caches/gateways.test.ts

@@ -1,100 +0,0 @@
-import { assert } from "chai";
-import INetClient from "../../src/net-client";
-import { Fixtures } from "../fixtures"
-import { Mock, Times } from "moq.ts";
-import GatewaysCache from "../../src/caches/gateways";
-
-describe("Caching gateways: when the validator returns", () => {
-    context("an empty list", () => {
-        it("Should return an empty list", async () => {
-            const perPage = 100;
-            const contractAddress = "mockContractAddress";
-            const emptyPromise = Promise.resolve(Fixtures.GatewaysResp.empty());
-            const mockClient = new Mock<INetClient>().setup(netClient => netClient.getGateways(contractAddress, perPage, undefined)).returns(emptyPromise);
-            const cache = new GatewaysCache(mockClient.object(), perPage);
-
-            await cache.refreshGateways(contractAddress);
-
-            mockClient.verify(netClient => netClient.getGateways(contractAddress, perPage, undefined), Times.Exactly(1));
-            assert.deepEqual([], cache.gateways);
-        });
-    })
-
-    context("a list of gatways that fits in a page", () => {
-        it("Should return that one page list", async () => {
-            const perPage = 2;
-            const contractAddress = "mockContractAddress";
-            const onePagePromise = Promise.resolve(Fixtures.GatewaysResp.onePage());
-            const mockClient = new Mock<INetClient>().setup(netClient => netClient.getGateways(contractAddress, perPage, undefined)).returns(onePagePromise);
-            const cache = new GatewaysCache(mockClient.object(), perPage);
-
-            await cache.refreshGateways(contractAddress);
-
-            mockClient.verify(netClient => netClient.getGateways(contractAddress, perPage, undefined), Times.Exactly(1));
-            assert.deepEqual(Fixtures.Gateways.list2(), cache.gateways);
-        })
-    })
-
-    context("a list of gateways that is longer than one page", () => {
-        it("Should return the full list assembled from all pages", async () => {
-            const perPage = 2; // we get back 2 per page
-            const contractAddress = "mockContractAddress";
-            const fullPageResult = Fixtures.GatewaysResp.page1of2();
-            const halfPageResult = Fixtures.GatewaysResp.halfPage2of2();
-            const mockClient = new Mock<INetClient>()
-            mockClient.setup(instance => instance.getGateways(contractAddress, perPage, undefined)).returns(Promise.resolve(fullPageResult));
-            mockClient.setup(instance => instance.getGateways(contractAddress, perPage, fullPageResult.start_next_after)).returns(Promise.resolve(halfPageResult));
-            const cache = new GatewaysCache(mockClient.object(), perPage);
-
-            await cache.refreshGateways(contractAddress); // should make multiple paginated requests because there are two pages in the response fixture
-            mockClient.verify(instance => instance.getGateways(contractAddress, perPage, undefined), Times.Exactly(1));
-            mockClient.verify(instance => instance.getGateways(contractAddress, perPage, fullPageResult.start_next_after), Times.Exactly(1));
-
-            assert.deepEqual(Fixtures.Gateways.list3(), cache.gateways); // there are a total of 3 nodes in the validator lists, we get them all back
-        })
-    })
-
-    context("a list of gateways that is two filled pages", () => {
-        it("Should return the full list assembled from all pages", async () => {
-            const perPage = 2; // we get back 2 per page
-            const contractAddress = "mockContractAddress";
-            const fullPageResult1 = Fixtures.GatewaysResp.page1of2();
-            const fullPageResult2 = Fixtures.GatewaysResp.fullPage2of2();
-            const mockClient = new Mock<INetClient>()
-            mockClient.setup(netClient => netClient.getGateways(contractAddress, perPage, undefined)).returns(Promise.resolve(fullPageResult1));
-            mockClient.setup(netClient => netClient.getGateways(contractAddress, perPage, fullPageResult1.start_next_after)).returns(Promise.resolve(fullPageResult2));
-
-            const cache = new GatewaysCache(mockClient.object(), perPage);
-
-            await cache.refreshGateways(contractAddress); // should make multiple paginated requests because there are two pages in the response fixture
-            mockClient.verify(netClient => netClient.getGateways(contractAddress, perPage, undefined), Times.Exactly(1));
-            mockClient.verify(netClient => netClient.getGateways(contractAddress, perPage, fullPageResult1.start_next_after), Times.Exactly(1));
-
-            assert.deepEqual(Fixtures.Gateways.list4(), cache.gateways); // there are a total of 3 nodes in the validator lists, we get them all back
-        })
-    })
-
-    context("refreshing the cache twice", () => {
-        it("returns one full list assembled from all pages", async () => {
-            const perPage = 2; // we get back 2 per page
-            const contractAddress = "mockContractAddress";
-            const fullPageResult1 = Fixtures.GatewaysResp.page1of2();
-            const fullPageResult2 = Fixtures.GatewaysResp.fullPage2of2();
-            const mockClient = new Mock<INetClient>()
-            mockClient.setup(netClient => netClient.getGateways(contractAddress, perPage, undefined)).returns(Promise.resolve(fullPageResult1));
-            mockClient.setup(netClient => netClient.getGateways(contractAddress, perPage, fullPageResult1.start_next_after)).returns(Promise.resolve(fullPageResult2));
-
-            const cache = new GatewaysCache(mockClient.object(), perPage);
-
-            await cache.refreshGateways(contractAddress); // should make multiple paginated requests because there are two pages in the response fixture
-            mockClient.verify(netClient => netClient.getGateways(contractAddress, perPage, undefined), Times.Exactly(1));
-            mockClient.verify(netClient => netClient.getGateways(contractAddress, perPage, fullPageResult1.start_next_after), Times.Exactly(1));
-
-            await cache.refreshGateways(contractAddress);
-            mockClient.verify(netClient => netClient.getGateways(contractAddress, perPage, undefined), Times.Exactly(2));
-            mockClient.verify(netClient => netClient.getGateways(contractAddress, perPage, fullPageResult1.start_next_after), Times.Exactly(2));
-
-            assert.deepEqual(Fixtures.Gateways.list4(), cache.gateways); // there are a total of 3 nodes in the validator lists, we get them all back
-        })
-    })
-});

clients/validator/tests/caches/mixnodes.test.ts

@@ -1,96 +0,0 @@
-import { assert } from "chai";
-import INetClient from "../../src/net-client";
-import { Fixtures } from "../fixtures"
-import { Mock, Times } from "moq.ts";
-import { MixnodesCache } from "../../src/caches/mixnodes"
-
-describe("Caching mixnodes: when the validator returns", () => {
-    context("an empty list", () => {
-        it("Should return an empty list", async () => {
-            const perPage = 100;
-            const contractAddress = "mockContractAddress";
-            const emptyPromise = Promise.resolve(Fixtures.MixNodesResp.empty());
-            const mockClient = new Mock<INetClient>().setup(netClient => netClient.getMixNodes(contractAddress, perPage, undefined)).returns(emptyPromise);
-            const cache = new MixnodesCache(mockClient.object(), perPage);
-
-            await cache.refreshMixNodes(contractAddress);
-
-            mockClient.verify(netClient => netClient.getMixNodes(contractAddress, perPage, undefined), Times.Exactly(1));
-            assert.deepEqual([], cache.mixNodes);
-        });
-    })
-    context("a list of nodes that fits in a page", () => {
-        it("Should return that one page list", async () => {
-            const perPage = 2;
-            const contractAddress = "mockContractAddress";
-            const onePagePromise = Promise.resolve(Fixtures.MixNodesResp.onePage());
-            const mockClient = new Mock<INetClient>().setup(netClient => netClient.getMixNodes(contractAddress, perPage, undefined)).returns(onePagePromise);
-            const cache = new MixnodesCache(mockClient.object(), perPage);
-
-            await cache.refreshMixNodes(contractAddress);
-
-            mockClient.verify(netClient => netClient.getMixNodes(contractAddress, perPage, undefined), Times.Exactly(1));
-            assert.deepEqual(Fixtures.MixNodes.list2(), cache.mixNodes);
-        })
-    })
-
-    context("a list of nodes that is longer than one page", () => {
-        it("Should return the full list assembled from all pages", async () => {
-            const perPage = 2; // we get back 2 per page
-            const contractAddress = "mockContractAddress";
-            const fullPageResult = Fixtures.MixNodesResp.page1of2();
-            const halfPageResult = Fixtures.MixNodesResp.halfPage2of2();
-            const mockClient = new Mock<INetClient>()
-            mockClient.setup(instance => instance.getMixNodes(contractAddress, perPage, undefined)).returns(Promise.resolve(fullPageResult));
-            mockClient.setup(instance => instance.getMixNodes(contractAddress, perPage, fullPageResult.start_next_after)).returns(Promise.resolve(halfPageResult));
-            const cache = new MixnodesCache(mockClient.object(), perPage);
-
-            await cache.refreshMixNodes(contractAddress); // should make multiple paginated requests because there are two pages in the response fixture
-            mockClient.verify(instance => instance.getMixNodes(contractAddress, perPage, undefined), Times.Exactly(1));
-            mockClient.verify(instance => instance.getMixNodes(contractAddress, perPage, fullPageResult.start_next_after), Times.Exactly(1));
-
-            assert.deepEqual(Fixtures.MixNodes.list3(), cache.mixNodes); // there are a total of 3 nodes in the validator lists, we get them all back
-        })
-    })
-
-    context("a list of nodes that is two filled pages", () => {
-        it("Should return the full list assembled from all pages", async () => {
-            const perPage = 2; // we get back 2 per page
-            const contractAddress = "mockContractAddress";
-            const fullPageResult1 = Fixtures.MixNodesResp.page1of2();
-            const fullPageResult2 = Fixtures.MixNodesResp.fullPage2of2();
-            const mockClient = new Mock<INetClient>()
-            mockClient.setup(netClient => netClient.getMixNodes(contractAddress, perPage, undefined)).returns(Promise.resolve(fullPageResult1));
-            mockClient.setup(netClient => netClient.getMixNodes(contractAddress, perPage, fullPageResult1.start_next_after)).returns(Promise.resolve(fullPageResult2));
-
-            const cache = new MixnodesCache(mockClient.object(), perPage);
-
-            await cache.refreshMixNodes(contractAddress); // should make multiple paginated requests because there are two pages in the response fixture
-            mockClient.verify(netClient => netClient.getMixNodes(contractAddress, perPage, undefined), Times.Exactly(1));
-            mockClient.verify(netClient => netClient.getMixNodes(contractAddress, perPage, fullPageResult1.start_next_after), Times.Exactly(1));
-
-            assert.deepEqual(Fixtures.MixNodes.list4(), cache.mixNodes); // there are a total of 3 nodes in the validator lists, we get them all back
-        })
-    })
-
-    context("refreshing the cache twice", () => {
-        it("returns one full list assembled from all pages", async () => {
-            const perPage = 2; // we get back 2 per page
-            const contractAddress = "mockContractAddress";
-            const fullPageResult1 = Fixtures.MixNodesResp.page1of2();
-            const fullPageResult2 = Fixtures.MixNodesResp.fullPage2of2();
-            const mockClient = new Mock<INetClient>()
-            mockClient.setup(netClient => netClient.getMixNodes(contractAddress, perPage, undefined)).returns(Promise.resolve(fullPageResult1));
-            mockClient.setup(netClient => netClient.getMixNodes(contractAddress, perPage, fullPageResult1.start_next_after)).returns(Promise.resolve(fullPageResult2));
-
-            const cache = new MixnodesCache(mockClient.object(), perPage);
-
-            await cache.refreshMixNodes(contractAddress); // should make multiple paginated requests because there are two pages in the response fixture
-            await cache.refreshMixNodes(contractAddress);
-            // mockClient.verify(netClient => netClient.getMixNodes(contractAddress, perPage, undefined), Times.Exactly(1));
-            // mockClient.verify(netClient => netClient.getMixNodes(contractAddress, perPage, fullPageResult1.start_next_after), Times.Exactly(1));
-
-            assert.deepEqual(Fixtures.MixNodes.list4(), cache.mixNodes); // there are a total of 3 nodes in the validator lists, we get them all back
-        })
-    })
-});

clients/validator/tests/fixtures.ts

@@ -1,156 +0,0 @@
-import { coins } from "@cosmjs/launchpad";
-import {PagedGatewayResponse, PagedMixnodeResponse} from "../src/net-client";
-import {GatewayBond, MixNodeBond} from "../src/types"
-
-export namespace Fixtures {
-    export class MixNodes {
-        static single(): MixNodeBond {
-            return {
-                amount: coins(666, "unym"),
-                owner: "bob",
-                mix_node: {
-                    host: "1.1.1.1",
-                    layer: 1,
-                    location: "London, UK",
-                    sphinx_key: "foo",
-                    version: "0.10.0",
-                }
-            };
-        }
-
-        static list1(): MixNodeBond[] {
-            return [MixNodes.single()]
-        }
-
-        static list2(): MixNodeBond[] {
-            return [MixNodes.single(), MixNodes.single()]
-        }
-
-        static list3(): MixNodeBond[] {
-            return [MixNodes.single(), MixNodes.single(), MixNodes.single()]
-        }
-
-        static list4(): MixNodeBond[] {
-            return [MixNodes.single(), MixNodes.single(), MixNodes.single(), MixNodes.single()]
-        }
-    }
-
-    export class MixNodesResp {
-        static empty(): PagedResponse {
-            return {
-                nodes: [],
-                per_page: 2,
-                start_next_after: null,
-            }
-        }
-
-        static onePage(): PagedResponse {
-            return {
-                nodes: MixNodes.list2(),
-                per_page: 2,
-                start_next_after: null
-            }
-        }
-
-        static page1of2(): PagedResponse {
-            return {
-                nodes: MixNodes.list2(),
-                per_page: 2,
-                start_next_after: "2"
-            }
-        }
-
-        static halfPage2of2(): PagedResponse {
-            return {
-                nodes: MixNodes.list1(),
-                per_page: 2,
-                start_next_after: null
-
-            }
-        }
-
-        static fullPage2of2(): PagedResponse {
-            return {
-                nodes: MixNodes.list2(),
-                per_page: 2,
-                start_next_after: null,
-            }
-        }
-    }
-
-    export class Gateways {
-        static single(): GatewayBond {
-            return {
-                amount: coins(666, "unym"),
-                owner: "bob",
-                gateway: {
-                    mix_host: "1.1.1.1:1234",
-                    clients_host: "ws://1.1.1.1:1235",
-                    location: "London, UK",
-                    identity_key: "bar",
-                    sphinx_key: "foo",
-                    version: "0.10.0",
-                }
-            };
-        }
-
-        static list1(): GatewayBond[] {
-            return [Gateways.single()]
-        }
-
-        static list2(): GatewayBond[] {
-            return [Gateways.single(), Gateways.single()]
-        }
-
-        static list3(): GatewayBond[] {
-            return [Gateways.single(), Gateways.single(), Gateways.single()]
-        }
-
-        static list4(): GatewayBond[] {
-            return [Gateways.single(), Gateways.single(), Gateways.single(), Gateways.single()]
-        }
-    }
-
-    export class GatewaysResp {
-        static empty(): PagedGatewayResponse {
-            return {
-                nodes: [],
-                per_page: 2,
-                start_next_after: "",
-            }
-        }
-
-        static onePage(): PagedGatewayResponse {
-            return {
-                nodes: Gateways.list2(),
-                per_page: 2,
-                start_next_after: "",
-            }
-        }
-
-        static page1of2(): PagedGatewayResponse {
-            return {
-                nodes: Gateways.list2(),
-                per_page: 2,
-                start_next_after: "2"
-            }
-        }
-
-        static halfPage2of2(): PagedGatewayResponse {
-            return {
-                nodes: Gateways.list1(),
-                per_page: 2,
-                start_next_after: "",
-
-            }
-        }
-
-        static fullPage2of2(): PagedGatewayResponse {
-            return {
-                nodes: Gateways.list2(),
-                per_page: 2,
-                start_next_after: "",
-            }
-        }
-    }
-}

clients/webassembly/Cargo.toml

@@ -7,6 +7,7 @@ keywords = ["nym", "sphinx", "wasm", "webassembly", "privacy", "client"]
 license = "Apache-2.0"
 repository = "https://github.com/nymtech/nym"
 description = "A webassembly client which can be used to interact with the the Nym privacy platform. Wasm is used for Sphinx packet generation."
+rust-version = "1.56"
 
 [lib]
 crate-type = ["cdylib", "rlib"]
@@ -14,6 +15,7 @@ crate-type = ["cdylib", "rlib"]
 [features]
 default = ["console_error_panic_hook"]
 offline-test = []
+coconut = ["coconut-interface", "credentials", "gateway-client/coconut"]
 
 [dependencies]
 futures = "0.3"
@@ -25,8 +27,8 @@ rand = { version = "0.7.3", features = ["wasm-bindgen"] }
 url = "2.2"
 
 # internal
-coconut-interface = { path = "../../common/coconut-interface" }
-credentials = { path = "../../common/credentials" }
+coconut-interface = { path = "../../common/coconut-interface", optional = true }
+credentials = { path = "../../common/credentials", optional = true }
 crypto = { path = "../../common/crypto" }
 nymsphinx = { path = "../../common/nymsphinx" }
 topology = { path = "../../common/topology" }

clients/webassembly/src/client/mod.rs

@@ -1,11 +1,9 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use coconut_interface::Credential;
-use credentials::bandwidth::prepare_for_spending;
-use credentials::obtain_aggregate_verification_key;
 use crypto::asymmetric::{encryption, identity};
 use futures::channel::mpsc;
+use gateway_client::bandwidth::BandwidthController;
 use gateway_client::GatewayClient;
 use nymsphinx::acknowledgements::AckKey;
 use nymsphinx::addressing::clients::Recipient;
@@ -101,35 +99,22 @@ impl NymClient {
         self.self_recipient().to_string()
     }
 
-    async fn prepare_credential(validators: &[Url], identity_bytes: &[u8]) -> Credential {
-        let verification_key = obtain_aggregate_verification_key(validators)
-            .await
-            .expect("could not obtain aggregate verification key of validators");
-
-        let bandwidth_credential =
-            credentials::bandwidth::obtain_signature(identity_bytes, validators)
-                .await
-                .expect("could not obtain bandwidth credential");
-        // the above would presumably be loaded from a file
-
-        // the below would only be executed once we know where we want to spend it (i.e. which gateway and stuff)
-        prepare_for_spending(identity_bytes, &bandwidth_credential, &verification_key)
-            .expect("could not prepare out bandwidth credential for spending")
-    }
-
     // Right now it's impossible to have async exported functions to take `&self` rather than self
     pub async fn initial_setup(self) -> Self {
-        let validator_server = self.validator_server.clone();
-        let identity_public_key = self.identity.public_key().clone();
+        #[cfg(feature = "coconut")]
+        let bandwidth_controller = Some(BandwidthController::new(
+            vec![self.validator_server.clone()],
+            *self.identity.public_key(),
+        ));
+        #[cfg(not(feature = "coconut"))]
+        let bandwidth_controller = None;
+
         let mut client = self.get_and_update_topology().await;
         let gateway = client.choose_gateway();
 
         let (mixnet_messages_sender, mixnet_messages_receiver) = mpsc::unbounded();
         let (ack_sender, ack_receiver) = mpsc::unbounded();
 
-        let coconut_credential =
-            Self::prepare_credential(&vec![validator_server], &identity_public_key.to_bytes())
-                .await;
         let mut gateway_client = GatewayClient::new(
             gateway.clients_address(),
             Arc::clone(&client.identity),
@@ -138,7 +123,7 @@ impl NymClient {
             mixnet_messages_sender,
             ack_sender,
             DEFAULT_GATEWAY_RESPONSE_TIMEOUT,
-            coconut_credential,
+            bandwidth_controller,
         );
 
         gateway_client
@@ -263,8 +248,8 @@ impl NymClient {
     pub(crate) async fn get_nym_topology(&self) -> NymTopology {
         let validator_client = validator_client::ApiClient::new(self.validator_server.clone());
 
-        let mixnodes = match validator_client.get_cached_mixnodes().await {
-            Err(err) => panic!("{}", err),
+        let mixnodes = match validator_client.get_cached_active_mixnodes().await {
+            Err(err) => panic!("{:?}", err),
             Ok(mixes) => mixes,
         };
 

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

@@ -10,14 +10,19 @@ edition = "2018"
 # TODO: (for this and other crates), similarly to 'tokio', import only required "futures" modules rather than
 # the entire crate
 futures = "0.3"
+json = "0.12.4"
 log = "0.4"
+thiserror = "1.0"
+url = "2.2"
 rand = { version = "0.7.3", features = ["wasm-bindgen"] }
 
 # internal
+credentials = { path = "../../credentials" }
 crypto = { path = "../../crypto" }
 gateway-requests = { path = "../../../gateway/gateway-requests" }
 nymsphinx = { path = "../../nymsphinx" }
-coconut-interface = { path = "../../coconut-interface" }
+coconut-interface = { path = "../../coconut-interface", optional = true }
+network-defaults = { path = "../../network-defaults" }
 
 [dependencies.tungstenite]
 version = "0.13"
@@ -31,6 +36,12 @@ features = ["macros", "rt", "net", "sync", "time"]
 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio-tungstenite]
 version = "0.14"
 
+[target."cfg(not(target_arch = \"wasm32\"))".dependencies.secp256k1]
+version = "0.20.3"
+
+[target."cfg(not(target_arch = \"wasm32\"))".dependencies.web3]
+version = "0.17.0"
+
 # wasm-only dependencies
 [target."cfg(target_arch = \"wasm32\")".dependencies.wasm-bindgen]
 version = "0.2"
@@ -57,3 +68,6 @@ features = ["js"]
 [dev-dependencies]
 # for tests
 #url = "2.1"
+
+[features]
+coconut = ["gateway-requests/coconut", "coconut-interface"]

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

@@ -0,0 +1,247 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+#[cfg(feature = "coconut")]
+use credentials::coconut::{
+    bandwidth::{
+        obtain_signature, prepare_for_spending, BandwidthVoucherAttributes, TOTAL_ATTRIBUTES,
+    },
+    utils::obtain_aggregate_verification_key,
+};
+#[cfg(not(feature = "coconut"))]
+use credentials::token::bandwidth::TokenCredential;
+#[cfg(not(feature = "coconut"))]
+use crypto::asymmetric::identity;
+use crypto::asymmetric::identity::PublicKey;
+use network_defaults::BANDWIDTH_VALUE;
+#[cfg(not(feature = "coconut"))]
+use network_defaults::{
+    eth_contract::ETH_JSON_ABI, ETH_BURN_FUNCTION_NAME, ETH_CONTRACT_ADDRESS, ETH_MIN_BLOCK_DEPTH,
+    TOKENS_TO_BURN,
+};
+#[cfg(not(feature = "coconut"))]
+use rand::rngs::OsRng;
+#[cfg(not(feature = "coconut"))]
+use secp256k1::SecretKey;
+#[cfg(not(feature = "coconut"))]
+use std::io::Write;
+#[cfg(not(feature = "coconut"))]
+use std::str::FromStr;
+#[cfg(not(feature = "coconut"))]
+use web3::{
+    contract::{Contract, Options},
+    transports::Http,
+    types::{Address, Bytes, U256, U64},
+    Web3,
+};
+
+use crate::error::GatewayClientError;
+
+#[cfg(not(feature = "coconut"))]
+pub fn eth_contract(web3: Web3<Http>) -> Contract<Http> {
+    Contract::from_json(
+        web3.eth(),
+        Address::from(ETH_CONTRACT_ADDRESS),
+        json::parse(ETH_JSON_ABI)
+            .expect("Invalid json abi")
+            .dump()
+            .as_bytes(),
+    )
+    .expect("Invalid json abi")
+}
+
+#[derive(Clone)]
+pub struct BandwidthController {
+    #[cfg(feature = "coconut")]
+    validator_endpoints: Vec<url::Url>,
+    #[cfg(feature = "coconut")]
+    identity: PublicKey,
+    #[cfg(not(feature = "coconut"))]
+    contract: Contract<Http>,
+    #[cfg(not(feature = "coconut"))]
+    eth_private_key: SecretKey,
+    #[cfg(not(feature = "coconut"))]
+    backup_bandwidth_token_keys_dir: std::path::PathBuf,
+}
+
+impl BandwidthController {
+    #[cfg(feature = "coconut")]
+    pub fn new(validator_endpoints: Vec<url::Url>, identity: PublicKey) -> Self {
+        BandwidthController {
+            validator_endpoints,
+            identity,
+        }
+    }
+
+    #[cfg(not(feature = "coconut"))]
+    pub fn new(
+        eth_endpoint: String,
+        eth_private_key: String,
+        backup_bandwidth_token_keys_dir: std::path::PathBuf,
+    ) -> Result<Self, GatewayClientError> {
+        // Fail early, on invalid url
+        let transport =
+            Http::new(&eth_endpoint).map_err(|_| GatewayClientError::InvalidURL(eth_endpoint))?;
+        let web3 = web3::Web3::new(transport);
+        // Fail early, on invalid abi
+        let contract = eth_contract(web3);
+        let eth_private_key = secp256k1::SecretKey::from_str(&eth_private_key)
+            .map_err(|_| GatewayClientError::InvalidEthereumPrivateKey)?;
+
+        Ok(BandwidthController {
+            contract,
+            eth_private_key,
+            backup_bandwidth_token_keys_dir,
+        })
+    }
+
+    #[cfg(not(feature = "coconut"))]
+    fn backup_keypair(&self, keypair: &identity::KeyPair) -> Result<(), GatewayClientError> {
+        std::fs::create_dir_all(&self.backup_bandwidth_token_keys_dir)?;
+        let file_path = self
+            .backup_bandwidth_token_keys_dir
+            .join(keypair.public_key().to_base58_string());
+        let mut file = std::fs::File::create(file_path)?;
+        file.write_all(&keypair.private_key().to_bytes())?;
+
+        Ok(())
+    }
+
+    #[cfg(feature = "coconut")]
+    pub async fn prepare_coconut_credential(
+        &self,
+    ) -> Result<coconut_interface::Credential, GatewayClientError> {
+        let verification_key = obtain_aggregate_verification_key(&self.validator_endpoints).await?;
+        let params = coconut_interface::Parameters::new(TOTAL_ATTRIBUTES).unwrap();
+
+        // TODO: Decide what is the value and additional info associated with the bandwidth voucher
+        let bandwidth_credential_attributes = BandwidthVoucherAttributes {
+            serial_number: params.random_scalar(),
+            binding_number: params.random_scalar(),
+            voucher_value: coconut_interface::hash_to_scalar(BANDWIDTH_VALUE.to_be_bytes()),
+            voucher_info: coconut_interface::hash_to_scalar(
+                String::from("BandwidthVoucher").as_bytes(),
+            ),
+        };
+
+        let bandwidth_credential = obtain_signature(
+            &params,
+            &bandwidth_credential_attributes,
+            &self.validator_endpoints,
+        )
+        .await?;
+        // the above would presumably be loaded from a file
+
+        // the below would only be executed once we know where we want to spend it (i.e. which gateway and stuff)
+        Ok(prepare_for_spending(
+            &self.identity.to_bytes(),
+            &bandwidth_credential,
+            &bandwidth_credential_attributes,
+            &verification_key,
+        )?)
+    }
+
+    #[cfg(not(feature = "coconut"))]
+    pub async fn prepare_token_credential(
+        &self,
+        gateway_identity: PublicKey,
+    ) -> Result<TokenCredential, GatewayClientError> {
+        let mut rng = OsRng;
+
+        let kp = identity::KeyPair::new(&mut rng);
+        self.backup_keypair(&kp)?;
+
+        let verification_key = *kp.public_key();
+        let signed_verification_key = kp.private_key().sign(&verification_key.to_bytes());
+        self.buy_token_credential(verification_key, signed_verification_key)
+            .await?;
+
+        let message: Vec<u8> = verification_key
+            .to_bytes()
+            .iter()
+            .chain(gateway_identity.to_bytes().iter())
+            .copied()
+            .collect();
+        let signature = kp.private_key().sign(&message);
+
+        Ok(TokenCredential::new(
+            verification_key,
+            gateway_identity,
+            BANDWIDTH_VALUE,
+            signature,
+        ))
+    }
+
+    #[cfg(not(feature = "coconut"))]
+    pub async fn buy_token_credential(
+        &self,
+        verification_key: PublicKey,
+        signed_verification_key: identity::Signature,
+    ) -> Result<(), GatewayClientError> {
+        // 0 means a transaction failure, 1 means success
+        let confirmations = if cfg!(debug_assertions) {
+            1
+        } else {
+            ETH_MIN_BLOCK_DEPTH
+        };
+        // 15 seconds per confirmation block + 10 seconds of network overhead
+        log::info!(
+            "Waiting for Ethereum transaction. This should take about {} seconds",
+            confirmations * 15 + 10
+        );
+        let recipt = self
+            .contract
+            .signed_call_with_confirmations(
+                ETH_BURN_FUNCTION_NAME,
+                (
+                    U256::from(TOKENS_TO_BURN),
+                    U256::from(&verification_key.to_bytes()),
+                    Bytes(signed_verification_key.to_bytes().to_vec()),
+                ),
+                Options::default(),
+                confirmations,
+                &self.eth_private_key,
+            )
+            .await?;
+        if Some(U64::from(0)) == recipt.status {
+            Err(GatewayClientError::BurnTokenError(
+                web3::Error::InvalidResponse(format!(
+                    "Transaction status is 0 (failure): {:?}",
+                    recipt.logs,
+                )),
+            ))
+        } else {
+            log::info!(
+                "Bought bandwidth on Ethereum: {} MB",
+                BANDWIDTH_VALUE / 1024 / 1024
+            );
+            Ok(())
+        }
+    }
+}
+
+#[cfg(not(feature = "coconut"))]
+#[cfg(test)]
+mod tests {
+    use network_defaults::ETH_EVENT_NAME;
+
+    use super::*;
+
+    #[test]
+    fn parse_contract() {
+        let transport =
+            Http::new("https://rinkeby.infura.io/v3/00000000000000000000000000000000").unwrap();
+        let web3 = web3::Web3::new(transport);
+        // test no panic occurs
+        eth_contract(web3);
+    }
+
+    #[test]
+    fn check_event_name_constant_against_abi() {
+        let transport =
+            Http::new("https://rinkeby.infura.io/v3/00000000000000000000000000000000").unwrap();
+        let web3 = web3::Web3::new(transport);
+        let contract = eth_contract(web3);
+        assert!(contract.abi().event(ETH_EVENT_NAME).is_ok());
+    }
+}

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

@@ -1,6 +1,7 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
+use crate::bandwidth::BandwidthController;
 use crate::cleanup_socket_message;
 use crate::error::GatewayClientError;
 use crate::packet_router::PacketRouter;
@@ -8,7 +9,10 @@ pub use crate::packet_router::{
     AcknowledgementReceiver, AcknowledgementSender, MixnetMessageReceiver, MixnetMessageSender,
 };
 use crate::socket_state::{PartiallyDelegated, SocketState};
+#[cfg(feature = "coconut")]
 use coconut_interface::Credential;
+#[cfg(not(feature = "coconut"))]
+use credentials::token::bandwidth::TokenCredential;
 use crypto::asymmetric::identity;
 use futures::{FutureExt, SinkExt, StreamExt};
 use gateway_requests::authentication::encrypted_address::EncryptedAddressBytes;
@@ -36,8 +40,7 @@ const DEFAULT_RECONNECTION_BACKOFF: Duration = Duration::from_secs(5);
 
 pub struct GatewayClient {
     authenticated: bool,
-    // TODO: This should be replaced by an actual bandwidth value, with 0 meaning no bandwidth
-    has_bandwidth: bool,
+    bandwidth_remaining: i64,
     gateway_address: String,
     gateway_identity: identity::PublicKey,
     local_identity: Arc<identity::KeyPair>,
@@ -45,6 +48,7 @@ pub struct GatewayClient {
     connection: SocketState,
     packet_router: PacketRouter,
     response_timeout_duration: Duration,
+    bandwidth_controller: Option<BandwidthController>,
 
     // reconnection related variables
     /// Specifies whether client should try to reconnect to gateway on connection failure.
@@ -54,7 +58,6 @@ pub struct GatewayClient {
     reconnection_attempts: usize,
     /// Delay between each subsequent reconnection attempt.
     reconnection_backoff: Duration,
-    coconut_credential: Credential,
 }
 
 impl GatewayClient {
@@ -68,11 +71,11 @@ impl GatewayClient {
         mixnet_message_sender: MixnetMessageSender,
         ack_sender: AcknowledgementSender,
         response_timeout_duration: Duration,
-        coconut_credential: Credential,
+        bandwidth_controller: Option<BandwidthController>,
     ) -> Self {
         GatewayClient {
             authenticated: false,
-            has_bandwidth: false,
+            bandwidth_remaining: 0,
             gateway_address,
             gateway_identity,
             local_identity,
@@ -80,10 +83,10 @@ impl GatewayClient {
             connection: SocketState::NotConnected,
             packet_router: PacketRouter::new(ack_sender, mixnet_message_sender),
             response_timeout_duration,
+            bandwidth_controller,
             should_reconnect_on_failure: true,
             reconnection_attempts: DEFAULT_RECONNECTION_ATTEMPTS,
             reconnection_backoff: DEFAULT_RECONNECTION_BACKOFF,
-            coconut_credential,
         }
     }
 
@@ -104,7 +107,6 @@ impl GatewayClient {
         gateway_address: String,
         gateway_identity: identity::PublicKey,
         local_identity: Arc<identity::KeyPair>,
-        coconut_credential: Credential,
         response_timeout_duration: Duration,
     ) -> Self {
         use futures::channel::mpsc;
@@ -117,7 +119,7 @@ impl GatewayClient {
 
         GatewayClient {
             authenticated: false,
-            has_bandwidth: false,
+            bandwidth_remaining: 0,
             gateway_address,
             gateway_identity,
             local_identity,
@@ -125,10 +127,10 @@ impl GatewayClient {
             connection: SocketState::NotConnected,
             packet_router,
             response_timeout_duration,
+            bandwidth_controller: None,
             should_reconnect_on_failure: false,
             reconnection_attempts: DEFAULT_RECONNECTION_ATTEMPTS,
             reconnection_backoff: DEFAULT_RECONNECTION_BACKOFF,
-            coconut_credential,
         }
     }
 
@@ -136,10 +138,14 @@ impl GatewayClient {
         self.gateway_identity
     }
 
+    pub fn remaining_bandwidth(&self) -> i64 {
+        self.bandwidth_remaining
+    }
+
     #[cfg(not(target_arch = "wasm32"))]
     async fn _close_connection(&mut self) -> Result<(), GatewayClientError> {
         match std::mem::replace(&mut self.connection, SocketState::NotConnected) {
-            SocketState::Available(mut socket) => Ok(socket.close(None).await?),
+            SocketState::Available(mut socket) => Ok((*socket).close(None).await?),
             SocketState::PartiallyDelegated(_) => {
                 unreachable!("this branch should have never been reached!")
             }
@@ -151,7 +157,7 @@ impl GatewayClient {
     async fn _close_connection(&mut self) -> Result<(), GatewayClientError> {
         match std::mem::replace(&mut self.connection, SocketState::NotConnected) {
             SocketState::Available(mut socket) => {
-                socket.close(None).await;
+                (*socket).close(None).await;
                 Ok(())
             }
             SocketState::PartiallyDelegated(_) => {
@@ -176,7 +182,7 @@ impl GatewayClient {
             Err(e) => return Err(GatewayClientError::NetworkError(e)),
         };
 
-        self.connection = SocketState::Available(ws_stream);
+        self.connection = SocketState::Available(Box::new(ws_stream));
         Ok(())
     }
 
@@ -187,7 +193,7 @@ impl GatewayClient {
             Err(e) => return Err(GatewayClientError::NetworkErrorWasm(e)),
         };
 
-        self.connection = SocketState::Available(ws_stream);
+        self.connection = SocketState::Available(Box::new(ws_stream));
         Ok(())
     }
 
@@ -430,8 +436,12 @@ impl GatewayClient {
             ClientControlRequest::new_authenticate(self_address, encrypted_address, iv).into();
 
         match self.send_websocket_message(msg).await? {
-            ServerResponse::Authenticate { status } => {
+            ServerResponse::Authenticate {
+                status,
+                bandwidth_remaining,
+            } => {
                 self.authenticated = status;
+                self.bandwidth_remaining = bandwidth_remaining;
                 Ok(())
             }
             ServerResponse::Error { message } => Err(GatewayClientError::GatewayError(message)),
@@ -456,6 +466,53 @@ impl GatewayClient {
         }
     }
 
+    #[cfg(feature = "coconut")]
+    async fn claim_coconut_bandwidth(
+        &mut self,
+        credential: Credential,
+    ) -> Result<(), GatewayClientError> {
+        let mut rng = OsRng;
+        let iv = IV::new_random(&mut rng);
+
+        let msg = ClientControlRequest::new_enc_coconut_bandwidth_credential(
+            &credential,
+            self.shared_key.as_ref().unwrap(),
+            iv,
+        )
+        .ok_or(GatewayClientError::SerializeCredential)?
+        .into();
+        self.bandwidth_remaining = match self.send_websocket_message(msg).await? {
+            ServerResponse::Bandwidth { available_total } => Ok(available_total),
+            ServerResponse::Error { message } => Err(GatewayClientError::GatewayError(message)),
+            _ => Err(GatewayClientError::UnexpectedResponse),
+        }?;
+        Ok(())
+    }
+
+    #[cfg(not(feature = "coconut"))]
+    async fn claim_token_bandwidth(
+        &mut self,
+        credential: TokenCredential,
+    ) -> Result<(), GatewayClientError> {
+        let mut rng = OsRng;
+
+        let iv = IV::new_random(&mut rng);
+
+        let msg = ClientControlRequest::new_enc_token_bandwidth_credential(
+            &credential,
+            self.shared_key.as_ref().unwrap(),
+            iv,
+        )
+        .into();
+        self.bandwidth_remaining = match self.send_websocket_message(msg).await? {
+            ServerResponse::Bandwidth { available_total } => Ok(available_total),
+            ServerResponse::Error { message } => Err(GatewayClientError::GatewayError(message)),
+            _ => Err(GatewayClientError::UnexpectedResponse),
+        }?;
+
+        Ok(())
+    }
+
     pub async fn claim_bandwidth(&mut self) -> Result<(), GatewayClientError> {
         if !self.authenticated {
             return Err(GatewayClientError::NotAuthenticated);
@@ -463,23 +520,38 @@ impl GatewayClient {
         if self.shared_key.is_none() {
             return Err(GatewayClientError::NoSharedKeyAvailable);
         }
+        if self.bandwidth_controller.is_none() {
+            return Err(GatewayClientError::NoBandwidthControllerAvailable);
+        }
 
-        let mut rng = OsRng;
-        let iv = IV::new_random(&mut rng);
+        warn!("Not enough bandwidth. Trying to get more bandwidth, this might take a while");
 
-        let msg = ClientControlRequest::new_enc_bandwidth_credential(
-            &self.coconut_credential,
-            self.shared_key.as_ref().unwrap(),
-            iv,
-        )
-        .ok_or(GatewayClientError::SerializeCredential)?
-        .into();
-        self.has_bandwidth = match self.send_websocket_message(msg).await? {
-            ServerResponse::Bandwidth { status } => Ok(status),
-            ServerResponse::Error { message } => Err(GatewayClientError::GatewayError(message)),
-            _ => Err(GatewayClientError::UnexpectedResponse),
-        }?;
-        Ok(())
+        #[cfg(feature = "coconut")]
+        let credential = self
+            .bandwidth_controller
+            .as_ref()
+            .unwrap()
+            .prepare_coconut_credential()
+            .await?;
+        #[cfg(not(feature = "coconut"))]
+        let credential = self
+            .bandwidth_controller
+            .as_ref()
+            .unwrap()
+            .prepare_token_credential(self.gateway_identity)
+            .await?;
+
+        #[cfg(feature = "coconut")]
+        return self.claim_coconut_bandwidth(credential).await;
+        #[cfg(not(feature = "coconut"))]
+        return self.claim_token_bandwidth(credential).await;
+    }
+
+    fn estimate_required_bandwidth(&self, packets: &[MixPacket]) -> i64 {
+        packets
+            .iter()
+            .map(|packet| packet.sphinx_packet().len())
+            .sum::<usize>() as i64
     }
 
     pub async fn batch_send_mix_packets(
@@ -489,8 +561,16 @@ impl GatewayClient {
         if !self.authenticated {
             return Err(GatewayClientError::NotAuthenticated);
         }
-        if !self.has_bandwidth {
-            return Err(GatewayClientError::NotEnoughBandwidth);
+        if self.estimate_required_bandwidth(&packets) > self.bandwidth_remaining {
+            // Try to claim more bandwidth first, and return an error only if that is still not
+            // enough (the current granularity for bandwidth should be sufficient)
+            self.claim_bandwidth().await?;
+            if self.estimate_required_bandwidth(&packets) > self.bandwidth_remaining {
+                return Err(GatewayClientError::NotEnoughBandwidth(
+                    self.estimate_required_bandwidth(&packets),
+                    self.bandwidth_remaining,
+                ));
+            }
         }
         if !self.connection.is_established() {
             return Err(GatewayClientError::ConnectionNotEstablished);
@@ -521,15 +601,10 @@ impl GatewayClient {
         }
     }
 
-    pub async fn send_ping_message(&mut self) -> Result<(), GatewayClientError> {
-        if !self.connection.is_established() {
-            return Err(GatewayClientError::ConnectionNotEstablished);
-        }
-
-        // as per RFC6455 section 5.5.2, `Ping frame MAY include "Application data".`
-        // so we don't need to include any here.
-        let msg = Message::Ping(Vec::new());
-
+    async fn send_with_reconnection_on_failure(
+        &mut self,
+        msg: Message,
+    ) -> Result<(), GatewayClientError> {
         if let Err(err) = self.send_websocket_message_without_response(msg).await {
             if err.is_closed_connection() && self.should_reconnect_on_failure {
                 info!("Going to attempt a reconnection");
@@ -542,6 +617,17 @@ impl GatewayClient {
         }
     }
 
+    pub async fn send_ping_message(&mut self) -> Result<(), GatewayClientError> {
+        if !self.connection.is_established() {
+            return Err(GatewayClientError::ConnectionNotEstablished);
+        }
+
+        // as per RFC6455 section 5.5.2, `Ping frame MAY include "Application data".`
+        // so we don't need to include any here.
+        let msg = Message::Ping(Vec::new());
+        self.send_with_reconnection_on_failure(msg).await
+    }
+
     // TODO: possibly make responses optional
     pub async fn send_mix_packet(
         &mut self,
@@ -550,8 +636,16 @@ impl GatewayClient {
         if !self.authenticated {
             return Err(GatewayClientError::NotAuthenticated);
         }
-        if !self.has_bandwidth {
-            return Err(GatewayClientError::NotEnoughBandwidth);
+        if (mix_packet.sphinx_packet().len() as i64) > self.bandwidth_remaining {
+            // Try to claim more bandwidth first, and return an error only if that is still not
+            // enough
+            self.claim_bandwidth().await?;
+            if (mix_packet.sphinx_packet().len() as i64) > self.bandwidth_remaining {
+                return Err(GatewayClientError::NotEnoughBandwidth(
+                    mix_packet.sphinx_packet().len() as i64,
+                    self.bandwidth_remaining,
+                ));
+            }
         }
         if !self.connection.is_established() {
             return Err(GatewayClientError::ConnectionNotEstablished);
@@ -563,17 +657,7 @@ impl GatewayClient {
                 .as_ref()
                 .expect("no shared key present even though we're authenticated!"),
         );
-
-        if let Err(err) = self.send_websocket_message_without_response(msg).await {
-            if err.is_closed_connection() && self.should_reconnect_on_failure {
-                info!("Going to attempt a reconnection");
-                self.attempt_reconnection().await
-            } else {
-                Err(err)
-            }
-        } else {
-            Ok(())
-        }
+        self.send_with_reconnection_on_failure(msg).await
     }
 
     async fn recover_socket_connection(&mut self) -> Result<(), GatewayClientError> {
@@ -589,7 +673,7 @@ impl GatewayClient {
             _ => unreachable!(),
         };
 
-        self.connection = SocketState::Available(conn);
+        self.connection = SocketState::Available(Box::new(conn));
         Ok(())
     }
 
@@ -598,9 +682,6 @@ impl GatewayClient {
         if !self.authenticated {
             return Err(GatewayClientError::NotAuthenticated);
         }
-        if !self.has_bandwidth {
-            return Err(GatewayClientError::NotEnoughBandwidth);
-        }
         if self.connection.is_partially_delegated() {
             return Ok(());
         }
@@ -612,7 +693,7 @@ impl GatewayClient {
             match std::mem::replace(&mut self.connection, SocketState::Invalid) {
                 SocketState::Available(conn) => {
                     PartiallyDelegated::split_and_listen_for_mixnet_messages(
-                        conn,
+                        *conn,
                         self.packet_router.clone(),
                         Arc::clone(
                             self.shared_key
@@ -633,7 +714,6 @@ impl GatewayClient {
             self.establish_connection().await?;
         }
         let shared_key = self.perform_initial_authentication().await?;
-        self.claim_bandwidth().await?;
 
         // this call is NON-blocking
         self.start_listening_for_mixnet_messages()?;

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

@@ -2,39 +2,83 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use gateway_requests::registration::handshake::error::HandshakeError;
-use std::fmt::{self, Error, Formatter};
 use std::io;
+use thiserror::Error;
 use tungstenite::Error as WsError;
 #[cfg(target_arch = "wasm32")]
 use wasm_bindgen::JsValue;
+#[cfg(not(feature = "coconut"))]
+use web3::Error as Web3Error;
 
-#[derive(Debug)]
+#[derive(Debug, Error)]
 pub enum GatewayClientError {
+    #[error("Connection to the gateway is not established")]
     ConnectionNotEstablished,
+
+    #[error("Gateway returned an error response - {0}")]
     GatewayError(String),
-    NetworkError(WsError),
+
+    #[error("There was a network error - {0}")]
+    NetworkError(#[from] WsError),
 
     // TODO: see if `JsValue` is a reasonable type for this
     #[cfg(target_arch = "wasm32")]
+    #[error("There was a network error")]
     NetworkErrorWasm(JsValue),
 
-    NoSharedKeyAvailable,
-    ConnectionAbruptlyClosed,
-    MalformedResponse,
-    SerializeCredential,
-    NotAuthenticated,
-    NotEnoughBandwidth,
-    UnexpectedResponse,
-    ConnectionInInvalidState,
-    RegistrationFailure(HandshakeError),
-    AuthenticationFailure,
-    Timeout,
-}
+    #[cfg(not(feature = "coconut"))]
+    #[error("Could not backup keypair - {0}")]
+    IOError(#[from] std::io::Error),
 
-impl From<WsError> for GatewayClientError {
-    fn from(err: WsError) -> Self {
-        GatewayClientError::NetworkError(err)
-    }
+    #[cfg(not(feature = "coconut"))]
+    #[error("Could not burn ERC20 token in Ethereum smart contract - {0}")]
+    BurnTokenError(#[from] Web3Error),
+
+    #[cfg(not(feature = "coconut"))]
+    #[error("Invalid Ethereum private key")]
+    InvalidEthereumPrivateKey,
+
+    #[error("Invalid URL - {0}")]
+    InvalidURL(String),
+
+    #[error("No shared key was provided or obtained")]
+    NoSharedKeyAvailable,
+
+    #[error("No bandwidth controller provided")]
+    NoBandwidthControllerAvailable,
+
+    #[error("Credential error - {0}")]
+    CredentialError(#[from] credentials::error::Error),
+
+    #[error("Connection was abruptly closed")]
+    ConnectionAbruptlyClosed,
+
+    #[error("Received response was malformed")]
+    MalformedResponse,
+
+    #[error("Credential could not be serialized")]
+    SerializeCredential,
+
+    #[error("Client is not authenticated")]
+    NotAuthenticated,
+
+    #[error("Client does not have enough bandwidth: estimated {0}, remaining: {1}")]
+    NotEnoughBandwidth(i64, i64),
+
+    #[error("Received an unexpected response")]
+    UnexpectedResponse,
+
+    #[error("Connection is in an invalid state - please send a bug report")]
+    ConnectionInInvalidState,
+
+    #[error("Failed to finish registration handshake - {0}")]
+    RegistrationFailure(HandshakeError),
+
+    #[error("Authentication failure")]
+    AuthenticationFailure,
+
+    #[error("Timed out")]
+    Timeout,
 }
 
 impl GatewayClientError {
@@ -54,60 +98,3 @@ impl GatewayClientError {
         }
     }
 }
-
-#[cfg(target_arch = "wasm32")]
-impl From<JsValue> for GatewayClientError {
-    fn from(err: JsValue) -> Self {
-        GatewayClientError::NetworkErrorWasm(err)
-    }
-}
-
-// better human readable representation of the error, mostly so that GatewayClientError
-// would implement std::error::Error
-impl fmt::Display for GatewayClientError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
-        match self {
-            GatewayClientError::ConnectionNotEstablished => {
-                write!(f, "connection to the gateway is not established")
-            }
-            GatewayClientError::NoSharedKeyAvailable => {
-                write!(f, "no shared key was provided or obtained")
-            }
-            GatewayClientError::NotAuthenticated => write!(f, "client is not authenticated"),
-
-            GatewayClientError::NetworkError(err) => {
-                write!(f, "there was a network error - {}", err)
-            }
-            #[cfg(target_arch = "wasm32")]
-            GatewayClientError::NetworkErrorWasm(err) => {
-                write!(f, "there was a network error - {:?}", err)
-            }
-
-            GatewayClientError::ConnectionAbruptlyClosed => {
-                write!(f, "connection was abruptly closed")
-            }
-            GatewayClientError::Timeout => write!(f, "timed out"),
-            GatewayClientError::MalformedResponse => write!(f, "received response was malformed"),
-            GatewayClientError::ConnectionInInvalidState => write!(
-                f,
-                "connection is in an invalid state - please send a bug report"
-            ),
-            GatewayClientError::RegistrationFailure(handshake_err) => write!(
-                f,
-                "failed to finish registration handshake - {}",
-                handshake_err
-            ),
-            GatewayClientError::AuthenticationFailure => write!(f, "authentication failure"),
-            GatewayClientError::GatewayError(err) => {
-                write!(f, "gateway returned an error response - {}", err)
-            }
-            GatewayClientError::UnexpectedResponse => write!(f, "received an unexpected response"),
-            GatewayClientError::NotEnoughBandwidth => {
-                write!(f, "client does not have enough bandwidth")
-            }
-            GatewayClientError::SerializeCredential => {
-                write!(f, "credential could not be serialized")
-            }
-        }
-    }
-}

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

@@ -8,6 +8,7 @@ pub use packet_router::{
 };
 use tungstenite::{protocol::Message, Error as WsError};
 
+pub mod bandwidth;
 pub mod client;
 pub mod error;
 pub mod packet_router;

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

@@ -119,7 +119,7 @@ impl PartiallyDelegated {
             }
             .is_err()
             {
-                panic!("failed to send back `mixnet_receiver_future` result on the oneshot channel")
+                warn!("failed to send back `mixnet_receiver_future` result on the oneshot channel")
             }
         };
 
@@ -173,9 +173,9 @@ impl PartiallyDelegated {
         // this call failing is incredibly unlikely, but not impossible.
         // basically the gateway connection must have failed after executing previous line but
         // before starting execution of this one.
-        if notify.send(()).is_err() {
-            return Err(GatewayClientError::ConnectionAbruptlyClosed);
-        }
+        notify
+            .send(())
+            .map_err(|_| GatewayClientError::ConnectionAbruptlyClosed)?;
 
         let stream_results: Result<_, GatewayClientError> = stream_receiver
             .await
@@ -193,7 +193,7 @@ impl PartiallyDelegated {
 // by notifying the future owning it to finish the execution and awaiting the result
 // which should be almost immediate (or an invalid state which should never, ever happen)
 pub(crate) enum SocketState {
-    Available(WsConn),
+    Available(Box<WsConn>),
     PartiallyDelegated(PartiallyDelegated),
     NotConnected,
     Invalid,

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

@@ -3,12 +3,14 @@ name = "validator-client"
 version = "0.1.0"
 authors = ["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
 
 [dependencies]
 base64 = "0.13"
 mixnet-contract = { path="../../../common/mixnet-contract" }
+vesting-contract = { path="../../../contracts/vesting" }
 serde = { version="1", features=["derive"] }
 serde_json = "1"
 reqwest = { version="0.11", features=["json"] }
@@ -25,13 +27,14 @@ network-defaults = { path = "../../network-defaults" }
 async-trait = { version = "0.1.51", optional = true }
 bip39 = { version = "1", features = ["rand"], optional = true }
 config = { path = "../../config", optional = true }
-cosmrs = { version = "0.1", features = ["rpc", "bip32", "cosmwasm"], optional = true }
-prost = { version = "0.7", default-features = false, optional = true }
+#cosmrs = { version = "0.3", features = ["rpc", "bip32", "cosmwasm"], optional = true }
+cosmrs = { git = "https://github.com/cosmos/cosmos-rust", rev="e5a1872083abb3d88fa62dda966e7f5408deba58", features = ["rpc", "bip32", "cosmwasm"], optional = true }
+prost = { version = "0.9", default-features = false, optional = true }
 flate2 = { version = "1.0.20", optional = true }
 sha2 = { version = "0.9.5", optional = true }
 itertools = { version = "0.10", optional = true }
-cosmwasm-std = { git = "https://github.com/jstuczyn/cosmwasm", branch="0.14.1-updatedk256", optional = true }
-ts-rs = "3.0"
+cosmwasm-std = { version = "1.0.0-beta2", optional = true }
+ts-rs = {version = "5.1", optional = true}
 
 [features]
 nymd-client = ["async-trait", "bip39", "config", "cosmrs", "prost", "flate2", "sha2", "itertools", "cosmwasm-std"]

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

@@ -5,9 +5,19 @@
 use crate::nymd::{
     error::NymdError, CosmWasmClient, NymdClient, QueryNymdClient, SigningNymdClient,
 };
+#[cfg(feature = "nymd-client")]
+use mixnet_contract::ContractStateParams;
+
 use crate::{validator_api, ValidatorClientError};
 use coconut_interface::{BlindSignRequestBody, BlindedSignatureResponse, VerificationKeyResponse};
+#[cfg(feature = "nymd-client")]
+use mixnet_contract::{
+    Delegation, MixnetContractVersion, MixnodeRewardingStatusResponse, RewardingIntervalResponse,
+};
 use mixnet_contract::{GatewayBond, MixNodeBond};
+
+#[cfg(feature = "nymd-client")]
+use std::str::FromStr;
 use url::Url;
 
 #[cfg(feature = "nymd-client")]
@@ -15,11 +25,11 @@ pub struct Config {
     api_url: Url,
     nymd_url: Url,
     mixnet_contract_address: Option<cosmrs::AccountId>,
+    vesting_contract_address: Option<cosmrs::AccountId>,
 
     mixnode_page_limit: Option<u32>,
     gateway_page_limit: Option<u32>,
     mixnode_delegations_page_limit: Option<u32>,
-    gateway_delegations_page_limit: Option<u32>,
 }
 
 #[cfg(feature = "nymd-client")]
@@ -28,15 +38,16 @@ impl Config {
         nymd_url: Url,
         api_url: Url,
         mixnet_contract_address: Option<cosmrs::AccountId>,
+        vesting_contract_address: Option<cosmrs::AccountId>,
     ) -> Self {
         Config {
             nymd_url,
             mixnet_contract_address,
+            vesting_contract_address,
             api_url,
             mixnode_page_limit: None,
             gateway_page_limit: None,
             mixnode_delegations_page_limit: None,
-            gateway_delegations_page_limit: None,
         }
     }
 
@@ -54,22 +65,17 @@ impl Config {
         self.mixnode_delegations_page_limit = limit;
         self
     }
-
-    pub fn with_gateway_delegations_page_limit(mut self, limit: Option<u32>) -> Config {
-        self.gateway_delegations_page_limit = limit;
-        self
-    }
 }
 
 #[cfg(feature = "nymd-client")]
 pub struct Client<C> {
     mixnet_contract_address: Option<cosmrs::AccountId>,
+    vesting_contract_address: Option<cosmrs::AccountId>,
     mnemonic: Option<bip39::Mnemonic>,
 
     mixnode_page_limit: Option<u32>,
     gateway_page_limit: Option<u32>,
     mixnode_delegations_page_limit: Option<u32>,
-    gateway_delegations_page_limit: Option<u32>,
 
     // ideally they would have been read-only, but unfortunately rust doesn't have such features
     pub validator_api: validator_api::Client,
@@ -86,16 +92,18 @@ impl Client<SigningNymdClient> {
         let nymd_client = NymdClient::connect_with_mnemonic(
             config.nymd_url.as_str(),
             config.mixnet_contract_address.clone(),
+            config.vesting_contract_address.clone(),
             mnemonic.clone(),
+            None,
         )?;
 
         Ok(Client {
             mixnet_contract_address: config.mixnet_contract_address,
+            vesting_contract_address: config.vesting_contract_address,
             mnemonic: Some(mnemonic),
             mixnode_page_limit: config.mixnode_page_limit,
             gateway_page_limit: config.gateway_page_limit,
             mixnode_delegations_page_limit: config.mixnode_delegations_page_limit,
-            gateway_delegations_page_limit: config.gateway_delegations_page_limit,
             validator_api: validator_api_client,
             nymd: nymd_client,
         })
@@ -105,7 +113,9 @@ impl Client<SigningNymdClient> {
         self.nymd = NymdClient::connect_with_mnemonic(
             new_endpoint.as_ref(),
             self.mixnet_contract_address.clone(),
+            self.vesting_contract_address.clone(),
             self.mnemonic.clone().unwrap(),
+            None,
         )?;
         Ok(())
     }
@@ -117,21 +127,23 @@ impl Client<QueryNymdClient> {
         let validator_api_client = validator_api::Client::new(config.api_url.clone());
         let nymd_client = NymdClient::connect(
             config.nymd_url.as_str(),
-            config
-                .mixnet_contract_address
-                .clone()
-                .ok_or(ValidatorClientError::NymdError(
-                    NymdError::NoContractAddressAvailable,
-                ))?,
+            config.mixnet_contract_address.clone().unwrap_or_else(|| {
+                cosmrs::AccountId::from_str(network_defaults::DEFAULT_MIXNET_CONTRACT_ADDRESS)
+                    .unwrap()
+            }),
+            config.vesting_contract_address.clone().unwrap_or_else(|| {
+                cosmrs::AccountId::from_str(network_defaults::DEFAULT_VESTING_CONTRACT_ADDRESS)
+                    .unwrap()
+            }),
         )?;
 
         Ok(Client {
             mixnet_contract_address: config.mixnet_contract_address,
+            vesting_contract_address: config.vesting_contract_address,
             mnemonic: None,
             mixnode_page_limit: config.mixnode_page_limit,
             gateway_page_limit: config.gateway_page_limit,
             mixnode_delegations_page_limit: config.mixnode_delegations_page_limit,
-            gateway_delegations_page_limit: config.gateway_delegations_page_limit,
             validator_api: validator_api_client,
             nymd: nymd_client,
         })
@@ -141,6 +153,7 @@ impl Client<QueryNymdClient> {
         self.nymd = NymdClient::connect(
             new_endpoint.as_ref(),
             self.mixnet_contract_address.clone().unwrap(),
+            self.vesting_contract_address.clone().unwrap(),
         )?;
         Ok(())
     }
@@ -158,6 +171,10 @@ impl<C> Client<C> {
         self.mixnet_contract_address = Some(mixnet_contract_address)
     }
 
+    pub fn get_mixnet_contract_address(&self) -> Option<cosmrs::AccountId> {
+        self.mixnet_contract_address.clone()
+    }
+
     pub async fn get_cached_mixnodes(&self) -> Result<Vec<MixNodeBond>, ValidatorClientError> {
         Ok(self.validator_api.get_mixnodes().await?)
     }
@@ -166,6 +183,71 @@ impl<C> Client<C> {
         Ok(self.validator_api.get_gateways().await?)
     }
 
+    pub async fn get_contract_settings(&self) -> Result<ContractStateParams, ValidatorClientError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        Ok(self.nymd.get_contract_settings().await?)
+    }
+
+    pub async fn get_mixnet_contract_version(&self) -> Result<MixnetContractVersion, NymdError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        Ok(self.nymd.get_mixnet_contract_version().await?)
+    }
+
+    pub async fn get_current_rewarding_interval(
+        &self,
+    ) -> Result<RewardingIntervalResponse, ValidatorClientError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        Ok(self.nymd.get_current_rewarding_interval().await?)
+    }
+
+    pub async fn get_rewarding_status(
+        &self,
+        mix_identity: mixnet_contract::IdentityKey,
+        rewarding_interval_nonce: u32,
+    ) -> Result<MixnodeRewardingStatusResponse, ValidatorClientError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        Ok(self
+            .nymd
+            .get_rewarding_status(mix_identity, rewarding_interval_nonce)
+            .await?)
+    }
+
+    pub async fn get_reward_pool(&self) -> Result<u128, ValidatorClientError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        Ok(self.nymd.get_reward_pool().await?.u128())
+    }
+
+    pub async fn get_circulating_supply(&self) -> Result<u128, ValidatorClientError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        Ok(self.nymd.get_circulating_supply().await?.u128())
+    }
+
+    pub async fn get_sybil_resistance_percent(&self) -> Result<u8, ValidatorClientError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        Ok(self.nymd.get_sybil_resistance_percent().await?)
+    }
+
+    pub async fn get_epoch_reward_percent(&self) -> Result<u8, ValidatorClientError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        Ok(self.nymd.get_epoch_reward_percent().await?)
+    }
+
     // basically handles paging for us
     pub async fn get_all_nymd_mixnodes(&self) -> Result<Vec<MixNodeBond>, ValidatorClientError>
     where
@@ -213,7 +295,7 @@ impl<C> Client<C> {
         Ok(gateways)
     }
 
-    pub async fn get_all_nymd_mixnode_delegations(
+    pub async fn get_all_nymd_single_mixnode_delegations(
         &self,
         identity: mixnet_contract::IdentityKey,
     ) -> Result<Vec<mixnet_contract::Delegation>, ValidatorClientError>
@@ -243,10 +325,7 @@ impl<C> Client<C> {
         Ok(delegations)
     }
 
-    pub async fn get_all_nymd_reverse_mixnode_delegations(
-        &self,
-        delegation_owner: &cosmrs::AccountId,
-    ) -> Result<Vec<mixnet_contract::IdentityKey>, ValidatorClientError>
+    pub async fn get_all_network_delegations(&self) -> Result<Vec<Delegation>, ValidatorClientError>
     where
         C: CosmWasmClient + Sync,
     {
@@ -255,64 +334,11 @@ impl<C> Client<C> {
         loop {
             let mut paged_response = self
                 .nymd
-                .get_reverse_mix_delegations_paged(
-                    mixnet_contract::Addr::unchecked(delegation_owner.as_ref()),
+                .get_all_network_delegations_paged(
                     start_after.take(),
                     self.mixnode_delegations_page_limit,
                 )
                 .await?;
-            delegations.append(&mut paged_response.delegated_nodes);
-
-            if let Some(start_after_res) = paged_response.start_next_after {
-                start_after = Some(start_after_res)
-            } else {
-                break;
-            }
-        }
-
-        Ok(delegations)
-    }
-
-    pub async fn get_all_nymd_mixnode_delegations_of_owner(
-        &self,
-        delegation_owner: &cosmrs::AccountId,
-    ) -> Result<Vec<mixnet_contract::Delegation>, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync,
-    {
-        let mut delegations = Vec::new();
-        for node_identity in self
-            .get_all_nymd_reverse_mixnode_delegations(delegation_owner)
-            .await?
-        {
-            let delegation = self
-                .nymd
-                .get_mix_delegation(node_identity, delegation_owner)
-                .await?;
-            delegations.push(delegation);
-        }
-
-        Ok(delegations)
-    }
-
-    pub async fn get_all_nymd_gateway_delegations(
-        &self,
-        identity: mixnet_contract::IdentityKey,
-    ) -> Result<Vec<mixnet_contract::Delegation>, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync,
-    {
-        let mut delegations = Vec::new();
-        let mut start_after = None;
-        loop {
-            let mut paged_response = self
-                .nymd
-                .get_gateway_delegations(
-                    identity.clone(),
-                    start_after.take(),
-                    self.gateway_delegations_page_limit,
-                )
-                .await?;
             delegations.append(&mut paged_response.delegations);
 
             if let Some(start_after_res) = paged_response.start_next_after {
@@ -325,10 +351,10 @@ impl<C> Client<C> {
         Ok(delegations)
     }
 
-    pub async fn get_all_nymd_reverse_gateway_delegations(
+    pub async fn get_all_delegator_delegations(
         &self,
         delegation_owner: &cosmrs::AccountId,
-    ) -> Result<Vec<mixnet_contract::IdentityKey>, ValidatorClientError>
+    ) -> Result<Vec<Delegation>, ValidatorClientError>
     where
         C: CosmWasmClient + Sync,
     {
@@ -337,13 +363,13 @@ impl<C> Client<C> {
         loop {
             let mut paged_response = self
                 .nymd
-                .get_reverse_gateway_delegations_paged(
-                    mixnet_contract::Addr::unchecked(delegation_owner.as_ref()),
+                .get_delegator_delegations_paged(
+                    delegation_owner.to_string(),
                     start_after.take(),
                     self.mixnode_delegations_page_limit,
                 )
                 .await?;
-            delegations.append(&mut paged_response.delegated_nodes);
+            delegations.append(&mut paged_response.delegations);
 
             if let Some(start_after_res) = paged_response.start_next_after {
                 start_after = Some(start_after_res)
@@ -355,28 +381,6 @@ impl<C> Client<C> {
         Ok(delegations)
     }
 
-    pub async fn get_all_nymd_gateway_delegations_of_owner(
-        &self,
-        delegation_owner: &cosmrs::AccountId,
-    ) -> Result<Vec<mixnet_contract::Delegation>, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync,
-    {
-        let mut delegations = Vec::new();
-        for node_identity in self
-            .get_all_nymd_reverse_gateway_delegations(delegation_owner)
-            .await?
-        {
-            let delegation = self
-                .nymd
-                .get_gateway_delegation(node_identity, delegation_owner)
-                .await?;
-            delegations.push(delegation);
-        }
-
-        Ok(delegations)
-    }
-
     pub async fn blind_sign(
         &self,
         request_body: &BlindSignRequestBody,
@@ -410,6 +414,12 @@ impl ApiClient {
         self.validator_api.change_url(new_endpoint);
     }
 
+    pub async fn get_cached_active_mixnodes(
+        &self,
+    ) -> Result<Vec<MixNodeBond>, ValidatorClientError> {
+        Ok(self.validator_api.get_active_mixnodes().await?)
+    }
+
     pub async fn get_cached_mixnodes(&self) -> Result<Vec<MixNodeBond>, ValidatorClientError> {
         Ok(self.validator_api.get_mixnodes().await?)
     }

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

@@ -4,7 +4,7 @@
 use crate::nymd::cosmwasm_client::helpers::create_pagination;
 use crate::nymd::cosmwasm_client::types::{
     Account, Code, CodeDetails, Contract, ContractCodeHistoryEntry, ContractCodeId,
-    SequenceResponse,
+    SequenceResponse, SimulateResponse,
 };
 use crate::nymd::error::NymdError;
 use async_trait::async_trait;
@@ -14,15 +14,19 @@ use cosmrs::proto::cosmos::auth::v1beta1::{
 use cosmrs::proto::cosmos::bank::v1beta1::{
     QueryAllBalancesRequest, QueryAllBalancesResponse, QueryBalanceRequest, QueryBalanceResponse,
 };
-use cosmrs::proto::cosmwasm::wasm::v1beta1::*;
+use cosmrs::proto::cosmos::tx::v1beta1::{
+    SimulateRequest, SimulateResponse as ProtoSimulateResponse,
+};
+use cosmrs::proto::cosmwasm::wasm::v1::*;
 use cosmrs::rpc::endpoint::block::Response as BlockResponse;
 use cosmrs::rpc::endpoint::broadcast;
 use cosmrs::rpc::endpoint::tx::Response as TxResponse;
 use cosmrs::rpc::query::Query;
 use cosmrs::rpc::{self, HttpClient, Order};
+use cosmrs::tendermint::abci::Code as AbciCode;
 use cosmrs::tendermint::abci::Transaction;
 use cosmrs::tendermint::{abci, block, chain};
-use cosmrs::{AccountId, Coin, Denom};
+use cosmrs::{tx, AccountId, Coin, Denom, Tx};
 use prost::Message;
 use serde::{Deserialize, Serialize};
 use std::convert::{TryFrom, TryInto};
@@ -49,6 +53,11 @@ pub trait CosmWasmClient: rpc::Client {
 
         let res = self.abci_query(path, buf, None, false).await?;
 
+        match res.code {
+            AbciCode::Err(code) => return Err(NymdError::AbciError(code, res.log)),
+            AbciCode::Ok => (),
+        }
+
         Ok(Res::decode(res.value.as_ref())?)
     }
 
@@ -153,12 +162,9 @@ pub trait CosmWasmClient: rpc::Client {
             .map_err(|_| NymdError::SerializationError("Coins".to_owned()))
     }
 
-    // disabled until https://github.com/tendermint/tendermint/issues/6802
-    // and consequently https://github.com/informalsystems/tendermint-rs/issues/942 is resolved
-    //
-    // async fn get_tx(&self, id: tx::Hash) -> Result<TxResponse, NymdError> {
-    //     Ok(self.tx(id, false).await?)
-    // }
+    async fn get_tx(&self, id: tx::Hash) -> Result<TxResponse, NymdError> {
+        Ok(self.tx(id, false).await?)
+    }
 
     async fn search_tx(&self, query: Query) -> Result<Vec<TxResponse>, NymdError> {
         // according to https://docs.tendermint.com/master/rpc/#/Info/tx_search
@@ -216,7 +222,7 @@ pub trait CosmWasmClient: rpc::Client {
     }
 
     async fn get_codes(&self) -> Result<Vec<Code>, NymdError> {
-        let path = Some("/cosmwasm.wasm.v1beta1.Query/Codes".parse().unwrap());
+        let path = Some("/cosmwasm.wasm.v1.Query/Codes".parse().unwrap());
 
         let mut raw_codes = Vec::new();
         let mut pagination = None;
@@ -243,7 +249,7 @@ pub trait CosmWasmClient: rpc::Client {
     }
 
     async fn get_code_details(&self, code_id: ContractCodeId) -> Result<CodeDetails, NymdError> {
-        let path = Some("/cosmwasm.wasm.v1beta1.Query/Code".parse().unwrap());
+        let path = Some("/cosmwasm.wasm.v1.Query/Code".parse().unwrap());
 
         let req = QueryCodeRequest { code_id };
 
@@ -258,11 +264,7 @@ pub trait CosmWasmClient: rpc::Client {
         }
     }
     async fn get_contracts(&self, code_id: ContractCodeId) -> Result<Vec<AccountId>, NymdError> {
-        let path = Some(
-            "/cosmwasm.wasm.v1beta1.Query/ContractsByCode"
-                .parse()
-                .unwrap(),
-        );
+        let path = Some("/cosmwasm.wasm.v1.Query/ContractsByCode".parse().unwrap());
 
         let mut raw_contracts = Vec::new();
         let mut pagination = None;
@@ -293,7 +295,7 @@ pub trait CosmWasmClient: rpc::Client {
     }
 
     async fn get_contract(&self, address: &AccountId) -> Result<Contract, NymdError> {
-        let path = Some("/cosmwasm.wasm.v1beta1.Query/ContractInfo".parse().unwrap());
+        let path = Some("/cosmwasm.wasm.v1.Query/ContractInfo".parse().unwrap());
 
         let req = QueryContractInfoRequest {
             address: address.to_string(),
@@ -318,11 +320,7 @@ pub trait CosmWasmClient: rpc::Client {
         &self,
         address: &AccountId,
     ) -> Result<Vec<ContractCodeHistoryEntry>, NymdError> {
-        let path = Some(
-            "/cosmwasm.wasm.v1beta1.Query/ContractHistory"
-                .parse()
-                .unwrap(),
-        );
+        let path = Some("/cosmwasm.wasm.v1.Query/ContractHistory".parse().unwrap());
 
         let mut raw_entries = Vec::new();
         let mut pagination = None;
@@ -356,11 +354,7 @@ pub trait CosmWasmClient: rpc::Client {
         address: &AccountId,
         query_data: Vec<u8>,
     ) -> Result<Vec<u8>, NymdError> {
-        let path = Some(
-            "/cosmwasm.wasm.v1beta1.Query/RawContractState"
-                .parse()
-                .unwrap(),
-        );
+        let path = Some("/cosmwasm.wasm.v1.Query/RawContractState".parse().unwrap());
 
         let req = QueryRawContractStateRequest {
             address: address.to_string(),
@@ -384,7 +378,7 @@ pub trait CosmWasmClient: rpc::Client {
         for<'a> T: Deserialize<'a>,
     {
         let path = Some(
-            "/cosmwasm.wasm.v1beta1.Query/SmartContractState"
+            "/cosmwasm.wasm.v1.Query/SmartContractState"
                 .parse()
                 .unwrap(),
         );
@@ -403,4 +397,27 @@ pub trait CosmWasmClient: rpc::Client {
 
         Ok(serde_json::from_slice(&res.data)?)
     }
+
+    // deprecation warning is due to the fact the protobuf files built were based on cosmos-sdk 0.44,
+    // where they prefer using tx_bytes directly. However, in 0.42, which we are using at the time
+    // of writing this, the option does not work
+    #[allow(deprecated)]
+    async fn query_simulate(
+        &self,
+        tx: Option<Tx>,
+        tx_bytes: Vec<u8>,
+    ) -> Result<SimulateResponse, NymdError> {
+        let path = Some("/cosmos.tx.v1beta1.Service/Simulate".parse().unwrap());
+
+        let req = SimulateRequest {
+            tx: tx.map(Into::into),
+            tx_bytes,
+        };
+
+        let res = self
+            .make_abci_query::<_, ProtoSimulateResponse>(path, req)
+            .await?;
+
+        res.try_into()
+    }
 }

common/client-libs/validator-client/src/nymd/cosmwasm_client/logs.rs

@@ -29,7 +29,7 @@ pub(crate) fn find_attribute<'a>(
 ) -> Option<&'a cosmwasm_std::Attribute> {
     logs.iter()
         .flat_map(|log| log.events.iter())
-        .find(|event| event.kind == event_type)?
+        .find(|event| event.ty == event_type)?
         .attributes
         .iter()
         .find(|attr| attr.key == attribute_key)
@@ -61,7 +61,7 @@ mod tests {
         assert_eq!(parsed.len(), 1);
         assert_eq!(parsed[0].msg_index, 0);
         assert_eq!(parsed[0].events.len(), 1);
-        assert_eq!(parsed[0].events[0].kind, "message");
+        assert_eq!(parsed[0].events[0].ty, "message");
         assert_eq!(parsed[0].events[0].attributes[3].key, "code_id");
         assert_eq!(parsed[0].events[0].attributes[3].value, "1");
     }
@@ -76,12 +76,12 @@ mod tests {
         assert_eq!(parsed[2].msg_index, 2);
 
         assert_eq!(parsed[0].events.len(), 1);
-        assert_eq!(parsed[0].events[0].kind, "message");
+        assert_eq!(parsed[0].events[0].ty, "message");
         assert_eq!(parsed[0].events[0].attributes[3].key, "code_id");
         assert_eq!(parsed[0].events[0].attributes[3].value, "9");
 
         assert_eq!(parsed[2].events.len(), 1);
-        assert_eq!(parsed[2].events[0].kind, "message");
+        assert_eq!(parsed[2].events[0].ty, "message");
         assert_eq!(parsed[2].events[0].attributes[2].key, "signer");
         assert_eq!(
             parsed[2].events[0].attributes[2].value,

common/client-libs/validator-client/src/nymd/cosmwasm_client/mod.rs

@@ -3,6 +3,7 @@
 
 use crate::nymd::error::NymdError;
 use crate::nymd::wallet::DirectSecp256k1HdWallet;
+use crate::nymd::GasPrice;
 use cosmrs::rpc::{Error as TendermintRpcError, HttpClient, HttpClientUrl};
 use std::convert::TryInto;
 
@@ -23,9 +24,10 @@ where
 pub fn connect_with_signer<U>(
     endpoint: U,
     signer: DirectSecp256k1HdWallet,
+    gas_price: Option<GasPrice>,
 ) -> Result<signing_client::Client, NymdError>
 where
     U: TryInto<HttpClientUrl, Error = TendermintRpcError>,
 {
-    signing_client::Client::connect_with_signer(endpoint, signer)
+    signing_client::Client::connect_with_signer(endpoint, signer, gas_price)
 }

common/client-libs/validator-client/src/nymd/cosmwasm_client/signing_client.rs

@@ -1,36 +1,100 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
+use std::convert::TryInto;
+
+use async_trait::async_trait;
+use cosmrs::bank::MsgSend;
+use cosmrs::distribution::MsgWithdrawDelegatorReward;
+use cosmrs::proto::cosmos::tx::signing::v1beta1::SignMode;
+use cosmrs::rpc::endpoint::broadcast;
+use cosmrs::rpc::{Error as TendermintRpcError, HttpClient, HttpClientUrl, SimpleRequest};
+use cosmrs::staking::{MsgDelegate, MsgUndelegate};
+use cosmrs::tx::{self, Msg, SignDoc, SignerInfo};
+use cosmrs::{cosmwasm, rpc, AccountId, Any, Coin, Tx};
+use log::debug;
+use serde::Serialize;
+use sha2::Digest;
+use sha2::Sha256;
+
 use crate::nymd::cosmwasm_client::client::CosmWasmClient;
 use crate::nymd::cosmwasm_client::helpers::{compress_wasm_code, CheckResponse};
 use crate::nymd::cosmwasm_client::logs::{self, parse_raw_logs};
 use crate::nymd::cosmwasm_client::types::*;
 use crate::nymd::error::NymdError;
+use crate::nymd::fee::{Fee, DEFAULT_SIMULATED_GAS_MULTIPLIER};
 use crate::nymd::wallet::DirectSecp256k1HdWallet;
-use async_trait::async_trait;
-use cosmrs::bank::MsgSend;
-use cosmrs::distribution::MsgWithdrawDelegatorReward;
-use cosmrs::rpc::endpoint::broadcast;
-use cosmrs::rpc::{Error as TendermintRpcError, HttpClient, HttpClientUrl, SimpleRequest};
-use cosmrs::staking::{MsgDelegate, MsgUndelegate};
-use cosmrs::tx::{Fee, Msg, MsgType, SignDoc, SignerInfo};
-use cosmrs::{cosmwasm, rpc, tx, AccountId, Coin};
-use serde::Serialize;
-use sha2::Digest;
-use sha2::Sha256;
-use std::convert::TryInto;
+use crate::nymd::{CosmosCoin, GasPrice};
+
+// we need to have **a** valid secp256k1 signature for simulation purposes.
+// it doesn't matter what it is as long as it parses correctly
+const DUMMY_SECP256K1_SIGNATURE: &[u8] = &[
+    54, 167, 169, 61, 100, 173, 231, 87, 1, 113, 179, 49, 102, 141, 67, 22, 170, 153, 52, 88, 178,
+    159, 200, 11, 37, 138, 76, 221, 187, 70, 104, 123, 98, 216, 190, 249, 149, 81, 1, 158, 0, 220,
+    32, 147, 101, 60, 64, 77, 44, 83, 221, 119, 170, 124, 109, 177, 73, 116, 46, 57, 102, 181, 98,
+    91,
+];
 
 #[async_trait]
 pub trait SigningCosmWasmClient: CosmWasmClient {
     fn signer(&self) -> &DirectSecp256k1HdWallet;
 
+    fn gas_price(&self) -> &GasPrice;
+
+    fn signer_public_key(&self, signer_address: &AccountId) -> Option<tx::SignerPublicKey> {
+        let signer_accounts = self.signer().try_derive_accounts().ok()?;
+        let account_from_signer = signer_accounts
+            .iter()
+            .find(|account| &account.address == signer_address)?;
+        let public_key = account_from_signer.public_key;
+        Some(public_key.into())
+    }
+
+    async fn simulate(
+        &self,
+        signer_address: &AccountId,
+        messages: Vec<Any>,
+        memo: impl Into<String> + Send + 'static,
+    ) -> Result<SimulateResponse, NymdError> {
+        let public_key = self.signer_public_key(signer_address);
+        let sequence_response = self.get_sequence(signer_address).await?;
+
+        let partial_tx = Tx {
+            body: tx::Body {
+                messages,
+                memo: memo.into(),
+                timeout_height: 0u32.into(),
+                extension_options: vec![],
+                non_critical_extension_options: vec![],
+            },
+            auth_info: tx::AuthInfo {
+                signer_infos: vec![tx::SignerInfo {
+                    public_key,
+                    mode_info: tx::ModeInfo::Single(tx::mode_info::Single {
+                        mode: SignMode::Unspecified,
+                    }),
+                    sequence: sequence_response.sequence,
+                }],
+                fee: tx::Fee::from_amount_and_gas(
+                    CosmosCoin {
+                        denom: "".parse().unwrap(),
+                        amount: 0u64.into(),
+                    },
+                    0,
+                ),
+            },
+            signatures: vec![DUMMY_SECP256K1_SIGNATURE.try_into().unwrap()],
+        };
+
+        self.query_simulate(Some(partial_tx), Vec::new()).await
+    }
+
     async fn upload(
         &self,
         sender_address: &AccountId,
         wasm_code: Vec<u8>,
         fee: Fee,
         memo: impl Into<String> + Send + 'static,
-        mut meta: Option<UploadMeta>,
     ) -> Result<UploadResult, NymdError> {
         let compressed = compress_wasm_code(&wasm_code)?;
         let compressed_size = compressed.len();
@@ -41,17 +105,9 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
         let upload_msg = cosmwasm::MsgStoreCode {
             sender: sender_address.clone(),
             wasm_byte_code: compressed,
-            source: meta
-                .as_mut()
-                .map(|meta| meta.source.take())
-                .unwrap_or_default(),
-            builder: meta
-                .as_mut()
-                .map(|meta| meta.builder.take())
-                .unwrap_or_default(),
             instantiate_permission: Default::default(),
         }
-        .to_msg()
+        .to_any()
         .map_err(|_| NymdError::SerializationError("MsgStoreCode".to_owned()))?;
 
         let tx_res = self
@@ -60,12 +116,13 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
             .check_response()?;
 
         let logs = parse_raw_logs(tx_res.deliver_tx.log)?;
+        let gas_info = GasInfo::new(tx_res.deliver_tx.gas_wanted, tx_res.deliver_tx.gas_used);
 
         // TODO: should those strings be extracted into some constants?
         // the reason I think unwrap here is fine is that if the transaction succeeded and those
         // fields do not exist or code_id is not a number, there's no way we can recover, we're probably connected
         // to wrong validator or something
-        let code_id = logs::find_attribute(&logs, "message", "code_id")
+        let code_id = logs::find_attribute(&logs, "store_code", "code_id")
             .unwrap()
             .value
             .parse()
@@ -79,6 +136,7 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
             code_id,
             logs,
             transaction_hash: tx_res.hash,
+            gas_info,
         })
     }
 
@@ -110,10 +168,10 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
             // now this is a weird one. the protobuf files say this field is optional,
             // but if you omit it, the initialisation will fail CheckTx
             label: Some(label),
-            init_msg: serde_json::to_vec(msg)?,
+            msg: serde_json::to_vec(msg)?,
             funds: options.map(|options| options.funds).unwrap_or_default(),
         }
-        .to_msg()
+        .to_any()
         .map_err(|_| NymdError::SerializationError("MsgInstantiateContract".to_owned()))?;
 
         let tx_res = self
@@ -122,12 +180,13 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
             .check_response()?;
 
         let logs = parse_raw_logs(tx_res.deliver_tx.log)?;
+        let gas_info = GasInfo::new(tx_res.deliver_tx.gas_wanted, tx_res.deliver_tx.gas_used);
 
         // TODO: should those strings be extracted into some constants?
         // the reason I think unwrap here is fine is that if the transaction succeeded and those
         // fields do not exist or address is malformed, there's no way we can recover, we're probably connected
         // to wrong validator or something
-        let contract_address = logs::find_attribute(&logs, "message", "contract_address")
+        let contract_address = logs::find_attribute(&logs, "instantiate", "_contract_address")
             .unwrap()
             .value
             .parse()
@@ -137,6 +196,7 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
             contract_address,
             logs,
             transaction_hash: tx_res.hash,
+            gas_info,
         })
     }
 
@@ -153,7 +213,7 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
             new_admin: new_admin.clone(),
             contract: contract_address.clone(),
         }
-        .to_msg()
+        .to_any()
         .map_err(|_| NymdError::SerializationError("MsgUpdateAdmin".to_owned()))?;
 
         let tx_res = self
@@ -161,9 +221,12 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
             .await?
             .check_response()?;
 
+        let gas_info = GasInfo::new(tx_res.deliver_tx.gas_wanted, tx_res.deliver_tx.gas_used);
+
         Ok(ChangeAdminResult {
             logs: parse_raw_logs(tx_res.deliver_tx.log)?,
             transaction_hash: tx_res.hash,
+            gas_info,
         })
     }
 
@@ -178,7 +241,7 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
             sender: sender_address.clone(),
             contract: contract_address.clone(),
         }
-        .to_msg()
+        .to_any()
         .map_err(|_| NymdError::SerializationError("MsgClearAdmin".to_owned()))?;
 
         let tx_res = self
@@ -186,9 +249,12 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
             .await?
             .check_response()?;
 
+        let gas_info = GasInfo::new(tx_res.deliver_tx.gas_wanted, tx_res.deliver_tx.gas_used);
+
         Ok(ChangeAdminResult {
             logs: parse_raw_logs(tx_res.deliver_tx.log)?,
             transaction_hash: tx_res.hash,
+            gas_info,
         })
     }
 
@@ -208,9 +274,9 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
             sender: sender_address.clone(),
             contract: contract_address.clone(),
             code_id,
-            migrate_msg: serde_json::to_vec(msg)?,
+            msg: serde_json::to_vec(msg)?,
         }
-        .to_msg()
+        .to_any()
         .map_err(|_| NymdError::SerializationError("MsgMigrateContract".to_owned()))?;
 
         let tx_res = self
@@ -218,9 +284,12 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
             .await?
             .check_response()?;
 
+        let gas_info = GasInfo::new(tx_res.deliver_tx.gas_wanted, tx_res.deliver_tx.gas_used);
+
         Ok(MigrateResult {
             logs: parse_raw_logs(tx_res.deliver_tx.log)?,
             transaction_hash: tx_res.hash,
+            gas_info,
         })
     }
 
@@ -242,7 +311,7 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
             msg: serde_json::to_vec(msg)?,
             funds,
         }
-        .to_msg()
+        .to_any()
         .map_err(|_| NymdError::SerializationError("MsgExecuteContract".to_owned()))?;
 
         let tx_res = self
@@ -250,9 +319,52 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
             .await?
             .check_response()?;
 
+        let gas_info = GasInfo::new(tx_res.deliver_tx.gas_wanted, tx_res.deliver_tx.gas_used);
+
         Ok(ExecuteResult {
             logs: parse_raw_logs(tx_res.deliver_tx.log)?,
             transaction_hash: tx_res.hash,
+            gas_info,
+        })
+    }
+
+    async fn execute_multiple<I, M>(
+        &self,
+        sender_address: &AccountId,
+        contract_address: &AccountId,
+        msgs: I,
+        fee: Fee,
+        memo: impl Into<String> + Send + 'static,
+    ) -> Result<ExecuteResult, NymdError>
+    where
+        I: IntoIterator<Item = (M, Vec<Coin>)> + Send,
+        M: Serialize,
+    {
+        let messages = msgs
+            .into_iter()
+            .map(|(msg, funds)| {
+                cosmwasm::MsgExecuteContract {
+                    sender: sender_address.clone(),
+                    contract: contract_address.clone(),
+                    msg: serde_json::to_vec(&msg)?,
+                    funds,
+                }
+                .to_any()
+                .map_err(|_| NymdError::SerializationError("MsgExecuteContract".to_owned()))
+            })
+            .collect::<Result<_, _>>()?;
+
+        let tx_res = self
+            .sign_and_broadcast_commit(sender_address, messages, fee, memo)
+            .await?
+            .check_response()?;
+
+        let gas_info = GasInfo::new(tx_res.deliver_tx.gas_wanted, tx_res.deliver_tx.gas_used);
+
+        Ok(ExecuteResult {
+            logs: parse_raw_logs(tx_res.deliver_tx.log)?,
+            transaction_hash: tx_res.hash,
+            gas_info,
         })
     }
 
@@ -269,11 +381,40 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
             to_address: recipient_address.clone(),
             amount,
         }
-        .to_msg()
+        .to_any()
         .map_err(|_| NymdError::SerializationError("MsgSend".to_owned()))?;
 
         self.sign_and_broadcast_commit(sender_address, vec![send_msg], fee, memo)
-            .await
+            .await?
+            .check_response()
+    }
+
+    async fn send_tokens_multiple<I>(
+        &self,
+        sender_address: &AccountId,
+        msgs: I,
+        fee: Fee,
+        memo: impl Into<String> + Send + 'static,
+    ) -> Result<broadcast::tx_commit::Response, NymdError>
+    where
+        I: IntoIterator<Item = (AccountId, Vec<Coin>)> + Send,
+    {
+        let messages = msgs
+            .into_iter()
+            .map(|(to_address, amount)| {
+                MsgSend {
+                    from_address: sender_address.clone(),
+                    to_address,
+                    amount,
+                }
+                .to_any()
+                .map_err(|_| NymdError::SerializationError("MsgExecuteContract".to_owned()))
+            })
+            .collect::<Result<_, _>>()?;
+
+        self.sign_and_broadcast_commit(sender_address, messages, fee, memo)
+            .await?
+            .check_response()
     }
 
     async fn delegate_tokens(
@@ -289,11 +430,12 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
             validator_address: validator_address.to_owned(),
             amount,
         }
-        .to_msg()
+        .to_any()
         .map_err(|_| NymdError::SerializationError("MsgDelegate".to_owned()))?;
 
         self.sign_and_broadcast_commit(delegator_address, vec![delegate_msg], fee, memo)
-            .await
+            .await?
+            .check_response()
     }
 
     async fn undelegate_tokens(
@@ -309,11 +451,12 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
             validator_address: validator_address.to_owned(),
             amount: Some(amount),
         }
-        .to_msg()
+        .to_any()
         .map_err(|_| NymdError::SerializationError("MsgUndelegate".to_owned()))?;
 
         self.sign_and_broadcast_commit(delegator_address, vec![undelegate_msg], fee, memo)
-            .await
+            .await?
+            .check_response()
     }
 
     async fn withdraw_rewards(
@@ -327,21 +470,63 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
             delegator_address: delegator_address.to_owned(),
             validator_address: validator_address.to_owned(),
         }
-        .to_msg()
+        .to_any()
         .map_err(|_| NymdError::SerializationError("MsgWithdrawDelegatorReward".to_owned()))?;
 
         self.sign_and_broadcast_commit(delegator_address, vec![withdraw_msg], fee, memo)
-            .await
+            .await?
+            .check_response()
+    }
+
+    // in this particular case we cannot generalise the argument to `&str` due to lifetime constraints
+    #[allow(clippy::ptr_arg)]
+    async fn determine_transaction_fee(
+        &self,
+        signer_address: &AccountId,
+        messages: &[Any],
+        fee: Fee,
+        memo: &String,
+    ) -> Result<tx::Fee, NymdError> {
+        let fee = match fee {
+            Fee::Manual(fee) => fee,
+            Fee::Auto(multiplier) => {
+                debug!("Trying to simulate gas costs...");
+                // from what I've seen in manual testing, gas estimation does not exist if transaction
+                // fails to get executed (for example if you send 'BondMixnode" with invalid signature)
+                let gas_estimation = self
+                    .simulate(signer_address, messages.to_vec(), memo.clone())
+                    .await?
+                    .gas_info
+                    .ok_or(NymdError::GasEstimationFailure)?
+                    .gas_used;
+
+                let multiplier = multiplier.unwrap_or(DEFAULT_SIMULATED_GAS_MULTIPLIER);
+                let gas = ((gas_estimation.value() as f32 * multiplier) as u64).into();
+
+                debug!("Gas estimation: {}", gas_estimation);
+                debug!("Multiplying the estimation by {}", multiplier);
+                debug!("Final gas limit used: {}", gas);
+
+                let fee = self.gas_price() * gas;
+                tx::Fee::from_amount_and_gas(fee, gas)
+            }
+        };
+        debug!("Fee used for the transaction: {:?}", fee);
+        Ok(fee)
     }
 
     /// Broadcast a transaction, returning immediately.
     async fn sign_and_broadcast_async(
         &self,
         signer_address: &AccountId,
-        messages: Vec<Msg>,
+        messages: Vec<Any>,
         fee: Fee,
         memo: impl Into<String> + Send + 'static,
     ) -> Result<broadcast::tx_async::Response, NymdError> {
+        let memo = memo.into();
+        let fee = self
+            .determine_transaction_fee(signer_address, &messages, fee, &memo)
+            .await?;
         let tx_raw = self.sign(signer_address, messages, fee, memo).await?;
         let tx_bytes = tx_raw
             .to_bytes()
@@ -354,10 +539,14 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
     async fn sign_and_broadcast_sync(
         &self,
         signer_address: &AccountId,
-        messages: Vec<Msg>,
+        messages: Vec<Any>,
         fee: Fee,
         memo: impl Into<String> + Send + 'static,
     ) -> Result<broadcast::tx_sync::Response, NymdError> {
+        let memo = memo.into();
+        let fee = self
+            .determine_transaction_fee(signer_address, &messages, fee, &memo)
+            .await?;
         let tx_raw = self.sign(signer_address, messages, fee, memo).await?;
         let tx_bytes = tx_raw
             .to_bytes()
@@ -370,10 +559,15 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
     async fn sign_and_broadcast_commit(
         &self,
         signer_address: &AccountId,
-        messages: Vec<Msg>,
+        messages: Vec<Any>,
         fee: Fee,
         memo: impl Into<String> + Send + 'static,
     ) -> Result<broadcast::tx_commit::Response, NymdError> {
+        let memo = memo.into();
+        let fee = self
+            .determine_transaction_fee(signer_address, &messages, fee, &memo)
+            .await?;
+
         let tx_raw = self.sign(signer_address, messages, fee, memo).await?;
         let tx_bytes = tx_raw
             .to_bytes()
@@ -385,8 +579,8 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
     fn sign_direct(
         &self,
         signer_address: &AccountId,
-        messages: Vec<Msg>,
-        fee: Fee,
+        messages: Vec<Any>,
+        fee: tx::Fee,
         memo: impl Into<String> + Send + 'static,
         signer_data: SignerData,
     ) -> Result<tx::Raw, NymdError> {
@@ -423,8 +617,8 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
     async fn sign(
         &self,
         signer_address: &AccountId,
-        messages: Vec<Msg>,
-        fee: Fee,
+        messages: Vec<Any>,
+        fee: tx::Fee,
         memo: impl Into<String> + Send + 'static,
     ) -> Result<tx::Raw, NymdError> {
         // TODO: Future optimisation: rather than grabbing current account_number and sequence
@@ -442,28 +636,34 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct Client {
     rpc_client: HttpClient,
     signer: DirectSecp256k1HdWallet,
+    gas_price: GasPrice,
 }
 
 impl Client {
     pub fn connect_with_signer<U>(
         endpoint: U,
         signer: DirectSecp256k1HdWallet,
+        gas_price: Option<GasPrice>,
     ) -> Result<Self, NymdError>
     where
         U: TryInto<HttpClientUrl, Error = TendermintRpcError>,
     {
         let rpc_client = HttpClient::new(endpoint)?;
-        Ok(Client { rpc_client, signer })
+        Ok(Client {
+            rpc_client,
+            signer,
+            gas_price: gas_price.unwrap_or_default(),
+        })
     }
 }
 
 #[async_trait]
 impl rpc::Client for Client {
-    async fn perform<R>(&self, request: R) -> rpc::Result<R::Response>
+    async fn perform<R>(&self, request: R) -> Result<R::Response, rpc::Error>
     where
         R: SimpleRequest,
     {
@@ -479,4 +679,8 @@ impl SigningCosmWasmClient for Client {
     fn signer(&self) -> &DirectSecp256k1HdWallet {
         &self.signer
     }
+
+    fn gas_price(&self) -> &GasPrice {
+        &self.gas_price
+    }
 }

common/client-libs/validator-client/src/nymd/cosmwasm_client/types.rs

@@ -7,15 +7,19 @@ use crate::nymd::cosmwasm_client::logs::Log;
 use crate::nymd::error::NymdError;
 use cosmrs::crypto::PublicKey;
 use cosmrs::proto::cosmos::auth::v1beta1::BaseAccount;
-use cosmrs::proto::cosmwasm::wasm::v1beta1::{
+use cosmrs::proto::cosmos::base::abci::v1beta1::{
+    GasInfo as ProtoGasInfo, Result as ProtoAbciResult,
+};
+use cosmrs::proto::cosmos::tx::v1beta1::SimulateResponse as ProtoSimulateResponse;
+use cosmrs::proto::cosmwasm::wasm::v1::{
     CodeInfoResponse, ContractCodeHistoryEntry as ProtoContractCodeHistoryEntry,
     ContractCodeHistoryOperationType, ContractInfo as ProtoContractInfo,
 };
-use cosmrs::tendermint::chain;
-use cosmrs::tx::{AccountNumber, SequenceNumber};
+use cosmrs::tendermint::{abci, chain};
+use cosmrs::tx::{AccountNumber, Gas, SequenceNumber};
 use cosmrs::{tx, AccountId, Coin};
 use serde::Serialize;
-use std::convert::TryFrom;
+use std::convert::{TryFrom, TryInto};
 
 pub type ContractCodeId = u64;
 
@@ -70,18 +74,6 @@ pub struct Code {
 
     /// sha256 hash of the code stored
     pub data_hash: Vec<u8>,
-
-    /// An URL to a .tar.gz archive of the source code of the contract,
-    /// which can be used to reproducibly build the Wasm bytecode.
-    ///
-    /// @see https://github.com/CosmWasm/cosmwasm-verify
-    pub source: Option<String>,
-
-    /// A docker image (including version) to reproducibly build the Wasm bytecode from the source code.
-    ///
-    /// @example ```cosmwasm/rust-optimizer:0.8.0```
-    /// @see https://github.com/CosmWasm/cosmwasm-verify
-    pub builder: Option<String>,
 }
 
 impl TryFrom<CodeInfoResponse> for Code {
@@ -92,31 +84,16 @@ impl TryFrom<CodeInfoResponse> for Code {
             code_id,
             creator,
             data_hash,
-            source,
-            builder,
         } = value;
 
         let creator = creator
             .parse()
             .map_err(|_| NymdError::MalformedAccountAddress(creator))?;
 
-        let source = if source.is_empty() {
-            None
-        } else {
-            Some(source)
-        };
-        let builder = if builder.is_empty() {
-            None
-        } else {
-            Some(builder)
-        };
-
         Ok(Code {
             code_id,
             creator,
             data_hash,
-            source,
-            builder,
         })
     }
 }
@@ -242,6 +219,101 @@ impl TryFrom<ProtoContractCodeHistoryEntry> for ContractCodeHistoryEntry {
     }
 }
 
+#[derive(Debug)]
+pub struct GasInfo {
+    /// GasWanted is the maximum units of work we allow this tx to perform.
+    pub gas_wanted: Gas,
+
+    /// GasUsed is the amount of gas actually consumed.
+    pub gas_used: Gas,
+}
+
+impl From<ProtoGasInfo> for GasInfo {
+    fn from(value: ProtoGasInfo) -> Self {
+        GasInfo {
+            gas_wanted: value.gas_wanted.into(),
+            gas_used: value.gas_used.into(),
+        }
+    }
+}
+
+impl GasInfo {
+    pub fn new(gas_wanted: Gas, gas_used: Gas) -> Self {
+        GasInfo {
+            gas_wanted,
+            gas_used,
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct AbciResult {
+    /// Data is any data returned from message or handler execution. It MUST be
+    /// length prefixed in order to separate data from multiple message executions.
+    pub data: Vec<u8>,
+
+    /// Log contains the log information from message or handler execution.
+    // todo: try to parse into Log?
+    pub log: String,
+
+    /// Events contains a slice of Event objects that were emitted during message
+    /// or handler execution.
+    pub events: Vec<abci::Event>,
+}
+
+impl TryFrom<ProtoAbciResult> for AbciResult {
+    type Error = NymdError;
+
+    fn try_from(value: ProtoAbciResult) -> Result<Self, Self::Error> {
+        let mut events = Vec::with_capacity(value.events.len());
+
+        for proto_event in value.events.into_iter() {
+            let type_str = proto_event.r#type;
+
+            let mut attributes = Vec::with_capacity(proto_event.attributes.len());
+            for proto_attribute in proto_event.attributes.into_iter() {
+                let stringified_ked = String::from_utf8(proto_attribute.key)
+                    .map_err(|_| NymdError::DeserializationError("EventAttributeKey".to_owned()))?;
+                let stringified_value = String::from_utf8(proto_attribute.value)
+                    .map_err(|_| NymdError::DeserializationError("EventAttributeKey".to_owned()))?;
+
+                attributes.push(abci::tag::Tag {
+                    key: stringified_ked.parse().unwrap(),
+                    value: stringified_value.parse().unwrap(),
+                })
+            }
+
+            events.push(abci::Event {
+                type_str,
+                attributes,
+            })
+        }
+
+        Ok(AbciResult {
+            data: value.data,
+            log: value.log,
+            events,
+        })
+    }
+}
+
+#[derive(Debug)]
+pub struct SimulateResponse {
+    pub gas_info: Option<GasInfo>,
+    pub result: Option<AbciResult>,
+}
+
+impl TryFrom<ProtoSimulateResponse> for SimulateResponse {
+    type Error = NymdError;
+
+    fn try_from(value: ProtoSimulateResponse) -> Result<Self, Self::Error> {
+        Ok(SimulateResponse {
+            gas_info: value.gas_info.map(|gas_info| gas_info.into()),
+            result: value.result.map(|result| result.try_into()).transpose()?,
+        })
+    }
+}
+
 // ##############################################################################
 // types specific to the signing client (perhaps they should go to separate file)
 // ##############################################################################
@@ -254,21 +326,6 @@ pub struct SignerData {
     pub chain_id: chain::Id,
 }
 
-#[derive(Debug)]
-pub struct UploadMeta {
-    /// An URL to a .tar.gz archive of the source code of the contract,
-    /// which can be used to reproducibly build the Wasm bytecode.
-    ///
-    /// @see https://github.com/CosmWasm/cosmwasm-verify
-    pub source: Option<String>,
-
-    /// A docker image (including version) to reproducibly build the Wasm bytecode from the source code.
-    ///
-    /// @example ```cosmwasm/rust-optimizer:0.8.0```
-    /// @see https://github.com/CosmWasm/cosmwasm-verify
-    pub builder: Option<String>,
-}
-
 #[derive(Debug)]
 pub struct UploadResult {
     /// Size of the original wasm code in bytes
@@ -290,6 +347,8 @@ pub struct UploadResult {
 
     /// Transaction hash (might be used as transaction ID)
     pub transaction_hash: tx::Hash,
+
+    pub gas_info: GasInfo,
 }
 
 #[derive(Debug)]
@@ -316,6 +375,8 @@ pub struct InstantiateResult {
 
     /// Transaction hash (might be used as transaction ID)
     pub transaction_hash: tx::Hash,
+
+    pub gas_info: GasInfo,
 }
 
 #[derive(Debug)]
@@ -324,6 +385,8 @@ pub struct ChangeAdminResult {
 
     /// Transaction hash (might be used as transaction ID)
     pub transaction_hash: tx::Hash,
+
+    pub gas_info: GasInfo,
 }
 
 #[derive(Debug)]
@@ -332,6 +395,8 @@ pub struct MigrateResult {
 
     /// Transaction hash (might be used as transaction ID)
     pub transaction_hash: tx::Hash,
+
+    pub gas_info: GasInfo,
 }
 
 #[derive(Debug)]
@@ -340,4 +405,6 @@ pub struct ExecuteResult {
 
     /// Transaction hash (might be used as transaction ID)
     pub transaction_hash: tx::Hash,
+
+    pub gas_info: GasInfo,
 }

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

@@ -2,11 +2,16 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::nymd::cosmwasm_client::types::ContractCodeId;
-use cosmrs::tendermint::block;
-use cosmrs::{bip32, rpc, tx, AccountId};
+use cosmrs::tendermint::{abci, block};
+use cosmrs::{bip32, tx, AccountId};
 use std::io;
 use thiserror::Error;
 
+pub use cosmrs::rpc::error::{
+    Error as TendermintRpcError, ErrorDetail as TendermintRpcErrorDetail,
+};
+pub use cosmrs::rpc::response_error::{Code, ResponseError};
+
 #[derive(Debug, Error)]
 pub enum NymdError {
     #[error("No contract address is available to perform the call")]
@@ -31,7 +36,7 @@ pub enum NymdError {
     InvalidTxHash(String),
 
     #[error("There was an issue with a tendermint RPC request - {0}")]
-    TendermintError(#[from] rpc::Error),
+    TendermintError(#[from] TendermintRpcError),
 
     #[error("There was an issue when attempting to serialize data")]
     SerializationError(String),
@@ -97,4 +102,63 @@ pub enum NymdError {
 
     #[error("The provided gas price is malformed")]
     MalformedGasPrice,
+
+    #[error("Failed to estimate gas price for the transaction")]
+    GasEstimationFailure,
+
+    #[error("Abci query failed with code {0} - {1}")]
+    AbciError(u32, abci::Log),
+}
+
+impl NymdError {
+    pub fn is_tendermint_response_timeout(&self) -> bool {
+        match &self {
+            NymdError::TendermintError(TendermintRpcError(
+                TendermintRpcErrorDetail::Response(err),
+                _,
+            )) => {
+                let response = &err.source;
+                if response.code() == Code::InternalError {
+                    // 0.34 (and earlier) versions of tendermint seemed to be using phrase "timed out waiting ..."
+                    // (https://github.com/tendermint/tendermint/blob/v0.34.13/rpc/core/mempool.go#L124)
+                    // while 0.35+ has "timeout waiting for ..."
+                    // https://github.com/tendermint/tendermint/blob/v0.35.0-rc3/internal/rpc/core/mempool.go#L99
+                    // note that as of the time of writing this comment (08.10.2021), the most recent version
+                    // of cosmos-sdk (v0.44.1) uses tendermint 0.34.13
+                    if let Some(data) = response.data() {
+                        data.contains("timed out") || data.contains("timeout")
+                    } else {
+                        false
+                    }
+                } else {
+                    false
+                }
+            }
+            _ => false,
+        }
+    }
+
+    pub fn is_tendermint_response_duplicate(&self) -> bool {
+        match &self {
+            NymdError::TendermintError(TendermintRpcError(
+                TendermintRpcErrorDetail::Response(err),
+                _,
+            )) => {
+                let response = &err.source;
+                if response.code() == Code::InternalError {
+                    // this particular error message seems to be unchanged between 0.34 and newer versions
+                    // https://github.com/tendermint/tendermint/blob/v0.34.13/mempool/errors.go#L10
+                    // https://github.com/tendermint/tendermint/blob/v0.35.0-rc3/types/mempool.go#L10
+                    if let Some(data) = response.data() {
+                        data.contains("tx already exists in cache")
+                    } else {
+                        false
+                    }
+                } else {
+                    false
+                }
+            }
+            _ => false,
+        }
+    }
 }

common/client-libs/validator-client/src/nymd/fee/gas_price.rs

@@ -3,8 +3,10 @@
 
 use crate::nymd::error::NymdError;
 use config::defaults;
-use cosmrs::Denom;
-use cosmwasm_std::Decimal;
+use cosmrs::tx::Gas;
+use cosmrs::{Coin, Denom};
+use cosmwasm_std::{Decimal, Fraction, Uint128};
+use std::ops::Mul;
 use std::str::FromStr;
 
 /// A gas price, i.e. the price of a single unit of gas. This is typically a fraction of
@@ -18,6 +20,36 @@ pub struct GasPrice {
     pub denom: Denom,
 }
 
+impl<'a> Mul<Gas> for &'a GasPrice {
+    type Output = Coin;
+
+    fn mul(self, gas_limit: Gas) -> Self::Output {
+        let limit_uint128 = Uint128::from(gas_limit.value());
+        let mut amount = self.amount * limit_uint128;
+
+        let gas_price_numerator = self.amount.numerator();
+        let gas_price_denominator = self.amount.denominator();
+
+        // gas price is a fraction of the smallest fee token unit, so we must ensure that
+        // for any multiplication, we have rounded up
+        //
+        // I don't really like the this solution as it has a theoretical chance of
+        // overflowing (internally cosmwasm uses U256 to avoid that)
+        // however, realistically that is impossible to happen as the resultant value
+        // would have to be way higher than our token limit of 10^15 (1 billion of tokens * 1 million for denomination)
+        // and max value of u128 is approximately 10^38
+        if limit_uint128 * gas_price_numerator > amount * gas_price_denominator {
+            amount += Uint128::new(1);
+        }
+
+        assert!(amount.u128() <= u64::MAX as u128);
+        Coin {
+            denom: self.denom.clone(),
+            amount: (amount.u128() as u64).into(),
+        }
+    }
+}
+
 impl FromStr for GasPrice {
     type Err = NymdError;
 
@@ -78,4 +110,15 @@ mod tests {
         assert!("0.025 upunk".parse::<GasPrice>().is_err());
         assert!("0.025UPUNK".parse::<GasPrice>().is_err());
     }
+
+    #[test]
+    fn gas_limit_multiplication() {
+        // real world example that caused an issue when the result was rounded down
+        let gas_price: GasPrice = "0.025upunk".parse().unwrap();
+        let gas_limit: Gas = 157500u64.into();
+
+        let fee = &gas_price * gas_limit;
+        // the failing behaviour was result value of 3937
+        assert_eq!(fee.amount, 3938u64.into());
+    }
 }

common/client-libs/validator-client/src/nymd/fee/helpers.rs

@@ -4,12 +4,11 @@
 use crate::nymd::GasPrice;
 use cosmrs::tx::{Fee, Gas};
 use cosmrs::Coin;
-use cosmwasm_std::Uint128;
 use serde::{Deserialize, Serialize};
 use std::fmt;
-use ts_rs::TS;
 
-#[derive(Debug, Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, Serialize, Deserialize, TS)]
+#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
+#[derive(Debug, Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, Serialize, Deserialize)]
 pub enum Operation {
     Upload,
     Init,
@@ -18,26 +17,33 @@ pub enum Operation {
     Send,
 
     BondMixnode,
+    BondMixnodeOnBehalf,
     UnbondMixnode,
+    UnbondMixnodeOnBehalf,
     DelegateToMixnode,
+    DelegateToMixnodeOnBehalf,
     UndelegateFromMixnode,
+    UndelegateFromMixnodeOnBehalf,
 
     BondGateway,
+    BondGatewayOnBehalf,
     UnbondGateway,
-    DelegateToGateway,
-    UndelegateFromGateway,
+    UnbondGatewayOnBehalf,
 
-    UpdateStateParams,
+    UpdateContractSettings,
+
+    BeginMixnodeRewarding,
+    FinishMixnodeRewarding,
+
+    TrackUnbondGateway,
+    TrackUnbondMixnode,
+    WithdrawVestedCoins,
+    TrackUndelegation,
+    CreatePeriodicVestingAccount,
 }
 
 pub(crate) fn calculate_fee(gas_price: &GasPrice, gas_limit: Gas) -> Coin {
-    let limit_uint128 = Uint128::from(gas_limit.value());
-    let amount = gas_price.amount * limit_uint128;
-    assert!(amount.u128() <= u64::MAX as u128);
-    Coin {
-        denom: gas_price.denom.clone(),
-        amount: (amount.u128() as u64).into(),
-    }
+    gas_price * gas_limit
 }
 
 impl fmt::Display for Operation {
@@ -49,14 +55,27 @@ impl fmt::Display for Operation {
             Operation::ChangeAdmin => f.write_str("ChangeAdmin"),
             Operation::Send => f.write_str("Send"),
             Operation::BondMixnode => f.write_str("BondMixnode"),
+            Operation::BondMixnodeOnBehalf => f.write_str("BondMixnodeOnBehalf"),
             Operation::UnbondMixnode => f.write_str("UnbondMixnode"),
-            Operation::DelegateToMixnode => f.write_str("DelegateToMixnode"),
-            Operation::UndelegateFromMixnode => f.write_str("UndelegateFromMixnode"),
+            Operation::UnbondMixnodeOnBehalf => f.write_str("UnbondMixnodeOnBehalf"),
             Operation::BondGateway => f.write_str("BondGateway"),
+            Operation::BondGatewayOnBehalf => f.write_str("BondGatewayOnBehalf"),
             Operation::UnbondGateway => f.write_str("UnbondGateway"),
-            Operation::DelegateToGateway => f.write_str("DelegateToGateway"),
-            Operation::UndelegateFromGateway => f.write_str("UndelegateFromGateway"),
-            Operation::UpdateStateParams => f.write_str("UpdateStateParams"),
+            Operation::UnbondGatewayOnBehalf => f.write_str("UnbondGatewayOnBehalf"),
+            Operation::DelegateToMixnode => f.write_str("DelegateToMixnode"),
+            Operation::DelegateToMixnodeOnBehalf => f.write_str("DelegateToMixnodeOnBehalf"),
+            Operation::UndelegateFromMixnode => f.write_str("UndelegateFromMixnode"),
+            Operation::UndelegateFromMixnodeOnBehalf => {
+                f.write_str("UndelegateFromMixnodeOnBehalf")
+            }
+            Operation::UpdateContractSettings => f.write_str("UpdateContractSettings"),
+            Operation::BeginMixnodeRewarding => f.write_str("BeginMixnodeRewarding"),
+            Operation::FinishMixnodeRewarding => f.write_str("FinishMixnodeRewarding"),
+            Operation::TrackUnbondGateway => f.write_str("TrackUnbondGateway"),
+            Operation::TrackUnbondMixnode => f.write_str("TrackUnbondMixnode"),
+            Operation::WithdrawVestedCoins => f.write_str("WithdrawVestedCoins"),
+            Operation::TrackUndelegation => f.write_str("TrackUndelegation"),
+            Operation::CreatePeriodicVestingAccount => f.write_str("CreatePeriodicVestingAccount"),
         }
     }
 }
@@ -65,36 +84,50 @@ impl Operation {
     // TODO: some value tweaking
     pub fn default_gas_limit(&self) -> Gas {
         match self {
-            Operation::Upload => 2_500_000u64.into(),
+            Operation::Upload => 3_000_000u64.into(),
             Operation::Init => 500_000u64.into(),
             Operation::Migrate => 200_000u64.into(),
             Operation::ChangeAdmin => 80_000u64.into(),
             Operation::Send => 80_000u64.into(),
 
             Operation::BondMixnode => 175_000u64.into(),
+            Operation::BondMixnodeOnBehalf => 200_000u64.into(),
             Operation::UnbondMixnode => 175_000u64.into(),
+            Operation::UnbondMixnodeOnBehalf => 175_000u64.into(),
             Operation::DelegateToMixnode => 175_000u64.into(),
+            Operation::DelegateToMixnodeOnBehalf => 175_000u64.into(),
             Operation::UndelegateFromMixnode => 175_000u64.into(),
+            Operation::UndelegateFromMixnodeOnBehalf => 175_000u64.into(),
 
             Operation::BondGateway => 175_000u64.into(),
+            Operation::BondGatewayOnBehalf => 200_000u64.into(),
             Operation::UnbondGateway => 175_000u64.into(),
-            Operation::DelegateToGateway => 175_000u64.into(),
-            Operation::UndelegateFromGateway => 175_000u64.into(),
+            Operation::UnbondGatewayOnBehalf => 200_000u64.into(),
 
-            Operation::UpdateStateParams => 175_000u64.into(),
+            Operation::UpdateContractSettings => 175_000u64.into(),
+            Operation::BeginMixnodeRewarding => 175_000u64.into(),
+            Operation::FinishMixnodeRewarding => 175_000u64.into(),
+            Operation::TrackUnbondGateway => 175_000u64.into(),
+            Operation::TrackUnbondMixnode => 175_000u64.into(),
+            Operation::WithdrawVestedCoins => 175_000u64.into(),
+            Operation::TrackUndelegation => 175_000u64.into(),
+            Operation::CreatePeriodicVestingAccount => 175_000u64.into(),
         }
     }
 
-    pub(crate) fn determine_fee(&self, gas_price: &GasPrice, gas_limit: Option<Gas>) -> Fee {
+    pub(crate) fn determine_custom_fee(gas_price: &GasPrice, gas_limit: Gas) -> Fee {
         // we need to know 2 of the following 3 parameters (the third one is being implicit) in order to construct Fee:
         // (source: https://docs.cosmos.network/v0.42/basics/gas-fees.html)
         // - gas price
         // - gas limit
         // - fees
-        let gas_limit = gas_limit.unwrap_or_else(|| self.default_gas_limit());
         let fee = calculate_fee(gas_price, gas_limit);
         Fee::from_amount_and_gas(fee, gas_limit)
     }
+
+    pub fn default_fee(&self, gas_price: &GasPrice) -> Fee {
+        Self::determine_custom_fee(gas_price, self.default_gas_limit())
+    }
 }
 
 #[cfg(test)]

common/client-libs/validator-client/src/nymd/fee/mod.rs

@@ -0,0 +1,33 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use cosmrs::tx;
+
+pub mod gas_price;
+pub mod helpers;
+
+pub const DEFAULT_SIMULATED_GAS_MULTIPLIER: f32 = 1.3;
+
+#[derive(Debug, Clone)]
+pub enum Fee {
+    Manual(tx::Fee),
+    Auto(Option<f32>),
+}
+
+impl From<tx::Fee> for Fee {
+    fn from(fee: tx::Fee) -> Self {
+        Fee::Manual(fee)
+    }
+}
+
+impl From<f32> for Fee {
+    fn from(multiplier: f32) -> Self {
+        Fee::Auto(Some(multiplier))
+    }
+}
+
+impl Default for Fee {
+    fn default() -> Self {
+        Fee::Auto(Some(DEFAULT_SIMULATED_GAS_MULTIPLIER))
+    }
+}

common/client-libs/validator-client/src/nymd/traits/mod.rs

@@ -0,0 +1,8 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+mod vesting_query_client;
+mod vesting_signing_client;
+
+pub use vesting_query_client::VestingQueryClient;
+pub use vesting_signing_client::VestingSigningClient;

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

@@ -0,0 +1,176 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+pub use crate::nymd::cosmwasm_client::client::CosmWasmClient;
+use crate::nymd::error::NymdError;
+use crate::nymd::NymdClient;
+use async_trait::async_trait;
+use cosmwasm_std::{Coin, Timestamp};
+use vesting_contract::messages::QueryMsg as VestingQueryMsg;
+
+#[async_trait]
+pub trait VestingQueryClient {
+    async fn locked_coins(
+        &self,
+        address: &str,
+        block_time: Option<Timestamp>,
+    ) -> Result<Coin, NymdError>;
+
+    async fn spendable_coins(
+        &self,
+        vesting_account_address: &str,
+        block_time: Option<Timestamp>,
+    ) -> Result<Coin, NymdError>;
+
+    async fn vested_coins(
+        &self,
+        vesting_account_address: &str,
+        block_time: Option<Timestamp>,
+    ) -> Result<Coin, NymdError>;
+
+    async fn vesting_coins(
+        &self,
+        vesting_account_address: &str,
+        block_time: Option<Timestamp>,
+    ) -> Result<Coin, NymdError>;
+
+    async fn vesting_start_time(
+        &self,
+        vesting_account_address: &str,
+    ) -> Result<Timestamp, NymdError>;
+
+    async fn vesting_end_time(&self, vesting_account_address: &str)
+        -> Result<Timestamp, NymdError>;
+
+    async fn original_vesting(&self, vesting_account_address: &str) -> Result<Coin, NymdError>;
+
+    async fn delegated_free(
+        &self,
+        vesting_account_address: &str,
+        block_time: Option<Timestamp>,
+    ) -> Result<Coin, NymdError>;
+
+    async fn delegated_vesting(
+        &self,
+        vesting_account_address: &str,
+        block_time: Option<Timestamp>,
+    ) -> Result<Coin, NymdError>;
+}
+
+#[async_trait]
+impl<C: CosmWasmClient + Sync + Send> VestingQueryClient for NymdClient<C> {
+    async fn locked_coins(
+        &self,
+        vesting_account_address: &str,
+        block_time: Option<Timestamp>,
+    ) -> Result<Coin, NymdError> {
+        let request = VestingQueryMsg::LockedCoins {
+            vesting_account_address: vesting_account_address.to_string(),
+            block_time,
+        };
+        self.client
+            .query_contract_smart(self.vesting_contract_address()?, &request)
+            .await
+    }
+
+    async fn spendable_coins(
+        &self,
+        vesting_account_address: &str,
+        block_time: Option<Timestamp>,
+    ) -> Result<Coin, NymdError> {
+        let request = VestingQueryMsg::SpendableCoins {
+            vesting_account_address: vesting_account_address.to_string(),
+            block_time,
+        };
+        self.client
+            .query_contract_smart(self.vesting_contract_address()?, &request)
+            .await
+    }
+    async fn vested_coins(
+        &self,
+        vesting_account_address: &str,
+        block_time: Option<Timestamp>,
+    ) -> Result<Coin, NymdError> {
+        let request = VestingQueryMsg::GetVestedCoins {
+            vesting_account_address: vesting_account_address.to_string(),
+            block_time,
+        };
+        self.client
+            .query_contract_smart(self.vesting_contract_address()?, &request)
+            .await
+    }
+    async fn vesting_coins(
+        &self,
+        vesting_account_address: &str,
+        block_time: Option<Timestamp>,
+    ) -> Result<Coin, NymdError> {
+        let request = VestingQueryMsg::GetVestingCoins {
+            vesting_account_address: vesting_account_address.to_string(),
+            block_time,
+        };
+        self.client
+            .query_contract_smart(self.vesting_contract_address()?, &request)
+            .await
+    }
+
+    async fn vesting_start_time(
+        &self,
+        vesting_account_address: &str,
+    ) -> Result<Timestamp, NymdError> {
+        let request = VestingQueryMsg::GetStartTime {
+            vesting_account_address: vesting_account_address.to_string(),
+        };
+        self.client
+            .query_contract_smart(self.vesting_contract_address()?, &request)
+            .await
+    }
+
+    async fn vesting_end_time(
+        &self,
+        vesting_account_address: &str,
+    ) -> Result<Timestamp, NymdError> {
+        let request = VestingQueryMsg::GetEndTime {
+            vesting_account_address: vesting_account_address.to_string(),
+        };
+        self.client
+            .query_contract_smart(self.vesting_contract_address()?, &request)
+            .await
+    }
+
+    async fn original_vesting(&self, vesting_account_address: &str) -> Result<Coin, NymdError> {
+        let request = VestingQueryMsg::GetOriginalVesting {
+            vesting_account_address: vesting_account_address.to_string(),
+        };
+        self.client
+            .query_contract_smart(self.vesting_contract_address()?, &request)
+            .await
+    }
+
+    async fn delegated_free(
+        &self,
+        vesting_account_address: &str,
+        block_time: Option<Timestamp>,
+    ) -> Result<Coin, NymdError> {
+        let request = VestingQueryMsg::GetDelegatedFree {
+            vesting_account_address: vesting_account_address.to_string(),
+            block_time,
+        };
+        self.client
+            .query_contract_smart(self.vesting_contract_address()?, &request)
+            .await
+    }
+
+    async fn delegated_vesting(
+        &self,
+        vesting_account_address: &str,
+        block_time: Option<Timestamp>,
+    ) -> Result<Coin, NymdError> {
+        let request = VestingQueryMsg::GetDelegatedVesting {
+            vesting_account_address: vesting_account_address.to_string(),
+            block_time,
+        };
+        self.client
+            .query_contract_smart(self.vesting_contract_address()?, &request)
+            .await
+    }
+}

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

@@ -0,0 +1,294 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+pub use crate::nymd::cosmwasm_client::signing_client::SigningCosmWasmClient;
+use crate::nymd::cosmwasm_client::types::ExecuteResult;
+use crate::nymd::error::NymdError;
+use crate::nymd::fee::helpers::Operation;
+use crate::nymd::{cosmwasm_coin_to_cosmos_coin, NymdClient};
+use async_trait::async_trait;
+use cosmwasm_std::Coin;
+use mixnet_contract::{Gateway, IdentityKey, IdentityKeyRef, MixNode};
+use vesting_contract::messages::ExecuteMsg as VestingExecuteMsg;
+
+#[async_trait]
+pub trait VestingSigningClient {
+    async fn vesting_bond_gateway(
+        &self,
+        gateway: Gateway,
+        owner_signature: &str,
+        pledge: Coin,
+    ) -> Result<ExecuteResult, NymdError>;
+
+    async fn vesting_unbond_gateway(&self) -> Result<ExecuteResult, NymdError>;
+
+    async fn vesting_track_unbond_gateway(
+        &self,
+        owner: &str,
+        amount: Coin,
+    ) -> Result<ExecuteResult, NymdError>;
+
+    async fn vesting_bond_mixnode(
+        &self,
+        mix_node: MixNode,
+        owner_signature: &str,
+        pledge: Coin,
+    ) -> Result<ExecuteResult, NymdError>;
+    async fn vesting_unbond_mixnode(&self) -> Result<ExecuteResult, NymdError>;
+
+    async fn vesting_track_unbond_mixnode(
+        &self,
+        owner: &str,
+        amount: Coin,
+    ) -> Result<ExecuteResult, NymdError>;
+
+    async fn withdraw_vested_coins(&self, amount: Coin) -> Result<ExecuteResult, NymdError>;
+
+    async fn vesting_track_undelegation(
+        &self,
+        address: &str,
+        mix_identity: IdentityKey,
+        amount: Coin,
+    ) -> Result<ExecuteResult, NymdError>;
+
+    async fn vesting_delegate_to_mixnode<'a>(
+        &self,
+        mix_identity: IdentityKeyRef<'a>,
+        amount: &Coin,
+    ) -> Result<ExecuteResult, NymdError>;
+
+    async fn vesting_undelegate_from_mixnode<'a>(
+        &self,
+        mix_identity: IdentityKeyRef<'a>,
+    ) -> Result<ExecuteResult, NymdError>;
+
+    async fn create_periodic_vesting_account(
+        &self,
+        address: &str,
+        start_time: Option<u64>,
+        amount: Coin,
+    ) -> Result<ExecuteResult, NymdError>;
+}
+
+#[async_trait]
+impl<C: SigningCosmWasmClient + Sync + Send> VestingSigningClient for NymdClient<C> {
+    async fn vesting_bond_gateway(
+        &self,
+        gateway: Gateway,
+        owner_signature: &str,
+        pledge: Coin,
+    ) -> Result<ExecuteResult, NymdError> {
+        let fee = self.operation_fee(Operation::BondGateway);
+        let req = VestingExecuteMsg::BondGateway {
+            gateway,
+            owner_signature: owner_signature.to_string(),
+        };
+        self.client
+            .execute(
+                self.address(),
+                self.vesting_contract_address()?,
+                &req,
+                fee,
+                "VestingContract::BondGateway",
+                vec![cosmwasm_coin_to_cosmos_coin(pledge)],
+            )
+            .await
+    }
+
+    async fn vesting_unbond_gateway(&self) -> Result<ExecuteResult, NymdError> {
+        let fee = self.operation_fee(Operation::UnbondGateway);
+        let req = VestingExecuteMsg::UnbondGateway {};
+        self.client
+            .execute(
+                self.address(),
+                self.vesting_contract_address()?,
+                &req,
+                fee,
+                "VestingContract::UnbondGateway",
+                vec![],
+            )
+            .await
+    }
+
+    async fn vesting_track_unbond_gateway(
+        &self,
+        owner: &str,
+        amount: Coin,
+    ) -> Result<ExecuteResult, NymdError> {
+        let fee = self.operation_fee(Operation::TrackUnbondGateway);
+        let req = VestingExecuteMsg::TrackUnbondGateway {
+            owner: owner.to_string(),
+            amount,
+        };
+        self.client
+            .execute(
+                self.address(),
+                self.vesting_contract_address()?,
+                &req,
+                fee,
+                "VestingContract::TrackUnbondGateway",
+                vec![],
+            )
+            .await
+    }
+
+    async fn vesting_bond_mixnode(
+        &self,
+        mix_node: MixNode,
+        owner_signature: &str,
+        pledge: Coin,
+    ) -> Result<ExecuteResult, NymdError> {
+        let fee = self.operation_fee(Operation::BondMixnode);
+        let req = VestingExecuteMsg::BondMixnode {
+            mix_node,
+            owner_signature: owner_signature.to_string(),
+        };
+        self.client
+            .execute(
+                self.address(),
+                self.vesting_contract_address()?,
+                &req,
+                fee,
+                "VestingContract::BondMixnode",
+                vec![cosmwasm_coin_to_cosmos_coin(pledge)],
+            )
+            .await
+    }
+
+    async fn vesting_unbond_mixnode(&self) -> Result<ExecuteResult, NymdError> {
+        let fee = self.operation_fee(Operation::UnbondMixnode);
+        let req = VestingExecuteMsg::UnbondMixnode {};
+        self.client
+            .execute(
+                self.address(),
+                self.vesting_contract_address()?,
+                &req,
+                fee,
+                "VestingContract::UnbondMixnode",
+                vec![],
+            )
+            .await
+    }
+
+    async fn vesting_track_unbond_mixnode(
+        &self,
+        owner: &str,
+        amount: Coin,
+    ) -> Result<ExecuteResult, NymdError> {
+        let fee = self.operation_fee(Operation::TrackUnbondMixnode);
+        let req = VestingExecuteMsg::TrackUnbondMixnode {
+            owner: owner.to_string(),
+            amount,
+        };
+        self.client
+            .execute(
+                self.address(),
+                self.vesting_contract_address()?,
+                &req,
+                fee,
+                "VestingContract::TrackUnbondMixnode",
+                vec![],
+            )
+            .await
+    }
+
+    async fn withdraw_vested_coins(&self, amount: Coin) -> Result<ExecuteResult, NymdError> {
+        let fee = self.operation_fee(Operation::WithdrawVestedCoins);
+        let req = VestingExecuteMsg::WithdrawVestedCoins { amount };
+        self.client
+            .execute(
+                self.address(),
+                self.vesting_contract_address()?,
+                &req,
+                fee,
+                "VestingContract::WithdrawVested",
+                vec![],
+            )
+            .await
+    }
+
+    async fn vesting_track_undelegation(
+        &self,
+        address: &str,
+        mix_identity: IdentityKey,
+        amount: Coin,
+    ) -> Result<ExecuteResult, NymdError> {
+        let fee = self.operation_fee(Operation::TrackUndelegation);
+        let req = VestingExecuteMsg::TrackUndelegation {
+            owner: address.to_string(),
+            mix_identity,
+            amount,
+        };
+        self.client
+            .execute(
+                self.address(),
+                self.vesting_contract_address()?,
+                &req,
+                fee,
+                "VestingContract::TrackUndelegation",
+                vec![],
+            )
+            .await
+    }
+    async fn vesting_delegate_to_mixnode<'a>(
+        &self,
+        mix_identity: IdentityKeyRef<'a>,
+        amount: &Coin,
+    ) -> Result<ExecuteResult, NymdError> {
+        let fee = self.operation_fee(Operation::DelegateToMixnode);
+        let req = VestingExecuteMsg::DelegateToMixnode {
+            mix_identity: mix_identity.into(),
+        };
+        self.client
+            .execute(
+                self.address(),
+                self.vesting_contract_address()?,
+                &req,
+                fee,
+                "VestingContract::DeledateToMixnode",
+                vec![cosmwasm_coin_to_cosmos_coin(amount.to_owned())],
+            )
+            .await
+    }
+    async fn vesting_undelegate_from_mixnode<'a>(
+        &self,
+        mix_identity: IdentityKeyRef<'a>,
+    ) -> Result<ExecuteResult, NymdError> {
+        let fee = self.operation_fee(Operation::UndelegateFromMixnode);
+        let req = VestingExecuteMsg::UndelegateFromMixnode {
+            mix_identity: mix_identity.into(),
+        };
+        self.client
+            .execute(
+                self.address(),
+                self.vesting_contract_address()?,
+                &req,
+                fee,
+                "VestingContract::UndelegateFromMixnode",
+                vec![],
+            )
+            .await
+    }
+    async fn create_periodic_vesting_account(
+        &self,
+        address: &str,
+        start_time: Option<u64>,
+        amount: Coin,
+    ) -> Result<ExecuteResult, NymdError> {
+        let fee = self.operation_fee(Operation::CreatePeriodicVestingAccount);
+        let req = VestingExecuteMsg::CreateAccount {
+            address: address.to_string(),
+            start_time,
+        };
+        self.client
+            .execute(
+                self.address(),
+                self.vesting_contract_address()?,
+                &req,
+                fee,
+                "VestingContract::CreatePeriodicVestingAccount",
+                vec![cosmwasm_coin_to_cosmos_coin(amount)],
+            )
+            .await
+    }
+}

common/client-libs/validator-client/src/nymd/wallet/mod.rs

@@ -10,7 +10,7 @@ use cosmrs::tx::SignDoc;
 use cosmrs::{tx, AccountId};
 
 /// Derivation information required to derive a keypair and an address from a mnemonic.
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 struct Secp256k1Derivation {
     hd_path: DerivationPath,
     prefix: String,
@@ -24,9 +24,23 @@ pub struct AccountData {
     pub(crate) private_key: SigningKey,
 }
 
+impl AccountData {
+    pub fn address(&self) -> &AccountId {
+        &self.address
+    }
+
+    pub fn public_key(&self) -> PublicKey {
+        self.public_key
+    }
+
+    pub fn private_key(&self) -> &SigningKey {
+        &self.private_key
+    }
+}
+
 type Secp256k1Keypair = (SigningKey, PublicKey);
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct DirectSecp256k1HdWallet {
     /// Base secret
     secret: bip39::Mnemonic,
@@ -193,9 +207,9 @@ mod tests {
     fn generating_account_addresses() {
         // test vectors produced from our js wallet
         let mnemonic_address = vec![
-            ("crush minute paddle tobacco message debate cabin peace bar jacket execute twenty winner view sure mask popular couch penalty fragile demise fresh pizza stove", "punk1jw6mp7d5xqc7w6xm79lha27glmd0vdt32a3fj2"),
-            ("acquire rebel spot skin gun such erupt pull swear must define ill chief turtle today flower chunk truth battle claw rigid detail gym feel", "punk1h5hgn94nsq4kh99rjj794hr5h5q6yfm22mcqqn"),
-            ("step income throw wheat mobile ship wave drink pool sudden upset jaguar bar globe rifle spice frost bless glimpse size regular carry aspect ball", "punk17n9flp6jflljg6fp05dsy07wcprf2uuujse962")
+            ("crush minute paddle tobacco message debate cabin peace bar jacket execute twenty winner view sure mask popular couch penalty fragile demise fresh pizza stove", "nymt1jw6mp7d5xqc7w6xm79lha27glmd0vdt339me94"),
+            ("acquire rebel spot skin gun such erupt pull swear must define ill chief turtle today flower chunk truth battle claw rigid detail gym feel", "nymt1h5hgn94nsq4kh99rjj794hr5h5q6yfm23rjshv"),
+            ("step income throw wheat mobile ship wave drink pool sudden upset jaguar bar globe rifle spice frost bless glimpse size regular carry aspect ball", "nymt17n9flp6jflljg6fp05dsy07wcprf2uuufgn4d4")
         ];
 
         for (mnemonic, address) in mnemonic_address.into_iter() {

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

@@ -68,6 +68,11 @@ impl Client {
             .await
     }
 
+    pub async fn get_active_mixnodes(&self) -> Result<Vec<MixNodeBond>, ValidatorAPIError> {
+        self.query_validator_api(&[routes::API_VERSION, routes::MIXNODES, routes::ACTIVE])
+            .await
+    }
+
     pub async fn blind_sign(
         &self,
         request_body: &BlindSignRequestBody,

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

@@ -7,5 +7,7 @@ pub const API_VERSION: &str = VALIDATOR_API_VERSION;
 pub const MIXNODES: &str = "mixnodes";
 pub const GATEWAYS: &str = "gateways";
 
+pub const ACTIVE: &str = "active";
+
 pub const COCONUT_BLIND_SIGN: &str = "blind_sign";
 pub const COCONUT_VERIFICATION_KEY: &str = "verification_key";

common/client-libs/validator-client/yarn.lock

@@ -0,0 +1,4 @@
+# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+# yarn lockfile v1
+
+