change location

continue rework
add base mocks for nymd client
2022-03-03 16:59:02 +00:00 · 2022-03-03 16:54:35 +00:00 · 2022-03-03 11:47:30 +00:00 · 2022-03-03 10:28:26 +00:00 · 2022-03-02 10:55:28 +00:00 · 2022-03-01 14:08:56 +00:00
565 changed files with 21956 additions and 10825 deletions
@@ -15,8 +15,8 @@
 * @futurechimp @mmsinclair

 # Rust rules:
-*.rs @durch @futurechimp @jstuczyn @neacsu
-Cargo.* @durch @futurechimp @jstuczyn @neacsu
+*.rs @durch @futurechimp @jstuczyn @neacsu @octol
+Cargo.* @durch @futurechimp @jstuczyn @neacsu @octol

 # JS rules:
 *.js @mmsinclair @fmtabbara @Aid19801
@@ -9,28 +9,14 @@ on:
      - 'explorer/**'

 jobs:
-  matrix_prep:
-    runs-on: ubuntu-latest
-    outputs:
-      matrix: ${{ steps.set-matrix.outputs.matrix }}
-    steps:
-      # creates the matrix strategy from build_matrix_includes.json
-      - uses: actions/checkout@v2
-      - id: set-matrix
-        uses: JoshuaTheMiller/conditional-build-matrix@main
-        with:
-          inputFile: '.github/workflows/build_matrix_includes.json'
-          filter: '[?runOnEvent==`${{ github.event_name }}` || runOnEvent==`always`]'
  build:
-    needs: matrix_prep
-    strategy:
-      matrix: ${{fromJson(needs.matrix_prep.outputs.matrix)}}
-    runs-on: ${{ matrix.os }}
-    continue-on-error: ${{ matrix.rust == 'nightly' || matrix.rust == 'beta' || matrix.os == 'windows-latest' }}
+    runs-on: [ self-hosted, custom-linux-exoscale ]
+    # Enable sccache via environment variable
+    env:
+      RUSTC_WRAPPER: /home/ubuntu/.cargo/bin/sccache
    steps:
      - name: Install Dependencies (Linux)
-        run: sudo apt-get update && sudo apt-get install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev squashfs-tools
-        if: matrix.os == 'ubuntu-latest'
+        run: sudo apt-get update && sudo apt-get -y install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev squashfs-tools

      - name: Check out repository code
        uses: actions/checkout@v2
@@ -39,7 +25,7 @@ jobs:
        uses: actions-rs/toolchain@v1
        with:
          profile: minimal
-          toolchain: ${{ matrix.rust }}
+          toolchain: stable
          override: true
          components: rustfmt, clippy

@@ -63,25 +49,16 @@ jobs:

      - uses: actions-rs/clippy-check@v1
        name: Clippy checks
-#        if: matrix.os == 'ubuntu-latest' && matrix.rust == 'stable'
        with:
          token: ${{ secrets.GITHUB_TOKEN }}
          args: --all-features

      - name: Run clippy
        uses: actions-rs/cargo@v1
-        if: ${{ matrix.rust != 'nightly' }}
        with:
          command: clippy
          args: -- -D warnings

-#        COCONUT stuff
-      - name: Reclaim some disk space (because Windows is being annoying)
-        uses: actions-rs/cargo@v1
-        if: ${{ matrix.os == 'windows-latest' }}
-        with:
-          command: clean
-
      - name: Build all binaries with coconut enabled
        uses: actions-rs/cargo@v1
        with:
@@ -96,7 +73,6 @@ jobs:

      - name: Run clippy with coconut enabled
        uses: actions-rs/cargo@v1
-        if: ${{ matrix.rust != 'nightly' }}
        with:
          command: clippy
-          args: --features=coconut -- -D warnings
+          args: --features=coconut -- -D warnings
@@ -10,41 +10,10 @@
    "rust":"stable",
    "runOnEvent":"pull_request"
  },
+
  {
    "os":"macos-latest",
    "rust":"stable",
    "runOnEvent":"pull_request"
-  },
-
-  {
-    "os":"ubuntu-latest",
-    "rust":"beta",
-    "runOnEvent":"pull_request"
-  },
-  {
-    "os":"windows-latest",
-    "rust":"beta",
-    "runOnEvent":"pull_request"
-  },
-  {
-    "os":"macos-latest",
-    "rust":"beta",
-    "runOnEvent":"pull_request"
-  },
-
-  {
-    "os":"ubuntu-latest",
-    "rust":"nightly",
-    "runOnEvent":"pull_request"
-  },
-  {
-    "os":"windows-latest",
-    "rust":"nightly",
-    "runOnEvent":"pull_request"
-  },
-  {
-    "os":"macos-latest",
-    "rust":"nightly",
-    "runOnEvent":"pull_request"
  }
-]
+]
@@ -41,9 +41,10 @@ jobs:
        EXCLUDE: "/dist/, /node_modules/"
    - name: Keybase - Node Install
      run: npm install
-      working-directory: .github/workflows/support-files/messages
+      working-directory: .github/workflows/support-files
    - name: Keybase - Send Notification
      env:
+        NYM_NOTIFICATION_KIND: network-explorer
        NYM_PROJECT_NAME: "Network Explorer"
        NYM_CI_WWW_BASE: "${{ secrets.NYM_CI_WWW_BASE }}"
        NYM_CI_WWW_LOCATION: "network-explorer-${{ env.GITHUB_REF_SLUG }}"
@@ -56,4 +57,4 @@ jobs:
        IS_SUCCESS: "${{ job.status == 'success' }}"
      uses: docker://keybaseio/client:stable-node
      with:
-        args: .github/workflows/support-files/messages/entry_point_notifications.sh
+        args: .github/workflows/support-files/notifications/entry_point.sh
@@ -0,0 +1,124 @@
+name: Nightly builds
+
+on:
+  schedule:
+    - cron: '14 4 * * *'
+jobs:
+  matrix_prep:
+    runs-on: ubuntu-latest
+    outputs:
+      matrix: ${{ steps.set-matrix.outputs.matrix }}
+    steps:
+      # creates the matrix strategy from nightly_build_matrix_includes.json
+      - uses: actions/checkout@v2
+      - id: set-matrix
+        uses: JoshuaTheMiller/conditional-build-matrix@main
+        with:
+          inputFile: '.github/workflows/nightly_build_matrix_includes.json'
+          filter: '[?runOnEvent==`${{ github.event_name }}` || runOnEvent==`always`]'
+  build:
+    needs: matrix_prep
+    strategy:
+      matrix: ${{fromJson(needs.matrix_prep.outputs.matrix)}}
+    runs-on: ${{ matrix.os }}
+    continue-on-error: ${{ matrix.rust == 'nightly' || matrix.rust == 'beta' || matrix.rust == 'stable' }}
+    steps:
+      - name: Install Dependencies (Linux)
+        run: sudo apt-get update && sudo apt-get install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev squashfs-tools
+        if: matrix.os == 'ubuntu-latest'
+
+      - name: Check out repository code
+        uses: actions/checkout@v2
+
+      - name: Install rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: ${{ matrix.rust }}
+          override: true
+          components: rustfmt, clippy
+
+      - name: Build all binaries
+        uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: --all
+
+      - name: Run all tests
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --all
+
+      - name: Check formatting
+        uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: --all -- --check
+
+      - uses: actions-rs/clippy-check@v1
+        name: Clippy checks
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          args: --all-features
+
+      - name: Run clippy
+        uses: actions-rs/cargo@v1
+        if: ${{ matrix.rust != 'nightly' }}
+        with:
+          command: clippy
+          args: -- -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
+  notification:
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - name: Collect jobs status
+        uses: technote-space/workflow-conclusion-action@v2
+      - name: Check out repository code
+        uses: actions/checkout@v2
+      - name: Keybase - Node Install
+        if: env.WORKFLOW_CONCLUSION == 'failure'
+        run: npm install
+        working-directory: .github/workflows/support-files
+      - name: Keybase - Send Notification
+        if: env.WORKFLOW_CONCLUSION == 'failure'
+        env:
+          NYM_NOTIFICATION_KIND: nightly
+          NYM_PROJECT_NAME: "Nym nightly build"
+          GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
+          GIT_COMMIT_MESSAGE: "${{ github.event.head_commit.message }}"
+          GIT_BRANCH: "${GITHUB_REF##*/}"
+          KEYBASE_NYMBOT_USERNAME: "${{ secrets.KEYBASE_NYMBOT_USERNAME }}"
+          KEYBASE_NYMBOT_PAPERKEY: "${{ secrets.KEYBASE_NYMBOT_PAPERKEY }}"
+          KEYBASE_NYMBOT_TEAM: "${{ secrets.KEYBASE_NYMBOT_TEAM }}"
+          KEYBASE_NYM_CHANNEL: "ci-nightly"
+          IS_SUCCESS: "${{ env.WORKFLOW_CONCLUSION == 'success' }}"
+        uses: docker://keybaseio/client:stable-node
+        with:
+          args: .github/workflows/support-files/notifications/entry_point.sh
@@ -0,0 +1,50 @@
+[
+  {
+    "os":"ubuntu-latest",
+    "rust":"stable",
+    "runOnEvent":"schedule"
+  },
+
+  {
+    "os":"windows-latest",
+    "rust":"stable",
+    "runOnEvent":"schedule"
+  },
+  {
+    "os":"macos-latest",
+    "rust":"stable",
+    "runOnEvent":"schedule"
+  },
+
+  {
+    "os":"ubuntu-latest",
+    "rust":"beta",
+    "runOnEvent":"schedule"
+  },
+  {
+    "os":"windows-latest",
+    "rust":"beta",
+    "runOnEvent":"schedule"
+  },
+  {
+    "os":"macos-latest",
+    "rust":"beta",
+    "runOnEvent":"schedule"
+  },
+
+  {
+    "os":"ubuntu-latest",
+    "rust":"nightly",
+    "runOnEvent":"schedule"
+  },
+  {
+    "os":"windows-latest",
+    "rust":"nightly",
+    "runOnEvent":"schedule"
+  },
+  {
+    "os":"macos-latest",
+    "rust":"nightly",
+    "runOnEvent":"schedule"
+  }
+]
@@ -0,0 +1,77 @@
+name: Publish Nym Wallet (MacOS)
+on:
+  release:
+    types: [created]
+
+defaults:
+  run:
+    working-directory: nym-wallet
+
+jobs:
+  publish-tauri:
+    strategy:
+      fail-fast: false
+      matrix:
+        platform: [macos-latest]
+
+    runs-on: ${{ matrix.platform }}
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Check the release tag starts with `nym-wallet-`
+        if: startsWith(github.ref, 'refs/tags/nym-wallet-') == false
+        uses: actions/github-script@v3
+        with:
+          script: |
+            core.setFailed('Release tag did not start with nym-wallet-...')
+
+      - name: Node v16
+        uses: actions/setup-node@v1
+        with:
+          node-version: 16.x
+      - name: Install Rust stable
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+      - name: Install the Apple developer certificate for code signing
+        env:
+          APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
+          APPLE_CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
+          KEYCHAIN_PASSWORD: ${{ secrets.KEYCHAIN_PASSWORD }}
+        run: |
+          # create variables
+          CERTIFICATE_PATH=$RUNNER_TEMP/build_certificate.p12
+          KEYCHAIN_PATH=$RUNNER_TEMP/app-signing.keychain-db
+
+          # import certificate and provisioning profile from secrets
+          echo -n "$APPLE_CERTIFICATE" | base64 --decode --output $CERTIFICATE_PATH
+
+          # create temporary keychain
+          security create-keychain -p "$KEYCHAIN_PASSWORD" $KEYCHAIN_PATH
+          security set-keychain-settings -lut 21600 $KEYCHAIN_PATH
+          security unlock-keychain -p "$KEYCHAIN_PASSWORD" $KEYCHAIN_PATH
+
+          # import certificate to keychain
+          security import $CERTIFICATE_PATH -P "$APPLE_CERTIFICATE_PASSWORD" -A -t cert -f pkcs12 -k $KEYCHAIN_PATH
+          security list-keychain -d user -s $KEYCHAIN_PATH
+
+      - name: Install app dependencies and build it
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          ENABLE_CODE_SIGNING: ${{ secrets.APPLE_CERTIFICATE }}
+          APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
+          APPLE_CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
+          APPLE_SIGNING_IDENTITY: ${{ secrets.APPLE_IDENTITY_ID }}
+          APPLE_ID: ${{ secrets.APPLE_ID }}
+          APPLE_PASSWORD: ${{ secrets.APPLE_PASSWORD }}
+        run: yarn && yarn build
+
+      - name: Upload to release based on tag name
+        uses: softprops/action-gh-release@v1
+        with:
+          files: nym-wallet/target/release/bundle/dmg/*.dmg
+
+      - name: Clean up keychain
+        if: ${{ always() }}
+        run: |
+          security delete-keychain $RUNNER_TEMP/app-signing.keychain-db
@@ -0,0 +1,46 @@
+name: Publish Nym Wallet (Ubuntu)
+on:
+  release:
+    types: [created]
+
+defaults:
+  run:
+    working-directory: nym-wallet
+
+jobs:
+  publish-tauri:
+    strategy:
+      fail-fast: false
+      matrix:
+        platform: [ubuntu-latest]
+
+    runs-on: ${{ matrix.platform }}
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Tauri dependencies
+        run: >
+          sudo apt-get update &&
+          sudo apt-get install -y webkit2gtk-4.0
+      - name: Check the release tag starts with `nym-wallet-`
+        if: startsWith(github.ref, 'refs/tags/nym-wallet-') == false
+        uses: actions/github-script@v3
+        with:
+          script: |
+            core.setFailed('Release tag did not start with nym-wallet-...')
+
+      - name: Node v16
+        uses: actions/setup-node@v1
+        with:
+          node-version: 16.x
+      - name: Install Rust stable
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+      - name: Install app dependencies and build it
+        run: yarn && yarn build
+
+      - name: Upload to release based on tag name
+        uses: softprops/action-gh-release@v1
+        with:
+          files: nym-wallet/target/release/bundle/appimage/*.AppImage
@@ -1,12 +0,0 @@
-name: Publish Nym Wallet
-on:
-  push:
-    tags:
-      - nym-wallet-*
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Run a one-line script
-        run: echo Hello, world!
@@ -10,7 +10,10 @@ on:

 jobs:
  nym-wallet-types:
-    runs-on: ubuntu-latest
+    runs-on: [ self-hosted, custom-linux-exoscale ]
+    # Enable sccache
+    env:
+      RUSTC_WRAPPER: /home/ubuntu/.cargo/bin/sccache
    if: ${{ github.event_name != 'pull_request' }}
    steps:
      - name: Prepare
@@ -0,0 +1,35 @@
+KEYBASE_NYM_CHANNEL=
+KEYBASE_NYMBOT_USERNAME=
+KEYBASE_NYMBOT_PAPERKEY=
+
+NYM_NOTIFICATION_KIND=nightly
+NYM_PROJECT_NAME=Nightly Build
+
+#----------------------------------------------------------------
+# Custom GitHub Actions mock env vars
+IS_SUCCESS=true
+
+#----------------------------------------------------------------
+# GitHub Actions context mock env vars
+GITHUB_SHA=abcdef
+GITHUB_RUN_ID=123456
+GITHUB_REPOSITORY=nymtech/nym
+GITHUB_SERVER_URL=https://github.com
+GIT_BRANCH_NAME=feature/testing-support-files
+GIT_BRANCH=feature/testing-support-files
+GIT_COMMIT_MESSAGE=This is the commit message
+GITHUB_ACTOR=octocat
+
+# add a Personal Access Token (PAT) generated from GitHub here for use in testing
+GITHUB_TOKEN=
+
+#----------------------------------------------------------------
+# Network Explorer
+NYM_CI_WWW_LOCATION=some-branch
+NYM_CI_WWW_BASE=example.com
+
+#----------------------------------------------------------------
+# Nightly builds
+WORKFLOW_CONCLUSION=success
+
+SHOW_DEBUG=true
@@ -0,0 +1,5 @@
+node_modules
+.idea
+
+# don't commit the lock file to avoid cross-platform issues
+package-lock.json
@@ -0,0 +1 @@
+16
@@ -0,0 +1,58 @@
+# GitHub Actions Support Files
+
+This is a collection of scripts and files to support GitHub Actions.
+
+## Sending Notifications
+
+These scripts send CI notifications to Keybase by creating messages from templates and env vars passed from GitHub Actions.
+
+### Adding notifications to a GitHub Action
+
+```
+jobs:
+  build:
+    ...
+    - name: Notifications - Node Install
+      run: npm install
+      working-directory: .github/workflows/support-files/notifications
+    - name: Notifications - Send
+      env:
+        NYM_NOTIFICATION_KIND: "my-component"
+        GIT_BRANCH: "${GITHUB_REF##*/}"
+        KEYBASE_NYMBOT_USERNAME: "${{ secrets.KEYBASE_NYMBOT_USERNAME }}"
+        KEYBASE_NYMBOT_PAPERKEY: "${{ secrets.KEYBASE_NYMBOT_PAPERKEY }}"
+        KEYBASE_NYMBOT_TEAM: "${{ secrets.KEYBASE_NYMBOT_TEAM }}"
+        KEYBASE_NYM_CHANNEL: "ci-network-explorer"
+        IS_SUCCESS: "${{ job.status == 'success' }}"
+      uses: docker://keybaseio/client:stable-node
+      with:
+        args: .github/workflows/support-files/notifications/entry_point.sh
+```
+
+Notifications are run by adding the snippet above to a GitHub Action, and:
+
+1. Installing node packages needed at run time
+2. Set the env vars as required:
+    - `NYM_NOTIFICATION_KIND` matches the directory in `.github/workflows/support-files/${NYM_NOTIFICATION_KIND}` to provide the templates and extra scripting in `index.js`
+    - Keybase credentials, channel and other env vars for the status of the build and repo
+3. Replacing the default entry point shell script on the `keybaseio/client:stable-node` docker image to run `.github/workflows/support-files/notifications/entry_point.sh` 
+
+### Running locally
+
+You will need:
+- Node 16 LTS
+- npm
+
+Copy `.github/workflows/support-files/.env.example` to `.github/workflows/support-files/.env` and valid Keybase credentials.
+
+Then run `npm install` to get dependencies.
+
+Start development mode for the notification type you want either by passing the value as an env var called `NYM_NOTIFICATION_KIND` or set the `.env` file values correctly.
+
+```bash
+cd .github/workflows/support-files
+npm install
+cp .env.example .env
+vi .env
+npm run dev
+```
@@ -0,0 +1 @@
+require('./notifications/send_message');
@@ -1,2 +0,0 @@
-node_modules
-.idea
@@ -1,69 +0,0 @@
-const Bot = require('keybase-bot');
-const Handlebars = require('handlebars');
-const fs = require('fs');
-
-async function main() {
-  const data = { env: process.env };
-  // const data = { ...PASTE TEST DATA HERE ... }; // -- DEV: uncomment to set test data
-
-  // validation of environment
-  if(!(process.env.NYM_PROJECT_NAME || data.env.NYM_PROJECT_NAME)) {
-    throw new Error('Please set env var NYM_PROJECT_NAME with the project name for displaying in notification messages');
-  }
-  const keybaseChannel = process.env.KEYBASE_NYM_CHANNEL || data.env.KEYBASE_NYM_CHANNEL;
-  if(!keybaseChannel) {
-    throw new Error('Please set env var KEYBASE_NYM_CHANNEL with the channel name for the notification message');
-  }
-
-  // extract the git branch name
-  const GIT_BRANCH_NAME = (process.env.GITHUB_REF || data.env.GITHUB_REF).split('/').slice(2).join('/');
-
-  data.env.GIT_BRANCH_NAME = GIT_BRANCH_NAME;
-  const source = fs
-    .readFileSync(process.env.IS_SUCCESS === 'true' ? 'success' : 'failure')
-    .toString();
-  const template = Handlebars.compile(source);
-  const result = template(data);
-
-  // -- DEV: uncomment to show what is available in the handlebars template / show the result
-  // console.dir({ data }, { depth: null });
-  // console.log(result);
-
-  const bot = new Bot();
-  try {
-    const username = process.env.KEYBASE_NYMBOT_USERNAME;
-    const paperkey = process.env.KEYBASE_NYMBOT_PAPERKEY;
-
-    if(!username) {
-      throw new Error('Username is not defined. Please set env var KEYBASE_NYMBOT_USERNAME');
-    }
-    if(!paperkey) {
-      throw new Error('Paperkey is not defined. Please set env var KEYBASE_NYMBOT_PAPERKEY');
-    }
-
-    console.log(`Initialising keybase with user "${username}" and key: "${'*'.repeat(paperkey.length)}"...`);
-    await bot.init(username, paperkey, { verbose: false });
-
-    const channel = {
-      name: 'nymtech_bot',
-      membersType: 'team',
-      topicName: keybaseChannel,
-      topic_type: 'CHAT',
-    };
-    const message = {
-      body: result,
-    };
-
-    console.log(`Sending to ${channel.name}#${channel.topicName}...`);
-    await bot.chat.send(channel, message);
-
-    console.log('Message sent!');
-  } catch (error) {
-    console.error(error);
-    process.exitCode = -1;
-  } finally {
-    await bot.deinit();
-  }
-}
-
-main();
@@ -0,0 +1,29 @@
+const Handlebars = require('handlebars');
+const fs = require('fs');
+const path = require('path');
+
+async function addToContextAndValidate(context) {
+  if (!context.env.NYM_CI_WWW_LOCATION) {
+    throw new Error('Please ensure the env var NYM_CI_WWW_LOCATION is set');
+  }
+  if (!context.env.NYM_CI_WWW_BASE) {
+    throw new Error('Please ensure the env var NYM_CI_WWW_BASE is set');
+  }
+}
+
+async function getMessageBody(context) {
+  const source = fs
+    .readFileSync(
+      context.env.IS_SUCCESS === 'true'
+        ? path.resolve(__dirname, 'templates', 'success')
+        : path.resolve(__dirname, 'templates', 'failure'),
+    )
+    .toString();
+  const template = Handlebars.compile(source);
+  return template(context);
+}
+
+module.exports = {
+  addToContextAndValidate,
+  getMessageBody,
+};
@@ -5,7 +5,7 @@
 > `commit` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/commit/{{ env.GITHUB_SHA }}
 > `build ` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/actions/runs/{{ env.GITHUB_RUN_ID }}

