signpost - unfinished just parking changes

Fix up Nym-Wallet README.md

.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:
-  ci:
-    runs-on: ${{ matrix.os }}
-    continue-on-error: ${{ matrix.rust == 'nightly' || matrix.rust == 'beta' }}
+  matrix_prep:
+    runs-on: ubuntu-latest
+    outputs:
+      matrix: ${{ steps.set-matrix.outputs.matrix }}
+    steps:
+      # creates the matrix strategy from build_matrix_includes.json
+      - uses: actions/checkout@v2
+      - id: set-matrix
+        uses: JoshuaTheMiller/conditional-build-matrix@main
+        with:
+          inputFile: '.github/workflows/build_matrix_includes.json'
+          filter: '[?runOnEvent==`${{ github.event_name }}` || runOnEvent==`always`]'
+  build:
+    needs: matrix_prep
     strategy:
-      matrix:
-        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/erc20_bridge_contract.yml

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

.github/workflows/mixnet_contract.yml

@@ -1,16 +1,34 @@
 name: Mixnet Contract
 
-on: [push, pull_request]
+on:
+  push:
+    paths-ignore:
+      - 'explorer/**'
+  pull_request:
+    paths-ignore:
+      - 'explorer/**'
 
 jobs:
-  ci:
+  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`]'
+  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' }}
+    needs: matrix_prep
     strategy:
-      matrix:
-        rust: [ stable, beta, nightly ]
+      matrix: ${{fromJson(needs.matrix_prep.outputs.matrix)}}
     steps:
       - uses: actions/checkout@v2
 
@@ -23,6 +41,8 @@ jobs:
           components: rustfmt, clippy
 
       - uses: actions-rs/cargo@v1
+        env:
+          RUSTFLAGS: '-C link-arg=-s'
         with:
           command: build
           args: --manifest-path contracts/mixnet/Cargo.toml --target wasm32-unknown-unknown

.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,57 @@
+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
+    - 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.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/tauri-wallet-publish.yml

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

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

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

.github/workflows/wasm_client_build.yml

@@ -1,9 +1,12 @@
 name: Wasm Client
 
-on: [push, pull_request]
+on:
+  pull_request:
+    paths-ignore:
+      - 'explorer/**'
 
 jobs:
-  ci:
+  wasm:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
@@ -16,10 +19,16 @@ jobs:
           override: true
           components: rustfmt, clippy
 
+# token credentials (non-coconut) don't work for wasm right now
+#      - uses: actions-rs/cargo@v1
+#        with:
+#          command: build
+#          args: --manifest-path clients/webassembly/Cargo.toml --target wasm32-unknown-unknown
+
       - uses: actions-rs/cargo@v1
         with:
           command: build
-          args: --manifest-path clients/webassembly/Cargo.toml --target wasm32-unknown-unknown
+          args: --manifest-path clients/webassembly/Cargo.toml --target wasm32-unknown-unknown --features=coconut
 
 # for some reason this does not seem to work correctly, leave it for later, building is good enough for now
 #      - uses: actions-rs/cargo@v1
@@ -36,4 +45,4 @@ jobs:
 #      - uses: actions-rs/cargo@v1
 #        with:
 #          command: clippy
-#          args: --manifest-path clients/webassembly/Cargo.toml --target wasm32-unknown-unknown -- -D warnings
+#          args: --manifest-path clients/webassembly/Cargo.toml --target wasm32-unknown-unknown -- -D warnings

.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
@@ -30,3 +29,8 @@ 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

Cargo.toml

@@ -4,6 +4,7 @@
 [profile.release]
 panic = "abort"
 opt-level = "s"
+overflow-checks = true
 
 [profile.dev]
 panic = "abort"
@@ -24,6 +25,7 @@ members = [
     "common/config",
     "common/credentials",
     "common/crypto",
+    "common/erc20-bridge-contract",
     "common/mixnet-contract",
     "common/mixnode-common",
     "common/network-defaults",
@@ -61,4 +63,4 @@ default-members = [
     "validator-api",
 ]
 
-exclude = ["explorer", "contracts"]
+exclude = ["explorer", "contracts", "tokenomics-py"]

README.md

@@ -5,8 +5,6 @@ SPDX-License-Identifier: Apache-2.0
 
 ## The Nym Privacy Platform
 
-This repository contains the Nym mixnet.
-
 The platform is composed of multiple Rust crates. Top-level executable binary crates include:
 
 * nym-mixnode - shuffles [Sphinx](https://github.com/nymtech/sphinx) packets together to provide privacy against network-level attackers.
@@ -15,6 +13,7 @@ The platform is composed of multiple Rust crates. Top-level executable binary cr
 * nym-gateway - acts sort of like a mailbox for mixnet messages, removing the need for directly delivery to potentially offline or firewalled devices.
 * nym-network-monitor - sends packets through the full system to check that they are working as expected, and stores node uptime histories as the basis of a rewards system ("mixmining" or "proof-of-mixing").
 * nym-explorer - a (projected) block explorer and (existing) mixnet viewer.
+* nym-wallet (currently in development)- a desktop wallet implemented using the [Tauri](https://tauri.studio/en/docs/about/intro) framework. 
 
 [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg?style=for-the-badge)](https://opensource.org/licenses/Apache-2.0)
 [![Build Status](https://img.shields.io/github/workflow/status/nymtech/nym/Continuous%20integration/develop?style=for-the-badge&logo=github-actions)](https://github.com/nymtech/nym/actions?query=branch%3Adevelop)
@@ -22,7 +21,7 @@ The platform is composed of multiple Rust crates. Top-level executable binary cr
 
 ### Building
 
-Platform build instructions are available on [our docs site](https://nymtech.net/docs).
+Platform build instructions are available on [our docs site](https://nymtech.net/docs/0.11.0/overview/index/).
 
 ### Developing
 
@@ -32,6 +31,45 @@ There's a `.env.sample-dev` file provided which you can rename to `.env` if you
 
 You can chat to us in [Keybase](https://keybase.io). Download their chat app, then click **Teams -> Join a team**. Type **nymtech.friends** into the team name and hit **continue**. For general chat, hang out in the **#general** channel. Our development takes places in the **#dev** channel. Node operators should be in the **#node-operators** channel.
 
+### Rewards
+
+Node, node operator and delegator rewards are determined according to the principles laid out in the section 6 of [Nym Whitepaper](https://nymtech.net/nym-whitepaper.pdf). Below is a TLDR of the variables and formulas involved in calculating the epoch rewards. Initial reward pool is set to 250 million Nym, making the circulating supply 750 million Nym.
+
+|Symbol|Definition|
+|---|---|
+|<img src="https://render.githubusercontent.com/render/math?math=R">|global share of rewards available, starts at 2% of the reward pool. 
+|<img src="https://render.githubusercontent.com/render/math?math=R_{i}">|node reward for mixnode `i`.
+|<img src="https://render.githubusercontent.com/render/math?math=\sigma_{i}">|ratio of total node stake (node bond + all delegations) to the token circulating supply.
+|<img src="https://render.githubusercontent.com/render/math?math=\lambda_{i}">|ratio of stake operator has 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
 
@@ -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" }
@@ -44,5 +45,8 @@ websocket-requests = { path = "websocket-requests" }
 validator-client = { path = "../../common/client-libs/validator-client" }
 version-checker = { path = "../../common/version-checker" }
 
+[features]
+coconut = ["coconut-interface", "credentials", "gateway-requests/coconut", "gateway-client/coconut"]
+
 [dev-dependencies]
 serde_json = "1.0" # for the "textsend" example

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

@@ -22,9 +22,6 @@ 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::{
@@ -38,6 +35,8 @@ use nymsphinx::anonymous_replies::ReplySurb;
 use nymsphinx::receiver::ReconstructedMessage;
 use tokio::runtime::Runtime;
 
+use gateway_client::bandwidth::BandwidthController;
+
 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

@@ -6,10 +6,7 @@ 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;
 use config::NymConfig;
-use credentials::bandwidth::prepare_for_spending;
-use credentials::obtain_aggregate_verification_key;
 use crypto::asymmetric::{encryption, identity};
 use gateway_client::GatewayClient;
 use gateway_requests::registration::handshake::SharedKeys;
@@ -25,7 +22,7 @@ use topology::{filter::VersionFilterable, gateway};
 use url::Url;
 
 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")
@@ -57,37 +54,32 @@ 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));
 
-// 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 {
-    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");
-
-    prepare_for_spending(raw_identity, &bandwidth_credential, &verification_key)
-        .expect("could not prepare out bandwidth credential for spending")
+    app
 }
 
 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 +202,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/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,8 +25,8 @@ 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" }
@@ -38,3 +39,6 @@ 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" }
+
+[features]
+coconut = ["coconut-interface", "credentials", "gateway-requests/coconut", "gateway-client/coconut"]

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

@@ -23,9 +23,6 @@ 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::{
@@ -37,6 +34,8 @@ use nymsphinx::addressing::clients::Recipient;
 use nymsphinx::addressing::nodes::NodeIdentity;
 use tokio::runtime::Runtime;
 
+use gateway_client::bandwidth::BandwidthController;
+
 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

@@ -6,10 +6,7 @@ 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;
 use config::NymConfig;
-use credentials::bandwidth::prepare_for_spending;
-use credentials::obtain_aggregate_verification_key;
 use crypto::asymmetric::{encryption, identity};
 use gateway_client::GatewayClient;
 use gateway_requests::registration::handshake::SharedKeys;
@@ -23,7 +20,7 @@ use topology::{filter::VersionFilterable, gateway};
 use url::Url;
 
 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")
@@ -57,37 +54,32 @@ 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));
 
-// 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 {
-    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");
-
-    prepare_for_spending(raw_identity, &bandwidth_credential, &verification_key)
-        .expect("could not prepare out bandwidth credential for spending")
+    app
 }
 
 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 +203,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/validator/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@nymproject/nym-validator-client",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "description": "A TypeScript client for interacting with smart contracts in Nym validators",
   "repository": "https://github.com/nymtech/nym",
   "main": "./dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
     "build": "tsc",
+    "run_cli": "clear && ts-node src/cli.ts",
     "test": "ts-mocha tests/**/*.test.ts",
     "coverage": "nyc npm test",
     "lint": "eslint \"**/*.ts\"",
@@ -22,6 +23,7 @@
   "devDependencies": {
     "@types/chai": "^4.2.15",
     "@types/expect": "^24.3.0",
+    "@types/inquirer": "^8.1.3",
     "@types/mocha": "^8.2.1",
     "@typescript-eslint/eslint-plugin": "^4.14.0",
     "@typescript-eslint/parser": "^4.14.0",
@@ -35,10 +37,11 @@
     "typescript": "^4.1.3"
   },
   "dependencies": {
-    "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/proto-signing": "^0.25.5",
+    "@cosmjs/stargate": "^0.25.5",
+    "axios": "^0.21.1",
+    "inquirer": "^8.2.0"
   }
-}
+}

clients/validator/src/caches/gateways.ts

@@ -1,7 +1,7 @@
-import { GatewayBond } from "../types";
+import {GatewayBond, PagedGatewayResponse} from "../types";
 import {INetClient} from "../net-client"
 import {IQueryClient} from "../query-client";
-import {PagedGatewayResponse, VALIDATOR_API_GATEWAYS, VALIDATOR_API_PORT} from "../index";
+import {VALIDATOR_API_GATEWAYS, VALIDATOR_API_PORT} from "../index";
 import axios from "axios";
 
 

clients/validator/src/caches/mixnodes.ts

@@ -1,60 +1,64 @@
-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 { MixNodeBond, PagedMixnodeResponse } from "../types";
+import { INetClient } from "../net-client";
+import { IQueryClient } from "../query-client";
+import { 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 
+ * 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
+  mixNodes: MixNodeBond[];
+  client: INetClient | IQueryClient;
+  perPage: number;
 
-    constructor(client: INetClient | IQueryClient, perPage: number) {
-        this.client = client;
-        this.mixNodes = [];
-        this.perPage = perPage;
+  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;
+      }
     }
 
-    /// 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;
+  }
 
-        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;
+      }
     }
-
-    /// 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")
-    }
-}
+    throw new Error("None of the provided validators seem to be alive");
+  }
+}

clients/validator/src/cli.ts

@@ -0,0 +1,317 @@
+import ValidatorClient from "./index";
+import inquirer from "inquirer";
+// This script runs a CLI to consume the Validator and provide mixnet information to the user
+
+const VALIDATOR_URLS: string[] = [
+  "https://testnet-milhon-validator1.nymtech.net",
+  // "https://testnet-milhon-validator2.nymtech.net", // <-- val 2 doesnt work apparently.
+];
+const DENOM = "punk";
+const MOCK_MNEMONIC =
+  "vault risk throw flat garlic pretty clay senior birth correct panic floor around pen horror mail entry arrest zoo devote message evoke street total";
+// ^^ addr: punk10dxwmqjy72s9nkm9x9pluyn6pyx0gkptjhs4k9
+// curr balance: 899999747
+
+// const MOCK_MNEMONIC =
+//   "oil once motion cute crawl patch happy wave donkey zoo retreat matrix emerge adult very universe aware error snap credit actress couple upset engine";
+// ^^ addr: punk1yzr7gtmtlfd0s7s9wpexhteeu05y4xlcvh65eh
+// curr balance: 5045 UPUNK
+
+// const MOCK_MNEMONIC =
+//   "sample menu edit midnight guard review call record horn antenna stairs awkward fringe document during amazing twelve wise wide escape matter betray staff someone";
+// ^^ addr: punk1wn8lwxe5hvdtx60c6p7ekskmu75agwfrslf0qs
+// curr balance:
+
+type AccountType = {
+  addr: string;
+  client: any;
+  mnemonic?: string;
+};
+function validatorCli() {
+  // define funcs to be used in CLI switch-case
+
+  let state: AccountType = {
+    addr: "",
+    client: null,
+    mnemonic: "",
+  };
+
+  function restartApp() {
+    setTimeout(() => {
+      validatorCli();
+    }, 300);
+  }
+
+  function generateNewAccount() {
+    const mnemonic = ValidatorClient.randomMnemonic();
+    ValidatorClient.mnemonicToAddress(mnemonic, "punk")
+      .then((address) => {
+        console.log("Your address is: ", address);
+        console.log("Your mnemonic is: ", mnemonic);
+        return address;
+      })
+      .catch((err) => {
+        console.log("err", err);
+      });
+    restartApp();
+  }
+
+  function sendFundsMenu() {
+    inquirer
+      .prompt([
+        {
+          name: "recipient",
+          type: "input",
+          message: "please enter the receipient:",
+        },
+        {
+          name: "amount",
+          type: "input",
+          message: "please enter the amount (UPUNK):",
+        },
+      ])
+      .then(async ({ recipient, amount }) => {
+        const { addr, client } = state;
+        console.log(
+          `🔥 Hold Tight - Sending ${amount}UPUNK to ${recipient} 🚀`
+        );
+
+        const res = await client.send(addr, recipient, [
+          {
+            denom: "upunk",
+            amount: amount,
+          },
+        ]);
+        console.log("Funds Transfer Response:", res);
+        restartApp();
+      });
+  }
+
+  async function delegateGateway() {
+    console.log(
+      "unfortunately - gateway delegation is switched off at the moment."
+    );
+    startTransactionMenu();
+    // const id = "punk1yzr7gtmtlfd0s7s9wpexhteeu05y4xlcvh65eh";
+    // const gatewayID = "EQhjPpUuy4i1u87nfQMW21WiBT5mJk4dcq4ju7Vct7cB";
+    // const coin = {
+    //   denom: "upunk",
+    //   amount: "101",
+    // };
+    // const res = await state.client.delegateToMixnode(gatewayID, coin);
+    // console.log("delegateMixnode ==> ", res);
+  }
+
+  async function delegateMixnode() {
+    const mixNodeID = "2cFpCe7yP79CcuRpf6JBRdJaSp7JF5YcA5SHi8JVm1d2";
+    // const mixNodeID = "2Vrr7s2peGiWsPh6xY3ZFEMDRmMNv8xLBUtV5XMyQLSB";
+    const coin = {
+      denom: "upunk",
+      amount: "1001",
+    };
+    const res = await state.client.delegateToMixnode(mixNodeID, coin);
+    console.log("delegate to mixnode response: ", res);
+  }
+  async function findMinimumMixnodeBond() {
+    const res = await state.client.minimumMixnodeBond();
+    console.log("res is back ", res);
+  }
+
+  async function bondMixnode() {
+    state.client.bondMixnode();
+  }
+
+  async function checkOwnsMixnodes() {
+    const res = await state.client.ownsMixNode();
+    console.log("owns mixnode? ", res);
+  }
+  function startTransactionMenu() {
+    inquirer
+      .prompt([
+        {
+          type: "list",
+          name: "task",
+          message: "What now?",
+          choices: [
+            "send_funds",
+            "get_mixnodes",
+            "refresh_mixnodes",
+            "refresh_val_api_mixnodes",
+            "min_mixn_bond",
+            "bond_mixnode",
+            "delegate_mixnode",
+            "delegate_gateway",
+            "check_owns_mixnode",
+          ],
+        },
+      ])
+      .then(({ task }) => {
+        switch (task) {
+          case "send_funds":
+            sendFundsMenu();
+            break;
+          case "get_mixnodes":
+            getMixnodes();
+            break;
+          case "refresh_mixnodes":
+            refreshMixnodes();
+            break;
+          case "refresh_val_api_mixnodes":
+            refreshValApiMixnodes();
+            break;
+          case "min_mixn_bond":
+            findMinimumMixnodeBond();
+            break;
+          case "bond_mixnode":
+            bondMixnode();
+            break;
+          case "delegate_gateway":
+            delegateGateway();
+            break;
+          case "delegate_mixnode":
+            delegateMixnode();
+            break;
+          case "check_owns_mixnode":
+            checkOwnsMixnodes();
+            break;
+          default:
+            return null;
+        }
+      });
+  }
+
+  function queryUserAccount() {
+    inquirer
+      .prompt([
+        {
+          type: "input",
+          name: "query_user",
+          message: "Please enter the public address of user you wish to query",
+        },
+      ])
+      .then(async ({ query_user }) => {
+        let response = "";
+        try {
+          const client = await ValidatorClient.connectForQuery(
+            query_user,
+            VALIDATOR_URLS,
+            DENOM
+          );
+          const balance = await client.getBalance(query_user);
+          response = `User ${query_user} has a balance of ${balance?.amount}${balance?.denom}`;
+          console.log(response);
+          return validatorCli();
+        } catch (error) {
+          console.log("error back ", error);
+          return validatorCli();
+        }
+      });
+  }
+
+  async function refreshMixnodes() {
+    const res = await state.client.refreshMixNodes(
+      "punk1yksauczytk60x5cejaras8w6nwf7r772n3kwkp"
+    );
+    console.log("done:", res);
+  }
+  function connectAccount() {
+    inquirer
+      .prompt([
+        {
+          name: "user_mnemonic",
+          type: "input",
+          message: "please enter your mnemonic:",
+        },
+      ])
+      .then(async ({ user_mnemonic }) => {
+        console.log("Connecting...");
+        const addr = await ValidatorClient.mnemonicToAddress(
+          MOCK_MNEMONIC,
+          // user_mnemonic,
+          "punk"
+        );
+
+        const client = await ValidatorClient.connect(
+          addr,
+          MOCK_MNEMONIC,
+          VALIDATOR_URLS,
+          DENOM
+        );
+
+        state = {
+          addr,
+          mnemonic: MOCK_MNEMONIC,
+          client,
+        };
+
+        const balance = await client.getBalance(addr);
+        console.log(`connected to validator, our address is ${client.address}`);
+        console.log("connected to validator", client.urls[0]);
+        console.log(
+          `💰 Your balance is ${balance?.amount}${balance?.denom.toUpperCase()}`
+        );
+
+        startTransactionMenu();
+      })
+      .catch((err) => {
+        console.log("error: ", err);
+      });
+  }
+  function buildAWallet() {
+    inquirer
+      .prompt([
+        {
+          message: "enter your mnemonic to build wallet:",
+          type: "input",
+          name: "mnemonic",
+        },
+      ])
+      .then(async ({ mnemonic }) => {
+        const res = await ValidatorClient.buildWallet(mnemonic, DENOM);
+        console.log("Build_Wallet Response: ", res);
+      });
+  }
+  async function refreshValApiMixnodes() {
+    const res = await state.client.refreshValidatorAPIMixNodes();
+    console.log("res is back: ", res);
+  }
+  function getMixnodes() {
+    const res = state.client.mixNodesCache;
+    console.log("Mixnodes", res);
+  }
+  // app provides a list of possible tasks
+  inquirer
+    .prompt([
+      {
+        type: "list",
+        name: "task",
+        message: "Yo, What would you like to do today?",
+        choices: [
+          "create_account",
+          "connect_account",
+          "build_wallet",
+          "query_user",
+        ],
+      },
+    ])
+    .then(({ task }) => {
+      switch (task) {
+        case "create_account":
+          generateNewAccount();
+          break;
+        case "connect_account":
+          connectAccount();
+          break;
+        case "build_wallet":
+          buildAWallet();
+          break;
+        case "query_user":
+          queryUserAccount();
+          break;
+        default:
+          return null;
+      }
+    });
+}
+
+validatorCli();

clients/validator/src/net-client.ts

@@ -6,7 +6,7 @@ import {
     PagedGatewayResponse, PagedMixDelegationsResponse,
     PagedMixnodeResponse,
     StateParams
-} from "./index";
+} from "./types";
 import { DirectSecp256k1HdWallet, EncodeObject } from "@cosmjs/proto-signing";
 import { Coin, StdFee } from "@cosmjs/stargate";
 import { BroadcastTxResponse } from "@cosmjs/stargate"

clients/validator/src/query-client.ts

@@ -7,7 +7,7 @@ import {
     PagedGatewayResponse, PagedMixDelegationsResponse,
     PagedMixnodeResponse,
     StateParams
-} from "./index";
+} from "./types";
 
 export interface IQueryClient {
     getBalance(address: string, stakeDenom: string): Promise<Coin | null>;

clients/validator/src/types.ts

@@ -1,5 +1,80 @@
 import { Coin } from "@cosmjs/stargate";
 
+
+/// One page of a possible multi-page set of mixnodes. The paging interface is quite
+/// inconvenient, as we don't have the two pieces of information we need to know
+/// in order to do paging nicely (namely `currentPage` and `totalPages` parameters).
+///
+/// Instead, we have only `start_next_page_after`, i.e. the key of the last record
+/// on this page. In order to get the *next* page, CosmWasm looks at that value,
+/// finds the next record, and builds the next page starting there. This happens
+/// **in series** rather than **in parallel** (!).
+///
+/// So we have some consistency problems:
+///
+/// * we can't make requests at a given block height, so the result set
+///    which we assemble over time may change while requests are being made.
+/// * at some point we will make a request for a `start_next_page_after` key
+///   which has just been deleted from the database.
+///
+/// TODO: more robust error handling on the "deleted key" case.
+export type PagedMixnodeResponse = {
+    nodes: MixNodeBond[],
+    per_page: number, // TODO: camelCase
+    start_next_after: string, // TODO: camelCase
+}
+
+// a temporary way of achieving the same paging behaviour for the gateways
+// the same points made for `PagedResponse` stand here.
+export type PagedGatewayResponse = {
+    nodes: GatewayBond[],
+    per_page: number, // TODO: camelCase
+    start_next_after: string, // TODO: camelCase
+}
+
+export type MixOwnershipResponse = {
+    address: string,
+    has_node: boolean,
+}
+
+export type GatewayOwnershipResponse = {
+    address: string,
+    has_gateway: boolean,
+}
+
+export type StateParams = {
+    epoch_length: number,
+    // ideally I'd want to define those as `number` rather than `string`, but
+    // rust-side they are defined as Uint128 and Decimal that don't have
+    // native javascript representations and therefore are interpreted as strings after deserialization
+    minimum_mixnode_bond: string,
+    minimum_gateway_bond: string,
+    mixnode_bond_reward_rate: string,
+    gateway_bond_reward_rate: string,
+    mixnode_delegation_reward_rate: string,
+    gateway_delegation_reward_rate: string,
+    mixnode_active_set_size: number,
+    gateway_active_set_size: number,
+}
+
+export type Delegation = {
+    owner: string,
+    amount: Coin,
+}
+
+export type PagedMixDelegationsResponse = {
+    node_owner: string,
+    delegations: Delegation[],
+    start_next_after: string
+}
+
+export type PagedGatewayDelegationsResponse = {
+    node_owner: string,
+    delegations: Delegation[],
+    start_next_after: string
+}
+
+
 export enum Layer {
     Gateway,
     One,

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,9 +1,6 @@
 // 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::GatewayClient;
@@ -20,6 +17,8 @@ use wasm_bindgen::prelude::*;
 use wasm_bindgen_futures::spawn_local;
 use wasm_utils::{console_log, console_warn};
 
+use gateway_client::bandwidth::BandwidthController;
+
 pub(crate) mod received_processor;
 
 const DEFAULT_AVERAGE_PACKET_DELAY: Duration = Duration::from_millis(200);
@@ -101,35 +100,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 +124,7 @@ impl NymClient {
             mixnet_messages_sender,
             ack_sender,
             DEFAULT_GATEWAY_RESPONSE_TIMEOUT,
-            coconut_credential,
+            bandwidth_controller,
         );
 
         gateway_client
@@ -263,7 +249,7 @@ 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 {
+        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,226 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::error::GatewayClientError;
+#[cfg(feature = "coconut")]
+use credentials::coconut::{
+    bandwidth::{obtain_signature, prepare_for_spending},
+    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;
+#[cfg(not(feature = "coconut"))]
+use network_defaults::{
+    eth_contract::ETH_JSON_ABI, BANDWIDTH_VALUE, 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,
+};
+
+#[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 bandwidth_credential =
+            obtain_signature(&self.identity.to_bytes(), &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,
+            &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 super::*;
+    use network_defaults::ETH_EVENT_NAME;
+
+    #[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,6 +3,7 @@ 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
 
@@ -25,12 +26,13 @@ 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 }
+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 = {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,14 @@
 use crate::nymd::{
     error::NymdError, CosmWasmClient, NymdClient, QueryNymdClient, SigningNymdClient,
 };
+#[cfg(feature = "nymd-client")]
+use mixnet_contract::StateParams;
+
 use crate::{validator_api, ValidatorClientError};
 use coconut_interface::{BlindSignRequestBody, BlindedSignatureResponse, VerificationKeyResponse};
 use mixnet_contract::{GatewayBond, MixNodeBond};
+#[cfg(feature = "nymd-client")]
+use mixnet_contract::{RawDelegationData, RewardingIntervalResponse};
 use url::Url;
 
 #[cfg(feature = "nymd-client")]
@@ -19,7 +24,6 @@ pub struct Config {
     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")]
@@ -36,7 +40,6 @@ impl Config {
             mixnode_page_limit: None,
             gateway_page_limit: None,
             mixnode_delegations_page_limit: None,
-            gateway_delegations_page_limit: None,
         }
     }
 
@@ -54,11 +57,6 @@ 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")]
@@ -69,7 +67,6 @@ pub struct Client<C> {
     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,
@@ -95,7 +92,6 @@ impl Client<SigningNymdClient> {
             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,
         })
@@ -131,7 +127,6 @@ impl Client<QueryNymdClient> {
             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,
         })
@@ -158,6 +153,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 +165,50 @@ impl<C> Client<C> {
         Ok(self.validator_api.get_gateways().await?)
     }
 
+    pub async fn get_state_params(&self) -> Result<StateParams, ValidatorClientError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        Ok(self.nymd.get_state_params().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_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 +256,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,6 +286,34 @@ impl<C> Client<C> {
         Ok(delegations)
     }
 
+    pub async fn get_all_nymd_mixnode_delegations(
+        &self,
+    ) -> Result<Vec<mixnet_contract::UnpackedDelegation<RawDelegationData>>, ValidatorClientError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        let mut delegations = Vec::new();
+        let mut start_after = None;
+        loop {
+            let mut paged_response = self
+                .nymd
+                .get_all_mix_delegations_paged(
+                    start_after.take(),
+                    self.mixnode_delegations_page_limit,
+                )
+                .await?;
+            delegations.append(&mut paged_response.delegations);
+
+            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_reverse_mixnode_delegations(
         &self,
         delegation_owner: &cosmrs::AccountId,
@@ -295,88 +366,6 @@ impl<C> Client<C> {
         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 {
-                start_after = Some(start_after_res)
-            } else {
-                break;
-            }
-        }
-
-        Ok(delegations)
-    }
-
-    pub async fn get_all_nymd_reverse_gateway_delegations(
-        &self,
-        delegation_owner: &cosmrs::AccountId,
-    ) -> Result<Vec<mixnet_contract::IdentityKey>, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync,
-    {
-        let mut delegations = Vec::new();
-        let mut start_after = None;
-        loop {
-            let mut paged_response = self
-                .nymd
-                .get_reverse_gateway_delegations_paged(
-                    mixnet_contract::Addr::unchecked(delegation_owner.as_ref()),
-                    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_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 +399,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

@@ -22,7 +22,7 @@ use cosmrs::rpc::query::Query;
 use cosmrs::rpc::{self, HttpClient, Order};
 use cosmrs::tendermint::abci::Transaction;
 use cosmrs::tendermint::{abci, block, chain};
-use cosmrs::{AccountId, Coin, Denom};
+use cosmrs::{tx, AccountId, Coin, Denom};
 use prost::Message;
 use serde::{Deserialize, Serialize};
 use std::convert::{TryFrom, TryInto};
@@ -153,12 +153,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

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

@@ -13,8 +13,9 @@ 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 cosmrs::tx::{Fee, Msg, SignDoc, SignerInfo};
+use cosmrs::{cosmwasm, rpc, tx, AccountId, Any, Coin};
+use log::debug;
 use serde::Serialize;
 use sha2::Digest;
 use sha2::Sha256;
@@ -51,7 +52,7 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
                 .unwrap_or_default(),
             instantiate_permission: Default::default(),
         }
-        .to_msg()
+        .to_any()
         .map_err(|_| NymdError::SerializationError("MsgStoreCode".to_owned()))?;
 
         let tx_res = self
@@ -113,7 +114,7 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
             init_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
@@ -153,7 +154,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
@@ -178,7 +179,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
@@ -210,7 +211,7 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
             code_id,
             migrate_msg: serde_json::to_vec(msg)?,
         }
-        .to_msg()
+        .to_any()
         .map_err(|_| NymdError::SerializationError("MsgMigrateContract".to_owned()))?;
 
         let tx_res = self
@@ -242,7 +243,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
@@ -256,6 +257,48 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
         })
     }
 
+    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()?;
+
+        debug!(
+            "gas wanted: {:?}, gas used: {:?}",
+            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,
+        })
+    }
+
     async fn send_tokens(
         &self,
         sender_address: &AccountId,
@@ -269,7 +312,7 @@ 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)
@@ -289,7 +332,7 @@ 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)
@@ -309,7 +352,7 @@ 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)
@@ -327,7 +370,7 @@ 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)
@@ -338,7 +381,7 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
     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> {
@@ -354,7 +397,7 @@ 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> {
@@ -370,7 +413,7 @@ 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> {
@@ -385,7 +428,7 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
     fn sign_direct(
         &self,
         signer_address: &AccountId,
-        messages: Vec<Msg>,
+        messages: Vec<Any>,
         fee: Fee,
         memo: impl Into<String> + Send + 'static,
         signer_data: SignerData,
@@ -423,7 +466,7 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
     async fn sign(
         &self,
         signer_address: &AccountId,
-        messages: Vec<Msg>,
+        messages: Vec<Any>,
         fee: Fee,
         memo: impl Into<String> + Send + 'static,
     ) -> Result<tx::Raw, NymdError> {
@@ -442,6 +485,7 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
     }
 }
 
+#[derive(Debug)]
 pub struct Client {
     rpc_client: HttpClient,
     signer: DirectSecp256k1HdWallet,
@@ -462,7 +506,7 @@ impl Client {
 
 #[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,
     {

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

@@ -3,10 +3,15 @@
 
 use crate::nymd::cosmwasm_client::types::ContractCodeId;
 use cosmrs::tendermint::block;
-use cosmrs::{bip32, rpc, tx, AccountId};
+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),
@@ -98,3 +103,56 @@ pub enum NymdError {
     #[error("The provided gas price is malformed")]
     MalformedGasPrice,
 }
+
+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_helpers.rs

@@ -4,9 +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;
 
-#[derive(Debug, Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
+#[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,
@@ -21,25 +23,41 @@ pub enum Operation {
 
     BondGateway,
     UnbondGateway,
-    DelegateToGateway,
-    UndelegateFromGateway,
 
     UpdateStateParams,
+
+    BeginMixnodeRewarding,
+    FinishMixnodeRewarding,
 }
 
 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 {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            Operation::Upload => f.write_str("Upload"),
+            Operation::Init => f.write_str("Init"),
+            Operation::Migrate => f.write_str("Migrate"),
+            Operation::ChangeAdmin => f.write_str("ChangeAdmin"),
+            Operation::Send => f.write_str("Send"),
+            Operation::BondMixnode => f.write_str("BondMixnode"),
+            Operation::UnbondMixnode => f.write_str("UnbondMixnode"),
+            Operation::BondGateway => f.write_str("BondGateway"),
+            Operation::UnbondGateway => f.write_str("UnbondGateway"),
+            Operation::DelegateToMixnode => f.write_str("DelegateToMixnode"),
+            Operation::UndelegateFromMixnode => f.write_str("UndelegateFromMixnode"),
+            Operation::UpdateStateParams => f.write_str("UpdateStateParams"),
+            Operation::BeginMixnodeRewarding => f.write_str("BeginMixnodeRewarding"),
+            Operation::FinishMixnodeRewarding => f.write_str("FinishMixnodeRewarding"),
+        }
     }
 }
 
 impl Operation {
     // TODO: some value tweaking
-    pub(crate) fn default_gas_limit(&self) -> Gas {
+    pub fn default_gas_limit(&self) -> Gas {
         match self {
             Operation::Upload => 2_500_000u64.into(),
             Operation::Init => 500_000u64.into(),
@@ -54,23 +72,27 @@ impl Operation {
 
             Operation::BondGateway => 175_000u64.into(),
             Operation::UnbondGateway => 175_000u64.into(),
-            Operation::DelegateToGateway => 175_000u64.into(),
-            Operation::UndelegateFromGateway => 175_000u64.into(),
 
             Operation::UpdateStateParams => 175_000u64.into(),
+            Operation::BeginMixnodeRewarding => 175_000u64.into(),
+            Operation::FinishMixnodeRewarding => 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(crate) fn determine_fee(&self, gas_price: &GasPrice, gas_limit: Option<Gas>) -> Fee {
+        let gas_limit = gas_limit.unwrap_or_else(|| self.default_gas_limit());
+        Self::determine_custom_fee(gas_price, gas_limit)
+    }
 }
 
 #[cfg(test)]

common/client-libs/validator-client/src/nymd/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.u128() * gas_price_numerator > amount.u128() * 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/mod.rs

@@ -4,21 +4,19 @@
 use crate::nymd::cosmwasm_client::signing_client;
 use crate::nymd::cosmwasm_client::types::{
     ChangeAdminResult, ContractCodeId, ExecuteResult, InstantiateOptions, InstantiateResult,
-    MigrateResult, UploadMeta, UploadResult,
+    MigrateResult, SequenceResponse, UploadMeta, UploadResult,
 };
 use crate::nymd::error::NymdError;
 use crate::nymd::fee_helpers::Operation;
 use crate::nymd::wallet::DirectSecp256k1HdWallet;
 use cosmrs::rpc::endpoint::broadcast;
 use cosmrs::rpc::{Error as TendermintRpcError, HttpClientUrl};
-use cosmrs::tx::{Fee, Gas};
-
-use cosmwasm_std::Coin;
+use cosmwasm_std::{Coin, Uint128};
 use mixnet_contract::{
     Addr, Delegation, ExecuteMsg, Gateway, GatewayOwnershipResponse, IdentityKey,
-    LayerDistribution, MixNode, MixOwnershipResponse, PagedGatewayDelegationsResponse,
+    LayerDistribution, MixNode, MixOwnershipResponse, PagedAllDelegationsResponse,
     PagedGatewayResponse, PagedMixDelegationsResponse, PagedMixnodeResponse,
-    PagedReverseGatewayDelegationsResponse, PagedReverseMixDelegationsResponse, QueryMsg,
+    PagedReverseMixDelegationsResponse, QueryMsg, RawDelegationData, RewardingIntervalResponse,
     StateParams,
 };
 use serde::Serialize;
@@ -29,16 +27,21 @@ pub use crate::nymd::cosmwasm_client::client::CosmWasmClient;
 pub use crate::nymd::cosmwasm_client::signing_client::SigningCosmWasmClient;
 pub use crate::nymd::gas_price::GasPrice;
 pub use cosmrs::rpc::HttpClient as QueryNymdClient;
+pub use cosmrs::tendermint::block::Height;
+pub use cosmrs::tendermint::hash;
+pub use cosmrs::tendermint::Time as TendermintTime;
+pub use cosmrs::tx::{Fee, Gas};
 pub use cosmrs::Coin as CosmosCoin;
-pub use cosmrs::{AccountId, Denom};
+pub use cosmrs::{AccountId, Decimal, Denom};
 pub use signing_client::Client as SigningNymdClient;
 
 pub mod cosmwasm_client;
 pub mod error;
-pub(crate) mod fee_helpers;
+pub mod fee_helpers;
 pub mod gas_price;
 pub mod wallet;
 
+#[derive(Debug)]
 pub struct NymdClient<C> {
     client: C,
     contract_address: Option<AccountId>,
@@ -124,6 +127,14 @@ impl<C> NymdClient<C> {
         self.custom_gas_limits.insert(operation, limit);
     }
 
+    pub fn get_gas_price(&self) -> GasPrice {
+        self.gas_price.clone()
+    }
+
+    pub fn get_custom_gas_limits(&self) -> HashMap<Operation, Gas> {
+        self.custom_gas_limits.clone()
+    }
+
     pub fn contract_address(&self) -> Result<&AccountId, NymdError> {
         self.contract_address
             .as_ref()
@@ -145,11 +156,51 @@ impl<C> NymdClient<C> {
         &self.client_address.as_ref().unwrap()[0]
     }
 
-    fn get_fee(&self, operation: Operation) -> Fee {
+    pub async fn account_sequence(&self) -> Result<SequenceResponse, NymdError>
+    where
+        C: SigningCosmWasmClient + Sync,
+    {
+        self.client.get_sequence(self.address()).await
+    }
+
+    pub fn get_fee(&self, operation: Operation) -> Fee {
         let gas_limit = self.custom_gas_limits.get(&operation).cloned();
         operation.determine_fee(&self.gas_price, gas_limit)
     }
 
+    pub fn calculate_custom_fee(&self, gas_limit: impl Into<Gas>) -> Fee {
+        Operation::determine_custom_fee(&self.gas_price, gas_limit.into())
+    }
+
+    pub async fn get_current_block_timestamp(&self) -> Result<TendermintTime, NymdError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        Ok(self.client.get_block(None).await?.block.header.time)
+    }
+
+    pub async fn get_current_block_height(&self) -> Result<Height, NymdError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        self.client.get_height().await
+    }
+
+    /// Obtains the hash of a block specified by the provided height.
+    ///
+    /// # Arguments
+    ///
+    /// * `height`: height of the block for which we want to obtain the hash.
+    pub async fn get_block_hash(&self, height: u32) -> Result<hash::Hash, NymdError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        self.client
+            .get_block(Some(height))
+            .await
+            .map(|block| block.block_id.hash)
+    }
+
     pub async fn get_balance(&self, address: &AccountId) -> Result<Option<CosmosCoin>, NymdError>
     where
         C: CosmWasmClient + Sync,
@@ -167,6 +218,18 @@ impl<C> NymdClient<C> {
             .await
     }
 
+    pub async fn get_current_rewarding_interval(
+        &self,
+    ) -> Result<RewardingIntervalResponse, NymdError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        let request = QueryMsg::CurrentRewardingInterval {};
+        self.client
+            .query_contract_smart(self.contract_address()?, &request)
+            .await
+    }
+
     pub async fn get_layer_distribution(&self) -> Result<LayerDistribution, NymdError>
     where
         C: CosmWasmClient + Sync,
@@ -177,6 +240,46 @@ impl<C> NymdClient<C> {
             .await
     }
 
+    pub async fn get_reward_pool(&self) -> Result<Uint128, NymdError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        let request = QueryMsg::GetRewardPool {};
+        self.client
+            .query_contract_smart(self.contract_address()?, &request)
+            .await
+    }
+
+    pub async fn get_circulating_supply(&self) -> Result<Uint128, NymdError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        let request = QueryMsg::GetCirculatingSupply {};
+        self.client
+            .query_contract_smart(self.contract_address()?, &request)
+            .await
+    }
+
+    pub async fn get_sybil_resistance_percent(&self) -> Result<u8, NymdError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        let request = QueryMsg::GetSybilResistancePercent {};
+        self.client
+            .query_contract_smart(self.contract_address()?, &request)
+            .await
+    }
+
+    pub async fn get_epoch_reward_percent(&self) -> Result<u8, NymdError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        let request = QueryMsg::GetEpochRewardPercent {};
+        self.client
+            .query_contract_smart(self.contract_address()?, &request)
+            .await
+    }
+
     /// Checks whether there is a bonded mixnode associated with the provided client's address
     pub async fn owns_mixnode(&self, address: &AccountId) -> Result<bool, NymdError>
     where
@@ -262,6 +365,25 @@ impl<C> NymdClient<C> {
             .await
     }
 
+    /// Gets list of all mixnode delegations on particular page.
+    pub async fn get_all_mix_delegations_paged(
+        &self,
+        // I really hate mixing cosmwasm and cosmos-sdk types here...
+        start_after: Option<Vec<u8>>,
+        page_limit: Option<u32>,
+    ) -> Result<PagedAllDelegationsResponse<RawDelegationData>, NymdError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        let request = QueryMsg::GetAllMixDelegations {
+            start_after,
+            limit: page_limit,
+        };
+        self.client
+            .query_contract_smart(self.contract_address()?, &request)
+            .await
+    }
+
     /// Gets list of all the mixnodes on which a particular address delegated.
     pub async fn get_reverse_mix_delegations_paged(
         &self,
@@ -300,64 +422,6 @@ impl<C> NymdClient<C> {
             .await
     }
 
-    /// Gets list of all delegations towards particular mixnode on particular page.
-    pub async fn get_gateway_delegations(
-        &self,
-        gateway_identity: IdentityKey,
-        start_after: Option<Addr>,
-        page_limit: Option<u32>,
-    ) -> Result<PagedGatewayDelegationsResponse, NymdError>
-    where
-        C: CosmWasmClient + Sync,
-    {
-        let request = QueryMsg::GetGatewayDelegations {
-            gateway_identity,
-            start_after,
-            limit: page_limit,
-        };
-        self.client
-            .query_contract_smart(self.contract_address()?, &request)
-            .await
-    }
-
-    /// Gets list of all the gateways on which a particular address delegated.
-    pub async fn get_reverse_gateway_delegations_paged(
-        &self,
-        delegation_owner: Addr,
-        start_after: Option<IdentityKey>,
-        page_limit: Option<u32>,
-    ) -> Result<PagedReverseGatewayDelegationsResponse, NymdError>
-    where
-        C: CosmWasmClient + Sync,
-    {
-        let request = QueryMsg::GetReverseGatewayDelegations {
-            delegation_owner,
-            start_after,
-            limit: page_limit,
-        };
-        self.client
-            .query_contract_smart(self.contract_address()?, &request)
-            .await
-    }
-
-    /// Checks value of delegation of given client towards particular gateway.
-    pub async fn get_gateway_delegation(
-        &self,
-        gateway_identity: IdentityKey,
-        delegator: &AccountId,
-    ) -> Result<Delegation, NymdError>
-    where
-        C: CosmWasmClient + Sync,
-    {
-        let request = QueryMsg::GetGatewayDelegation {
-            gateway_identity,
-            address: Addr::unchecked(delegator.as_ref()),
-        };
-        self.client
-            .query_contract_smart(self.contract_address()?, &request)
-            .await
-    }
-
     /// Send funds from one address to another
     pub async fn send(
         &self,
@@ -391,6 +455,23 @@ impl<C> NymdClient<C> {
             .await
     }
 
+    pub async fn execute_multiple<I, M>(
+        &self,
+        contract_address: &AccountId,
+        msgs: I,
+        fee: Fee,
+        memo: impl Into<String> + Send + 'static,
+    ) -> Result<ExecuteResult, NymdError>
+    where
+        C: SigningCosmWasmClient + Sync,
+        I: IntoIterator<Item = (M, Vec<CosmosCoin>)> + Send,
+        M: Serialize,
+    {
+        self.client
+            .execute_multiple(self.address(), contract_address, msgs, fee, memo)
+            .await
+    }
+
     pub async fn upload(
         &self,
         wasm_code: Vec<u8>,
@@ -517,15 +598,17 @@ impl<C> NymdClient<C> {
     /// Delegates specified amount of stake to particular mixnode.
     pub async fn delegate_to_mixnode(
         &self,
-        mix_identity: IdentityKey,
-        amount: Coin,
+        mix_identity: &str,
+        amount: &Coin,
     ) -> Result<ExecuteResult, NymdError>
     where
         C: SigningCosmWasmClient + Sync,
     {
         let fee = self.get_fee(Operation::DelegateToMixnode);
 
-        let req = ExecuteMsg::DelegateToMixnode { mix_identity };
+        let req = ExecuteMsg::DelegateToMixnode {
+            mix_identity: mix_identity.to_string(),
+        };
         self.client
             .execute(
                 self.address(),
@@ -533,7 +616,7 @@ impl<C> NymdClient<C> {
                 &req,
                 fee,
                 "Delegating to mixnode from rust!",
-                vec![cosmwasm_coin_to_cosmos_coin(amount)],
+                vec![cosmwasm_coin_ptr_to_cosmos_coin(amount)],
             )
             .await
     }
@@ -541,14 +624,16 @@ impl<C> NymdClient<C> {
     /// Removes stake delegation from a particular mixnode.
     pub async fn remove_mixnode_delegation(
         &self,
-        mix_identity: IdentityKey,
+        mix_identity: &str,
     ) -> Result<ExecuteResult, NymdError>
     where
         C: SigningCosmWasmClient + Sync,
     {
         let fee = self.get_fee(Operation::UndelegateFromMixnode);
 
-        let req = ExecuteMsg::UndelegateFromMixnode { mix_identity };
+        let req = ExecuteMsg::UndelegateFromMixnode {
+            mix_identity: mix_identity.to_string(),
+        };
         self.client
             .execute(
                 self.address(),
@@ -605,53 +690,6 @@ impl<C> NymdClient<C> {
             .await
     }
 
-    /// Delegates specified amount of stake to particular gateway.
-    pub async fn delegate_to_gateway(
-        &self,
-        gateway_identity: IdentityKey,
-        amount: Coin,
-    ) -> Result<ExecuteResult, NymdError>
-    where
-        C: SigningCosmWasmClient + Sync,
-    {
-        let fee = self.get_fee(Operation::DelegateToGateway);
-
-        let req = ExecuteMsg::DelegateToGateway { gateway_identity };
-        self.client
-            .execute(
-                self.address(),
-                self.contract_address()?,
-                &req,
-                fee,
-                "Delegating to gateway from rust!",
-                vec![cosmwasm_coin_to_cosmos_coin(amount)],
-            )
-            .await
-    }
-
-    /// Removes stake delegation from a particular gateway.
-    pub async fn remove_gateway_delegation(
-        &self,
-        gateway_identity: IdentityKey,
-    ) -> Result<ExecuteResult, NymdError>
-    where
-        C: SigningCosmWasmClient + Sync,
-    {
-        let fee = self.get_fee(Operation::UndelegateFromGateway);
-
-        let req = ExecuteMsg::UndelegateFromGateway { gateway_identity };
-        self.client
-            .execute(
-                self.address(),
-                self.contract_address()?,
-                &req,
-                fee,
-                "Removing gateway delegation from rust!",
-                Vec::new(),
-            )
-            .await
-    }
-
     pub async fn update_state_params(
         &self,
         new_params: StateParams,
@@ -673,6 +711,54 @@ impl<C> NymdClient<C> {
             )
             .await
     }
+
+    pub async fn begin_mixnode_rewarding(
+        &self,
+        rewarding_interval_nonce: u32,
+    ) -> Result<ExecuteResult, NymdError>
+    where
+        C: SigningCosmWasmClient + Sync,
+    {
+        let fee = self.get_fee(Operation::BeginMixnodeRewarding);
+
+        let req = ExecuteMsg::BeginMixnodeRewarding {
+            rewarding_interval_nonce,
+        };
+        self.client
+            .execute(
+                self.address(),
+                self.contract_address()?,
+                &req,
+                fee,
+                "Beginning mixnode rewarding procedure",
+                Vec::new(),
+            )
+            .await
+    }
+
+    pub async fn finish_mixnode_rewarding(
+        &self,
+        rewarding_interval_nonce: u32,
+    ) -> Result<ExecuteResult, NymdError>
+    where
+        C: SigningCosmWasmClient + Sync,
+    {
+        let fee = self.get_fee(Operation::FinishMixnodeRewarding);
+
+        let req = ExecuteMsg::FinishMixnodeRewarding {
+            rewarding_interval_nonce,
+        };
+        self.client
+            .execute(
+                self.address(),
+                self.contract_address()?,
+                &req,
+                fee,
+                "Finishing mixnode rewarding procedure",
+                Vec::new(),
+            )
+            .await
+    }
 }
 
 fn cosmwasm_coin_to_cosmos_coin(coin: Coin) -> CosmosCoin {
@@ -682,3 +768,11 @@ fn cosmwasm_coin_to_cosmos_coin(coin: Coin) -> CosmosCoin {
         amount: (coin.amount.u128() as u64).into(),
     }
 }
+
+fn cosmwasm_coin_ptr_to_cosmos_coin(coin: &Coin) -> CosmosCoin {
+    CosmosCoin {
+        denom: coin.denom.parse().unwrap(),
+        // this might be a bit iffy, cosmwasm coin stores value as u128, while cosmos does it as u64
+        amount: (coin.amount.u128() as u64).into(),
+    }
+}

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

@@ -10,6 +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)]
 struct Secp256k1Derivation {
     hd_path: DerivationPath,
     prefix: String,
@@ -23,8 +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)]
 pub struct DirectSecp256k1HdWallet {
     /// Base secret
     secret: bip39::Mnemonic,

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/credentials/Cargo.toml

@@ -11,4 +11,6 @@ url = "2.2"
 
 # I guess temporarily until we get serde support in coconut up and running
 coconut-interface = { path = "../coconut-interface" }
+crypto = { path = "../crypto" }
+network-defaults = { path = "../network-defaults" }
 validator-client = { path = "../client-libs/validator-client" }

common/credentials/src/coconut/bandwidth.rs

@@ -8,11 +8,10 @@
 
 use url::Url;
 
+use super::utils::{obtain_aggregate_signature, prepare_credential_for_spending};
 use crate::error::Error;
-use crate::utils::{obtain_aggregate_signature, prepare_credential_for_spending};
 use coconut_interface::{hash_to_scalar, Credential, Parameters, Signature, VerificationKey};
-
-const BANDWIDTH_VALUE: u64 = 1024 * 1024; // 1 MB
+use network_defaults::BANDWIDTH_VALUE;
 
 pub const PUBLIC_ATTRIBUTES: u32 = 1;
 pub const PRIVATE_ATTRIBUTES: u32 = 1;

common/credentials/src/coconut/mod.rs

@@ -0,0 +1,5 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+pub mod bandwidth;
+pub mod utils;

common/credentials/src/lib.rs

@@ -1,8 +1,8 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-pub mod bandwidth;
+pub mod coconut;
 pub mod error;
-mod utils;
+pub mod token;
 
-pub use utils::{obtain_aggregate_signature, obtain_aggregate_verification_key};
+pub use coconut::utils::{obtain_aggregate_signature, obtain_aggregate_verification_key};

common/credentials/src/token/bandwidth.rs

@@ -0,0 +1,140 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crypto::asymmetric::identity::{PublicKey, Signature, PUBLIC_KEY_LENGTH, SIGNATURE_LENGTH};
+
+use crate::error::Error;
+use std::convert::TryInto;
+
+#[cfg(not(feature = "coconut"))]
+pub struct TokenCredential {
+    verification_key: PublicKey,
+    gateway_identity: PublicKey,
+    bandwidth: u64,
+    signature: Signature,
+}
+
+#[cfg(not(feature = "coconut"))]
+impl TokenCredential {
+    pub fn new(
+        verification_key: PublicKey,
+        gateway_identity: PublicKey,
+        bandwidth: u64,
+        signature: Signature,
+    ) -> Self {
+        TokenCredential {
+            verification_key,
+            gateway_identity,
+            bandwidth,
+            signature,
+        }
+    }
+
+    pub fn verification_key(&self) -> PublicKey {
+        self.verification_key
+    }
+
+    pub fn gateway_identity(&self) -> PublicKey {
+        self.gateway_identity
+    }
+
+    pub fn bandwidth(&self) -> u64 {
+        self.bandwidth
+    }
+
+    pub fn signature_bytes(&self) -> [u8; 64] {
+        self.signature.to_bytes()
+    }
+
+    pub fn verify_signature(&self) -> bool {
+        let message: Vec<u8> = self
+            .verification_key
+            .to_bytes()
+            .iter()
+            .chain(self.gateway_identity.to_bytes().iter())
+            .copied()
+            .collect();
+        self.verification_key
+            .verify(&message, &self.signature)
+            .is_ok()
+    }
+
+    pub fn to_bytes(&self) -> Vec<u8> {
+        self.verification_key
+            .to_bytes()
+            .iter()
+            .chain(self.gateway_identity.to_bytes().iter())
+            .chain(self.bandwidth.to_be_bytes().iter())
+            .chain(self.signature.to_bytes().iter())
+            .copied()
+            .collect()
+    }
+
+    pub fn from_bytes(b: &[u8]) -> Result<Self, Error> {
+        if b.len() != 2 * PUBLIC_KEY_LENGTH + 8 + SIGNATURE_LENGTH {
+            return Err(Error::BandwidthCredentialError);
+        }
+        let verification_key = PublicKey::from_bytes(&b[..PUBLIC_KEY_LENGTH])
+            .map_err(|_| Error::BandwidthCredentialError)?;
+        let gateway_identity = PublicKey::from_bytes(&b[PUBLIC_KEY_LENGTH..2 * PUBLIC_KEY_LENGTH])
+            .map_err(|_| Error::BandwidthCredentialError)?;
+        let bandwidth = u64::from_be_bytes(
+            b[2 * PUBLIC_KEY_LENGTH..2 * PUBLIC_KEY_LENGTH + 8]
+                .try_into()
+                // unwrapping is safe because we know we have 8 bytes
+                .unwrap(),
+        );
+        let signature = Signature::from_bytes(&b[2 * PUBLIC_KEY_LENGTH + 8..])
+            .map_err(|_| Error::BandwidthCredentialError)?;
+        Ok(TokenCredential {
+            verification_key,
+            gateway_identity,
+            bandwidth,
+            signature,
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[cfg(not(feature = "coconut"))]
+    #[test]
+    fn token_serde() {
+        // pre-generated, valid values
+        let verification_key = PublicKey::from_bytes(&[
+            103, 105, 71, 177, 149, 245, 26, 32, 73, 121, 76, 50, 94, 88, 119, 231, 91, 229, 167,
+            56, 39, 62, 185, 39, 83, 246, 153, 27, 17, 155, 109, 73,
+        ])
+        .unwrap();
+        let gateway_identity = PublicKey::from_bytes(&[
+            37, 113, 137, 189, 157, 82, 35, 2, 187, 136, 61, 119, 98, 5, 245, 82, 46, 124, 67, 45,
+            165, 255, 53, 222, 185, 252, 6, 148, 128, 15, 206, 19,
+        ])
+        .unwrap();
+        let signature = Signature::from_bytes(&[
+            117, 251, 162, 217, 57, 2, 50, 210, 206, 81, 236, 90, 74, 201, 69, 237, 240, 247, 214,
+            158, 220, 89, 235, 222, 85, 134, 73, 73, 8, 60, 25, 39, 183, 28, 83, 193, 31, 174, 25,
+            24, 38, 215, 205, 228, 159, 135, 35, 4, 171, 59, 100, 157, 12, 249, 77, 52, 143, 4, 32,
+            28, 147, 70, 182, 14,
+        ])
+        .unwrap();
+        let credential = TokenCredential::new(verification_key, gateway_identity, 1024, signature);
+        let serialized_credential = credential.to_bytes();
+        let deserialized_credential = TokenCredential::from_bytes(&serialized_credential).unwrap();
+        assert_eq!(
+            credential.verification_key,
+            deserialized_credential.verification_key
+        );
+        assert_eq!(
+            credential.gateway_identity,
+            deserialized_credential.gateway_identity
+        );
+        assert_eq!(credential.bandwidth, deserialized_credential.bandwidth);
+        assert_eq!(
+            credential.signature.to_bytes(),
+            deserialized_credential.signature.to_bytes()
+        );
+    }
+}

common/credentials/src/token/mod.rs

@@ -0,0 +1,4 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+pub mod bandwidth;

common/crypto/Cargo.toml

@@ -7,15 +7,14 @@ edition = "2018"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-aes-ctr = "0.6.0"
-bs58 = "0.4"
-blake3 = "0.3"
-#blake3 = { version = "0.3", features = ["traits-preview"]}
-digest = "0.9"
+aes = { version = "0.7.4", features = ["ctr"] }
+bs58 = "0.4.0"
+blake3 = { version = "1.0.0", features = ["traits-preview"] }
+digest = "0.9.0"
 generic-array = "0.14"
-hkdf = "0.10"
-hmac = "0.8"
-cipher = "0.2"
+hkdf = "0.11.0"
+hmac = "0.11.0"
+cipher = "0.3.0"
 x25519-dalek = "1.1"
 ed25519-dalek = "1.0"
 log = "0.4"

common/crypto/src/hkdf.rs

@@ -5,18 +5,13 @@ use digest::{BlockInput, FixedOutput, Reset, Update};
 use generic_array::ArrayLength;
 use hkdf::Hkdf;
 
-#[derive(Debug)]
-pub enum HkdfError {
-    InvalidOkmLength,
-}
-
 /// Perform HKDF `extract` then `expand` as a single step.
 pub fn extract_then_expand<D>(
     salt: Option<&[u8]>,
     ikm: &[u8],
     info: Option<&[u8]>,
     okm_length: usize,
-) -> Result<Vec<u8>, HkdfError>
+) -> Result<Vec<u8>, hkdf::InvalidLength>
 where
     D: Update + BlockInput + FixedOutput + Reset + Default + Clone,
     D::BlockSize: ArrayLength<u8>,
@@ -27,9 +22,7 @@ where
 
     let hkdf = Hkdf::<D>::new(salt, ikm);
     let mut okm = vec![0u8; okm_length];
-    if hkdf.expand(info.unwrap_or_else(|| &[]), &mut okm).is_err() {
-        return Err(HkdfError::InvalidOkmLength);
-    }
+    hkdf.expand(info.unwrap_or_else(|| &[]), &mut okm)?;
 
     Ok(okm)
 }

common/crypto/src/hmac.rs

@@ -18,7 +18,7 @@ where
     D::OutputSize: ArrayLength<u8>,
 {
     let mut hmac =
-        Hmac::<D>::new_varkey(key).expect("HMAC should be able to take key of any size!");
+        Hmac::<D>::new_from_slice(key).expect("HMAC should be able to take key of any size!");
     hmac.update(data);
     hmac.finalize()
 }
@@ -31,7 +31,7 @@ where
     D::OutputSize: ArrayLength<u8>,
 {
     let mut hmac =
-        Hmac::<D>::new_varkey(key).expect("HMAC should be able to take key of any size!");
+        Hmac::<D>::new_from_slice(key).expect("HMAC should be able to take key of any size!");
     hmac.update(data);
     // note, under the hood ct_eq is called
     hmac.verify(tag).is_ok()

common/crypto/src/lib.rs

@@ -13,7 +13,7 @@ pub use generic_array;
 
 // with the below my idea was to try to introduce having a single place of importing all hashing, encryption,
 // etc. algorithms and import them elsewhere as needed via common/crypto
-pub use aes_ctr;
+pub use aes;
 pub use blake3;
 
 // TODO: this function uses all three modules: asymmetric crypto, symmetric crypto and derives key...,

common/crypto/src/shared_key.rs

@@ -3,7 +3,7 @@
 
 use crate::asymmetric::encryption;
 use crate::hkdf;
-use cipher::stream::{Key, NewStreamCipher, SyncStreamCipher};
+use cipher::{CipherKey, NewCipher, StreamCipher};
 use digest::{BlockInput, FixedOutput, Reset, Update};
 use generic_array::{typenum::Unsigned, ArrayLength};
 use rand::{CryptoRng, RngCore};
@@ -13,9 +13,9 @@ use rand::{CryptoRng, RngCore};
 pub fn new_ephemeral_shared_key<C, D, R>(
     rng: &mut R,
     remote_key: &encryption::PublicKey,
-) -> (encryption::KeyPair, Key<C>)
+) -> (encryption::KeyPair, CipherKey<C>)
 where
-    C: SyncStreamCipher + NewStreamCipher,
+    C: StreamCipher + NewCipher,
     D: Update + BlockInput + FixedOutput + Reset + Default + Clone,
     D::BlockSize: ArrayLength<u8>,
     D::OutputSize: ArrayLength<u8>,
@@ -31,7 +31,7 @@ where
         .expect("somehow too long okm was provided");
 
     let derived_shared_key =
-        Key::<C>::from_exact_iter(okm).expect("okm was expanded to incorrect length!");
+        CipherKey::<C>::from_exact_iter(okm).expect("okm was expanded to incorrect length!");
 
     (ephemeral_keypair, derived_shared_key)
 }
@@ -40,9 +40,9 @@ where
 pub fn recompute_shared_key<C, D>(
     remote_key: &encryption::PublicKey,
     local_key: &encryption::PrivateKey,
-) -> Key<C>
+) -> CipherKey<C>
 where
-    C: SyncStreamCipher + NewStreamCipher,
+    C: StreamCipher + NewCipher,
     D: Update + BlockInput + FixedOutput + Reset + Default + Clone,
     D::BlockSize: ArrayLength<u8>,
     D::OutputSize: ArrayLength<u8>,
@@ -53,5 +53,5 @@ where
     let okm = hkdf::extract_then_expand::<D>(None, &dh_result, None, C::KeySize::to_usize())
         .expect("somehow too long okm was provided");
 
-    Key::<C>::from_exact_iter(okm).expect("okm was expanded to incorrect length!")
+    CipherKey::<C>::from_exact_iter(okm).expect("okm was expanded to incorrect length!")
 }

common/crypto/src/symmetric/stream_cipher.rs

@@ -1,13 +1,14 @@
 // Copyright 2020 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use cipher::stream::{Nonce, StreamCipher, SyncStreamCipher};
+use cipher::{Nonce, StreamCipher};
 use generic_array::{typenum::Unsigned, GenericArray};
 use rand::{CryptoRng, RngCore};
 
 // re-export this for ease of use
-pub use cipher::stream::{Key, NewStreamCipher};
+pub use cipher::{CipherKey, NewCipher};
 
+// SECURITY:
 // TODO: note that this is not the most secure approach here
 // we are not using nonces properly but instead "kinda" thinking of them as IVs.
 // Nonce require, as the name suggest, being only seen once. Ever.
@@ -20,9 +21,9 @@ pub use cipher::stream::{Key, NewStreamCipher};
 #[allow(clippy::upper_case_acronyms)]
 pub type IV<C> = Nonce<C>;
 
-pub fn generate_key<C, R>(rng: &mut R) -> Key<C>
+pub fn generate_key<C, R>(rng: &mut R) -> CipherKey<C>
 where
-    C: NewStreamCipher,
+    C: NewCipher,
     R: RngCore + CryptoRng,
 {
     let mut key = GenericArray::default();
@@ -32,7 +33,7 @@ where
 
 pub fn random_iv<C, R>(rng: &mut R) -> IV<C>
 where
-    C: NewStreamCipher,
+    C: NewCipher,
     R: RngCore + CryptoRng,
 {
     let mut iv = GenericArray::default();
@@ -42,14 +43,14 @@ where
 
 pub fn zero_iv<C>() -> IV<C>
 where
-    C: NewStreamCipher,
+    C: NewCipher,
 {
     GenericArray::default()
 }
 
 pub fn iv_from_slice<C>(b: &[u8]) -> &IV<C>
 where
-    C: NewStreamCipher,
+    C: NewCipher,
 {
     if b.len() != C::NonceSize::to_usize() {
         // `from_slice` would have caused a panic about this issue anyway.
@@ -66,38 +67,42 @@ where
 // TODO: there's really no way to use more parts of the keystream if it was required at some point.
 // However, do we really expect to ever need it?
 
-pub fn encrypt<C>(key: &Key<C>, iv: &IV<C>, data: &[u8]) -> Vec<u8>
+#[inline]
+pub fn encrypt<C>(key: &CipherKey<C>, iv: &IV<C>, data: &[u8]) -> Vec<u8>
 where
-    C: SyncStreamCipher + NewStreamCipher,
+    C: StreamCipher + NewCipher,
 {
     let mut ciphertext = data.to_vec();
     encrypt_in_place::<C>(key, iv, &mut ciphertext);
     ciphertext
 }
 
-pub fn encrypt_in_place<C>(key: &Key<C>, iv: &IV<C>, data: &mut [u8])
+#[inline]
+pub fn encrypt_in_place<C>(key: &CipherKey<C>, iv: &IV<C>, data: &mut [u8])
 where
-    C: SyncStreamCipher + NewStreamCipher,
+    C: StreamCipher + NewCipher,
 {
     let mut cipher = C::new(key, iv);
-    cipher.encrypt(data)
+    cipher.apply_keystream(data)
 }
 
-pub fn decrypt<C>(key: &Key<C>, iv: &IV<C>, ciphertext: &[u8]) -> Vec<u8>
+#[inline]
+pub fn decrypt<C>(key: &CipherKey<C>, iv: &IV<C>, ciphertext: &[u8]) -> Vec<u8>
 where
-    C: SyncStreamCipher + NewStreamCipher,
+    C: StreamCipher + NewCipher,
 {
     let mut data = ciphertext.to_vec();
     decrypt_in_place::<C>(key, iv, &mut data);
     data
 }
 
-pub fn decrypt_in_place<C>(key: &Key<C>, iv: &IV<C>, data: &mut [u8])
+#[inline]
+pub fn decrypt_in_place<C>(key: &CipherKey<C>, iv: &IV<C>, data: &mut [u8])
 where
-    C: SyncStreamCipher + NewStreamCipher,
+    C: StreamCipher + NewCipher,
 {
     let mut cipher = C::new(key, iv);
-    cipher.decrypt(data)
+    cipher.apply_keystream(data)
 }
 
 #[cfg(test)]
@@ -108,7 +113,7 @@ mod tests {
     #[cfg(test)]
     mod aes_ctr128 {
         use super::*;
-        use aes_ctr::Aes128Ctr;
+        use aes::Aes128Ctr;
 
         #[test]
         fn zero_iv_is_actually_zero() {

common/erc20-bridge-contract/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "erc20-bridge-contract"
+version = "0.1.0"
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+schemars = "0.8"
+serde = { version = "1.0.103", default-features = false, features = ["derive"] }

common/erc20-bridge-contract/src/keys.rs

@@ -0,0 +1,45 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+
+// Serializable structures for what we find in common/crypto
+#[derive(Serialize, Deserialize, Copy, Clone, Debug, PartialEq, JsonSchema)]
+pub struct PublicKey([u8; 32]);
+
+impl PublicKey {
+    pub fn new(bytes: [u8; 32]) -> Self {
+        PublicKey(bytes)
+    }
+    pub fn to_bytes(&self) -> [u8; 32] {
+        self.0
+    }
+}
+
+impl AsRef<[u8]> for PublicKey {
+    #[inline]
+    fn as_ref(&self) -> &[u8] {
+        &self.0
+    }
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
+pub struct Signature([u8; 32], [u8; 32]);
+
+impl Signature {
+    pub fn new(bytes: [u8; 64]) -> Self {
+        let mut sig1 = [0u8; 32];
+        let mut sig2 = [0u8; 32];
+        sig1.copy_from_slice(&bytes[..32]);
+        sig2.copy_from_slice(&bytes[32..]);
+
+        Signature(sig1, sig2)
+    }
+    pub fn to_bytes(&self) -> [u8; 64] {
+        let mut res = [0u8; 64];
+        res[..32].copy_from_slice(&self.0);
+        res[32..].copy_from_slice(&self.1);
+        res
+    }
+}

common/erc20-bridge-contract/src/lib.rs

@@ -0,0 +1,3 @@
+pub mod keys;
+pub mod msg;
+pub mod payment;

common/erc20-bridge-contract/src/msg.rs

@@ -0,0 +1,30 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+
+use crate::keys::PublicKey;
+use crate::payment::LinkPaymentData;
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
+pub struct InstantiateMsg {}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
+#[serde(rename_all = "snake_case")]
+pub enum ExecuteMsg {
+    LinkPayment { data: LinkPaymentData },
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
+#[serde(rename_all = "snake_case")]
+pub enum QueryMsg {
+    GetPayments {
+        limit: Option<u32>,
+        start_after: Option<PublicKey>,
+    },
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
+#[serde(rename_all = "snake_case")]
+pub struct MigrateMsg {}

common/erc20-bridge-contract/src/payment.rs

@@ -0,0 +1,73 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+
+use crate::keys::{PublicKey, Signature};
+
+#[derive(Clone, Debug, Deserialize, PartialEq, Serialize, JsonSchema)]
+pub struct Payment {
+    verification_key: PublicKey,
+    gateway_identity: PublicKey,
+    bandwidth: u64,
+}
+
+impl Payment {
+    pub fn new(verification_key: PublicKey, gateway_identity: PublicKey, bandwidth: u64) -> Self {
+        Payment {
+            verification_key,
+            gateway_identity,
+            bandwidth,
+        }
+    }
+
+    pub fn verification_key(&self) -> PublicKey {
+        self.verification_key
+    }
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
+pub struct LinkPaymentData {
+    pub verification_key: PublicKey,
+    pub gateway_identity: PublicKey,
+    pub bandwidth: u64,
+    pub signature: Signature,
+}
+
+impl LinkPaymentData {
+    pub fn new(
+        verification_key: [u8; 32],
+        gateway_identity: [u8; 32],
+        bandwidth: u64,
+        signature: [u8; 64],
+    ) -> Self {
+        LinkPaymentData {
+            verification_key: PublicKey::new(verification_key),
+            gateway_identity: PublicKey::new(gateway_identity),
+            bandwidth,
+            signature: Signature::new(signature),
+        }
+    }
+}
+
+#[derive(Clone, Debug, Deserialize, PartialEq, Serialize, JsonSchema)]
+pub struct PagedPaymentResponse {
+    pub payments: Vec<Payment>,
+    pub per_page: usize,
+    pub start_next_after: Option<PublicKey>,
+}
+
+impl PagedPaymentResponse {
+    pub fn new(
+        payments: Vec<Payment>,
+        per_page: usize,
+        start_next_after: Option<PublicKey>,
+    ) -> Self {
+        PagedPaymentResponse {
+            payments,
+            per_page,
+            start_next_after,
+        }
+    }
+}

common/mixnet-contract/Cargo.toml

@@ -8,9 +8,18 @@ edition = "2018"
 
 [dependencies]
 # this branch is identical to 0.14.1 with addition of updated k256 dependency required to help poor cargo choose correct version
-cosmwasm-std = { git = "https://github.com/jstuczyn/cosmwasm", branch="0.14.1-updatedk256" }
+cosmwasm-std = { git = "https://github.com/jstuczyn/cosmwasm", branch = "0.14.1-updatedk256" }
 #cosmwasm-std = { version = "0.14.1" }
 
 serde = { version = "1.0", features = ["derive"] }
 serde_repr = "0.1"
 schemars = "0.8"
+ts-rs = { version = "5.1", optional = true }
+thiserror = "1.0"
+network-defaults = { path = "../network-defaults" }
+fixed = "1.1"
+az = "1.1"
+log = "0.4.14"
+
+[features]
+default = []

common/mixnet-contract/src/delegation.rs

@@ -7,7 +7,24 @@ use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use std::fmt::Display;
 
-#[derive(Debug, Deserialize, PartialEq, Serialize)]
+#[derive(Clone, Debug, Deserialize, PartialEq, Serialize, JsonSchema)]
+pub struct UnpackedDelegation<T> {
+    pub owner: Addr,
+    pub node_identity: IdentityKey,
+    pub delegation_data: T,
+}
+
+impl<T> UnpackedDelegation<T> {
+    pub fn new(owner: Addr, node_identity: IdentityKey, delegation_data: T) -> Self {
+        UnpackedDelegation {
+            owner,
+            node_identity,
+            delegation_data,
+        }
+    }
+}
+
+#[derive(Clone, Debug, Deserialize, PartialEq, Serialize, JsonSchema)]
 pub struct RawDelegationData {
     pub amount: Uint128,
     pub block_height: u64,
@@ -104,43 +121,16 @@ impl PagedReverseMixDelegationsResponse {
 }
 
 #[derive(Clone, Debug, Deserialize, PartialEq, Serialize, JsonSchema)]
-pub struct PagedGatewayDelegationsResponse {
-    pub node_identity: IdentityKey,
-    pub delegations: Vec<Delegation>,
-    pub start_next_after: Option<Addr>,
+pub struct PagedAllDelegationsResponse<T> {
+    pub delegations: Vec<UnpackedDelegation<T>>,
+    pub start_next_after: Option<Vec<u8>>,
 }
 
-impl PagedGatewayDelegationsResponse {
-    pub fn new(
-        node_identity: IdentityKey,
-        delegations: Vec<Delegation>,
-        start_next_after: Option<Addr>,
-    ) -> Self {
-        PagedGatewayDelegationsResponse {
-            node_identity,
+impl<T> PagedAllDelegationsResponse<T> {
+    pub fn new(delegations: Vec<UnpackedDelegation<T>>, start_next_after: Option<Vec<u8>>) -> Self {
+        PagedAllDelegationsResponse {
             delegations,
             start_next_after,
         }
     }
 }
-
-#[derive(Clone, Debug, Deserialize, PartialEq, Serialize, JsonSchema)]
-pub struct PagedReverseGatewayDelegationsResponse {
-    pub delegation_owner: Addr,
-    pub delegated_nodes: Vec<IdentityKey>,
-    pub start_next_after: Option<IdentityKey>,
-}
-
-impl PagedReverseGatewayDelegationsResponse {
-    pub fn new(
-        delegation_owner: Addr,
-        delegated_nodes: Vec<IdentityKey>,
-        start_next_after: Option<IdentityKey>,
-    ) -> Self {
-        PagedReverseGatewayDelegationsResponse {
-            delegation_owner,
-            delegated_nodes,
-            start_next_after,
-        }
-    }
-}

common/mixnet-contract/src/error.rs

@@ -0,0 +1,9 @@
+use thiserror::Error;
+
+#[derive(Error, Debug, PartialEq)]
+pub enum MixnetContractError {
+    #[error("Overflow Error")]
+    OverflowError(#[from] cosmwasm_std::OverflowError),
+    #[error("reward_blockstamp field not set, set_reward_blockstamp must be called before attempting to issue rewards")]
+    BlockstampNotSet,
+}

common/mixnet-contract/src/gateway.rs

@@ -2,14 +2,14 @@
 #![allow(clippy::field_reassign_with_default)]
 
 use crate::{IdentityKey, SphinxKey};
-use cosmwasm_std::{coin, Addr, Coin};
+use cosmwasm_std::{Addr, Coin};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
+use std::cmp::Ordering;
 use std::fmt::Display;
 
-use crate::current_block_height;
-
-#[derive(Clone, Debug, Deserialize, PartialEq, Serialize, JsonSchema)]
+#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
+#[derive(Clone, Debug, Deserialize, PartialEq, PartialOrd, Serialize, JsonSchema)]
 pub struct Gateway {
     pub host: String,
     pub mix_port: u16,
@@ -24,9 +24,7 @@ pub struct Gateway {
 #[derive(Clone, Debug, Deserialize, PartialEq, Serialize, JsonSchema)]
 pub struct GatewayBond {
     pub bond_amount: Coin,
-    pub total_delegation: Coin,
     pub owner: Addr,
-    #[serde(default = "current_block_height")]
     pub block_height: u64,
     pub gateway: Gateway,
 }
@@ -34,7 +32,6 @@ pub struct GatewayBond {
 impl GatewayBond {
     pub fn new(bond_amount: Coin, owner: Addr, block_height: u64, gateway: Gateway) -> Self {
         GatewayBond {
-            total_delegation: coin(0, &bond_amount.denom),
             bond_amount,
             owner,
             block_height,
@@ -59,6 +56,39 @@ impl GatewayBond {
     }
 }
 
+impl PartialOrd for GatewayBond {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        // first remove invalid cases
+        if self.bond_amount.denom != other.bond_amount.denom {
+            return None;
+        }
+
+        // try to order by total bond
+        let bond_cmp = self
+            .bond_amount
+            .amount
+            .partial_cmp(&other.bond_amount.amount)?;
+        if bond_cmp != Ordering::Equal {
+            return Some(bond_cmp);
+        }
+
+        // then check block height
+        let height_cmp = self.block_height.partial_cmp(&other.block_height)?;
+        if height_cmp != Ordering::Equal {
+            return Some(height_cmp);
+        }
+
+        // finally go by the rest of the fields in order. It doesn't really matter at this point
+        // but we should be deterministic.
+        let owner_cmp = self.owner.partial_cmp(&other.owner)?;
+        if owner_cmp != Ordering::Equal {
+            return Some(owner_cmp);
+        }
+
+        self.gateway.partial_cmp(&other.gateway)
+    }
+}
+
 impl Display for GatewayBond {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         write!(
@@ -95,3 +125,85 @@ pub struct GatewayOwnershipResponse {
     pub address: Addr,
     pub has_gateway: bool,
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn gateway_fixture() -> Gateway {
+        Gateway {
+            host: "1.1.1.1".to_string(),
+            mix_port: 123,
+            clients_port: 456,
+            location: "foomplandia".to_string(),
+            sphinx_key: "sphinxkey".to_string(),
+            identity_key: "identitykey".to_string(),
+            version: "0.11.0".to_string(),
+        }
+    }
+
+    #[test]
+    fn gateway_bond_partial_ord() {
+        let _150foos = Coin::new(150, "foo");
+        let _140foos = Coin::new(140, "foo");
+        let _50foos = Coin::new(50, "foo");
+        let _0foos = Coin::new(0, "foo");
+
+        let gate1 = GatewayBond {
+            bond_amount: _150foos.clone(),
+            owner: Addr::unchecked("foo1"),
+            block_height: 100,
+            gateway: gateway_fixture(),
+        };
+
+        let gate2 = GatewayBond {
+            bond_amount: _150foos,
+            owner: Addr::unchecked("foo2"),
+            block_height: 120,
+            gateway: gateway_fixture(),
+        };
+
+        let gate3 = GatewayBond {
+            bond_amount: _50foos,
+            owner: Addr::unchecked("foo3"),
+            block_height: 120,
+            gateway: gateway_fixture(),
+        };
+
+        let gate4 = GatewayBond {
+            bond_amount: _140foos,
+            owner: Addr::unchecked("foo4"),
+            block_height: 120,
+            gateway: gateway_fixture(),
+        };
+
+        let gate5 = GatewayBond {
+            bond_amount: _0foos,
+            owner: Addr::unchecked("foo5"),
+            block_height: 120,
+            gateway: gateway_fixture(),
+        };
+
+        // summary:
+        // gate1: 150bond, foo1, 100
+        // gate2: 150bond, foo2, 120
+        // gate3: 50bond, foo3, 120
+        // gate4: 140bond, foo4, 120
+        // gate5: 0bond, foo5, 120
+
+        // highest total bond is used
+        // finally just the rest of the fields
+
+        // gate1 has higher total than gate4 or gate5
+        assert!(gate1 > gate4);
+        assert!(gate1 > gate5);
+
+        // gate1 has the same total as gate3, however, gate1 has more tokens in bond
+        assert!(gate1 > gate3);
+        // same case for gate4 and gate5
+        assert!(gate4 > gate5);
+
+        // same bond and delegation, so it's just ordered by height
+        assert!(gate1 < gate2);
+    }
+}

common/mixnet-contract/src/lib.rs

@@ -2,24 +2,21 @@
 // SPDX-License-Identifier: Apache-2.0
 
 mod delegation;
+pub mod error;
 mod gateway;
-mod mixnode;
+pub mod mixnode;
 mod msg;
 mod types;
 
 pub use cosmwasm_std::{Addr, Coin};
 pub use delegation::{
-    Delegation, PagedGatewayDelegationsResponse, PagedMixDelegationsResponse,
-    PagedReverseGatewayDelegationsResponse, PagedReverseMixDelegationsResponse, RawDelegationData,
+    Delegation, PagedAllDelegationsResponse, PagedMixDelegationsResponse,
+    PagedReverseMixDelegationsResponse, RawDelegationData, UnpackedDelegation,
 };
 pub use gateway::{Gateway, GatewayBond, GatewayOwnershipResponse, PagedGatewayResponse};
 pub use mixnode::{Layer, MixNode, MixNodeBond, MixOwnershipResponse, PagedMixnodeResponse};
 pub use msg::{ExecuteMsg, InstantiateMsg, MigrateMsg, QueryMsg};
-pub use types::{IdentityKey, IdentityKeyRef, LayerDistribution, SphinxKey, StateParams};
-
-use std::sync::atomic::{AtomicU64, Ordering};
-pub static CURRENT_BLOCK_HEIGHT: AtomicU64 = AtomicU64::new(0);
-
-pub fn current_block_height() -> u64 {
-    CURRENT_BLOCK_HEIGHT.load(Ordering::Relaxed)
-}
+pub use types::{
+    IdentityKey, IdentityKeyRef, LayerDistribution, RewardingIntervalResponse, SphinxKey,
+    StateParams,
+};

common/mixnet-contract/src/mixnode.rs

@@ -2,15 +2,20 @@
 #![allow(clippy::field_reassign_with_default)]
 
 use crate::{IdentityKey, SphinxKey};
-use cosmwasm_std::{coin, Addr, Coin};
+use az::CheckedCast;
+use cosmwasm_std::{coin, Addr, Coin, Uint128};
+use log::error;
+use network_defaults::{DEFAULT_OPERATOR_EPOCH_COST, DEFAULT_PROFIT_MARGIN};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use serde_repr::{Deserialize_repr, Serialize_repr};
+use std::cmp::Ordering;
 use std::fmt::Display;
 
-use crate::current_block_height;
+type U128 = fixed::types::U75F53; // u128 with 18 significant digits
 
-#[derive(Clone, Debug, Deserialize, PartialEq, Serialize, JsonSchema)]
+#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
+#[derive(Clone, Debug, Deserialize, PartialEq, PartialOrd, Serialize, JsonSchema)]
 pub struct MixNode {
     pub host: String,
     pub mix_port: u16,
@@ -22,7 +27,19 @@ pub struct MixNode {
     pub version: String,
 }
 
-#[derive(Copy, Clone, Debug, Serialize_repr, PartialEq, Deserialize_repr, JsonSchema)]
+#[derive(
+    Copy,
+    Clone,
+    Debug,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Hash,
+    Serialize_repr,
+    Deserialize_repr,
+    JsonSchema,
+)]
 #[repr(u8)]
 pub enum Layer {
     Gateway = 0,
@@ -31,15 +48,106 @@ pub enum Layer {
     Three = 3,
 }
 
+#[derive(Debug, Clone, JsonSchema, PartialEq, Serialize, Deserialize, Copy)]
+pub struct NodeRewardParams {
+    period_reward_pool: Uint128,
+    k: Uint128,
+    reward_blockstamp: u64,
+    circulating_supply: Uint128,
+    uptime: Uint128,
+    sybil_resistance_percent: u8,
+}
+
+impl NodeRewardParams {
+    pub fn new(
+        period_reward_pool: u128,
+        k: u128,
+        reward_blockstamp: u64,
+        circulating_supply: u128,
+        uptime: u128,
+        sybil_resistance_percent: u8,
+    ) -> NodeRewardParams {
+        NodeRewardParams {
+            period_reward_pool: Uint128(period_reward_pool),
+            k: Uint128(k),
+            reward_blockstamp,
+            circulating_supply: Uint128(circulating_supply),
+            uptime: Uint128(uptime),
+            sybil_resistance_percent,
+        }
+    }
+
+    pub fn performance(&self) -> U128 {
+        U128::from_num(self.uptime.u128()) / U128::from_num(100)
+    }
+
+    pub fn operator_cost(&self) -> U128 {
+        U128::from_num(self.uptime.u128() / 100u128 * DEFAULT_OPERATOR_EPOCH_COST as u128)
+    }
+
+    pub fn set_reward_blockstamp(&mut self, blockstamp: u64) {
+        self.reward_blockstamp = blockstamp;
+    }
+
+    pub fn period_reward_pool(&self) -> u128 {
+        self.period_reward_pool.u128()
+    }
+
+    pub fn k(&self) -> u128 {
+        self.k.u128()
+    }
+
+    pub fn circulating_supply(&self) -> u128 {
+        self.circulating_supply.u128()
+    }
+
+    pub fn reward_blockstamp(&self) -> u64 {
+        self.reward_blockstamp
+    }
+
+    pub fn uptime(&self) -> u128 {
+        self.uptime.u128()
+    }
+
+    pub fn one_over_k(&self) -> U128 {
+        U128::from_num(1) / U128::from_num(self.k.u128())
+    }
+
+    pub fn alpha(&self) -> U128 {
+        U128::from_num(self.sybil_resistance_percent) / U128::from_num(100)
+    }
+}
+
+#[derive(Debug)]
+pub struct NodeRewardResult {
+    reward: U128,
+    lambda: U128,
+    sigma: U128,
+}
+
+impl NodeRewardResult {
+    pub fn reward(&self) -> U128 {
+        self.reward
+    }
+
+    pub fn lambda(&self) -> U128 {
+        self.lambda
+    }
+
+    pub fn sigma(&self) -> U128 {
+        self.sigma
+    }
+}
+
 #[derive(Clone, Debug, Deserialize, PartialEq, Serialize, JsonSchema)]
 pub struct MixNodeBond {
     pub bond_amount: Coin,
     pub total_delegation: Coin,
     pub owner: Addr,
     pub layer: Layer,
-    #[serde(default = "current_block_height")]
     pub block_height: u64,
     pub mix_node: MixNode,
+    pub profit_margin_percent: Option<u8>,
 }
 
 impl MixNodeBond {
@@ -49,6 +157,7 @@ impl MixNodeBond {
         layer: Layer,
         block_height: u64,
         mix_node: MixNode,
+        profit_margin_percent: Option<u8>,
     ) -> Self {
         MixNodeBond {
             total_delegation: coin(0, &bond_amount.denom),
@@ -57,9 +166,15 @@ impl MixNodeBond {
             layer,
             block_height,
             mix_node,
+            profit_margin_percent,
         }
     }
 
+    pub fn profit_margin(&self) -> U128 {
+        U128::from_num(self.profit_margin_percent.unwrap_or(DEFAULT_PROFIT_MARGIN))
+            / U128::from_num(100)
+    }
+
     pub fn identity(&self) -> &String {
         &self.mix_node.identity_key
     }
@@ -75,6 +190,187 @@ impl MixNodeBond {
     pub fn mix_node(&self) -> &MixNode {
         &self.mix_node
     }
+
+    pub fn total_stake(&self) -> Option<u128> {
+        if self.bond_amount.denom != self.total_delegation.denom {
+            None
+        } else {
+            Some(self.bond_amount.amount.u128() + self.total_delegation.amount.u128())
+        }
+    }
+
+    pub fn total_delegation(&self) -> Coin {
+        self.total_delegation.clone()
+    }
+
+    pub fn bond_to_circulating_supply(&self, circulating_supply: u128) -> U128 {
+        U128::from_num(self.bond_amount().amount.u128()) / U128::from_num(circulating_supply)
+    }
+
+    pub fn total_stake_to_circulating_supply(&self, circulating_supply: u128) -> U128 {
+        U128::from_num(self.bond_amount().amount.u128() + self.total_delegation().amount.u128())
+            / U128::from_num(circulating_supply)
+    }
+
+    pub fn lambda(&self, params: &NodeRewardParams) -> U128 {
+        // Ratio of a bond to the token circulating supply
+        let bond_to_circulating_supply_ratio =
+            self.bond_to_circulating_supply(params.circulating_supply());
+        bond_to_circulating_supply_ratio.min(params.one_over_k())
+    }
+
+    pub fn sigma(&self, params: &NodeRewardParams) -> U128 {
+        // Ratio of a delegation to the the token circulating supply
+        let total_stake_to_circulating_supply_ratio =
+            self.total_stake_to_circulating_supply(params.circulating_supply());
+        total_stake_to_circulating_supply_ratio.min(params.one_over_k())
+    }
+
+    pub fn reward(&self, params: &NodeRewardParams) -> NodeRewardResult {
+        // Assuming uniform work distribution across the network this is one_over_k * k
+        let omega_k = U128::from_num(1u128);
+        let lambda = self.lambda(params);
+        let sigma = self.sigma(params);
+
+        let reward = params.performance()
+            * params.period_reward_pool()
+            * (sigma * omega_k + params.alpha() * lambda * sigma * params.k())
+            / (U128::from_num(1) + params.alpha());
+
+        NodeRewardResult {
+            reward,
+            lambda,
+            sigma,
+        }
+    }
+
+    pub fn node_profit(&self, params: &NodeRewardParams) -> U128 {
+        if self.reward(params).reward() < params.operator_cost() {
+            U128::from_num(0)
+        } else {
+            self.reward(params).reward() - params.operator_cost()
+        }
+    }
+
+    pub fn operator_reward(&self, params: &NodeRewardParams) -> u128 {
+        let reward = self.reward(params);
+        let profit = if reward.reward < params.operator_cost() {
+            U128::from_num(0)
+        } else {
+            reward.reward - params.operator_cost()
+        };
+        let operator_base_reward = reward.reward.min(params.operator_cost());
+        let operator_reward = (self.profit_margin()
+            + (U128::from_num(1) - self.profit_margin()) * reward.lambda / reward.sigma)
+            * profit;
+
+        let reward = (operator_reward + operator_base_reward).max(U128::from_num(0));
+
+        if let Some(int_reward) = reward.checked_cast() {
+            int_reward
+        } else {
+            error!(
+                "Could not cast reward ({}) to u128, returning 0 - mixnode {}",
+                reward,
+                self.identity()
+            );
+            0u128
+        }
+    }
+
+    pub fn sigma_ratio(&self, params: &NodeRewardParams) -> U128 {
+        if self.total_stake_to_circulating_supply(params.circulating_supply()) < params.one_over_k()
+        {
+            self.total_stake_to_circulating_supply(params.circulating_supply())
+        } else {
+            params.one_over_k()
+        }
+    }
+
+    pub fn reward_delegation(&self, delegation_amount: Uint128, params: &NodeRewardParams) -> u128 {
+        let scaled_delegation_amount =
+            U128::from_num(delegation_amount.u128()) / U128::from_num(params.circulating_supply());
+
+        let delegator_reward = (U128::from_num(1) - self.profit_margin())
+            * scaled_delegation_amount
+            / self.sigma(params)
+            * self.node_profit(params);
+
+        let reward = delegator_reward.max(U128::from_num(0));
+        if let Some(int_reward) = reward.checked_cast() {
+            int_reward
+        } else {
+            error!(
+                "Could not cast delegator reward ({}) to u128, returning 0 - mixnode {}",
+                reward,
+                self.identity()
+            );
+            0u128
+        }
+    }
+}
+
+impl PartialOrd for MixNodeBond {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        // first remove invalid cases
+        if self.bond_amount.denom != self.total_delegation.denom {
+            return None;
+        }
+
+        if other.bond_amount.denom != other.total_delegation.denom {
+            return None;
+        }
+
+        if self.bond_amount.denom != other.bond_amount.denom {
+            return None;
+        }
+
+        // try to order by total bond + delegation
+        let total_cmp = (self.bond_amount.amount + self.total_delegation.amount)
+            .partial_cmp(&(self.bond_amount.amount + self.total_delegation.amount))?;
+
+        if total_cmp != Ordering::Equal {
+            return Some(total_cmp);
+        }
+
+        // then if those are equal, prefer higher bond over delegation
+        let bond_cmp = self
+            .bond_amount
+            .amount
+            .partial_cmp(&other.bond_amount.amount)?;
+        if bond_cmp != Ordering::Equal {
+            return Some(bond_cmp);
+        }
+
+        // then look at delegation (I'm not sure we can get here, but better safe than sorry)
+        let delegation_cmp = self
+            .total_delegation
+            .amount
+            .partial_cmp(&other.total_delegation.amount)?;
+        if delegation_cmp != Ordering::Equal {
+            return Some(delegation_cmp);
+        }
+
+        // then check block height
+        let height_cmp = self.block_height.partial_cmp(&other.block_height)?;
+        if height_cmp != Ordering::Equal {
+            return Some(height_cmp);
+        }
+
+        // finally go by the rest of the fields in order. It doesn't really matter at this point
+        // but we should be deterministic.
+        let owner_cmp = self.owner.partial_cmp(&other.owner)?;
+        if owner_cmp != Ordering::Equal {
+            return Some(owner_cmp);
+        }
+
+        let layer_cmp = self.layer.partial_cmp(&other.layer)?;
+        if layer_cmp != Ordering::Equal {
+            return Some(layer_cmp);
+        }
+
+        self.mix_node.partial_cmp(&other.mix_node)
+    }
 }
 
 impl Display for MixNodeBond {
@@ -113,3 +409,100 @@ pub struct MixOwnershipResponse {
     pub address: Addr,
     pub has_node: bool,
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn mixnode_fixture() -> MixNode {
+        MixNode {
+            host: "1.1.1.1".to_string(),
+            mix_port: 123,
+            verloc_port: 456,
+            http_api_port: 789,
+            sphinx_key: "sphinxkey".to_string(),
+            identity_key: "identitykey".to_string(),
+            version: "0.11.0".to_string(),
+        }
+    }
+
+    #[test]
+    fn mixnode_bond_partial_ord() {
+        let _150foos = Coin::new(150, "foo");
+        let _50foos = Coin::new(50, "foo");
+        let _0foos = Coin::new(0, "foo");
+
+        let mix1 = MixNodeBond {
+            bond_amount: _150foos.clone(),
+            total_delegation: _50foos.clone(),
+            owner: Addr::unchecked("foo1"),
+            layer: Layer::One,
+            block_height: 100,
+            mix_node: mixnode_fixture(),
+            profit_margin_percent: Some(10),
+        };
+
+        let mix2 = MixNodeBond {
+            bond_amount: _150foos.clone(),
+            total_delegation: _50foos.clone(),
+            owner: Addr::unchecked("foo2"),
+            layer: Layer::One,
+            block_height: 120,
+            mix_node: mixnode_fixture(),
+            profit_margin_percent: Some(10),
+        };
+
+        let mix3 = MixNodeBond {
+            bond_amount: _50foos,
+            total_delegation: _150foos.clone(),
+            owner: Addr::unchecked("foo3"),
+            layer: Layer::One,
+            block_height: 120,
+            mix_node: mixnode_fixture(),
+            profit_margin_percent: Some(10),
+        };
+
+        let mix4 = MixNodeBond {
+            bond_amount: _150foos.clone(),
+            total_delegation: _0foos.clone(),
+            owner: Addr::unchecked("foo4"),
+            layer: Layer::One,
+            block_height: 120,
+            mix_node: mixnode_fixture(),
+            profit_margin_percent: Some(10),
+        };
+
+        let mix5 = MixNodeBond {
+            bond_amount: _0foos,
+            total_delegation: _150foos,
+            owner: Addr::unchecked("foo5"),
+            layer: Layer::One,
+            block_height: 120,
+            mix_node: mixnode_fixture(),
+            profit_margin_percent: Some(10),
+        };
+
+        // summary:
+        // mix1: 150bond + 50delegation, foo1, 100
+        // mix2: 150bond + 50delegation, foo2, 120
+        // mix3: 50bond + 150delegation, foo3, 120
+        // mix4: 150bond + 0delegation, foo4, 120
+        // mix5: 0bond + 150delegation, foo5, 120
+
+        // highest total bond+delegation is used
+        // then bond followed by delegation
+        // finally just the rest of the fields
+
+        // mix1 has higher total than mix4 or mix5
+        assert!(mix1 > mix4);
+        assert!(mix1 > mix5);
+
+        // mix1 has the same total as mix3, however, mix1 has more tokens in bond
+        assert!(mix1 > mix3);
+        // same case for mix4 and mix5
+        assert!(mix4 > mix5);
+
+        // same bond and delegation, so it's just ordered by height
+        assert!(mix1 < mix2);
+    }
+}

common/mixnet-contract/src/msg.rs

@@ -1,6 +1,7 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
+use crate::mixnode::NodeRewardParams;
 use crate::StateParams;
 use crate::{Gateway, IdentityKey, MixNode};
 use cosmwasm_std::Addr;
@@ -31,24 +32,32 @@ pub enum ExecuteMsg {
         mix_identity: IdentityKey,
     },
 
-    DelegateToGateway {
-        gateway_identity: IdentityKey,
-    },
-
-    UndelegateFromGateway {
-        gateway_identity: IdentityKey,
+    BeginMixnodeRewarding {
+        // nonce of the current rewarding interval
+        rewarding_interval_nonce: u32,
     },
 
     RewardMixnode {
         identity: IdentityKey,
         // percentage value in range 0-100
         uptime: u32,
+
+        // nonce of the current rewarding interval
+        rewarding_interval_nonce: u32,
     },
 
-    RewardGateway {
+    FinishMixnodeRewarding {
+        // nonce of the current rewarding interval
+        rewarding_interval_nonce: u32,
+    },
+
+    RewardMixnodeV2 {
         identity: IdentityKey,
         // percentage value in range 0-100
-        uptime: u32,
+        params: NodeRewardParams,
+
+        // nonce of the current rewarding interval
+        rewarding_interval_nonce: u32,
     },
 }
 
@@ -70,11 +79,16 @@ pub enum QueryMsg {
         address: Addr,
     },
     StateParams {},
+    CurrentRewardingInterval {},
     GetMixDelegations {
         mix_identity: IdentityKey,
         start_after: Option<Addr>,
         limit: Option<u32>,
     },
+    GetAllMixDelegations {
+        start_after: Option<Vec<u8>>,
+        limit: Option<u32>,
+    },
     GetReverseMixDelegations {
         delegation_owner: Addr,
         start_after: Option<IdentityKey>,
@@ -84,21 +98,11 @@ pub enum QueryMsg {
         mix_identity: IdentityKey,
         address: Addr,
     },
-    GetGatewayDelegations {
-        gateway_identity: IdentityKey,
-        start_after: Option<Addr>,
-        limit: Option<u32>,
-    },
-    GetReverseGatewayDelegations {
-        delegation_owner: Addr,
-        start_after: Option<IdentityKey>,
-        limit: Option<u32>,
-    },
-    GetGatewayDelegation {
-        gateway_identity: IdentityKey,
-        address: Addr,
-    },
     LayerDistribution {},
+    GetRewardPool {},
+    GetCirculatingSupply {},
+    GetEpochRewardPercent {},
+    GetSybilResistancePercent {},
 }
 
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]

common/mixnet-contract/src/types.rs

@@ -26,16 +26,29 @@ impl LayerDistribution {
     }
 }
 
+#[derive(Debug, Default, Serialize, Deserialize, Copy, Clone, Eq, PartialEq)]
+pub struct RewardingIntervalResponse {
+    pub current_rewarding_interval_starting_block: u64,
+    pub current_rewarding_interval_nonce: u32,
+    pub rewarding_in_progress: bool,
+}
+
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
 pub struct StateParams {
-    pub epoch_length: u32, // length of an epoch, expressed in hours
+    pub epoch_length: u32, // length of a rewarding epoch/interval, expressed in hours
 
     pub minimum_mixnode_bond: Uint128, // minimum amount a mixnode must bond to get into the system
     pub minimum_gateway_bond: Uint128, // minimum amount a gateway must bond to get into the system
+
     pub mixnode_bond_reward_rate: Decimal, // annual reward rate, expressed as a decimal like 1.25
-    pub gateway_bond_reward_rate: Decimal, // annual reward rate, expressed as a decimal like 1.25
     pub mixnode_delegation_reward_rate: Decimal, // annual reward rate, expressed as a decimal like 1.25
-    pub gateway_delegation_reward_rate: Decimal, // annual reward rate, expressed as a decimal like 1.25
+
+    // number of mixnode that are going to get rewarded during current rewarding interval (k_m)
+    // based on overall demand for private bandwidth-
+    pub mixnode_rewarded_set_size: u32,
+
+    // subset of rewarded mixnodes that are actively receiving mix traffic
+    // used to handle shorter-term (e.g. hourly) fluctuations of demand
     pub mixnode_active_set_size: u32,
 }
 
@@ -50,11 +63,6 @@ impl Display for StateParams {
             "mixnode bond reward rate: {}; ",
             self.mixnode_bond_reward_rate
         )?;
-        write!(
-            f,
-            "gateway bond reward rate: {}; ",
-            self.gateway_bond_reward_rate
-        )?;
         write!(
             f,
             "mixnode delegation reward rate: {}; ",
@@ -62,12 +70,12 @@ impl Display for StateParams {
         )?;
         write!(
             f,
-            "gateway delegation reward rate: {}; ",
-            self.gateway_delegation_reward_rate
+            "mixnode rewarded set size: {}",
+            self.mixnode_rewarded_set_size
         )?;
         write!(
             f,
-            "mixnode active set size: {} ]",
+            "mixnode active set size: {}",
             self.mixnode_active_set_size
         )
     }

common/network-defaults/Cargo.toml

@@ -7,4 +7,7 @@ edition = "2018"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+hex-literal = "0.3.3"
+serde = {version = "1.0", features = ["derive"]}
 url = "2.2"
+time = { version = "0.3", features = ["macros"] }

common/network-defaults/src/eth_contract.rs

@@ -0,0 +1,132 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+// This should be modified whenever an updated Ethereum contract is uploaded
+pub const ETH_JSON_ABI: &str = r#"
+[
+  {
+    "inputs": [
+      {
+        "internalType": "contract ERC20Burnable",
+        "name": "_erc20",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "constructor"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "Bandwidth",
+        "type": "uint256"
+      },
+      {
+        "indexed": true,
+        "internalType": "uint256",
+        "name": "VerificationKey",
+        "type": "uint256"
+      },
+      {
+        "indexed": false,
+        "internalType": "bytes",
+        "name": "SignedVerificationKey",
+        "type": "bytes"
+      }
+    ],
+    "name": "Burned",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "previousOwner",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "newOwner",
+        "type": "address"
+      }
+    ],
+    "name": "OwnershipTransferred",
+    "type": "event"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "amount",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "verificationKey",
+        "type": "uint256"
+      },
+      {
+        "internalType": "bytes",
+        "name": "signedVerificationKey",
+        "type": "bytes"
+      }
+    ],
+    "name": "burnTokenForAccessCode",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "erc20",
+    "outputs": [
+      {
+        "internalType": "contract ERC20Burnable",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "owner",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "renounceOwnership",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "newOwner",
+        "type": "address"
+      }
+    ],
+    "name": "transferOwnership",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  }
+]
+        "#;