-Commit message:
+Commit message by `{{ env.GITHUB_ACTOR }}` at {{ timestamp }}:
 ```
 {{ env.GIT_COMMIT_MESSAGE }}
 ```
@@ -0,0 +1,162 @@
+const Handlebars = require('handlebars');
+const fs = require('fs');
+const path = require('path');
+const { Octokit, App } = require('octokit');
+
+async function addToContextAndValidate(context) {
+  if (!context.env.WORKFLOW_CONCLUSION) {
+    throw new Error('Please ensure the env var WORKFLOW_CONCLUSION is set');
+  }
+  if (!context.env.GITHUB_TOKEN) {
+    throw new Error('Please ensure the env var GITHUB_TOKEN is set');
+  }
+  if (!context.env.GITHUB_RUN_ID) {
+    throw new Error('Please ensure the env var GITHUB_RUN_ID is set');
+  }
+  if (!context.env.GITHUB_REPOSITORY) {
+    throw new Error('Please ensure the env var GITHUB_REPOSITORY is set');
+  }
+}
+
+async function getMessageBody(context) {
+  const source = fs
+    .readFileSync(
+      context.env.WORKFLOW_CONCLUSION === 'success'
+        ? path.resolve(__dirname, 'templates', 'success')
+        : path.resolve(__dirname, 'templates', 'failure'),
+    )
+    .toString();
+  const template = Handlebars.compile(source);
+
+  // get job details from GitHub API
+  const octokit = new Octokit({ auth: context.env.GITHUB_TOKEN });
+  const [owner, repo] = context.env.GITHUB_REPOSITORY.split('/');
+  const {
+    data: { jobs },
+  } = await octokit.rest.actions.listJobsForWorkflowRun({
+    run_id: context.env.GITHUB_RUN_ID,
+    owner,
+    repo,
+  });
+
+  // uncomment this to see what is available for each job
+  if(process.env.SHOW_DEBUG) {
+    console.dir(jobs, { depth: null });
+  }
+
+  /*
+
+   a sample of the response is:
+
+    {
+      total_count: 10,
+      jobs: [
+        {
+          id: 5182940024,
+          run_id: 1840752095,
+          run_url: 'https://api.github.com/repos/nymtech/nym/actions/runs/1840752095',
+          run_attempt: 1,
+          node_id: 'CR_kwDODdjOis8AAAABNO1jeA',
+          head_sha: 'aa00eb70d57751bfa556bd3602df87c7473367fc',
+          url: 'https://api.github.com/repos/nymtech/nym/actions/jobs/5182940024',
+          html_url: 'https://github.com/nymtech/nym/runs/5182940024?check_suite_focus=true',
+          status: 'completed',
+          conclusion: 'success',
+          started_at: '2022-02-14T11:28:34Z',
+          completed_at: '2022-02-14T11:28:38Z',
+          name: 'matrix_prep',
+          steps: [
+            {
+              name: 'Set up job',
+              status: 'completed',
+              conclusion: 'success',
+              number: 1,
+              started_at: '2022-02-14T13:28:34.000+02:00',
+              completed_at: '2022-02-14T13:28:36.000+02:00'
+            },
+            {
+              name: 'Run actions/checkout@v2',
+              status: 'completed',
+              conclusion: 'success',
+              number: 2,
+              started_at: '2022-02-14T13:28:36.000+02:00',
+              completed_at: '2022-02-14T13:28:37.000+02:00'
+            },
+            ...
+          ],
+          check_run_url: 'https://api.github.com/repos/nymtech/nym/check-runs/5182940024',
+          labels: [ 'ubuntu-latest' ],
+          runner_id: 1,
+          runner_name: 'Hosted Agent',
+          runner_group_id: 2,
+          runner_group_name: 'GitHub Actions'
+        },
+        {
+          id: 5182943473,
+          run_id: 1840752095,
+          run_url: 'https://api.github.com/repos/nymtech/nym/actions/runs/1840752095',
+          run_attempt: 1,
+          node_id: 'CR_kwDODdjOis8AAAABNO1w8Q',
+          head_sha: 'aa00eb70d57751bfa556bd3602df87c7473367fc',
+          url: 'https://api.github.com/repos/nymtech/nym/actions/jobs/5182943473',
+          html_url: 'https://github.com/nymtech/nym/runs/5182943473?check_suite_focus=true',
+          status: 'completed',
+          conclusion: 'failure',
+          started_at: '2022-02-14T11:29:04Z',
+          completed_at: '2022-02-14T11:55:45Z',
+          name: 'build (macos-latest, stable, schedule)',
+          steps: [
+            {
+              name: 'Set up job',
+              status: 'completed',
+              conclusion: 'success',
+              number: 1,
+              started_at: '2022-02-14T13:29:04.000+02:00',
+              completed_at: '2022-02-14T13:29:26.000+02:00'
+            },
+            {
+              name: 'Install Dependencies (Linux)',
+              status: 'completed',
+              conclusion: 'skipped',
+              number: 2,
+              started_at: '2022-02-14T13:29:26.000+02:00',
+              completed_at: '2022-02-14T13:29:26.000+02:00'
+            },
+            {
+              name: 'Keybase - Send Notification',
+              status: 'completed',
+              conclusion: 'failure',
+              number: 15,
+              started_at: '2022-02-14T13:55:44.000+02:00',
+              completed_at: '2022-02-14T13:55:44.000+02:00'
+            },
+          ],
+          check_run_url: 'https://api.github.com/repos/nymtech/nym/check-runs/5182943473',
+          labels: [ 'macos-latest' ],
+          runner_id: 4,
+          runner_name: 'GitHub Actions 4',
+          runner_group_id: 2,
+          runner_group_name: 'GitHub Actions'
+        },
+        ...
+      ]
+    }
+   */
+
+  const jobResults = jobs
+    .map((job) => {
+      const icon = job.conclusion === 'success' ? '🟩' : '🟥';
+
+      // each job is converted into formatted markdown text
+      return `${icon} ${job.conclusion}: ${job.name} - ${job.html_url}`;
+    })
+    // and join with newlines for display in the template
+    .join('\n');
+
+  return template({ ...context, jobResults });
+}
+
+module.exports = {
+  addToContextAndValidate,
+  getMessageBody,
+};
@@ -0,0 +1,9 @@
+🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥
+> :rocket: {{ env.NYM_PROJECT_NAME }}
+> 🔴 **FAILURE** :cry:
+> `when` {{ timestamp }}
+> `branch` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/tree/{{ env.GIT_BRANCH_NAME }}
+> `commit` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/commit/{{ env.GITHUB_SHA }}
+> `build ` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/actions/runs/{{ env.GITHUB_RUN_ID }}
+
+{{ jobResults }}
@@ -0,0 +1,9 @@
+🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩
+> :rocket: {{ env.NYM_PROJECT_NAME }}
+> ✅ **SUCCESS**
+> `when` {{ timestamp }}
+> `branch` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/tree/{{ env.GIT_BRANCH_NAME }}
+> `commit` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/commit/{{ env.GITHUB_SHA }}
+> `build ` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/actions/runs/{{ env.GITHUB_RUN_ID }}
+
+{{ jobResults }}
@@ -0,0 +1,153 @@
+require('dotenv').config();
+
+const Bot = require('keybase-bot');
+
+let context = {
+  kinds: ['network-explorer', 'nightly'],
+};
+
+/**
+ * Validate that all required env and context vars are available
+ */
+function validateContext() {
+  if (!context.env.NYM_NOTIFICATION_KIND) {
+    throw new Error(
+      'Please set env var NYM_NOTIFICATION_KIND with the project kind that matches a directory in ".github/workflows/support-files"',
+    );
+  }
+  if (!context.kinds.includes(context.env.NYM_NOTIFICATION_KIND)) {
+    throw new Error(`Env var NYM_NOTIFICATION_KIND is not in ${context.kinds}`);
+  }
+  if (!context.env.NYM_PROJECT_NAME) {
+    throw new Error(
+      'Please set env var NYM_PROJECT_NAME with the project name for displaying in notification messages',
+    );
+  }
+  if (!context.env.KEYBASE_NYM_CHANNEL) {
+    throw new Error(
+      'Please set env var KEYBASE_NYM_CHANNEL with the channel name for the notification message',
+    );
+  }
+  if (!context.env.KEYBASE_NYMBOT_USERNAME) {
+    throw new Error(
+      'Username is not defined. Please set env var KEYBASE_NYMBOT_USERNAME',
+    );
+  }
+  if (!context.env.KEYBASE_NYMBOT_PAPERKEY) {
+    throw new Error(
+      'Paperkey is not defined. Please set env var KEYBASE_NYMBOT_PAPERKEY',
+    );
+  }
+}
+
+/**
+ * Creates a context that will be available in the templates for rendering notifications
+ */
+function createTemplateContext() {
+  const options = { dateStyle: 'full', timeStyle: 'long' };
+  context.timestamp = new Date().toLocaleString(undefined, options);
+
+  // add environment to template context and validate
+  context.env = process.env;
+  try {
+    validateContext();
+  } catch (e) {
+    if(process.env.SHOW_DEBUG) {
+      // recursively print the context for easy debugging and rethrow the error
+      console.dir({ context }, { depth: null });
+    }
+    throw e;
+  }
+
+  context.kind = context.env.NYM_NOTIFICATION_KIND;
+
+  context.keybase = {
+    channel: context.env.KEYBASE_NYM_CHANNEL,
+    username: context.env.KEYBASE_NYMBOT_USERNAME,
+    paperkey: context.env.KEYBASE_NYMBOT_PAPERKEY,
+  };
+
+  if (!context.env.GIT_BRANCH_NAME) {
+    context.env.GIT_BRANCH_NAME = context.env.GITHUB_REF.split('/')
+      .slice(2)
+      .join('/');
+  }
+
+  context.status = process.env.IS_SUCCESS === 'true' ? 'success' : 'failure';
+}
+
+async function sendKeybaseMessage(messageBody) {
+  const bot = new Bot();
+  try {
+    console.log(
+      `Initialising keybase with user "${
+        context.keybase.username
+      }" and key: "${'*'.repeat(context.keybase.paperkey.length)}"...`,
+    );
+    await bot.init(context.keybase.username, context.keybase.paperkey, {
+      verbose: false,
+    });
+
+    const channel = {
+      name: 'nymtech_bot',
+      membersType: 'team',
+      topicName: context.keybase.channel,
+      topic_type: 'CHAT',
+    };
+    const message = {
+      body: messageBody,
+    };
+
+    console.log(`Sending to ${channel.name}#${channel.topicName}...`);
+    await bot.chat.send(channel, message);
+
+    console.log('Message sent!');
+  } catch (error) {
+    console.error(error);
+    process.exitCode = -1;
+  } finally {
+    await bot.deinit();
+  }
+}
+
+/**
+ * Uses the `kind` set in the context to process the context and generate a notification message
+ * @returns {Promise<string>} A string notification message body
+ */
+async function processKindScript() {
+  const script = require(`../${context.kind}`);
+  if (!script.addToContextAndValidate) {
+    throw new Error(
+      `"./${context.kind}/index.js" does not export a method called "async addToContextAndValidate(context)"`,
+    );
+  }
+  if (!script.getMessageBody) {
+    throw new Error(
+      `"./${context.kind}/index.js" does not export a method called "async getMessageBody(context)"`,
+    );
+  }
+
+  // call the script to modify and validate the context
+  await script.addToContextAndValidate(context);
+
+  // let the script create a message body and return the result as a string for sending
+  return await script.getMessageBody(context);
+}
+
+/**
+ * The main function, as async so that await syntax is available
+ */
+async function main() {
+  createTemplateContext();
+  console.log(`Sending notification for kind "${context.kind}"...`);
+  const messageBody = await processKindScript();
+  if(process.env.SHOW_DEBUG) {
+    console.log('-----------------------------------------');
+    console.log(messageBody);
+    console.log('-----------------------------------------');
+  }
+  await sendKeybaseMessage(messageBody);
+}
+
+// call main function and let NodeJS handle the promise
+main();
@@ -4,11 +4,14 @@
  "version": "1.0.0",
  "private": true,
  "scripts": {
-    "format": "prettier --write send_message.js"
+    "dev": "node dev.js",
+    "format": "prettier --write **/*.js"
  },
  "dependencies": {
+    "dotenv": "^16.0.0",
    "handlebars": "^4.7.7",
-    "keybase-bot": "^3.6.1"
+    "keybase-bot": "^3.6.1",
+    "octokit": "^1.7.1"
  },
  "devDependencies": {
    "prettier": "2.3.2"
@@ -19,30 +19,27 @@ jobs:
          override: true
          components: rustfmt, clippy

-# token credentials (non-coconut) don't work for wasm right now
-#      - uses: actions-rs/cargo@v1
-#        with:
-#          command: build
-#          args: --manifest-path clients/webassembly/Cargo.toml --target wasm32-unknown-unknown
+      - uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: --manifest-path clients/webassembly/Cargo.toml --target wasm32-unknown-unknown

      - uses: actions-rs/cargo@v1
        with:
          command: build
          args: --manifest-path clients/webassembly/Cargo.toml --target wasm32-unknown-unknown --features=coconut

-# for some reason this does not seem to work correctly, leave it for later, building is good enough for now
-#      - uses: actions-rs/cargo@v1
-#        with:
-#          command: test
-#          args: --manifest-path clients/webassembly/Cargo.toml --target wasm32-unknown-unknown
+      - uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --manifest-path clients/webassembly/Cargo.toml

      - uses: actions-rs/cargo@v1
        with:
          command: fmt
          args: --manifest-path clients/webassembly/Cargo.toml -- --check

-# for some reason this does not seem to work correctly, leave it for later, building is good enough for now
-#      - uses: actions-rs/cargo@v1
-#        with:
-#          command: clippy
-#          args: --manifest-path clients/webassembly/Cargo.toml --target wasm32-unknown-unknown -- -D warnings
+      - uses: actions-rs/cargo@v1
+        with:
+          command: clippy
+          args: --manifest-path clients/webassembly/Cargo.toml --target wasm32-unknown-unknown -- -D warnings
@@ -11,13 +11,13 @@ panic = "abort"

 [workspace]

+resolver = "2"
 members = [
    "clients/client-core",
    "clients/native",
    "clients/native/websocket-requests",
    "clients/socks5",
    "clients/tauri-client/src-tauri",
-    "clients/webassembly",
    "common/client-libs/gateway-client",
    "common/client-libs/mixnet-client",
    "common/client-libs/validator-client",
@@ -26,7 +26,9 @@ members = [
    "common/credentials",
    "common/crypto",
    "common/bandwidth-claim-contract",
-    "common/mixnet-contract",
+    "common/cosmwasm-smart-contracts/contracts-common",
+    "common/cosmwasm-smart-contracts/mixnet-contract",
+    "common/cosmwasm-smart-contracts/vesting-contract",
    "common/mixnode-common",
    "common/network-defaults",
    "common/nonexhaustive-delayqueue",
@@ -52,12 +54,12 @@ members = [
    "mixnode",
    "service-providers/network-requester",
    "validator-api",
+    "validator-api/validator-api-requests",
 ]

 default-members = [
    "clients/native",
    "clients/socks5",
-#    "clients/webassembly",
    "gateway",
    "service-providers/network-requester",
    "mixnode",
@@ -65,4 +67,4 @@ default-members = [
    "explorer-api",
 ]

-exclude = ["explorer", "contracts", "tokenomics-py"]
+exclude = ["explorer", "contracts", "tokenomics-py", "clients/webassembly"]
@@ -1,8 +1,9 @@
-all: clippy-all test fmt
-happy: clippy-happy test fmt
+test: build clippy-all cargo-test wasm fmt
+happy: fmt clippy-happy test
 clippy-all: clippy-all-main clippy-all-contracts clippy-all-wallet
 clippy-happy: clippy-happy-main clippy-happy-contracts clippy-happy-wallet
-test: test-main test-contracts test-wallet
+cargo-test: test-main test-contracts test-wallet
+build: build-main build-contracts build-wallet
 fmt: fmt-main fmt-contracts fmt-wallet

 clippy-happy-main:
@@ -32,6 +33,15 @@ test-contracts:
 test-wallet:
 	cargo test --manifest-path nym-wallet/Cargo.toml --all-features

+build-main:
+	cargo build --all
+
+build-contracts:
+	cargo build --manifest-path contracts/Cargo.toml --all
+
+build-wallet:
+	cargo build --manifest-path nym-wallet/Cargo.toml --all
+
 fmt-main:
 	cargo fmt --all

@@ -21,7 +21,8 @@ The platform is composed of multiple Rust crates. Top-level executable binary cr

 ### Building

-Platform build instructions are available on [our docs site](https://nymtech.net/docs/0.11.0/overview/index/).
+Platform build instructions are available on [our docs site](https://nymtech.net/docs/stable/run-nym-nodes/build-nym).
+Wallet build instructions are also available on [our docs site](https://nymtech.net/docs/stable/nym-apps/wallet#for-developers).

 ### Developing

@@ -2,7 +2,7 @@
 name = "client-core"
 version = "0.12.0"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
-edition = "2018"
+edition = "2021"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

@@ -79,9 +79,9 @@ impl KeyManager {
            ))?;

        let gateway_shared_key: SharedKeys =
-            pemstore::load_key(&client_pathfinder.gateway_shared_key().to_owned())?;
+            pemstore::load_key(client_pathfinder.gateway_shared_key())?;

-        let ack_key: AckKey = pemstore::load_key(&client_pathfinder.ack_key().to_owned())?;
+        let ack_key: AckKey = pemstore::load_key(client_pathfinder.ack_key())?;

        // TODO: ack key is never stored so it is generated now. But perhaps it should be stored
        // after all for consistency sake?
@@ -59,7 +59,7 @@ impl ReplyKeyStorage {
    ) -> Result<(), ReplyKeyStorageError> {
        let digest = encryption_key.compute_digest();

-        let insertion_result = match self.db.insert(digest.to_vec(), encryption_key.to_bytes()) {
+        let insertion_result = match self.db.insert(digest, encryption_key.to_bytes()) {
            Err(e) => Err(ReplyKeyStorageError::DbWriteError(e)),
            Ok(existing_key) => {
                if existing_key.is_some() {
@@ -79,7 +79,7 @@ impl ReplyKeyStorage {
        &self,
        key_digest: EncryptionKeyDigest,
    ) -> Result<Option<SurbEncryptionKey>, ReplyKeyStorageError> {
-        let removal_result = match self.db.remove(&key_digest.to_vec()) {
+        let removal_result = match self.db.remove(key_digest) {
            Err(e) => Err(ReplyKeyStorageError::DbReadError(e)),
            Ok(existing_key) => {
                Ok(existing_key.map(|existing_key| self.read_encryption_key(existing_key)))
@@ -121,12 +121,16 @@ impl<T: NymConfig> Config<T> {
        self.client.testnet_mode = testnet_mode;
    }

-    pub fn with_gateway_id<S: Into<String>>(&mut self, id: S) {
-        self.client.gateway_id = id.into();
+    pub fn with_gateway_endpoint<S: Into<String>>(&mut self, id: S, owner: S, listener: S) {
+        self.client.gateway_endpoint = GatewayEndpoint {
+            gateway_id: id.into(),
+            gateway_owner: owner.into(),
+            gateway_listener: listener.into(),
+        };
    }

-    pub fn with_gateway_listener<S: Into<String>>(&mut self, gateway_listener: S) {
-        self.client.gateway_listener = gateway_listener.into();
+    pub fn with_gateway_id<S: Into<String>>(&mut self, id: S) {
+        self.client.gateway_endpoint.gateway_id = id.into();
    }

    #[cfg(not(feature = "coconut"))]
@@ -198,11 +202,15 @@ impl<T: NymConfig> Config<T> {
    }

    pub fn get_gateway_id(&self) -> String {
-        self.client.gateway_id.clone()
+        self.client.gateway_endpoint.gateway_id.clone()
+    }
+
+    pub fn get_gateway_owner(&self) -> String {
+        self.client.gateway_endpoint.gateway_owner.clone()
    }

    pub fn get_gateway_listener(&self) -> String {
-        self.client.gateway_listener.clone()
+        self.client.gateway_endpoint.gateway_listener.clone()
    }

    #[cfg(not(feature = "coconut"))]
@@ -272,6 +280,19 @@ impl<T: NymConfig> Default for Config<T> {
    }
 }

+#[derive(Debug, Default, Deserialize, PartialEq, Serialize)]
+struct GatewayEndpoint {
+    /// gateway_id specifies ID of the gateway to which the client should send messages.
+    /// If initially omitted, a random gateway will be chosen from the available topology.
+    gateway_id: String,
+
+    /// Address of the gateway owner to which the client should send messages.
+    gateway_owner: String,
+
+    /// Address of the gateway listener to which all client requests should be sent.
+    gateway_listener: String,
+}
+
 #[derive(Debug, Deserialize, PartialEq, Serialize)]
 pub struct Client<T> {
    /// Version of the client for which this configuration was created.
@@ -313,12 +334,8 @@ pub struct Client<T> {
    /// sent but not received back.
    reply_encryption_key_store_path: PathBuf,

-    /// gateway_id specifies ID of the gateway to which the client should send messages.
-    /// If initially omitted, a random gateway will be chosen from the available topology.
-    gateway_id: String,
-
-    /// Address of the gateway listener to which all client requests should be sent.
-    gateway_listener: String,
+    /// Information regarding how the client should send data to gateway.
+    gateway_endpoint: GatewayEndpoint,

    /// 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.
@@ -357,8 +374,7 @@ impl<T: NymConfig> Default for Client<T> {
            gateway_shared_key_file: Default::default(),
            ack_key_file: Default::default(),
            reply_encryption_key_store_path: Default::default(),
-            gateway_id: "".to_string(),
-            gateway_listener: "".to_string(),
+            gateway_endpoint: Default::default(),
            #[cfg(not(feature = "coconut"))]
            backup_bandwidth_token_keys_dir: Default::default(),
            #[cfg(not(feature = "coconut"))]
@@ -2,7 +2,7 @@
 name = "nym-client"
 version = "0.12.1"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>", "Jędrzej Stuczyński <andrew@nymtech.net>"]
-edition = "2018"
+edition = "2021"
 rust-version = "1.56"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -2441,9 +2441,9 @@
      }
    },
    "node_modules/follow-redirects": {
-      "version": "1.14.1",
-      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.14.1.tgz",
-      "integrity": "sha512-HWqDgT7ZEkqRzBvc2s64vSZ/hfOceEol3ac/7tKwzuvEyWx3/4UegXh5oBOIotkGsObyk3xznnSRVADBgWSQVg==",
+      "version": "1.14.8",
+      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.14.8.tgz",
+      "integrity": "sha512-1x0S9UVJHsQprFcEC/qnNzBLcIxsjAV905f/UkQxbclCsoTWlacCNOpQa/anodLl2uaEKFhfWOvM2Qg77+15zA==",
      "dev": true,
      "funding": [
        {
@@ -3806,9 +3806,9 @@
      "optional": true
    },
    "node_modules/nanoid": {
-      "version": "3.1.23",
-      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.1.23.tgz",
-      "integrity": "sha512-FiB0kzdP0FFVGDKlRLEQ1BgDzU87dy5NnzjeW9YZNt+/c3+q82EQDUwniSAUxp/F0gFNI1ZhKU1FqYsMuqZVnw==",
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.2.0.tgz",
+      "integrity": "sha512-fmsZYa9lpn69Ad5eDn7FMcnnSR+8R34W9qJEijxYhTbfOWzr22n1QxCMzXLK+ODyW2973V3Fux959iQoUxzUIA==",
      "dev": true,
      "peer": true,
      "bin": {
@@ -3943,9 +3943,9 @@
      }
    },
    "node_modules/nth-check": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/nth-check/-/nth-check-2.0.0.tgz",
-      "integrity": "sha512-i4sc/Kj8htBrAiH1viZ0TgU8Y5XqCaV/FziYK6TBczxmeKm3AEFWqqF3195yKudrarqy7Zu80Ra5dobFjn9X/Q==",
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/nth-check/-/nth-check-2.0.1.tgz",
+      "integrity": "sha512-it1vE95zF6dTT9lBsYbxvqh0Soy4SPowchj0UBGj/V6cTPnXXtQOPUbhZ6CmGzAD/rW22LQK6E96pcdJXk4A4w==",
      "dependencies": {
        "boolbase": "^1.0.0"
      },
@@ -6085,9 +6085,9 @@
      }
    },
    "node_modules/url-parse": {
-      "version": "1.5.1",
-      "resolved": "https://registry.npmjs.org/url-parse/-/url-parse-1.5.1.tgz",
-      "integrity": "sha512-HOfCOUJt7iSYzEx/UqgtwKRMC6EU91NFhsCHMv9oM03VJcVo2Qrp8T8kI9D7amFf1cu+/3CEhgb3rF9zL7k85Q==",
+      "version": "1.5.7",
+      "resolved": "https://registry.npmjs.org/url-parse/-/url-parse-1.5.7.tgz",
+      "integrity": "sha512-HxWkieX+STA38EDk7CE9MEryFeHCKzgagxlGvsdS7WBImq9Mk+PGwiT56w82WI3aicwJA8REp42Cxo98c8FZMA==",
      "dev": true,
      "dependencies": {
        "querystringify": "^2.1.1",
@@ -8853,9 +8853,9 @@
      }
    },
    "follow-redirects": {
-      "version": "1.14.1",
-      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.14.1.tgz",
-      "integrity": "sha512-HWqDgT7ZEkqRzBvc2s64vSZ/hfOceEol3ac/7tKwzuvEyWx3/4UegXh5oBOIotkGsObyk3xznnSRVADBgWSQVg==",
+      "version": "1.14.8",
+      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.14.8.tgz",
+      "integrity": "sha512-1x0S9UVJHsQprFcEC/qnNzBLcIxsjAV905f/UkQxbclCsoTWlacCNOpQa/anodLl2uaEKFhfWOvM2Qg77+15zA==",
      "dev": true
    },
    "for-in": {
@@ -9871,9 +9871,9 @@
      "optional": true
    },
    "nanoid": {
-      "version": "3.1.23",
-      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.1.23.tgz",
-      "integrity": "sha512-FiB0kzdP0FFVGDKlRLEQ1BgDzU87dy5NnzjeW9YZNt+/c3+q82EQDUwniSAUxp/F0gFNI1ZhKU1FqYsMuqZVnw==",
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.2.0.tgz",
+      "integrity": "sha512-fmsZYa9lpn69Ad5eDn7FMcnnSR+8R34W9qJEijxYhTbfOWzr22n1QxCMzXLK+ODyW2973V3Fux959iQoUxzUIA==",
      "dev": true,
      "peer": true
    },
@@ -9984,9 +9984,9 @@
      }
    },
    "nth-check": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/nth-check/-/nth-check-2.0.0.tgz",
-      "integrity": "sha512-i4sc/Kj8htBrAiH1viZ0TgU8Y5XqCaV/FziYK6TBczxmeKm3AEFWqqF3195yKudrarqy7Zu80Ra5dobFjn9X/Q==",
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/nth-check/-/nth-check-2.0.1.tgz",
+      "integrity": "sha512-it1vE95zF6dTT9lBsYbxvqh0Soy4SPowchj0UBGj/V6cTPnXXtQOPUbhZ6CmGzAD/rW22LQK6E96pcdJXk4A4w==",
      "requires": {
        "boolbase": "^1.0.0"
      }
@@ -11733,9 +11733,9 @@
      }
    },
    "url-parse": {
-      "version": "1.5.1",
-      "resolved": "https://registry.npmjs.org/url-parse/-/url-parse-1.5.1.tgz",
-      "integrity": "sha512-HOfCOUJt7iSYzEx/UqgtwKRMC6EU91NFhsCHMv9oM03VJcVo2Qrp8T8kI9D7amFf1cu+/3CEhgb3rF9zL7k85Q==",
+      "version": "1.5.7",
+      "resolved": "https://registry.npmjs.org/url-parse/-/url-parse-1.5.7.tgz",
+      "integrity": "sha512-HxWkieX+STA38EDk7CE9MEryFeHCKzgagxlGvsdS7WBImq9Mk+PGwiT56w82WI3aicwJA8REp42Cxo98c8FZMA==",
      "dev": true,
      "requires": {
        "querystringify": "^2.1.1",
@@ -35,7 +35,7 @@ async fn send_file_with_reply() {
    let (mut ws_stream, _) = connect_async(uri).await.unwrap();

    let recipient = get_self_address(&mut ws_stream).await;
-    println!("our full address is: {}", recipient.to_string());
+    println!("our full address is: {}", recipient);

    let read_data = std::fs::read("examples/dummy_file").unwrap();

@@ -83,7 +83,7 @@ async fn send_file_without_reply() {
    let (mut ws_stream, _) = connect_async(uri).await.unwrap();

    let recipient = get_self_address(&mut ws_stream).await;
-    println!("our full address is: {}", recipient.to_string());
+    println!("our full address is: {}", recipient);

    let read_data = std::fs::read("examples/dummy_file").unwrap();

@@ -36,7 +36,7 @@ async fn send_text_with_reply() {
    let (mut ws_stream, _) = connect_async(uri).await.unwrap();

    let recipient = get_self_address(&mut ws_stream).await;
-    println!("our full address is: {}", recipient.to_string());
+    println!("our full address is: {}", recipient);

    let send_request = json!({
        "type" : "send",
@@ -76,7 +76,7 @@ async fn send_text_without_reply() {
    let (mut ws_stream, _) = connect_async(uri).await.unwrap();

    let recipient = get_self_address(&mut ws_stream).await;
-    println!("our full address is: {}", recipient.to_string());
+    println!("our full address is: {}", recipient);

    let send_request = json!({
        "type" : "send",
@@ -59,12 +59,6 @@ eth_endpoint = '{{ client.eth_endpoint }}'

 ##### additional client config options #####

-# ID of the gateway from which the client should be fetching messages.
-gateway_id = '{{ client.gateway_id }}'
-
-# Address of the gateway listener to which all client requests should be sent.
-gateway_listener = '{{ client.gateway_listener }}'
-
 # A gateway specific, optional, base58 stringified shared key used for
 # communication with particular gateway.
 gateway_shared_key_file = '{{ client.gateway_shared_key_file }}'
@@ -78,6 +72,17 @@ ack_key_file = '{{ client.ack_key_file }}'
 # Absolute path to the home Nym Clients directory.
 nym_root_directory = '{{ client.nym_root_directory }}'

+[client.gateway_endpoint]
+# ID of the gateway from which the client should be fetching messages.
+gateway_id = '{{ client.gateway_endpoint.gateway_id }}'
+
+# Address of the gateway owner to which the client should send messages.
+gateway_owner = '{{ client.gateway_endpoint.gateway_owner }}'
+
+# Address of the gateway listener to which all client requests should be sent.
+gateway_listener = '{{ client.gateway_endpoint.gateway_listener }}'
+
+

 ##### socket config options #####

@@ -160,6 +160,10 @@ impl NymClient {
        if gateway_id.is_empty() {
            panic!("The identity of the gateway is unknown - did you run `nym-client` init?")
        }
+        let gateway_owner = self.config.get_base().get_gateway_owner();
+        if gateway_owner.is_empty() {
+            panic!("The owner of the gateway is unknown - did you run `nym-client` init?")
+        }
        let gateway_address = self.config.get_base().get_gateway_listener();
        if gateway_address.is_empty() {
            panic!("The address of the gateway is unknown - did you run `nym-client` init?")
@@ -185,6 +189,7 @@ impl NymClient {
            gateway_address,
            self.key_manager.identity_keypair(),
            gateway_identity,
+            gateway_owner,
            Some(self.key_manager.gateway_shared_key()),
            mixnet_message_sender,
            ack_sender,
@@ -136,6 +136,7 @@ async fn register_with_gateway(
    let mut gateway_client = GatewayClient::new_init(
        gateway.clients_address(),
        gateway.identity_key,
+        gateway.owner.clone(),
        our_identity.clone(),
        timeout,
    );
@@ -255,15 +256,14 @@ pub async fn execute(matches: ArgMatches<'static>) {
            chosen_gateway_id,
        )
        .await;
-        config
-            .get_base_mut()
-            .with_gateway_id(gateway_details.identity_key.to_base58_string());
        let shared_keys =
            register_with_gateway(&gateway_details, key_manager.identity_keypair()).await;

-        config
-            .get_base_mut()
-            .with_gateway_listener(gateway_details.clients_address());
+        config.get_base_mut().with_gateway_endpoint(
+            gateway_details.identity_key.to_base58_string(),
+            gateway_details.owner.clone(),
+            gateway_details.clients_address(),
+        );
        key_manager.insert_gateway_shared_key(shared_keys);

        let pathfinder = ClientKeyPathfinder::new_from_config(config.get_base());
@@ -32,7 +32,7 @@ fn parse_validators(raw: &str) -> Vec<Url> {
        .collect()
 }

-pub(crate) fn override_config(mut config: Config, matches: &ArgMatches) -> Config {
+pub(crate) fn override_config(mut config: Config, matches: &ArgMatches<'_>) -> Config {
    if let Some(raw_validators) = matches.value_of("validators") {
        config
            .get_base_mut()
@@ -58,7 +58,7 @@ pub(crate) fn override_config(mut config: Config, matches: &ArgMatches) -> Confi
    #[cfg(not(feature = "coconut"))]
    if let Some(eth_endpoint) = matches.value_of(ETH_ENDPOINT_ARG_NAME) {
        config.get_base_mut().with_eth_endpoint(eth_endpoint);
-    } else {
+    } else if !cfg!(feature = "eth") {
        config
            .get_base_mut()
            .with_eth_endpoint(DEFAULT_ETH_ENDPOINT);
@@ -66,7 +66,7 @@ pub(crate) fn override_config(mut config: Config, matches: &ArgMatches) -> Confi
    #[cfg(not(feature = "coconut"))]
    if let Some(eth_private_key) = matches.value_of(ETH_PRIVATE_KEY_ARG_NAME) {
        config.get_base_mut().with_eth_private_key(eth_private_key);
-    } else {
+    } else if !cfg!(feature = "eth") {
        config
            .get_base_mut()
            .with_eth_private_key(DEFAULT_ETH_PRIVATE_KEY);
@@ -95,7 +95,7 @@ fn parse_package_version() -> Version {

 fn minor_0_12_upgrade(
    mut config: Config,
-    _matches: &ArgMatches,
+    _matches: &ArgMatches<'_>,
    config_version: &Version,
    package_version: &Version,
 ) -> Config {
@@ -131,7 +131,7 @@ fn minor_0_12_upgrade(
    config
 }

-fn do_upgrade(mut config: Config, matches: &ArgMatches, package_version: Version) {
+fn do_upgrade(mut config: Config, matches: &ArgMatches<'_>, package_version: Version) {
    loop {
        let config_version = parse_config_version(&config);

@@ -151,7 +151,7 @@ fn do_upgrade(mut config: Config, matches: &ArgMatches, package_version: Version
    }
 }

-pub fn execute(matches: &ArgMatches) {
+pub fn execute(matches: &ArgMatches<'_>) {
    let package_version = parse_package_version();

    let id = matches.value_of("id").unwrap();
@@ -2,7 +2,7 @@
 name = "websocket-requests"
 version = "0.1.0"
 authors = ["Jędrzej Stuczyński <andrew@nymtech.net>"]
-edition = "2018"
+edition = "2021"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

@@ -2,7 +2,7 @@
 name = "nym-socks5-client"
 version = "0.12.1"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
-edition = "2018"
+edition = "2021"
 rust-version = "1.56"

 [lib]
@@ -59,12 +59,6 @@ eth_endpoint = '{{ client.eth_endpoint }}'

 ##### additional client config options #####

-# ID of the gateway from which the client should be fetching messages.
-gateway_id = '{{ client.gateway_id }}'
-
-# Address of the gateway listener to which all client requests should be sent.
-gateway_listener = '{{ client.gateway_listener }}'
-
 # A gateway specific, optional, base58 stringified shared key used for
 # communication with particular gateway.
 gateway_shared_key_file = '{{ client.gateway_shared_key_file }}'
@@ -72,12 +66,22 @@ gateway_shared_key_file = '{{ client.gateway_shared_key_file }}'
 # Path to file containing key used for encrypting and decrypting the content of an
 # acknowledgement so that nobody besides the client knows which packet it refers to.
 ack_key_file = '{{ client.ack_key_file }}'
-    
+
 ##### advanced configuration options #####

 # Absolute path to the home Nym Clients directory.
 nym_root_directory = '{{ client.nym_root_directory }}'

+[client.gateway_endpoint]
+# ID of the gateway from which the client should be fetching messages.
+gateway_id = '{{ client.gateway_endpoint.gateway_id }}'
+
+# Address of the gateway owner to which the client should send messages.
+gateway_owner = '{{ client.gateway_endpoint.gateway_owner }}'
+
+# Address of the gateway listener to which all client requests should be sent.
+gateway_listener = '{{ client.gateway_endpoint.gateway_listener }}'
+

 ##### socket config options #####

@@ -148,6 +148,10 @@ impl NymClient {
        if gateway_id.is_empty() {
            panic!("The identity of the gateway is unknown - did you run `nym-client` init?")
        }
+        let gateway_owner = self.config.get_base().get_gateway_owner();
+        if gateway_owner.is_empty() {
+            panic!("The owner of the gateway is unknown - did you run `nym-client` init?")
+        }
        let gateway_address = self.config.get_base().get_gateway_listener();
        if gateway_address.is_empty() {
            panic!("The address of the gateway is unknown - did you run `nym-client` init?")
@@ -173,6 +177,7 @@ impl NymClient {
            gateway_address,
            self.key_manager.identity_keypair(),
            gateway_identity,
+            gateway_owner,
            Some(self.key_manager.gateway_shared_key()),
            mixnet_message_sender,
            ack_sender,
@@ -136,6 +136,7 @@ async fn register_with_gateway(
    let mut gateway_client = GatewayClient::new_init(
        gateway.clients_address(),
        gateway.identity_key,
+        gateway.owner.clone(),
        our_identity.clone(),
        timeout,
    );
@@ -256,15 +257,14 @@ pub async fn execute(matches: ArgMatches<'static>) {
            chosen_gateway_id,
        )
        .await;
-        config
-            .get_base_mut()
-            .with_gateway_id(gateway_details.identity_key.to_base58_string());
        let shared_keys =
            register_with_gateway(&gateway_details, key_manager.identity_keypair()).await;

-        config
-            .get_base_mut()
-            .with_gateway_listener(gateway_details.clients_address());
+        config.get_base_mut().with_gateway_endpoint(
+            gateway_details.identity_key.to_base58_string(),
+            gateway_details.owner.clone(),
+            gateway_details.clients_address(),
+        );
        key_manager.insert_gateway_shared_key(shared_keys);

        let pathfinder = ClientKeyPathfinder::new_from_config(config.get_base());
@@ -32,7 +32,7 @@ fn parse_validators(raw: &str) -> Vec<Url> {
        .collect()
 }

-pub(crate) fn override_config(mut config: Config, matches: &ArgMatches) -> Config {
+pub(crate) fn override_config(mut config: Config, matches: &ArgMatches<'_>) -> Config {
    if let Some(raw_validators) = matches.value_of("validators") {
        config
            .get_base_mut()
@@ -54,7 +54,7 @@ pub(crate) fn override_config(mut config: Config, matches: &ArgMatches) -> Confi
    #[cfg(not(feature = "coconut"))]
    if let Some(eth_endpoint) = matches.value_of(ETH_ENDPOINT_ARG_NAME) {
        config.get_base_mut().with_eth_endpoint(eth_endpoint);
-    } else {
+    } else if !cfg!(feature = "eth") {
        config
            .get_base_mut()
            .with_eth_endpoint(DEFAULT_ETH_ENDPOINT);
@@ -62,7 +62,7 @@ pub(crate) fn override_config(mut config: Config, matches: &ArgMatches) -> Confi
    #[cfg(not(feature = "coconut"))]
    if let Some(eth_private_key) = matches.value_of(ETH_PRIVATE_KEY_ARG_NAME) {
        config.get_base_mut().with_eth_private_key(eth_private_key);
-    } else {
+    } else if !cfg!(feature = "eth") {
        config
            .get_base_mut()
            .with_eth_private_key(DEFAULT_ETH_PRIVATE_KEY);
@@ -95,7 +95,7 @@ fn parse_package_version() -> Version {

 fn minor_0_12_upgrade(
    mut config: Config,
-    _matches: &ArgMatches,
+    _matches: &ArgMatches<'_>,
    config_version: &Version,
    package_version: &Version,
 ) -> Config {
@@ -131,7 +131,7 @@ fn minor_0_12_upgrade(
    config
 }

-fn do_upgrade(mut config: Config, matches: &ArgMatches, package_version: Version) {
+fn do_upgrade(mut config: Config, matches: &ArgMatches<'_>, package_version: Version) {
    loop {
        let config_version = parse_config_version(&config);

@@ -151,7 +151,7 @@ fn do_upgrade(mut config: Config, matches: &ArgMatches, package_version: Version
    }
 }

-pub fn execute(matches: &ArgMatches) {
+pub fn execute(matches: &ArgMatches<'_>) {
    let package_version = parse_package_version();

    let id = matches.value_of("id").unwrap();
@@ -11,6 +11,7 @@
        "@tauri-apps/api": "^1.0.0-beta.4",
        "compression": "^1.7.1",
        "polka": "next",
+        "qrious": "^4.0.2",
        "sirv": "^1.0.0"
      },
      "devDependencies": {
@@ -6758,6 +6759,11 @@
        "node": ">=8"
      }
    },
+    "node_modules/qrious": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/qrious/-/qrious-4.0.2.tgz",
+      "integrity": "sha512-xWPJIrK1zu5Ypn898fBp8RHkT/9ibquV2Kv24S/JY9VYEhMBMKur1gHVsOiNUh7PHP9uCgejjpZUHUIXXKoU/g=="
+    },
    "node_modules/query-string": {
      "version": "5.1.1",
      "resolved": "https://registry.npmjs.org/query-string/-/query-string-5.1.1.tgz",
@@ -7579,11 +7585,10 @@
      "license": "MIT"
    },
    "node_modules/simple-get": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/simple-get/-/simple-get-3.1.0.tgz",
-      "integrity": "sha512-bCR6cP+aTdScaQCnQKbPKtJOKDp/hj9EDLJo3Nw4y1QksqaovlW/bnptB6/c1e+qmNIDHRK+oXFDdEqBT8WzUA==",
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/simple-get/-/simple-get-3.1.1.tgz",
+      "integrity": "sha512-CQ5LTKGfCpvE1K0n2us+kuMPbk/q0EKl82s4aheV9oXjFEz6W/Y7oQFVJuU6QG77hRT4Ghb5RURteF5vnWjupA==",
      "dev": true,
-      "license": "MIT",
      "dependencies": {
        "decompress-response": "^4.2.0",
        "once": "^1.3.1",
@@ -13474,6 +13479,11 @@
        "escape-goat": "^2.0.0"
      }
    },
+    "qrious": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/qrious/-/qrious-4.0.2.tgz",
+      "integrity": "sha512-xWPJIrK1zu5Ypn898fBp8RHkT/9ibquV2Kv24S/JY9VYEhMBMKur1gHVsOiNUh7PHP9uCgejjpZUHUIXXKoU/g=="
+    },
    "query-string": {
      "version": "5.1.1",
      "resolved": "https://registry.npmjs.org/query-string/-/query-string-5.1.1.tgz",
@@ -14036,9 +14046,9 @@
      "dev": true
    },
    "simple-get": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/simple-get/-/simple-get-3.1.0.tgz",
-      "integrity": "sha512-bCR6cP+aTdScaQCnQKbPKtJOKDp/hj9EDLJo3Nw4y1QksqaovlW/bnptB6/c1e+qmNIDHRK+oXFDdEqBT8WzUA==",
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/simple-get/-/simple-get-3.1.1.tgz",
+      "integrity": "sha512-CQ5LTKGfCpvE1K0n2us+kuMPbk/q0EKl82s4aheV9oXjFEz6W/Y7oQFVJuU6QG77hRT4Ghb5RURteF5vnWjupA==",
      "dev": true,
      "requires": {
        "decompress-response": "^4.2.0",
@@ -6,7 +6,7 @@ authors = ["you"]
 license = ""
 repository = ""
 default-run = "app"
-edition = "2018"
+edition = "2021"
 build = "src/build.rs"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -1813,7 +1813,7 @@ decompress-response@^3.2.0, decompress-response@^3.3.0:

 decompress-response@^4.2.0:
  version "4.2.1"
-  resolved "https://registry.npmjs.org/decompress-response/-/decompress-response-4.2.1.tgz"
+  resolved "https://registry.yarnpkg.com/decompress-response/-/decompress-response-4.2.1.tgz#414023cc7a302da25ce2ec82d0d5238ccafd8986"
  integrity sha512-jOSne2qbyE+/r8G1VU+G/82LBs2Fs4LAsTiLSHOCOMZQl2OKZ6i8i4IyHemTe+/yIXOtTcRQMzPcgyhoFlqPkw==
  dependencies:
    mimic-response "^2.0.0"
@@ -3130,7 +3130,7 @@ mimic-response@^1.0.0, mimic-response@^1.0.1:

 mimic-response@^2.0.0:
  version "2.1.0"
-  resolved "https://registry.npmjs.org/mimic-response/-/mimic-response-2.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/mimic-response/-/mimic-response-2.1.0.tgz#d13763d35f613d09ec37ebb30bac0469c0ee8f43"
  integrity sha512-wXqjST+SLt7R009ySCglWBCFpjUygmCIfD790/kVbiGmUgfYGuB14PiTd5DwVxSV4NcYHjzMkoj5LjQZwTQLEA==

 mimic-response@^3.1.0:
@@ -4056,13 +4056,13 @@ signal-exit@^3.0.0, signal-exit@^3.0.2:

 simple-concat@^1.0.0:
  version "1.0.1"
-  resolved "https://registry.npmjs.org/simple-concat/-/simple-concat-1.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/simple-concat/-/simple-concat-1.0.1.tgz#f46976082ba35c2263f1c8ab5edfe26c41c9552f"
  integrity sha512-cSFtAPtRhljv69IK0hTVZQ+OfE9nePi/rtJmw5UjHeVyVroEqJXP1sFztKUy1qU+xvz3u/sfYJLa947b7nAN2Q==

 simple-get@^3.0.3, simple-get@^3.1.0:
-  version "3.1.0"
-  resolved "https://registry.npmjs.org/simple-get/-/simple-get-3.1.0.tgz"
-  integrity sha512-bCR6cP+aTdScaQCnQKbPKtJOKDp/hj9EDLJo3Nw4y1QksqaovlW/bnptB6/c1e+qmNIDHRK+oXFDdEqBT8WzUA==
+  version "3.1.1"
+  resolved "https://registry.yarnpkg.com/simple-get/-/simple-get-3.1.1.tgz#cc7ba77cfbe761036fbfce3d021af25fc5584d55"
+  integrity sha512-CQ5LTKGfCpvE1K0n2us+kuMPbk/q0EKl82s4aheV9oXjFEz6W/Y7oQFVJuU6QG77hRT4Ghb5RURteF5vnWjupA==
  dependencies:
    decompress-response "^4.2.0"
    once "^1.3.1"
@@ -4673,7 +4673,7 @@ wrap-ansi@^7.0.0:

 wrappy@1:
  version "1.0.2"
-  resolved "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/wrappy/-/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f"
  integrity sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=

 write-file-atomic@^3.0.0:
@@ -1,6 +1,25 @@
+# CLIENT INIT
 NYMD_URL=https://sandbox-validator.nymtech.net
 VALIDATOR_API=https://sandbox-validator.nymtech.net/api
 MIXNET_CONTRACT=nymt1ghd753shjuwexxywmgs4xz7x2q732vcnstz02j
 VESTING_CONTRACT=nymt1nc5tatafv6eyq7llkr2gv50ff9e22mnfp9pc5s
 CURRENCY_PREFIX=nymt
-CHAIN_ID=nym-sandbox
+CHAIN_ID=nym-sandbox
+
+# USER DETAILS
+USER_MNEMONIC=
+USER_WALLET_ADDRESS=
+
+# MIXNODE DETAILS
+MIXNODE_IDENTITY=
+MIXNODE_SPHINX_KEY=
+MIXNODE_SIGNATURE=
+MIXNODE_HOST="1.1.1.1"
+MIXNODE_VERSION="0.12.1"
+
+# GATEWAY DETAILS
+GATEWAY_IDENTITY=
+GATEWAY_SPHINX=
+GATEAWAY_LOCATION=
+GATEWAY_HOST="1.1.1.1"
+GATEWAY_VERSION="0.12.1"
@@ -2,5 +2,6 @@ module.exports = {
  preset: 'ts-jest',
  testEnvironment: 'node',
  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'node'],
-  setupFiles: ["dotenv/config"]
+  setupFiles: ["dotenv/config"],
+  testTimeout: 20000
 };
@@ -6,7 +6,7 @@
  "main": "./dist/index.js",
  "types": "dist/index.d.ts",
  "scripts": {
-    "test": "jest --coverage --verbose false",
+    "test": "jest --verbose false",
    "lint": "eslint src",
    "lint:fix": "eslint src --fix",
    "docs": "typedoc --out docs src/index.ts"
@@ -44,6 +44,7 @@
    "@cosmjs/tendermint-rpc": "^0.27.0-rc2",
    "axios": "^0.21.1",
    "cosmjs-types": "^0.4.0",
-    "dotenv": "^10.0.0"
+    "dotenv": "^10.0.0",
+    "moq.ts": "^7.3.4"
  }
 }
@@ -180,8 +180,8 @@ export default class ValidatorClient implements INymClient {
    return this.client.getSybilResistancePercent(this.mixnetContract);
  }

-  public async getEpochRewardPercent(): Promise<number> {
-    return this.client.getEpochRewardPercent(this.mixnetContract);
+  public async getIntervalRewardPercent(): Promise<number> {
+    return this.client.getIntervalRewardPercent(this.mixnetContract);
  }

  public async getAllNymdMixnodes(): Promise<MixNodeBond[]> {
@@ -433,6 +433,14 @@ export default class ValidatorClient implements INymClient {
    return (this.client as ISigningClient).undelegateFromMixNode(this.mixnetContract, mixIdentity, fee, memo);
  }

+  public async updateMixnodeConfig(
+    mixIdentity: string,
+    fee: StdFee | 'auto' | number,
+    profitPercentage: number,
+  ): Promise<ExecuteResult> {
+    return (this.client as ISigningClient).updateMixnodeConfig(this.mixnetContract, mixIdentity, profitPercentage, fee);
+  }
+
  public async updateContractStateParams(
    newParams: ContractStateParams,
    fee?: StdFee | 'auto' | number,
@@ -441,4 +449,4 @@ export default class ValidatorClient implements INymClient {
    this.assertSigning();
    return (this.client as ISigningClient).updateContractStateParams(this.mixnetContract, newParams, fee, memo);
  }
-}
+}
@@ -18,7 +18,6 @@ import {
  PagedGatewayResponse,
  PagedMixDelegationsResponse,
  PagedMixnodeResponse,
-  RewardingIntervalResponse,
  RewardingStatus,
 } from './types';

@@ -79,12 +78,6 @@ export default class NymdQuerier implements INymdQuery {
    });
  }

-  getCurrentRewardingInterval(mixnetContractAddress: string): Promise<RewardingIntervalResponse> {
-    return this.client.queryContractSmart(mixnetContractAddress, {
-      current_rewarding_interval: {},
-    });
-  }
-
  getAllNetworkDelegationsPaged(
    mixnetContractAddress: string,
    limit?: number,
@@ -155,9 +148,9 @@ export default class NymdQuerier implements INymdQuery {
    });
  }

-  getEpochRewardPercent(mixnetContractAddress: string): Promise<number> {
+  getIntervalRewardPercent(mixnetContractAddress: string): Promise<number> {
    return this.client.queryContractSmart(mixnetContractAddress, {
-      get_epoch_reward_percent: {},
+      get_interval_reward_percent: {},
    });
  }

@@ -28,7 +28,6 @@ import {
  PagedGatewayResponse,
  PagedMixDelegationsResponse,
  PagedMixnodeResponse,
-  RewardingIntervalResponse,
  RewardingStatus,
 } from './types';
 import ValidatorApiQuerier, { IValidatorApiQuery } from './validator-api-querier';
@@ -63,7 +62,6 @@ export interface INymdQuery {
  ownsMixNode(mixnetContractAddress: string, address: string): Promise<MixOwnershipResponse>;
  ownsGateway(mixnetContractAddress: string, address: string): Promise<GatewayOwnershipResponse>;
  getStateParams(mixnetContractAddress: string): Promise<ContractStateParams>;
-  getCurrentRewardingInterval(mixnetContractAddress: string): Promise<RewardingIntervalResponse>;

  getAllNetworkDelegationsPaged(
    mixnetContractAddress: string,
@@ -87,7 +85,7 @@ export interface INymdQuery {
  getLayerDistribution(mixnetContractAddress: string): Promise<LayerDistribution>;
  getRewardPool(mixnetContractAddress: string): Promise<string>;
  getCirculatingSupply(mixnetContractAddress: string): Promise<string>;
-  getEpochRewardPercent(mixnetContractAddress: string): Promise<number>;
+  getIntervalRewardPercent(mixnetContractAddress: string): Promise<number>;
  getSybilResistancePercent(mixnetContractAddress: string): Promise<number>;
  getRewardingStatus(
    mixnetContractAddress: string,
@@ -138,10 +136,6 @@ export default class QueryClient extends CosmWasmClient implements IQueryClient
    return this.nymdQuerier.getStateParams(mixnetContractAddress);
  }

-  getCurrentRewardingInterval(mixnetContractAddress: string): Promise<RewardingIntervalResponse> {
-    return this.nymdQuerier.getCurrentRewardingInterval(mixnetContractAddress);
-  }
-
  getAllNetworkDelegationsPaged(
    mixnetContractAddress: string,
    limit?: number,
@@ -184,8 +178,8 @@ export default class QueryClient extends CosmWasmClient implements IQueryClient
    return this.nymdQuerier.getCirculatingSupply(mixnetContractAddress);
  }

-  getEpochRewardPercent(mixnetContractAddress: string): Promise<number> {
-    return this.nymdQuerier.getEpochRewardPercent(mixnetContractAddress);
+  getIntervalRewardPercent(mixnetContractAddress: string): Promise<number> {
+    return this.nymdQuerier.getIntervalRewardPercent(mixnetContractAddress);
  }

  getSybilResistancePercent(mixnetContractAddress: string): Promise<number> {
@@ -31,7 +31,6 @@ import {
  PagedGatewayResponse,
  PagedMixDelegationsResponse,
  PagedMixnodeResponse,
-  RewardingIntervalResponse,
  RewardingStatus,
 } from './types';
 import ValidatorApiQuerier from './validator-api-querier';
@@ -178,6 +177,13 @@ export interface ISigningClient extends IQueryClient, ICosmWasmSigning, INymSign
    memo?: string,
  ): Promise<ExecuteResult>;

+  updateMixnodeConfig(
+    mixnetContractAddress: string,
+    mixIdentity: string,
+    profitMarginPercent: number,
+    fee: StdFee | 'auto' | number,
+  ): Promise<ExecuteResult>;
+
  updateContractStateParams(
    mixnetContractAddress: string,
    newParams: ContractStateParams,
@@ -250,10 +256,6 @@ export default class SigningClient extends SigningCosmWasmClient implements ISig
    return this.nymdQuerier.getStateParams(mixnetContractAddress);
  }

-  getCurrentRewardingInterval(mixnetContractAddress: string): Promise<RewardingIntervalResponse> {
-    return this.nymdQuerier.getCurrentRewardingInterval(mixnetContractAddress);
-  }
-
  getAllNetworkDelegationsPaged(
    mixnetContractAddress: string,
    limit?: number,
@@ -296,8 +298,8 @@ export default class SigningClient extends SigningCosmWasmClient implements ISig
    return this.nymdQuerier.getCirculatingSupply(mixnetContractAddress);
  }

-  getEpochRewardPercent(mixnetContractAddress: string): Promise<number> {
-    return this.nymdQuerier.getEpochRewardPercent(mixnetContractAddress);
+  getIntervalRewardPercent(mixnetContractAddress: string): Promise<number> {
+    return this.nymdQuerier.getIntervalRewardPercent(mixnetContractAddress);
  }

  getSybilResistancePercent(mixnetContractAddress: string): Promise<number> {
@@ -448,6 +450,20 @@ export default class SigningClient extends SigningCosmWasmClient implements ISig
    );
  }

+  updateMixnodeConfig(
+    mixnetContractAddress: string,
+    mixIdentity: string,
+    profitMarginPercent: number,
+    fee: StdFee | 'auto' | number,
+  ): Promise<ExecuteResult> {
+    return this.execute(
+      this.clientAddress,
+      mixnetContractAddress,
+      { update_mixnode_config: { profit_margin_percent: profitMarginPercent, mix_identity: mixIdentity } },
+      fee,
+    );
+  }
+
  updateContractStateParams(
    mixnetContractAddress: string,
    newParams: ContractStateParams,
@@ -1,8 +1,14 @@
 import axios from 'axios';
 import { GasPrice } from '@cosmjs/stargate';

+const mainnetPrefix = 'n';
+const mainnetDenom = 'nym';
+
 export function nymGasPrice(prefix: string): GasPrice {
  if (typeof prefix === 'string') {
+    if (prefix === mainnetPrefix) {
+      prefix = mainnetDenom;
+    }
    return GasPrice.fromString(`0.025u${prefix}`); // TODO: ideally this ugly conversion shouldn't be hardcoded here.
  }
  else {
@@ -43,12 +43,6 @@ export type ContractStateParams = {
  mixnode_active_set_size: number;
 };

-export type RewardingIntervalResponse = {
-  current_rewarding_interval_starting_block: number;
-  current_rewarding_interval_nonce: number;
-  rewarding_in_progress: boolean;
-};
-
 export type LayerDistribution = {
  gateways: number;
  layer1: number;
@@ -135,6 +129,7 @@ export type MixNode = {
  sphinx_key: string;
  identity_key: string;
  version: string;
+  profit_margin_percent: number;
 };

 export type GatewayBond = {
@@ -1,92 +0,0 @@
-import validatorClient from "../../src/index";
-import { config } from '../test-utils/config';
-
-let client: validatorClient;
-let mnemonic: string;
-
-beforeEach(async () => {
-    mnemonic = validatorClient.randomMnemonic();
-    client = await validatorClient.connect(
-        mnemonic,
-        config.NYMD_URL as string,
-        config.VALIDATOR_API as string,
-        config.CURRENCY_PREFIX as string,
-        config.MIXNET_CONTRACT as string,
-        config.VESTING_CONTRACT as string
-    );
-});
-
-//todos
-//we want to mock the majority of these tests
-//and keep a few integration tests in place
-
-describe("connect to the nym validator client and perform integration tests against the current testnet", () => {
-    test("get cached mixnodes", async () => {
-        try {
-            const response = await client.getCachedMixnodes();
-            //expect all mixnodes to have their owner address
-            response.forEach(mixnodeDetails => {
-                expect(mixnodeDetails.owner).toHaveLength(43)
-            });
-        }
-        catch (e) {
-            console.log(e);
-        }
-    });
-
-    test("get balance of address and denom of the network", async () => {
-        try {
-            //provide a users address and get their balance
-            //we expect their balance to be zero, as it's a new account
-            const address = await validatorClient.mnemonicToAddress(mnemonic, config.CURRENCY_PREFIX as string);
-            const response = await client.getBalance(address);
-            expect(response.amount).toStrictEqual("0");
-            expect(response.denom).toBe("unymt");
-        }
-        catch (e) {
-            console.log(e);
-        }
-    });
-
-    test("get minimium pledge amount for a mixnode", async () => {
-        try {
-            const response = await client.minimumMixnodePledge();
-            expect(response.amount).toBe("100000000");
-            expect(response.denom).toBe(config.CURRENCY_PREFIX as string);
-        }
-        catch (e) {
-            console.log(e);
-        }
-    });
-
-    test("get minimium gateway pledge amount", async () => {
-        try {
-            const response = await client.minimumGatewayPledge();
-            expect(response.amount).toBe("100000000");
-            expect(response.denom).toBe(config.CURRENCY_PREFIX as string);
-        }
-        catch (e) {
-            console.log(e);
-        }
-    });
-
-    test("get current mixnet contract address", () => {
-        try {
-            const response = client.mixnetContract;
-            expect(response).toStrictEqual(config.MIXNET_CONTRACT as string)
-        }
-        catch (e) {
-            console.log(e);
-        }
-    });
-
-    test("get current vesting contract address", () => {
-        try {
-            const response = client.vestingContract;
-            expect(response).toStrictEqual(config.VESTING_CONTRACT as string)
-        }
-        catch (e) {
-            console.log(e);
-        }
-    });
-});
@@ -0,0 +1,201 @@
+import validator from "../../src/index";
+import { ExecuteResult } from "@cosmjs/cosmwasm-stargate";
+import { config } from "../test-utils/config";
+import {buildCoin, buildWallet, profitPercentage} from "../test-utils/utils"
+import {
+  Gateway,
+  GatewayOwnershipResponse,
+  MixNode,
+  MixOwnershipResponse,
+} from "../../src/types";
+
+let response: ExecuteResult;
+let validatorClient: validator;
+let ownsMixNode: MixOwnershipResponse;
+let ownsGateway: GatewayOwnershipResponse;
+
+beforeEach(async () => {
+  validatorClient = await validator.connect(
+    config.USER_MNEMONIC,
+    config.NYMD_URL,
+    config.VALIDATOR_API,
+    config.NETWORK_BECH,
+    config.MIXNET_CONTRACT,
+    config.VESTING_CONTRACT
+  );
+});
+
+describe("long running e2e tests", () => {
+  test.skip("token transfer", async () => {
+    try {
+      //make sure there's enough balance in the wallet
+      
+      let coin = buildCoin("50000", "nymt");
+      let userAddress = await buildWallet();
+      let send = await validatorClient.send(
+        userAddress,
+        Array(coin),
+        "auto",
+        "send-tokens"
+      );
+      let jsonParse = JSON.parse(send.rawLog as string);
+
+      //check successful network broadcast - via events
+      //1 - get key attributes values for sender an assert them
+      //2 - get key attributes for receiver assert they match
+      //3 - transaction hash present  in response
+
+      // { array of events -> attribute -> event information }
+      expect(jsonParse[0].events[1].attributes[1].value).toStrictEqual(
+        config.USER_WALLET_ADDRESS
+      );
+      expect(jsonParse[0].events[1].attributes[0].value).toStrictEqual(
+        userAddress
+      );
+      expect(jsonParse[0].events[1].type).toStrictEqual(
+        "transfer"
+      );
+      expect(send.transactionHash).toStrictEqual(expect.any(String));
+    } catch (error) {
+      throw error;
+    }
+  });
+
+  test.skip("update mixnode profit percentage", async () => {
+      const nodeIdentity = config.MIXNODE_IDENTITY;
+      const profitPercent = profitPercentage();
+
+      try {
+          //use auto fees - simulated gas
+          response = await validatorClient.updateMixnodeConfig(nodeIdentity, 'auto', profitPercent);
+      }
+      catch (error) {
+          throw error;
+      }
+      try {
+          ownsMixNode = await validatorClient.client.ownsMixNode(config.MIXNET_CONTRACT, config.USER_WALLET_ADDRESS);
+      }
+      catch (error) {
+          throw error;
+      }
+      expect(ownsMixNode.mixnode?.mix_node.profit_margin_percent).toStrictEqual(profitPercent);
+  });
+
+  test.skip("unbond and bond mixnode", async () => {
+
+      try {
+          await validatorClient.unbondMixNode("auto", "unbond-mixnode");
+      }
+      catch (error) {
+          throw error;
+      }
+
+      const profitPercent = profitPercentage();
+
+      const mixnodeDetails = <MixNode>{
+          host: config.MIXNODE_HOST,
+          mix_port: 1789,
+          verloc_port: 1790,
+          http_api_port: 8080,
+          identity_key: config.MIXNODE_IDENTITY,
+          sphinx_key: config.MIXNODE_SPHINX_KEY,
+          version: config.MIXNODE_VERSION,
+          profit_margin_percent: profitPercent
+      };
+
+      const bond = buildCoin("100000000", config.CURRENCY_DENOM)
+
+      try {
+          response = await validatorClient.bondMixNode(
+              mixnodeDetails,
+              config.MIXNODE_SIGNATURE,
+              bond,
+              "auto"
+          );
+      }
+      catch (error) {
+          throw error;
+      }
+
+      ownsMixNode = await validatorClient.client.ownsMixNode(config.MIXNET_CONTRACT, config.USER_WALLET_ADDRESS);
+      expect(ownsMixNode.mixnode?.mix_node.profit_margin_percent).toStrictEqual(profitPercent);
+  });
+
+  test.skip("unbond and bond gateway", async () => {
+      //gateway requires different user wallet
+      //init inside test
+      //todo 
+
+      try {
+          await validatorClient.unbondGateway("auto", "unbonding gateway");
+      }
+      catch (error) {
+          throw error;
+      }
+
+      const gateway = <Gateway>{
+          host: config.GATEWAY_HOST,
+          mix_port: 1789,
+          clients_port: 9000,
+          version: config.GATEWAY_VERSION,
+          sphinx_key: config.GATEWAY_SPHINX,
+          identity_key: config.GATEWAY_IDENTITY,
+          location: "earth"
+      };
+
+      const bond = buildCoin("100000000", config.CURRENCY_DENOM)
+
+      try {
+          response = await validatorClient.bondGateway(
+              gateway,
+              config.GATEWAY_SIGNATURE,
+              bond,
+              "auto"
+          );
+      }
+      catch (error) {
+          throw error;
+      }
+      ownsGateway = await validatorClient.client.ownsGateway(config.MIXNET_CONTRACT, config.USER_WALLET_ADDRESS);
+      expect(ownsGateway.gateway?.bond_amount).toStrictEqual(bond.amount);
+      expect(ownsGateway.address).toStrictEqual(config.USER_WALLET_ADDRESS);
+  });
+
+  test.skip("delegate to mixnode, then undelegate", async () => {
+
+      const pledge = buildCoin("100000000", config.CURRENCY_DENOM)
+
+      try {
+          response = await validatorClient.delegateToMixNode(
+              config.MIXNODE_IDENTITY,
+              pledge,
+              "auto"
+          );
+          //todo - we can assert the events for responses
+          response.logs.forEach((log) => {
+              console.log(log.events);
+              console.log(log.log);
+              console.log(log.msg_index);
+          })
+      }
+      catch (error) {
+          throw error;
+      }
+      try {
+          const unbond = await validatorClient.undelegateFromMixNode(
+              config.MIXNODE_IDENTITY,
+              "auto"
+          );
+
+        //todo - we can assert the events for responses
+          unbond.logs.forEach((logs) => {
+              logs.events.forEach((events) => {
+                  console.log(events.type);
+                  console.log(events.attributes);
+              })
+          });
+      } catch (error) {
+          throw error;
+      }
+  });
+});
@@ -1,66 +0,0 @@
-import SigningClient from '../../src/signing-client';
-import validator from "../../src/index";
-import { CosmWasmClient } from '@cosmjs/cosmwasm-stargate';
-import { DirectSecp256k1HdWallet } from '@cosmjs/proto-signing';
-import { config } from '../test-utils/config';
-
-let cosmWasmClient: CosmWasmClient;
-let signingClient: SigningClient;
-let mnemonic: string;
-
-beforeEach(async () => {
-    cosmWasmClient = await SigningClient.connect(config.NYMD_URL as string);
-    
-    mnemonic = validator.randomMnemonic();
-    const wallet = await DirectSecp256k1HdWallet.fromMnemonic(mnemonic)
-    signingClient = await SigningClient.connectWithNymSigner(
-        wallet,
-        config.NYMD_URL as string,
-        config.VALIDATOR_API as string,
-        config.CURRENCY_PREFIX as string);
-});
-
-describe("alternate between the signing clients of nym and perform basic requests", () => {
-    test("retrieve balance using the cosmwasm client", async () => {
-        try {
-            const randomAddress = await validator.mnemonicToAddress(mnemonic, config.CURRENCY_PREFIX as string);
-            const balance  = await cosmWasmClient.getBalance(randomAddress, config.CURRENCY_PREFIX as string);
-            expect(balance.denom).toStrictEqual(config.CURRENCY_PREFIX as string);
-            expect(balance.amount).toStrictEqual("0");
-        }
-        catch (e) {
-            console.log(e);
-        }
-    });
-    test("get the chain id of the network", async () => {
-        try {
-            //pass these values in environment variables in the future
-            const chainId = await cosmWasmClient.getChainId();
-            expect(chainId).toStrictEqual(config.CHAIN_ID as string);
-        }
-        catch (e) {
-            console.log(e);
-        }
-    });
-    test("get height then search its block", async () => {
-        try {
-            const height = await cosmWasmClient.getHeight()
-            const block = await cosmWasmClient.getBlock(height);
-            expect(block.header.chainId).toStrictEqual(config.CHAIN_ID as string);
-            expect(block.header.height).toStrictEqual(height);
-        }
-        catch (e) {
-            console.log(e);
-        }
-    });
-    test("get current reward pool", async () => {
-        try {
-            //this is due to change due to when rewards get distributed
-            const rewards = await signingClient.getRewardPool(config.MIXNET_CONTRACT as string);
-            expect(rewards).toStrictEqual("250000000000000");
-        }
-        catch (e) {
-            console.log(e);
-        }
-    });
-});
@@ -1,70 +0,0 @@
-import ValidatorApiQuerier from '../../src/validator-api-querier';
-import { config } from '../test-utils/config';
-import { now, elapsed} from '../test-utils/utils';
-
-let client: ValidatorApiQuerier;
-
-beforeEach(() => {
-    client = new ValidatorApiQuerier(config.VALIDATOR_API as string);
-});
-
-//todos
-//we want to mock the majority of these tests
-//and keep a few integration tests in place
-
-describe("call out to the validator api and run queries", () => {
-    test.skip("build client and get all mixnodes", async () => {
-        try {
-            //this test was currently ran against a set of prefix data
-            //this will change
-            const ownerAddress = "nymt1ydqkmz0ddpvkd3l0vyf8k5xjrqtcnxxvhlpdsr";
-            let response = await client.getActiveMixnodes();
-            expect(response[0].owner).toStrictEqual(ownerAddress);
-        }
-        catch (e) {
-            console.log(e);
-        }
-    });
-
-    test("get rewarded mixnodes", async () => {
-        try {
-            // we assume that all mixnodes will have their owners address
-            // also active sets will determine rewarded mixnodes
-            let response = await client.getRewardedMixnodes();
-
-            response.forEach(rNode => {
-                expect(rNode.owner.length).toStrictEqual(43);
-            })
-        }
-        catch (e) {
-            console.log(e);
-        }
-    });
-
-    test("get cached gateways and it should be six", async () => {
-        try {
-            //current gateways running in sandbox-testnet 6
-            let response = await client.getCachedGateways();
-            expect(response.length).toStrictEqual(6);
-        }
-        catch (e) {
-            console.log(e);
-        }
-    });
-
-
-    test("get cached mixnodes", async () => {
-        try {
-            const start = now();
-            let response = await client.getCachedMixnodes();
-            response.forEach(mixnode => {
-                expect(mixnode.owner.length).toStrictEqual(43);
-            })
-            console.log(elapsed(start, true));
-        }
-        catch (e) {
-            console.log(e);
-        }
-    });
-});
-
@@ -0,0 +1,46 @@
+import { Mock, Times } from "moq.ts";
+import { Block, BlockHeader } from "@cosmjs/stargate";
+import { CosmWasmClient } from "@cosmjs/cosmwasm-stargate";
+
+describe("implement cosmwasm client test", () => {
+  test.only("get height of a block then search for it", async () => {
+    let height = Promise.resolve(200);
+
+    let blockHeader = <BlockHeader>{
+      version: {
+        block: "200",
+        app: "testing",
+      },
+      height: 200,
+      chainId: "nym",
+      time: "today",
+    };
+
+    let block = Promise.resolve(<Block>{
+      header: blockHeader,
+      id: "test",
+      txs: [],
+    });
+
+    const getheight = new Mock<CosmWasmClient>()
+      .setup((nym) => nym.getHeight())
+      .returns(height);
+
+    const getblock = new Mock<CosmWasmClient>()
+      .setup((nym) => nym.getBlock(200))
+      .returns(block);
+
+    let heightC = getheight.object();
+    let blockC = getblock.object();
+
+    let executeHeight = await heightC.getHeight();
+    let executeBlock = await blockC.getBlock(200);
+
+    getheight.verify((nym) => nym.getHeight(), Times.Exactly(1));
+    getblock.verify((nym) => nym.getBlock(200), Times.Exactly(1));
+
+    expect(executeHeight).toStrictEqual(await height);
+    expect(executeBlock.header.height).toStrictEqual(await height);
+    expect(executeBlock.header.chainId).toStrictEqual("nym");
+  });
+});
@@ -0,0 +1,25 @@
+import { Mock, Times } from "moq.ts";
+import { INymdQuery } from "../../src/query-client";
+
+describe("nym-client mocks", () => {
+  test.only("gets interval rewarding percent", async () => {
+    let contract = "mixnet_contract";
+    let response = Promise.resolve(Number(2));
+
+    const client = new Mock<INymdQuery>()
+      .setup((nym) => nym.getIntervalRewardPercent(contract))
+      .returns(response);
+
+    const obj = client.object();
+
+    let execute = await obj.getIntervalRewardPercent(contract);
+
+    client.verify(
+      (nym) => nym.getIntervalRewardPercent(contract),
+      Times.Exactly(1)
+    );
+
+    expect(execute).toStrictEqual(await response);
+  });
+});
+
@@ -0,0 +1,176 @@
+import { Coin } from "@cosmjs/proto-signing";
+import { Mock, Times } from "moq.ts";
+import ValidatorClient from "../../src/index";
+import { Gateway, MixNode } from "../../src/types";
+import { config } from "../test-utils/config";
+import { buildWallet, buildCoin, profitPercentage } from "../test-utils/utils";
+import { promiseExecuteResult } from "../test-utils/expectedResults";
+import { promiseTxResult } from "../test-utils/expectedResults"
+ 
+describe("mock validator client tests", () => {
+  test.skip("token transfer", async () => {
+
+    //arrange
+    //todo -- add more here
+    let recipientAddress = "nymt14ev4p8qaa7ayr06cg3z7y2u2kxc9a8f4h9gkch";
+    let sender = "nymt1cv59jumgvz2chn7ffst8tzvnapqzp282m5vat2";
+
+    const coin = buildCoin("50000", "nymt");
+
+    let transaction = promiseTxResult();
+
+    let mockClient = new Mock<ValidatorClient>()
+      .setup((nym) => nym.send(recipientAddress, [coin], "auto", "test")).returns(transaction);
+
+    let token = mockClient.object();
+
+    //act 
+    let response = await token.send(recipientAddress, [coin], "auto", "test");
+    
+    //assert
+    mockClient.verify(cl => cl.send(recipientAddress, [coin], "auto"), Times.Exactly(1));
+  });
+
+  test.only("bond mixnode test", async () => {
+    //arrange
+    let ownerSignature = "ownersignature";
+    let coin = buildCoin("50000", "nymt");
+    let expectedResult = promiseExecuteResult();
+
+    const profitPercent = profitPercentage();
+
+    const mixnode = <MixNode>{
+      host: "1.1.1.1",
+      mix_port: 1789,
+      verloc_port: 1790,
+      http_api_port: 8080,
+      identity_key: "identity",
+      sphinx_key: "identity",
+      version: "0.12.1",
+      profit_margin_percent: profitPercent,
+    };
+
+    let client = new Mock<ValidatorClient>()
+      .setup((client) =>
+        client.bondMixNode(mixnode, ownerSignature, coin, "auto")
+      )
+      .returns(expectedResult);
+
+    let mixnodeBond = client.object();
+
+    //act
+    let response = await mixnodeBond.bondMixNode(
+      mixnode,
+      ownerSignature,
+      coin,
+      "auto"
+    );
+    client.verify((cl) =>
+      cl.bondMixNode(mixnode, ownerSignature, coin, "auto")
+    );
+
+    //assert
+    expect(response.logs[0].log).toStrictEqual("test");
+    expect(response.transactionHash).toStrictEqual(
+      "9C7BF465AB5CAB0D62446CBB251CF89CD173A640C5DE8DBC14A4BB950916114E"
+    );
+  });
+
+  test.only("un-bond mixnode", async () => {
+    //arrange
+    let expectedResult = promiseExecuteResult();
+
+    let client = new Mock<ValidatorClient>()
+      .setup((client) => client.unbondMixNode("auto"))
+      .returns(expectedResult);
+
+    let unbondNode = client.object();
+
+    //act
+    let response = await unbondNode.unbondMixNode("auto");
+    client.verify((cl) => cl.unbondMixNode("auto"));
+
+    //assert
+    expect(response.logs[0].log).toStrictEqual("test");
+    expect(response.transactionHash).toStrictEqual(
+      "9C7BF465AB5CAB0D62446CBB251CF89CD173A640C5DE8DBC14A4BB950916114E"
+    );
+  });
+
+
+  test.only("bond gateway", async () => {
+    //arrange
+    let expectedResult = promiseExecuteResult();
+    let ownerSignature = "ownersigntature";
+    let coin = buildCoin("50000", "nymt");
+
+    const gateway = <Gateway>{
+      host: '1.2.3.4',
+      mix_port: 1789,
+      clients_port: 9000,
+      version: "0.12.1",
+      sphinx_key: "sphinx_key",
+      identity_key: "identity_key",
+      location: "earth"
+  };
+
+    let client = new Mock<ValidatorClient>()
+      .setup((client) => client.bondGateway(gateway, ownerSignature, coin, "auto", "memo"))
+      .returns(expectedResult);
+
+    let mock = client.object();
+
+    //act
+    let response = await mock.bondGateway(gateway, ownerSignature, coin, "auto", "memo");
+    client.verify((cl) => cl.bondGateway(gateway, ownerSignature, coin, "auto", "memo"));
+
+    //assert
+    expect(response.logs[0].log).toStrictEqual("test");
+    expect(response.transactionHash).toStrictEqual(
+      "9C7BF465AB5CAB0D62446CBB251CF89CD173A640C5DE8DBC14A4BB950916114E"
+    );
+  });
+
+  test.only("unbond gateway", async () => {
+    //arrange
+    let expectedResult = promiseExecuteResult();
+    let client = new Mock<ValidatorClient>()
+      .setup((client) => client.unbondGateway())
+      .returns(expectedResult);
+
+    let mock = client.object();
+
+    //act
+    let response = await mock.unbondGateway();
+    client.verify((cl) => cl.unbondGateway());
+
+    //assert
+    expect(response.logs[0].log).toStrictEqual("test");
+    expect(response.transactionHash).toStrictEqual(
+      "9C7BF465AB5CAB0D62446CBB251CF89CD173A640C5DE8DBC14A4BB950916114E"
+    );
+  });
+
+  test.only("retrieve a newly created account and the balance should be empty", async () => {
+    let nymWallet = await buildWallet();
+
+    let coin = Promise.resolve(<Coin>{
+      denom: `${config.CURRENCY_DENOM}`,
+      amount: "0",
+    });
+
+    let client = new Mock<ValidatorClient>()
+      .setup((nym) => nym.getBalance(nymWallet))
+      .returns(coin);
+
+    let obj = client.object();
+
+    let execute = await obj.getBalance(nymWallet);
+
+    client.verify((nym) => nym.getBalance(nymWallet), Times.Exactly(1));
+
+    expect(execute).toStrictEqual(await coin);
+  });
+});
+
+
@@ -1,9 +1,23 @@
 export const config = {
-    NYMD_URL: process.env.NYMD_URL,
-    VALIDATOR_API: process.env.VALIDATOR_API,
-    MIXNET_CONTRACT: process.env.MIXNET_CONTRACT,
-    VESTING_CONTRACT: process.env.MIXNET_CONTRACT,
-    USER_MNEMONIC: process.env.MNEMONIC,
-    CURRENCY_PREFIX: process.env.CURRENCY_PREFIX,
-    CHAIN_ID: process.env.CHAIN_ID
-}
+    NYMD_URL: process.env.NYMD_URL as string,
+    VALIDATOR_API: process.env.VALIDATOR_API as string,
+    MIXNET_CONTRACT: process.env.MIXNET_CONTRACT as string,
+    VESTING_CONTRACT: process.env.VESTING_CONTRACT as string,
+    USER_MNEMONIC: process.env.USER_MNEMONIC as string,
+    USER_WALLET_ADDRESS: process.env.USER_WALLET_ADDRESS as string,
+    CURRENCY_DENOM: process.env.CURRENCY_DENOM as string,
+    CHAIN_ID: process.env.CHAIN_ID as string,
+    MIXNODE_IDENTITY: process.env.MIXNODE_IDENTITY as string,
+    MIXNODE_SPHINX_KEY: process.env.MIXNODE_SPHINX_KEY as string,
+    MIXNODE_SIGNATURE: process.env.MIXNODE_SIGNATURE as string,
+    MIXNODE_HOST: process.env.MIXNODE_HOST as string,
+    MIXNODE_VERSION: process.env.MIXNODE_VERSION as string,
+    GATEWAY_IDENTITY: process.env.GATEWAY_IDENTITY as string,
+    GATEWAY_SIGNATURE: process.env.GATEWAY_SIGNATURE as string,
+    GATEWAY_SPHINX: process.env.GATEWAY_SPHINX as string,
+    GATEWAY_LOCATION: process.env.GATEWAY_LOCATION as string,
+    GATEWAY_HOST: process.env.GATEWAY_HOST as string,
+    GATEWAY_VERSION: process.env.GATEWAY_VERSION as string,
+    NETWORK_BECH: process.env.NETWORK_BECH as string,
+  };
+  
@@ -0,0 +1,27 @@
+import { ExecuteResult } from "@cosmjs/cosmwasm-stargate";
+import { DeliverTxResponse, logs } from "@cosmjs/stargate";
+
+export const promiseExecuteResult = (): Promise<ExecuteResult> => {
+  let log = <logs.Log>{
+    msg_index: 0,
+    log: "test",
+    events: [],
+  };
+  return Promise.resolve(<ExecuteResult>{
+    logs: [log],
+    transactionHash:
+      "9C7BF465AB5CAB0D62446CBB251CF89CD173A640C5DE8DBC14A4BB950916114E",
+  });
+};
+
+export const promiseTxResult = (): Promise<DeliverTxResponse> => {
+  return Promise.resolve(<DeliverTxResponse>{
+    code: 0,
+    height: 1208302,
+    rawLog: "[]",
+    transactionHash:
+      "9C7BF465AB5CAB0D62446CBB251CF89CD173A640C5DE8DBC14A4BB950916114E",
+    gasUsed: 65042,
+    gasWanted: 67977,
+  });
+};
@@ -1,17 +1,46 @@
 // timer actions
+
+import ValidatorClient, { Coin } from "../../src";
+import { config } from "./config";
+
 // Store current time as `start`
 export const now = (eventName = null) => {
    if (eventName) {
-        console.log(`Started ${eventName}..`);
+      console.log(`Started ${eventName}..`);
    }
    return new Date().getTime();
-}
-
-//takes arg of start time 
-export const elapsed = (beginning: number, log = false) => {
+  };
+  
+  //takes arg of start time
+  export const elapsed = (beginning: number, log = false) => {
    const duration = new Date().getTime() - beginning;
    if (log) {
-        console.log(`${duration / 1000}s`);
+      console.log(`${duration / 1000}s`);
    }
    return duration;
-}
+  };
+  
+  export const profitPercentage = (): number => {
+    return Math.floor(Math.random() * 100) + 1;
+  };
+  
+  
+  export const buildCoin = (amount: string, denomination: string): Coin => {
+    return {
+      denom: `u${denomination}`,
+      amount: amount,
+    };
+  };
+  
+  export const buildWallet = async (): Promise<string> => {
+      let mnemonic = ValidatorClient.randomMnemonic();
+     
+      const randomAddress = await ValidatorClient.buildWallet(
+        mnemonic,
+        config.NETWORK_BECH
+      );
+    let accountdetails = await randomAddress.getAccounts();
+    let nymWallet = accountdetails[0].address;
+    return nymWallet;
+  };
+  
@@ -1,10 +1,10 @@
-const currency = require('../../src/currency');
+const currency = require("../../src/currency");

-describe("provide unit tests around the the currency module", () => {
-    test.skip("convert to native balance", () => {
-        const decimal = "12.0346";
-        const value = currency.printableBalanceToNative(decimal);
-        expect(value).toStrictEqual("12034600");
-    });
+describe("currency module tests", () => {
+  test.skip("convert to native balance", () => {
+    const decimal = "12.0346";
+    const value = currency.printableBalanceToNative(decimal);
+
+    expect(value).toStrictEqual("12034600");
+  });
 });
-
@@ -1,27 +1,19 @@
 const stargate = require("../../src/stargate-helper");
-import { config } from '../test-utils/config';
+import { config } from "../test-utils/config";

-describe("test the stargate functions within the client", () => {
-    test("test that the gas price is returned correctly", () => {
-        const nymCurrency = config.CURRENCY_PREFIX as string;
-        const getGasPrice = stargate.nymGasPrice(nymCurrency);
-        expect(getGasPrice.denom).toBe(`u${nymCurrency}`);
-    });
+describe("test the stargate functions within the project", () => {
+  test.skip("gas price is returned correctly", () => {
+    const nymCurrency = config.CURRENCY_DENOM;
+    const getGasPrice = stargate.nymGasPrice(nymCurrency);

-    test("provide invalid type returns an error message", () => {
-        //pass invalid type
-        expect(() => {
-            const nymCurrency = 13;
-            stargate.nymGasPrice(nymCurrency);
-        }).toThrow("13 is not of type string");
-    });
+    expect(getGasPrice.denom).toBe(`u${nymCurrency}`);
+  });

-    //provide test for downloading wasm 
-    //mock this test  
-    // test.skip("providing nothing returns", async () => {
-    //     //pass invalid type
-    //     const downloadWasm = stargate.downloadWasm("http://localhost");
-    //     console.log(downloadWasm);
-    // })
+  test.skip("provide invalid type returns an error message", () => {
+    //pass invalid type
+    expect(() => {
+      const nymCurrency = 13;
+      stargate.nymGasPrice(nymCurrency);
+    }).toThrow("13 is not of type string");
+  });
 });
-
@@ -1,19 +1,10 @@
 import validator from "../../src/index";
-import { config } from '../test-utils/config';

-const NETWORK_DENOM = config.CURRENCY_PREFIX as string;
+describe("validator build network mnemonic", () => {
+  test.skip("get mnemonic", async () => {
+    const mnemonic = validator.randomMnemonic();
+    const mnemonicCount = mnemonic.split(" ").length;

-describe("perform basic interactions with the validator", () => {
-    test("build client and get all mixnodes", async () => {
-        const mnemonic = validator.randomMnemonic();
-        const mnemonicCount = mnemonic.split(" ").length;
-        expect(mnemonicCount).toStrictEqual(24);
-    });
-
-    test("build client and get all mixnodes", async () => {
-        const buildMnemonic = validator.randomMnemonic();
-        const mnemonic = await validator.mnemonicToAddress(buildMnemonic, NETWORK_DENOM);
-        expect(mnemonic).toHaveLength(43);
-        expect(mnemonic).toContain(NETWORK_DENOM);
-    });
+    expect(mnemonicCount).toStrictEqual(24);
+  });
 });
@@ -3149,6 +3149,13 @@ minimist@^1.2.0, minimist@^1.2.5:
  resolved "https://registry.npmjs.org/minimist/-/minimist-1.2.5.tgz"
  integrity sha512-FM9nNUYrRBAELZQT3xeZQ7fmMOBg6nWNmJKTcgsJeaLstP/UODVpGsr5OhXhhXg6f+qtJ8uiZ+PUxkDWcgIXLw==

+moq.ts@^7.3.4:
+  version "7.3.4"
+  resolved "https://registry.yarnpkg.com/moq.ts/-/moq.ts-7.3.4.tgz#982c3b195a54fd58c7a40a84e37a870374d15927"
+  integrity sha512-rOelPx7ns+RzyliPwHH2wFVqGowITKRQtECLvVKhiIt4oM4r2hYq4AmgQh0NpWlMxWl2fuZtPJhikrhVpAoF5g==
+  dependencies:
+    tslib "2.1.0"
+
 ms@2.0.0:
  version "2.0.0"
  resolved "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz"
@@ -3939,6 +3946,11 @@ tsconfig-paths@^3.12.0:
    minimist "^1.2.0"
    strip-bom "^3.0.0"

+tslib@2.1.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.1.0.tgz#da60860f1c2ecaa5703ab7d39bc05b6bf988b97a"
+  integrity sha512-hcVC3wYEziELGGmEEXue7D75zbwIIVUMWAVbHItGPx0ziyXxrOMQx4rQEVEV45Ut/1IotuEvwqPopzIOkDMf0A==
+
 tslib@^1.8.1:
  version "1.14.1"
  resolved "https://registry.npmjs.org/tslib/-/tslib-1.14.1.tgz"
@@ -2,7 +2,7 @@
 name = "nym-client-wasm"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>", "Jedrzej Stuczynski <andrew@nymtech.net>"]
 version = "0.12.0"
-edition = "2018"
+edition = "2021"
 keywords = ["nym", "sphinx", "wasm", "webassembly", "privacy", "client"]
 license = "Apache-2.0"
 repository = "https://github.com/nymtech/nym"
@@ -20,7 +20,7 @@ coconut = ["coconut-interface", "credentials", "gateway-client/coconut"]
 [dependencies]
 futures = "0.3"
 serde = { version = "1.0", features = ["derive"] }
-wasm-bindgen = { version = "0.2", features = ["serde-serialize"]  }
+wasm-bindgen = { version = "=0.2.78", features = ["serde-serialize"]  }
 wasm-bindgen-futures = "0.4"
 js-sys = "0.3"
 rand = { version = "0.7.3", features = ["wasm-bindgen"] }
@@ -32,7 +32,7 @@ credentials = { path = "../../common/credentials", optional = true }
 crypto = { path = "../../common/crypto" }
 nymsphinx = { path = "../../common/nymsphinx" }
 topology = { path = "../../common/topology" }
-gateway-client = { path = "../../common/client-libs/gateway-client" }
+gateway-client = { path = "../../common/client-libs/gateway-client", default-features = false, features = ["wasm"] }
 validator-client = { path = "../../common/client-libs/validator-client", default-features = false }
 wasm-utils = { path = "../../common/wasm-utils" }

@@ -22,7 +22,10 @@
        "webpack-dev-server": "^3.11.0"
      }
    },
-    "../pkg": {},
+    "../pkg": {
+      "name": "@nymproject/nym-client-wasm",
+      "version": "0.0.1"
+    },
    "node_modules/@nymproject/nym-client-wasm": {
      "resolved": "../pkg",
      "link": true
@@ -2351,9 +2354,9 @@
      }
    },
    "node_modules/follow-redirects": {
-      "version": "1.14.1",
-      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.14.1.tgz",
-      "integrity": "sha512-HWqDgT7ZEkqRzBvc2s64vSZ/hfOceEol3ac/7tKwzuvEyWx3/4UegXh5oBOIotkGsObyk3xznnSRVADBgWSQVg==",
+      "version": "1.14.8",
+      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.14.8.tgz",
+      "integrity": "sha512-1x0S9UVJHsQprFcEC/qnNzBLcIxsjAV905f/UkQxbclCsoTWlacCNOpQa/anodLl2uaEKFhfWOvM2Qg77+15zA==",
      "dev": true,
      "funding": [
        {
@@ -5859,9 +5862,9 @@
      }
    },
    "node_modules/url-parse": {
-      "version": "1.5.1",
-      "resolved": "https://registry.npmjs.org/url-parse/-/url-parse-1.5.1.tgz",
-      "integrity": "sha512-HOfCOUJt7iSYzEx/UqgtwKRMC6EU91NFhsCHMv9oM03VJcVo2Qrp8T8kI9D7amFf1cu+/3CEhgb3rF9zL7k85Q==",
+      "version": "1.5.7",
+      "resolved": "https://registry.npmjs.org/url-parse/-/url-parse-1.5.7.tgz",
+      "integrity": "sha512-HxWkieX+STA38EDk7CE9MEryFeHCKzgagxlGvsdS7WBImq9Mk+PGwiT56w82WI3aicwJA8REp42Cxo98c8FZMA==",
      "dev": true,
      "dependencies": {
        "querystringify": "^2.1.1",
@@ -6500,9 +6503,9 @@
      "dev": true
    },
    "node_modules/ws": {
-      "version": "6.2.1",
-      "resolved": "https://registry.npmjs.org/ws/-/ws-6.2.1.tgz",
-      "integrity": "sha512-GIyAXC2cB7LjvpgMt9EKS2ldqr0MTrORaleiOno6TweZ6r3TKtoFQWay/2PceJ3RuBasOHzXNn5Lrw1X0bEjqA==",
+      "version": "6.2.2",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-6.2.2.tgz",
+      "integrity": "sha512-zmhltoSR8u1cnDsD43TX59mzoMZsLKqUweyYBAIvTngR3shc0W6aOZylZmq/7hqyVxPdi+5Ud2QInblgyE72fw==",
      "dev": true,
      "dependencies": {
        "async-limiter": "~1.0.0"
@@ -8542,9 +8545,9 @@
      }
    },
    "follow-redirects": {
-      "version": "1.14.1",
-      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.14.1.tgz",
-      "integrity": "sha512-HWqDgT7ZEkqRzBvc2s64vSZ/hfOceEol3ac/7tKwzuvEyWx3/4UegXh5oBOIotkGsObyk3xznnSRVADBgWSQVg==",
+      "version": "1.14.8",
+      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.14.8.tgz",
+      "integrity": "sha512-1x0S9UVJHsQprFcEC/qnNzBLcIxsjAV905f/UkQxbclCsoTWlacCNOpQa/anodLl2uaEKFhfWOvM2Qg77+15zA==",
      "dev": true
    },
    "for-in": {
@@ -11399,9 +11402,9 @@
      }
    },
    "url-parse": {
-      "version": "1.5.1",
-      "resolved": "https://registry.npmjs.org/url-parse/-/url-parse-1.5.1.tgz",
-      "integrity": "sha512-HOfCOUJt7iSYzEx/UqgtwKRMC6EU91NFhsCHMv9oM03VJcVo2Qrp8T8kI9D7amFf1cu+/3CEhgb3rF9zL7k85Q==",
+      "version": "1.5.7",
+      "resolved": "https://registry.npmjs.org/url-parse/-/url-parse-1.5.7.tgz",
+      "integrity": "sha512-HxWkieX+STA38EDk7CE9MEryFeHCKzgagxlGvsdS7WBImq9Mk+PGwiT56w82WI3aicwJA8REp42Cxo98c8FZMA==",
      "dev": true,
      "requires": {
        "querystringify": "^2.1.1",
@@ -8,7 +8,7 @@
    "@testing-library/react": "^9.5.0",
    "@testing-library/user-event": "^7.2.1",
    "bootstrap": "^4.5.0",
-    "node-sass": "^4.14.1",
+    "node-sass": "^7.0.0",
    "react": "^16.13.1",
    "react-dom": "^16.13.1",
    "react-scripts": "^4.0.0",
@@ -3,7 +3,6 @@

 use crypto::asymmetric::{encryption, identity};
 use futures::channel::mpsc;
-use gateway_client::bandwidth::BandwidthController;
 use gateway_client::GatewayClient;
 use nymsphinx::acknowledgements::AckKey;
 use nymsphinx::addressing::clients::Recipient;
@@ -111,7 +110,7 @@ impl NymClient {
        let testnet_mode = self.testnet_mode;

        #[cfg(feature = "coconut")]
-        let bandwidth_controller = Some(BandwidthController::new(
+        let bandwidth_controller = Some(gateway_client::bandwidth::BandwidthController::new(
            vec![self.validator_server.clone()],
            *self.identity.public_key(),
        ));
@@ -128,6 +127,7 @@ impl NymClient {
            gateway.clients_address(),
            Arc::clone(&client.identity),
            gateway.identity_key,
+            gateway.owner.clone(),
            None,
            mixnet_messages_sender,
            ack_sender,
@@ -1,7 +1,7 @@
 [package]
 name = "bandwidth-claim-contract"
 version = "0.1.0"
-edition = "2018"
+edition = "2021"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

@@ -2,7 +2,7 @@
 name = "gateway-client"
 version = "0.1.0"
 authors = ["Jędrzej Stuczyński <andrew@nymtech.net>"]
-edition = "2018"
+edition = "2021"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

@@ -15,12 +15,15 @@ log = "0.4"
 thiserror = "1.0"
 url = "2.2"
 rand = { version = "0.7.3", features = ["wasm-bindgen"] }
+secp256k1 = "0.20.3"
+web3 = { version = "0.17.0", default-features = false }

 # internal
 credentials = { path = "../../credentials" }
 crypto = { path = "../../crypto" }
 gateway-requests = { path = "../../../gateway/gateway-requests" }
 nymsphinx = { path = "../../nymsphinx" }
+pemstore = { path = "../../pemstore" }
 coconut-interface = { path = "../../coconut-interface", optional = true }
 network-defaults = { path = "../../network-defaults" }

@@ -36,12 +39,6 @@ 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"
@@ -70,4 +67,6 @@ features = ["js"]
 #url = "2.1"

 [features]
-coconut = ["gateway-requests/coconut", "coconut-interface"]
+coconut = ["gateway-requests/coconut", "coconut-interface"]
+wasm = ["web3/wasm", "web3/http", "web3/signing"]
+default = ["web3/default"]
@@ -16,22 +16,27 @@ use crypto::asymmetric::identity::PublicKey;
 use network_defaults::BANDWIDTH_VALUE;
 #[cfg(not(feature = "coconut"))]
 use network_defaults::{
-    eth_contract::ETH_JSON_ABI, ETH_BURN_FUNCTION_NAME, ETH_CONTRACT_ADDRESS, ETH_MIN_BLOCK_DEPTH,
-    TOKENS_TO_BURN,
+    eth_contract::ETH_ERC20_JSON_ABI, eth_contract::ETH_JSON_ABI, ETH_BURN_FUNCTION_NAME,
+    ETH_CONTRACT_ADDRESS, ETH_ERC20_APPROVE_FUNCTION_NAME, ETH_ERC20_CONTRACT_ADDRESS,
+    ETH_MIN_BLOCK_DEPTH, TOKENS_TO_BURN, UTOKENS_TO_BURN,
 };
 #[cfg(not(feature = "coconut"))]
+use pemstore::traits::PemStorableKeyPair;
+#[cfg(not(feature = "coconut"))]
 use rand::rngs::OsRng;
 #[cfg(not(feature = "coconut"))]
 use secp256k1::SecretKey;
 #[cfg(not(feature = "coconut"))]
-use std::io::Write;
+use std::io::{Read, Write};
 #[cfg(not(feature = "coconut"))]
 use std::str::FromStr;
 #[cfg(not(feature = "coconut"))]
 use web3::{
    contract::{Contract, Options},
+    ethabi::Token,
+    signing::{Key, SecretKeyRef},
    transports::Http,
-    types::{Address, Bytes, U256, U64},
+    types::{Address, U256, U64},
    Web3,
 };

@@ -50,6 +55,19 @@ pub fn eth_contract(web3: Web3<Http>) -> Contract<Http> {
    .expect("Invalid json abi")
 }

+#[cfg(not(feature = "coconut"))]
+pub fn eth_erc20_contract(web3: Web3<Http>) -> Contract<Http> {
+    Contract::from_json(
+        web3.eth(),
+        Address::from(ETH_ERC20_CONTRACT_ADDRESS),
+        json::parse(ETH_ERC20_JSON_ABI)
+            .expect("Invalid json abi")
+            .dump()
+            .as_bytes(),
+    )
+    .expect("Invalid json abi")
+}
+
 #[derive(Clone)]
 pub struct BandwidthController {
    #[cfg(feature = "coconut")]
@@ -59,6 +77,8 @@ pub struct BandwidthController {
    #[cfg(not(feature = "coconut"))]
    contract: Contract<Http>,
    #[cfg(not(feature = "coconut"))]
+    erc20_contract: Contract<Http>,
+    #[cfg(not(feature = "coconut"))]
    eth_private_key: SecretKey,
    #[cfg(not(feature = "coconut"))]
    backup_bandwidth_token_keys_dir: std::path::PathBuf,
@@ -84,12 +104,14 @@ impl BandwidthController {
            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 contract = eth_contract(web3.clone());
+        let erc20_contract = eth_erc20_contract(web3);
        let eth_private_key = secp256k1::SecretKey::from_str(&eth_private_key)
            .map_err(|_| GatewayClientError::InvalidEthereumPrivateKey)?;

        Ok(BandwidthController {
            contract,
+            erc20_contract,
            eth_private_key,
            backup_bandwidth_token_keys_dir,
        })
@@ -107,6 +129,45 @@ impl BandwidthController {
        Ok(())
    }

+    #[cfg(not(feature = "coconut"))]
+    fn restore_keypair(&self) -> Result<identity::KeyPair, GatewayClientError> {
+        std::fs::create_dir_all(&self.backup_bandwidth_token_keys_dir)?;
+        let file = std::fs::read_dir(&self.backup_bandwidth_token_keys_dir)?
+            .find(|entry| {
+                entry
+                    .as_ref()
+                    .map(|entry| entry.path().is_file())
+                    .unwrap_or(false)
+            })
+            .unwrap_or_else(|| Err(std::io::Error::from(std::io::ErrorKind::NotFound)))?;
+        let file_path = file.path();
+        let pub_key = file_path
+            .file_name()
+            .ok_or_else(|| std::io::Error::from(std::io::ErrorKind::NotFound))?
+            .to_str()
+            .ok_or_else(|| std::io::Error::from(std::io::ErrorKind::NotFound))?;
+        let mut priv_key = vec![];
+        std::fs::File::open(file_path.clone())?.read_to_end(&mut priv_key)?;
+        Ok(identity::KeyPair::from_keys(
+            identity::PrivateKey::from_bytes(&priv_key).unwrap(),
+            identity::PublicKey::from_base58_string(pub_key).unwrap(),
+        ))
+    }
+
+    #[cfg(not(feature = "coconut"))]
+    fn mark_keypair_as_spent(&self, keypair: &identity::KeyPair) -> Result<(), GatewayClientError> {
+        let mut spent_dir = self.backup_bandwidth_token_keys_dir.clone();
+        spent_dir.push("spent");
+        std::fs::create_dir_all(&spent_dir)?;
+        let file_path_old = self
+            .backup_bandwidth_token_keys_dir
+            .join(keypair.public_key().to_base58_string());
+        let file_path_new = spent_dir.join(keypair.public_key().to_base58_string());
+        std::fs::rename(file_path_old, file_path_new)?;
+
+        Ok(())
+    }
+
    #[cfg(feature = "coconut")]
    pub async fn prepare_coconut_credential(
        &self,
@@ -145,17 +206,25 @@ impl BandwidthController {
    pub async fn prepare_token_credential(
        &self,
        gateway_identity: PublicKey,
+        gateway_owner: String,
    ) -> Result<TokenCredential, GatewayClientError> {
-        let mut rng = OsRng;
-
-        let kp = identity::KeyPair::new(&mut rng);
-        self.backup_keypair(&kp)?;
+        let kp = match self.restore_keypair() {
+            Ok(kp) => kp,
+            Err(_) => {
+                let mut rng = OsRng;
+                let kp = identity::KeyPair::new(&mut rng);
+                self.backup_keypair(&kp)?;
+                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)
+        self.buy_token_credential(verification_key, signed_verification_key, gateway_owner)
            .await?;

+        self.mark_keypair_as_spent(&kp)?;
+
        let message: Vec<u8> = verification_key
            .to_bytes()
            .iter()
@@ -177,33 +246,114 @@ impl BandwidthController {
        &self,
        verification_key: PublicKey,
        signed_verification_key: identity::Signature,
+        gateway_owner: String,
    ) -> 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
+        // 15 seconds per confirmation block + 10 seconds of network overhead + 20 seconds of wait for kill
        log::info!(
            "Waiting for Ethereum transaction. This should take about {} seconds",
-            confirmations * 15 + 10
+            (confirmations + 1) * 15 + 30
        );
+        let mut options = Options::default();
+        let estimation = self
+            .erc20_contract
+            .estimate_gas(
+                ETH_ERC20_APPROVE_FUNCTION_NAME,
+                (
+                    Token::Address(Address::from(ETH_CONTRACT_ADDRESS)),
+                    Token::Uint(U256::from(UTOKENS_TO_BURN)),
+                ),
+                SecretKeyRef::from(&self.eth_private_key).address(),
+                options.clone(),
+            )
+            .await?;
+        options.gas = Some(estimation);
+        log::info!("Calling ERC20 approve in 10 seconds with an estimated gas of {}. Kill the process if you want to abort", estimation);
+        #[cfg(not(target_arch = "wasm32"))]
+        tokio::time::sleep(tokio::time::Duration::from_secs(10)).await;
+        #[cfg(target_arch = "wasm32")]
+        if let Err(err) = fluvio_wasm_timer::Delay::new(std::time::Duration::from_secs(10)).await {
+            log::error!(
+                "the timer has gone away while waiting for possible kill! - {}",
+                err
+            );
+        }
+        let recipt = self
+            .erc20_contract
+            .signed_call_with_confirmations(
+                ETH_ERC20_APPROVE_FUNCTION_NAME,
+                (
+                    Token::Address(Address::from(ETH_CONTRACT_ADDRESS)),
+                    Token::Uint(U256::from(UTOKENS_TO_BURN)),
+                ),
+                options,
+                1, // One confirmation is enough, as we'll be consuming the approved token next anyway
+                &self.eth_private_key,
+            )
+            .await?;
+        if Some(U64::from(0u64)) == recipt.status {
+            return Err(GatewayClientError::BurnTokenError(
+                web3::Error::InvalidResponse(format!(
+                    "Approve transaction status is 0 (failure): {:?}",
+                    recipt.logs,
+                )),
+            ));
+        } else {
+            log::info!(
+                "Approved {} tokens for bandwidth use on Ethereum",
+                TOKENS_TO_BURN
+            );
+        }
+
+        let mut options = Options::default();
+        let estimation = self
+            .contract
+            .estimate_gas(
+                ETH_BURN_FUNCTION_NAME,
+                (
+                    Token::Uint(U256::from(UTOKENS_TO_BURN)),
+                    Token::Uint(U256::from(&verification_key.to_bytes())),
+                    Token::Bytes(signed_verification_key.to_bytes().to_vec()),
+                    Token::String(gateway_owner.clone()),
+                ),
+                SecretKeyRef::from(&self.eth_private_key).address(),
+                options.clone(),
+            )
+            .await?;
+        options.gas = Some(estimation);
+        log::info!("Generating bandwidth on ETH contract in 10 seconds with an estimated gas of {}. \
+         Kill the process if you want to abort. Keep in mind that if you abort now, you'll still have \
+         some tokens approved for bandwidth spending from the previous action. \
+         If you don't want that, you'll need to manually decreaseAllowance to revert the approval.", estimation);
+        #[cfg(not(target_arch = "wasm32"))]
+        tokio::time::sleep(tokio::time::Duration::from_secs(10)).await;
+        #[cfg(target_arch = "wasm32")]
+        if let Err(err) = fluvio_wasm_timer::Delay::new(std::time::Duration::from_secs(10)).await {
+            log::error!(
+                "the timer has gone away while waiting for possible kill! - {}",
+                err
+            );
+        }
        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()),
+                    Token::Uint(U256::from(UTOKENS_TO_BURN)),
+                    Token::Uint(U256::from(&verification_key.to_bytes())),
+                    Token::Bytes(signed_verification_key.to_bytes().to_vec()),
+                    Token::String(gateway_owner),
                ),
-                Options::default(),
+                options,
                confirmations,
                &self.eth_private_key,
            )
            .await?;
-        if Some(U64::from(0)) == recipt.status {
+        if Some(U64::from(0u64)) == recipt.status {
            Err(GatewayClientError::BurnTokenError(
                web3::Error::InvalidResponse(format!(
                    "Transaction status is 0 (failure): {:?}",
@@ -236,6 +386,15 @@ mod tests {
        eth_contract(web3);
    }

+    #[test]
+    fn parse_erc20_contract() {
+        let transport =
+            Http::new("https://rinkeby.infura.io/v3/00000000000000000000000000000000").unwrap();
+        let web3 = web3::Web3::new(transport);
+        // test no panic occurs
+        eth_erc20_contract(web3);
+    }
+
    #[test]
    fn check_event_name_constant_against_abi() {
        let transport =
@@ -20,6 +20,7 @@ use gateway_requests::iv::IV;
 use gateway_requests::registration::handshake::{client_handshake, SharedKeys};
 use gateway_requests::{BinaryRequest, ClientControlRequest, ServerResponse};
 use log::*;
+use network_defaults::{REMAINING_BANDWIDTH_THRESHOLD, TOKENS_TO_BURN};
 use nymsphinx::forwarding::packet::MixPacket;
 use rand::rngs::OsRng;
 use std::convert::TryFrom;
@@ -44,6 +45,7 @@ pub struct GatewayClient {
    bandwidth_remaining: i64,
    gateway_address: String,
    gateway_identity: identity::PublicKey,
+    gateway_owner: String,
    local_identity: Arc<identity::KeyPair>,
    shared_key: Option<Arc<SharedKeys>>,
    connection: SocketState,
@@ -68,6 +70,7 @@ impl GatewayClient {
        gateway_address: String,
        local_identity: Arc<identity::KeyPair>,
        gateway_identity: identity::PublicKey,
+        gateway_owner: String,
        shared_key: Option<Arc<SharedKeys>>,
        mixnet_message_sender: MixnetMessageSender,
        ack_sender: AcknowledgementSender,
@@ -80,6 +83,7 @@ impl GatewayClient {
            bandwidth_remaining: 0,
            gateway_address,
            gateway_identity,
+            gateway_owner,
            local_identity,
            shared_key,
            connection: SocketState::NotConnected,
@@ -112,6 +116,7 @@ impl GatewayClient {
    pub fn new_init(
        gateway_address: String,
        gateway_identity: identity::PublicKey,
+        gateway_owner: String,
        local_identity: Arc<identity::KeyPair>,
        response_timeout_duration: Duration,
    ) -> Self {
@@ -129,6 +134,7 @@ impl GatewayClient {
            bandwidth_remaining: 0,
            gateway_address,
            gateway_identity,
+            gateway_owner,
            local_identity,
            shared_key: None,
            connection: SocketState::NotConnected,
@@ -548,6 +554,8 @@ impl GatewayClient {
            return self.try_claim_testnet_bandwidth().await;
        }

+        let _gateway_owner = self.gateway_owner.clone();
+
        #[cfg(feature = "coconut")]
        let credential = self
            .bandwidth_controller
@@ -560,7 +568,7 @@ impl GatewayClient {
            .bandwidth_controller
            .as_ref()
            .unwrap()
-            .prepare_token_credential(self.gateway_identity)
+            .prepare_token_credential(self.gateway_identity, _gateway_owner)
            .await?;

        #[cfg(feature = "coconut")]
@@ -584,15 +592,10 @@ impl GatewayClient {
            return Err(GatewayClientError::NotAuthenticated);
        }
        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,
-                ));
-            }
+            return Err(GatewayClientError::NotEnoughBandwidth(
+                self.estimate_required_bandwidth(&packets),
+                self.bandwidth_remaining,
+            ));
        }
        if !self.connection.is_established() {
            return Err(GatewayClientError::ConnectionNotEstablished);
@@ -659,15 +662,10 @@ impl GatewayClient {
            return Err(GatewayClientError::NotAuthenticated);
        }
        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,
-                ));
-            }
+            return Err(GatewayClientError::NotEnoughBandwidth(
+                mix_packet.sphinx_packet().len() as i64,
+                self.bandwidth_remaining,
+            ));
        }
        if !self.connection.is_established() {
            return Err(GatewayClientError::ConnectionNotEstablished);
@@ -737,6 +735,12 @@ impl GatewayClient {
        }
        let shared_key = self.perform_initial_authentication().await?;

+        if self.bandwidth_remaining < REMAINING_BANDWIDTH_THRESHOLD {
+            info!("Claiming more bandwidth for your tokens. This will use {} token(s) from your wallet. \
+            Stop the process now if you don't want that to happen.", TOKENS_TO_BURN);
+            self.claim_bandwidth().await?;
+        }
+
        // this call is NON-blocking
        self.start_listening_for_mixnet_messages()?;

@@ -8,7 +8,7 @@ use tungstenite::Error as WsError;
 #[cfg(target_arch = "wasm32")]
 use wasm_bindgen::JsValue;
 #[cfg(not(feature = "coconut"))]
-use web3::Error as Web3Error;
+use web3::{contract::Error as Web3ContractError, Error as Web3Error};

 #[derive(Debug, Error)]
 pub enum GatewayClientError {
@@ -27,13 +27,17 @@ pub enum GatewayClientError {
    NetworkErrorWasm(JsValue),

    #[cfg(not(feature = "coconut"))]
-    #[error("Could not backup keypair - {0}")]
+    #[error("Keypair IO error - {0}")]
    IOError(#[from] std::io::Error),

    #[cfg(not(feature = "coconut"))]
    #[error("Could not burn ERC20 token in Ethereum smart contract - {0}")]
    BurnTokenError(#[from] Web3Error),

+    #[cfg(not(feature = "coconut"))]
+    #[error("Could not run web3 contract - {0}")]
+    Web3ContractError(#[from] Web3ContractError),
+
    #[cfg(not(feature = "coconut"))]
    #[error("Invalid Ethereum private key")]
    InvalidEthereumPrivateKey,
@@ -2,7 +2,7 @@
 name = "mixnet-client"
 version = "0.1.0"
 authors = ["Jedrzej Stuczynski <andrew@nymtech.net>"]
-edition = "2018"
+edition = "2021"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

@@ -41,6 +41,17 @@ impl Config {
    }
 }

+pub trait SendWithoutResponse {
+    // Without response in this context means we will not listen for anything we might get back (not
+    // that we should get anything), including any possible io errors
+    fn send_without_response(
+        &mut self,
+        address: NymNodeRoutingAddress,
+        packet: SphinxPacket,
+        packet_mode: PacketMode,
+    ) -> io::Result<()>;
+}
+
 pub struct Client {
    conn_new: HashMap<NymNodeRoutingAddress, ConnectionSender>,
    config: Config,
@@ -186,10 +197,10 @@ impl Client {
            .await
        });
    }
+}

-    // without response in this context means we will not listen for anything we might get back
-    // (not that we should get anything), including any possible io errors
-    pub fn send_without_response(
+impl SendWithoutResponse for Client {
+    fn send_without_response(
        &mut self,
        address: NymNodeRoutingAddress,
        packet: SphinxPacket,
@@ -1,7 +1,7 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::client::{Client, Config};
+use crate::client::{Client, Config, SendWithoutResponse};
 use futures::channel::mpsc;
 use futures::StreamExt;
 use log::*;
@@ -4,4 +4,4 @@
 pub mod client;
 pub mod forwarder;

-pub use client::{Client, Config};
+pub use client::{Client, Config, SendWithoutResponse};
@@ -2,24 +2,26 @@
 name = "validator-client"
 version = "0.1.0"
 authors = ["Jędrzej Stuczyński <andrew@nymtech.net>"]
-edition = "2018"
+edition = "2021"
 rust-version = "1.56"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [dependencies]
 base64 = "0.13"
-mixnet-contract = { path="../../../common/mixnet-contract" }
-vesting-contract = { path="../../../contracts/vesting" }
-serde = { version="1", features=["derive"] }
+mixnet-contract-common = { path= "../../cosmwasm-smart-contracts/mixnet-contract" }
+vesting-contract-common = { path= "../../cosmwasm-smart-contracts/vesting-contract" }
+vesting-contract = { path = "../../../contracts/vesting" }
+serde = { version = "1", features = ["derive"] }
 serde_json = "1"
-reqwest = { version="0.11", features=["json"] }
+reqwest = { version = "0.11", features = ["json"] }
 thiserror = "1"
 log = "0.4"
 url = { version = "2.2", features = ["serde"] }

 coconut-interface = { path = "../../coconut-interface" }
 network-defaults = { path = "../../network-defaults" }
+validator-api-requests = { path = "../../../validator-api/validator-api-requests" }

 # required for nymd-client
 # at some point it might be possible to make it wasm-compatible
@@ -27,14 +29,29 @@ 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.3", features = ["rpc", "bip32", "cosmwasm"], optional = true }
-cosmrs = { git = "https://github.com/cosmos/cosmos-rust", rev="e5a1872083abb3d88fa62dda966e7f5408deba58", features = ["rpc", "bip32", "cosmwasm"], optional = true }
+cosmrs = { version = "0.4.1", 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 = { version = "1.0.0-beta3", optional = true }
-ts-rs = {version = "5.1", optional = true}
+# Leaving it as * so that it inherits whatever the wallet is using
+ts-rs = { version = "*", optional = true }

 [features]
-nymd-client = ["async-trait", "bip39", "config", "cosmrs", "prost", "flate2", "sha2", "itertools", "cosmwasm-std"]
+nymd-client = [
+    "async-trait",
+    "bip39",
+    "config",
+    "cosmrs",
+    "prost",
+    "flate2",
+    "sha2",
+    "itertools",
+    "cosmwasm-std",
+]
+typescript-types = ["ts-rs", "validator-api-requests/ts-rs"]
@@ -1,53 +1,69 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

+use crate::{validator_api, ValidatorClientError};
+use coconut_interface::{BlindSignRequestBody, BlindedSignatureResponse, VerificationKeyResponse};
+use mixnet_contract_common::{GatewayBond, IdentityKeyRef, MixNodeBond};
+use url::Url;
+use validator_api_requests::models::{
+    CoreNodeStatusResponse, MixnodeStatusResponse, RewardEstimationResponse,
+    StakeSaturationResponse,
+};
+
 #[cfg(feature = "nymd-client")]
 use crate::nymd::{
    error::NymdError, CosmWasmClient, NymdClient, QueryNymdClient, SigningNymdClient,
 };
 #[cfg(feature = "nymd-client")]
-use mixnet_contract::ContractStateParams;
+use mixnet_contract_common::ContractStateParams;

-use crate::{validator_api, ValidatorClientError};
-use coconut_interface::{BlindSignRequestBody, BlindedSignatureResponse, VerificationKeyResponse};
 #[cfg(feature = "nymd-client")]
-use mixnet_contract::{
-    Delegation, MixnetContractVersion, MixnodeRewardingStatusResponse, RewardingIntervalResponse,
+use mixnet_contract_common::{
+    Delegation, IdentityKey, Interval, MixnetContractVersion, MixnodeRewardingStatusResponse,
+    RewardedSetNodeStatus, RewardedSetUpdateDetails,
 };
-use mixnet_contract::{GatewayBond, MixNodeBond};
-
+#[cfg(feature = "nymd-client")]
+use std::collections::{HashMap, HashSet};
 #[cfg(feature = "nymd-client")]
 use std::str::FromStr;
-use url::Url;

 #[cfg(feature = "nymd-client")]
+#[must_use]
 pub struct Config {
+    network: network_defaults::all::Network,
    api_url: Url,
    nymd_url: Url,
    mixnet_contract_address: Option<cosmrs::AccountId>,
    vesting_contract_address: Option<cosmrs::AccountId>,
+    erc20_bridge_contract_address: Option<cosmrs::AccountId>,

    mixnode_page_limit: Option<u32>,
    gateway_page_limit: Option<u32>,
    mixnode_delegations_page_limit: Option<u32>,
+    rewarded_set_page_limit: Option<u32>,
 }

 #[cfg(feature = "nymd-client")]
 impl Config {
    pub fn new(
+        network: network_defaults::all::Network,
        nymd_url: Url,
        api_url: Url,
        mixnet_contract_address: Option<cosmrs::AccountId>,
        vesting_contract_address: Option<cosmrs::AccountId>,
+        erc20_bridge_contract_address: Option<cosmrs::AccountId>,
    ) -> Self {
        Config {
+            network,
            nymd_url,
            mixnet_contract_address,
            vesting_contract_address,
+            erc20_bridge_contract_address,
            api_url,
            mixnode_page_limit: None,
            gateway_page_limit: None,
            mixnode_delegations_page_limit: None,
+            rewarded_set_page_limit: None,
        }
    }

@@ -65,17 +81,25 @@ impl Config {
        self.mixnode_delegations_page_limit = limit;
        self
    }
+
+    pub fn with_rewarded_set_page_limit(mut self, limit: Option<u32>) -> Config {
+        self.rewarded_set_page_limit = limit;
+        self
+    }
 }

 #[cfg(feature = "nymd-client")]
 pub struct Client<C> {
+    network: network_defaults::all::Network,
    mixnet_contract_address: Option<cosmrs::AccountId>,
    vesting_contract_address: Option<cosmrs::AccountId>,
+    erc20_bridge_contract_address: Option<cosmrs::AccountId>,
    mnemonic: Option<bip39::Mnemonic>,

    mixnode_page_limit: Option<u32>,
    gateway_page_limit: Option<u32>,
    mixnode_delegations_page_limit: Option<u32>,
+    rewarded_set_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,
@@ -90,20 +114,25 @@ impl Client<SigningNymdClient> {
    ) -> Result<Client<SigningNymdClient>, ValidatorClientError> {
        let validator_api_client = validator_api::Client::new(config.api_url.clone());
        let nymd_client = NymdClient::connect_with_mnemonic(
+            config.network,
            config.nymd_url.as_str(),
            config.mixnet_contract_address.clone(),
            config.vesting_contract_address.clone(),
+            config.erc20_bridge_contract_address.clone(),
            mnemonic.clone(),
            None,
        )?;

        Ok(Client {
+            network: config.network,
            mixnet_contract_address: config.mixnet_contract_address,
            vesting_contract_address: config.vesting_contract_address,
+            erc20_bridge_contract_address: config.erc20_bridge_contract_address,
            mnemonic: Some(mnemonic),
            mixnode_page_limit: config.mixnode_page_limit,
            gateway_page_limit: config.gateway_page_limit,
            mixnode_delegations_page_limit: config.mixnode_delegations_page_limit,
+            rewarded_set_page_limit: None,
            validator_api: validator_api_client,
            nymd: nymd_client,
        })
@@ -111,9 +140,11 @@ impl Client<SigningNymdClient> {

    pub fn change_nymd(&mut self, new_endpoint: Url) -> Result<(), ValidatorClientError> {
        self.nymd = NymdClient::connect_with_mnemonic(
+            self.network,
            new_endpoint.as_ref(),
            self.mixnet_contract_address.clone(),
            self.vesting_contract_address.clone(),
+            self.erc20_bridge_contract_address.clone(),
            self.mnemonic.clone().unwrap(),
            None,
        )?;
@@ -127,23 +158,37 @@ impl Client<QueryNymdClient> {
        let validator_api_client = validator_api::Client::new(config.api_url.clone());
        let nymd_client = NymdClient::connect(
            config.nymd_url.as_str(),
-            config.mixnet_contract_address.clone().unwrap_or_else(|| {
+            Some(config.mixnet_contract_address.clone().unwrap_or_else(|| {
                cosmrs::AccountId::from_str(network_defaults::DEFAULT_MIXNET_CONTRACT_ADDRESS)
                    .unwrap()
-            }),
-            config.vesting_contract_address.clone().unwrap_or_else(|| {
+            })),
+            Some(config.vesting_contract_address.clone().unwrap_or_else(|| {
                cosmrs::AccountId::from_str(network_defaults::DEFAULT_VESTING_CONTRACT_ADDRESS)
                    .unwrap()
-            }),
+            })),
+            Some(
+                config
+                    .erc20_bridge_contract_address
+                    .clone()
+                    .unwrap_or_else(|| {
+                        cosmrs::AccountId::from_str(
+                            network_defaults::DEFAULT_BANDWIDTH_CLAIM_CONTRACT_ADDRESS,
+                        )
+                        .unwrap()
+                    }),
+            ),
        )?;

        Ok(Client {
+            network: config.network,
            mixnet_contract_address: config.mixnet_contract_address,
            vesting_contract_address: config.vesting_contract_address,
+            erc20_bridge_contract_address: config.erc20_bridge_contract_address,
            mnemonic: None,
            mixnode_page_limit: config.mixnode_page_limit,
            gateway_page_limit: config.gateway_page_limit,
            mixnode_delegations_page_limit: config.mixnode_delegations_page_limit,
+            rewarded_set_page_limit: config.rewarded_set_page_limit,
            validator_api: validator_api_client,
            nymd: nymd_client,
        })
@@ -152,8 +197,9 @@ impl Client<QueryNymdClient> {
    pub fn change_nymd(&mut self, new_endpoint: Url) -> Result<(), ValidatorClientError> {
        self.nymd = NymdClient::connect(
            new_endpoint.as_ref(),
-            self.mixnet_contract_address.clone().unwrap(),
-            self.vesting_contract_address.clone().unwrap(),
+            self.mixnet_contract_address.clone(),
+            self.vesting_contract_address.clone(),
+            self.erc20_bridge_contract_address.clone(),
        )?;
        Ok(())
    }
@@ -179,6 +225,18 @@ impl<C> Client<C> {
        Ok(self.validator_api.get_mixnodes().await?)
    }

+    pub async fn get_cached_rewarded_mixnodes(
+        &self,
+    ) -> Result<Vec<MixNodeBond>, ValidatorClientError> {
+        Ok(self.validator_api.get_rewarded_mixnodes().await?)
+    }
+
+    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_gateways(&self) -> Result<Vec<GatewayBond>, ValidatorClientError> {
        Ok(self.validator_api.get_gateways().await?)
    }
@@ -194,21 +252,12 @@ impl<C> Client<C> {
    where
        C: CosmWasmClient + Sync,
    {
-        Ok(self.nymd.get_mixnet_contract_version().await?)
-    }
-
-    pub async fn get_current_rewarding_interval(
-        &self,
-    ) -> Result<RewardingIntervalResponse, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync,
-    {
-        Ok(self.nymd.get_current_rewarding_interval().await?)
+        self.nymd.get_mixnet_contract_version().await
    }

    pub async fn get_rewarding_status(
        &self,
-        mix_identity: mixnet_contract::IdentityKey,
+        mix_identity: mixnet_contract_common::IdentityKey,
        rewarding_interval_nonce: u32,
    ) -> Result<MixnodeRewardingStatusResponse, ValidatorClientError>
    where
@@ -227,6 +276,13 @@ impl<C> Client<C> {
        Ok(self.nymd.get_reward_pool().await?.u128())
    }

+    pub async fn get_current_interval(&self) -> Result<Interval, ValidatorClientError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        Ok(self.nymd.get_current_interval().await?)
+    }
+
    pub async fn get_circulating_supply(&self) -> Result<u128, ValidatorClientError>
    where
        C: CosmWasmClient + Sync,
@@ -241,14 +297,136 @@ impl<C> Client<C> {
        Ok(self.nymd.get_sybil_resistance_percent().await?)
    }

-    pub async fn get_epoch_reward_percent(&self) -> Result<u8, ValidatorClientError>
+    pub async fn get_active_set_work_factor(&self) -> Result<u8, ValidatorClientError>
    where
        C: CosmWasmClient + Sync,
    {
-        Ok(self.nymd.get_epoch_reward_percent().await?)
+        Ok(self.nymd.get_active_set_work_factor().await?)
+    }
+
+    pub async fn get_interval_reward_percent(&self) -> Result<u8, ValidatorClientError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        Ok(self.nymd.get_interval_reward_percent().await?)
+    }
+
+    pub async fn get_current_rewarded_set_update_details(
+        &self,
+    ) -> Result<RewardedSetUpdateDetails, ValidatorClientError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        Ok(self
+            .nymd
+            .query_current_rewarded_set_update_details()
+            .await?)
    }

    // basically handles paging for us
+    pub async fn get_all_nymd_rewarded_set_mixnode_identities(
+        &self,
+    ) -> Result<Vec<(IdentityKey, RewardedSetNodeStatus)>, ValidatorClientError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        let mut identities = Vec::new();
+        let mut start_after = None;
+        let mut height = None;
+
+        loop {
+            let mut paged_response = self
+                .nymd
+                .get_rewarded_set_identities_paged(
+                    start_after.take(),
+                    self.rewarded_set_page_limit,
+                    height,
+                )
+                .await?;
+            identities.append(&mut paged_response.identities);
+
+            if height.is_none() {
+                // keep using the same height (the first query happened at the most recent height)
+                height = Some(paged_response.at_height)
+            }
+
+            if let Some(start_after_res) = paged_response.start_next_after {
+                start_after = Some(start_after_res)
+            } else {
+                break;
+            }
+        }
+
+        Ok(identities)
+    }
+
+    pub async fn get_nymd_rewarded_and_active_sets(
+        &self,
+    ) -> Result<Vec<(MixNodeBond, RewardedSetNodeStatus)>, ValidatorClientError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        let all_mixnodes = self.get_all_nymd_mixnodes().await?;
+        let rewarded_set_identities = self
+            .get_all_nymd_rewarded_set_mixnode_identities()
+            .await?
+            .into_iter()
+            .collect::<HashMap<_, _>>();
+
+        Ok(all_mixnodes
+            .into_iter()
+            .filter_map(|node| {
+                rewarded_set_identities
+                    .get(node.identity())
+                    .map(|status| (node, *status))
+            })
+            .collect())
+    }
+
+    /// If you need both rewarded and the active set, consider using [Self::get_nymd_rewarded_and_active_sets] instead
+    pub async fn get_nymd_rewarded_set(&self) -> Result<Vec<MixNodeBond>, ValidatorClientError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        let all_mixnodes = self.get_all_nymd_mixnodes().await?;
+        let rewarded_set_identities = self
+            .get_all_nymd_rewarded_set_mixnode_identities()
+            .await?
+            .into_iter()
+            .map(|(identity, _status)| identity)
+            .collect::<HashSet<_>>();
+
+        Ok(all_mixnodes
+            .into_iter()
+            .filter(|node| rewarded_set_identities.contains(node.identity()))
+            .collect())
+    }
+
+    /// If you need both rewarded and the active set, consider using [Self::get_nymd_rewarded_and_active_sets] instead
+    pub async fn get_nymd_active_set(&self) -> Result<Vec<MixNodeBond>, ValidatorClientError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        let all_mixnodes = self.get_all_nymd_mixnodes().await?;
+        let active_set_identities = self
+            .get_all_nymd_rewarded_set_mixnode_identities()
+            .await?
+            .into_iter()
+            .filter_map(|(identity, status)| {
+                if status.is_active() {
+                    Some(identity)
+                } else {
+                    None
+                }
+            })
+            .collect::<HashSet<_>>();
+
+        Ok(all_mixnodes
+            .into_iter()
+            .filter(|node| active_set_identities.contains(node.identity()))
+            .collect())
+    }
+
    pub async fn get_all_nymd_mixnodes(&self) -> Result<Vec<MixNodeBond>, ValidatorClientError>
    where
        C: CosmWasmClient + Sync,
@@ -297,8 +475,8 @@ impl<C> Client<C> {

    pub async fn get_all_nymd_single_mixnode_delegations(
        &self,
-        identity: mixnet_contract::IdentityKey,
-    ) -> Result<Vec<mixnet_contract::Delegation>, ValidatorClientError>
+        identity: IdentityKey,
+    ) -> Result<Vec<Delegation>, ValidatorClientError>
    where
        C: CosmWasmClient + Sync,
    {
@@ -420,6 +598,12 @@ impl ApiClient {
        Ok(self.validator_api.get_active_mixnodes().await?)
    }

+    pub async fn get_cached_rewarded_mixnodes(
+        &self,
+    ) -> Result<Vec<MixNodeBond>, ValidatorClientError> {
+        Ok(self.validator_api.get_rewarded_mixnodes().await?)
+    }
+
    pub async fn get_cached_mixnodes(&self) -> Result<Vec<MixNodeBond>, ValidatorClientError> {
        Ok(self.validator_api.get_mixnodes().await?)
    }
@@ -428,6 +612,55 @@ impl ApiClient {
        Ok(self.validator_api.get_gateways().await?)
    }

+    pub async fn get_gateway_core_status_count(
+        &self,
+        identity: IdentityKeyRef<'_>,
+        since: Option<i64>,
+    ) -> Result<CoreNodeStatusResponse, ValidatorClientError> {
+        Ok(self
+            .validator_api
+            .get_gateway_core_status_count(identity, since)
+            .await?)
+    }
+
+    pub async fn get_mixnode_core_status_count(
+        &self,
+        identity: IdentityKeyRef<'_>,
+        since: Option<i64>,
+    ) -> Result<CoreNodeStatusResponse, ValidatorClientError> {
+        Ok(self
+            .validator_api
+            .get_mixnode_core_status_count(identity, since)
+            .await?)
+    }
+
+    pub async fn get_mixnode_status(
+        &self,
+        identity: IdentityKeyRef<'_>,
+    ) -> Result<MixnodeStatusResponse, ValidatorClientError> {
+        Ok(self.validator_api.get_mixnode_status(identity).await?)
+    }
+
+    pub async fn get_mixnode_reward_estimation(
+        &self,
+        identity: IdentityKeyRef<'_>,
+    ) -> Result<RewardEstimationResponse, ValidatorClientError> {
+        Ok(self
+            .validator_api
+            .get_mixnode_reward_estimation(identity)
+            .await?)
+    }
+
+    pub async fn get_mixnode_stake_saturation(
+        &self,
+        identity: IdentityKeyRef<'_>,
+    ) -> Result<StakeSaturationResponse, ValidatorClientError> {
+        Ok(self
+            .validator_api
+            .get_mixnode_stake_saturation(identity)
+            .await?)
+    }
+
    pub async fn blind_sign(
        &self,
        request_body: &BlindSignRequestBody,
@@ -9,6 +9,7 @@ pub mod validator_api;

 pub use crate::client::ApiClient;
 pub use crate::error::ValidatorClientError;
+pub use validator_api_requests::*;

 #[cfg(feature = "nymd-client")]
 pub use client::{Client, Config};
@@ -1,7 +1,7 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::nymd::cosmwasm_client::helpers::create_pagination;
+use crate::nymd::cosmwasm_client::helpers::{create_pagination, next_page_key};
 use crate::nymd::cosmwasm_client::types::{
    Account, Code, CodeDetails, Contract, ContractCodeHistoryEntry, ContractCodeId,
    SequenceResponse, SimulateResponse,
@@ -13,6 +13,7 @@ use cosmrs::proto::cosmos::auth::v1beta1::{
 };
 use cosmrs::proto::cosmos::bank::v1beta1::{
    QueryAllBalancesRequest, QueryAllBalancesResponse, QueryBalanceRequest, QueryBalanceResponse,
+    QueryTotalSupplyRequest, QueryTotalSupplyResponse,
 };
 use cosmrs::proto::cosmos::tx::v1beta1::{
    SimulateRequest, SimulateResponse as ProtoSimulateResponse,
@@ -27,6 +28,7 @@ use cosmrs::tendermint::abci::Code as AbciCode;
 use cosmrs::tendermint::abci::Transaction;
 use cosmrs::tendermint::{abci, block, chain};
 use cosmrs::{tx, AccountId, Coin, Denom, Tx};
+use cosmwasm_std::Coin as CosmWasmCoin;
 use prost::Message;
 use serde::{Deserialize, Serialize};
 use std::convert::{TryFrom, TryInto};
@@ -148,8 +150,8 @@ pub trait CosmWasmClient: rpc::Client {
                .await?;

            raw_balances.append(&mut res.balances);
-            if let Some(pagination_info) = res.pagination {
-                pagination = Some(create_pagination(pagination_info.next_key))
+            if let Some(next_key) = next_page_key(res.pagination) {
+                pagination = Some(create_pagination(next_key))
            } else {
                break;
            }
@@ -162,6 +164,43 @@ pub trait CosmWasmClient: rpc::Client {
            .map_err(|_| NymdError::SerializationError("Coins".to_owned()))
    }

+    // this is annoyingly and inconsistently returning `Vec<CosmWasmCoin>` rather than
+    // Vec<Coin>, since cosmrs::Coin can't deal with IBC denoms.
+    // Presumably after https://github.com/cosmos/cosmos-rust/issues/173 is resolved,
+    // the code could be adjusted
+    async fn get_total_supply(&self) -> Result<Vec<CosmWasmCoin>, NymdError> {
+        let path = Some("/cosmos.bank.v1beta1.Query/TotalSupply".parse().unwrap());
+
+        let mut supply = Vec::new();
+        let mut pagination = None;
+
+        loop {
+            let req = QueryTotalSupplyRequest { pagination };
+
+            let mut res = self
+                .make_abci_query::<_, QueryTotalSupplyResponse>(path.clone(), req)
+                .await?;
+
+            supply.append(&mut res.supply);
+            if let Some(next_key) = next_page_key(res.pagination) {
+                pagination = Some(create_pagination(next_key))
+            } else {
+                break;
+            }
+        }
+
+        supply
+            .into_iter()
+            .map(|coin| {
+                coin.amount.parse().map(|amount| CosmWasmCoin {
+                    denom: coin.denom,
+                    amount,
+                })
+            })
+            .collect::<Result<_, _>>()
+            .map_err(|_| NymdError::SerializationError("Coins".to_owned()))
+    }
+
    async fn get_tx(&self, id: tx::Hash) -> Result<TxResponse, NymdError> {
        Ok(self.tx(id, false).await?)
    }
@@ -235,8 +274,8 @@ pub trait CosmWasmClient: rpc::Client {
                .await?;

            raw_codes.append(&mut res.code_infos);
-            if let Some(pagination_info) = res.pagination {
-                pagination = Some(create_pagination(pagination_info.next_key))
+            if let Some(next_key) = next_page_key(res.pagination) {
+                pagination = Some(create_pagination(next_key))
            } else {
                break;
            }
@@ -280,8 +319,8 @@ pub trait CosmWasmClient: rpc::Client {
                .await?;

            raw_contracts.append(&mut res.contracts);
-            if let Some(pagination_info) = res.pagination {
-                pagination = Some(create_pagination(pagination_info.next_key))
+            if let Some(next_key) = next_page_key(res.pagination) {
+                pagination = Some(create_pagination(next_key))
            } else {
                break;
            }
@@ -336,8 +375,8 @@ pub trait CosmWasmClient: rpc::Client {
                .await?;

            raw_entries.append(&mut res.entries);
-            if let Some(pagination_info) = res.pagination {
-                pagination = Some(create_pagination(pagination_info.next_key))
+            if let Some(next_key) = next_page_key(res.pagination) {
+                pagination = Some(create_pagination(next_key))
            } else {
                break;
            }
@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::nymd::error::NymdError;
-use cosmrs::proto::cosmos::base::query::v1beta1::PageRequest;
+use cosmrs::proto::cosmos::base::query::v1beta1::{PageRequest, PageResponse};
 use cosmrs::rpc::endpoint::broadcast;
 use flate2::write::GzEncoder;
 use flate2::Compression;
@@ -53,3 +53,15 @@ pub(crate) fn create_pagination(key: Vec<u8>) -> PageRequest {
        count_total: false,
    }
 }
+
+pub(crate) fn next_page_key(pagination_info: Option<PageResponse>) -> Option<Vec<u8>> {
+    if let Some(next_page_info) = pagination_info {
+        // it turns out, even though `PageResponse` is always returned wrapped in an `Option`,
+        // the `next_key` can still be empty, so check whether we actually need to perform another call
+        if !next_page_info.next_key.is_empty() {
+            return Some(next_page_info.next_key);
+        }
+    }
+
+    None
+}
@@ -24,7 +24,7 @@ where
 pub fn connect_with_signer<U>(
    endpoint: U,
    signer: DirectSecp256k1HdWallet,
-    gas_price: Option<GasPrice>,
+    gas_price: GasPrice,
 ) -> Result<signing_client::Client, NymdError>
 where
    U: TryInto<HttpClientUrl, Error = TendermintRpcError>,
@@ -160,10 +160,7 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
    {
        let init_msg = cosmwasm::MsgInstantiateContract {
            sender: sender_address.clone(),
-            admin: options
-                .as_mut()
-                .map(|options| options.admin.take())
-                .flatten(),
+            admin: options.as_mut().and_then(|options| options.admin.take()),
            code_id,
            // now this is a weird one. the protobuf files say this field is optional,
            // but if you omit it, the initialisation will fail CheckTx
@@ -647,7 +644,7 @@ impl Client {
    pub fn connect_with_signer<U>(
        endpoint: U,
        signer: DirectSecp256k1HdWallet,
-        gas_price: Option<GasPrice>,
+        gas_price: GasPrice,
    ) -> Result<Self, NymdError>
    where
        U: TryInto<HttpClientUrl, Error = TendermintRpcError>,
@@ -656,7 +653,7 @@ impl Client {
        Ok(Client {
            rpc_client,
            signer,
-            gas_price: gas_price.unwrap_or_default(),
+            gas_price,
        })
    }
 }
@@ -71,11 +71,9 @@ impl FromStr for GasPrice {
    }
 }

-impl Default for GasPrice {
-    fn default() -> Self {
-        format!("{}{}", defaults::GAS_PRICE_AMOUNT, defaults::DENOM)
-            .parse()
-            .unwrap()
+impl GasPrice {
+    pub fn new_with_default_price(denom: String) -> Result<Self, NymdError> {
+        format!("{}{}", defaults::GAS_PRICE_AMOUNT, denom).parse()
    }
 }

@@ -85,7 +83,8 @@ mod tests {

    #[test]
    fn default_gas_price_is_valid() {
-        let _ = GasPrice::default();
+        let denom = "unym".parse().unwrap();
+        let _ = GasPrice::new_with_default_price(denom);
    }

    #[test]
--- a/Show More
+++ b/Show More