Merge branch 'develop-with-release-1.1.0-merged-in' into feature/validator-api-tests

WIP
2022-11-09 10:15:54 +01:00 · 2022-11-09 10:05:47 +01:00 · 2022-11-08 16:22:39 +01:00 · 2022-11-08 12:30:27 +01:00 · 2022-11-07 18:37:31 +01:00 · 2022-11-07 17:36:21 +01:00
553 changed files with 33011 additions and 19604 deletions
@@ -3,3 +3,21 @@

 RUST_LOG=info
 RUST_BACKTRACE=1
+
+#########################################
+# geoipupdate (needed for explorer-api) #
+#########################################
+# MaxMind account ID (change it to a valid account ID)
+GEOIPUPDATE_ACCOUNT_ID=xxx
+# MaxMind license key (change it to a valid license key)
+GEOIPUPDATE_LICENSE_KEY=xxx
+# List of space-separated database edition IDs. Edition IDs may
+# consist of letters, digits, and dashes. For example, GeoIP2-City
+# would download the GeoIP2 City database (GeoIP2-City).
+GEOIPUPDATE_EDITION_IDS=GeoLite2-Country
+# The number of hours between geoipupdate runs. If this is not set
+# or is set to 0, geoipupdate will run once and exit.
+GEOIPUPDATE_FREQUENCY=72
+# The path to the directory where geoipupdate will download the
+# database.
+GEOIP_DB_DIRECTORY=./explorer-api/geo_ip
@@ -1,36 +1,49 @@
 name: Daily security audit

-on: workflow_dispatch
+on:
+  schedule:
+    - cron: '5 9 * * *'
 jobs:
-  security_audit:
+  cargo-deny:
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v1
-      - uses: actions-rs/audit-check@v1
+      - name: Checkout repository code
+        uses: actions/checkout@v2
+      - name: Install rust toolchain
+        uses: actions-rs/toolchain@v1
        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-
+          toolchain: stable
+      - name: Install cargo deny
+        run: cargo install --locked cargo-deny
+      - name: Run cargo deny
+        run: cargo deny check advisories --hide-inclusion-graph &> .github/workflows/support-files/notifications/deny.message
+      - uses: actions/upload-artifact@v3
+        with:
+          name: report
+          path: .github/workflows/support-files/notifications/deny.message
  notification:
-    if: ${{ failure() }}
-    needs: security_audit
+    needs: cargo-deny
    runs-on: ubuntu-latest
    steps:
      - name: Check out repository code
        uses: actions/checkout@v2
+      - name: Download report from previous job
+        uses: actions/download-artifact@v3
+        with:
+          name: report
+          path: .github/workflows/support-files/notifications
      - name: Keybase - Node Install
        run: npm install
        working-directory: .github/workflows/support-files
      - name: Keybase - Send Notification
        env:
-          NYM_NOTIFICATION_KIND: nightly
-          NYM_PROJECT_NAME: "Nym daily audit"
+          NYM_NOTIFICATION_KIND: security
+          NYM_PROJECT_NAME: "Daily security report"
          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_NYMBTECH_TEAM }}"
-          KEYBASE_NYM_CHANNEL: "test"
+          KEYBASE_NYMBOT_TEAM: "${{ secrets.KEYBASE_NYMBOT_TEAM }}"
+          KEYBASE_NYM_CHANNEL: "security"
        uses: docker://keybaseio/client:stable-node
        with:
          args: .github/workflows/support-files/notifications/entry_point.sh
@@ -16,7 +16,7 @@ jobs:
      RUSTC_WRAPPER: /home/ubuntu/.cargo/bin/sccache
    steps:
      - name: Install Dependencies (Linux)
-        run: sudo apt-get update && sudo apt-get -y install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev squashfs-tools
+        run: sudo apt-get update && sudo apt-get -y install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libudev-dev squashfs-tools

      - name: Check out repository code
        uses: actions/checkout@v2
@@ -24,7 +24,7 @@ jobs:
    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
+        run: sudo apt-get update && sudo apt-get install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libudev-dev squashfs-tools
        if: matrix.os == 'ubuntu-latest'

      - name: Check out repository code
@@ -2,6 +2,12 @@ name: Publish Nym binaries

 on:
  workflow_dispatch:
+    inputs:  
+      add_tokio_unstable:
+        description: 'True to add RUSTFLAGS="--cfg tokio_unstable"'
+        required: true
+        default: false
+        type: boolean 
  release:
    types: [created]
    
@@ -25,6 +31,11 @@ jobs:
        with:
          script: |
            core.setFailed('Release tag did not start with nym-binaries-...')
+            
+      - name: Sets env vars for tokio if set in manual dispatch inputs
+        run: |
+          echo 'RUSTFLAGS="--cfg tokio_unstable"' >> $GITHUB_ENV
+        if: github.event_name == 'workflow_dispatch' && inputs.add_tokio_unstable == true

      - name: Install Rust stable
        uses: actions-rs/toolchain@v1
@@ -3,7 +3,7 @@ require('dotenv').config();
 const Bot = require('keybase-bot');

 let context = {
-  kinds: ['nym-wallet', 'ts-packages', 'network-explorer', 'nightly', 'nym-connect'],
+  kinds: ['nym-wallet', 'ts-packages', 'network-explorer', 'nightly', 'nym-connect','security'],
 };

 /**
@@ -0,0 +1,24 @@
+const Handlebars = require('handlebars');
+const fs = require('fs');
+const path = require('path');
+const { Octokit, App } = require('octokit');
+
+async function addToContextAndValidate(context) {
+  return
+}
+
+async function getMessageBody(context) {
+  try {
+    const source = fs
+    .readFileSync("deny.message").toString();
+    return source;
+} catch (error) {
+    console.error(error);
+}
+
+}
+
+module.exports = {
+  addToContextAndValidate,
+  getMessageBody,
+};
@@ -0,0 +1,32 @@
+name: Tests for validator API
+
+on:
+  push:
+    paths:
+      - "validator-api/tests/**"
+
+defaults:
+  run:
+    working-directory: validator-api/tests
+
+jobs:
+  test:
+    name: validator api tests
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Node v18
+        uses: actions/setup-node@v3
+        with:
+          node-version: 18.1.0
+
+      - name: Install yarn
+        run: yarn install
+
+      - name: Run yarn
+        run: yarn
+
+      - name: Launch tests
+        run: yarn test
+        working-directory: validator-api/tests
@@ -12,10 +12,18 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://
 - common/ledger: new library for communicating with a Ledger device ([#1640])
 - native-client/socks5-client: `disable_loop_cover_traffic_stream` Debug config option to disable the separate loop cover traffic stream ([#1666])
 - native-client/socks5-client: `disable_main_poisson_packet_distribution` Debug config option to make the client ignore poisson distribution in the main packet stream and ONLY send real message (and as fast as they come) ([#1664])
+- native-client/socks5-client: `use_extended_packet_size` Debug config option to make the client use 'ExtendedPacketSize' for its traffic (32kB as opposed to 2kB in 1.0.2) ([#1671])
+- wasm-client: uses updated wasm-compatible `client-core` so that it's now capable of packet retransmission, cover traffic and poisson delay (among other things!) ([#1673])
+- validator-api: add `interval_operating_cost` and `profit_margin_percent` to cmpute reward estimation endpoint
+- native-client/socks5-client/network-requester: improve handling error cases ([#1713])
+- vesting-contract: optional locked token pledge cap per account ([#1687]), defaults to 100_000 NYM
+- clients: add testing-only support for two more extended packet sizes (8kb and 16kb).

 ### Fixed

 - validator-api, mixnode, gateway should now prefer values in config.toml over mainnet defaults ([#1645])
+- validator-api should now correctly update historical uptimes for all mixnodes and gateways every 24h ([#1721])
+- socks5-client: fix bug where in some cases packet reordering could trigger a connection being closed too early ([#1702],[#1724])

 ### Changed

@@ -23,6 +31,9 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://
 - socks5 client: graceful shutdown should fix error on disconnect in nym-connect ([#1591])
 - wasm-client: fixed build errors on MacOS and changed example JS code to use mainnet ([#1585])
 - gateway-client: will attempt to read now as many as 8 websocket messages at once, assuming they're already available on the socket ([#1669])
+- validator-api: changed error serialization on `inclusion_probability`, `stake-saturation` and `reward-estimation` endpoints to provide more accurate information ([#1681]) 
+- moved `Percent` struct to to `contracts-common`, change affects explorer-api
+- clients: bound the sphinx packet channel and reduce sending rate if gateway can't keep up ([#1703],[#1725])

 [#1541]: https://github.com/nymtech/nym/pull/1541
 [#1558]: https://github.com/nymtech/nym/pull/1558
@@ -34,6 +45,16 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://
 [#1664]: https://github.com/nymtech/nym/pull/1664
 [#1666]: https://github.com/nymtech/nym/pull/1645
 [#1669]: https://github.com/nymtech/nym/pull/1669
+[#1671]: https://github.com/nymtech/nym/pull/1671
+[#1673]: https://github.com/nymtech/nym/pull/1673
+[#1681]: https://github.com/nymtech/nym/pull/1681
+[#1687]: https://github.com/nymtech/nym/pull/1687
+[#1702]: https://github.com/nymtech/nym/pull/1702
+[#1703]: https://github.com/nymtech/nym/pull/1703
+[#1713]: https://github.com/nymtech/nym/pull/1713
+[#1721]: https://github.com/nymtech/nym/pull/1721
+[#1724]: https://github.com/nymtech/nym/pull/1724
+[#1725]: https://github.com/nymtech/nym/pull/1725


 ## [nym-binaries-1.0.2](https://github.com/nymtech/nym/tree/nym-binaries-1.0.2)
@@ -193,12 +193,6 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"

-[[package]]
-name = "az"
-version = "1.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b7e4c2464d97fe331d41de9d5db0def0a96f4d823b8b32a2efd503578988973"
-
 [[package]]
 name = "bandwidth-claim-contract"
 version = "0.1.0"
@@ -428,12 +422,6 @@ version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e3b5ca7a04898ad4bcd41c90c5285445ff5b791899bb1b0abdd2a2aa791211d7"

-[[package]]
-name = "bytemuck"
-version = "1.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f5715e491b5a1598fc2bef5a606847b5dc1d48ea625bd3c02c00de8285591da"
-
 [[package]]
 name = "byteorder"
 version = "1.4.3"
@@ -673,6 +661,15 @@ dependencies = [
 "unicode-width",
 ]

+[[package]]
+name = "completions"
+version = "0.1.0"
+dependencies = [
+ "clap 3.2.8",
+ "clap_complete",
+ "clap_complete_fig",
+]
+
 [[package]]
 name = "config"
 version = "0.1.0"
@@ -740,6 +737,10 @@ name = "contracts-common"
 version = "0.1.0"
 dependencies = [
 "cosmwasm-std",
+ "schemars",
+ "serde",
+ "serde_json",
+ "thiserror",
 ]

 [[package]]
@@ -904,6 +905,7 @@ dependencies = [
 "cfg-if 0.1.10",
 "clap 3.2.8",
 "coconut-interface",
+ "completions",
 "config",
 "credential-storage",
 "credentials",
@@ -1584,10 +1586,13 @@ version = "1.0.1"
 dependencies = [
 "chrono",
 "clap 3.2.8",
+ "contracts-common",
+ "dotenv",
 "humantime-serde",
 "isocountry",
 "itertools",
 "log",
+ "logging",
 "maxminddb",
 "mixnet-contract-common",
 "network-defaults",
@@ -1665,19 +1670,6 @@ dependencies = [
 "version_check",
 ]

-[[package]]
-name = "fixed"
-version = "1.19.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0371cd413fb63f8ec1b9eb4dff47fa2c88b21abc681771234c84808b9920991"
-dependencies = [
- "az",
- "bytemuck",
- "half 2.1.0",
- "serde",
- "typenum",
-]
-
 [[package]]
 name = "fixedbitset"
 version = "0.4.1"
@@ -2102,15 +2094,6 @@ version = "1.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "eabb4a44450da02c90444cf74558da904edde8fb4e9035a9a6a4e15445af0bd7"

-[[package]]
-name = "half"
-version = "2.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad6a9459c9c30b177b925162351f97e7d967c7ea8bab3b8352805327daf45554"
-dependencies = [
- "crunchy",
-]
-
 [[package]]
 name = "handlebars"
 version = "3.5.5"
@@ -2238,6 +2221,17 @@ version = "0.3.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7ebdb29d2ea9ed0083cd8cece49bbd968021bd99b0849edb4a9a7ee0fdf6a4e0"

+[[package]]
+name = "hidapi"
+version = "1.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d26e1151deaab68f34fbfd16d491a2a0170cf98d69d3efa23873b567a4199e1"
+dependencies = [
+ "cc",
+ "libc",
+ "pkg-config",
+]
+
 [[package]]
 name = "hkdf"
 version = "0.11.0"
@@ -2605,6 +2599,54 @@ version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"

+[[package]]
+name = "ledger"
+version = "0.1.0"
+dependencies = [
+ "bip32",
+ "k256",
+ "ledger-transport",
+ "ledger-transport-hid",
+ "thiserror",
+]
+
+[[package]]
+name = "ledger-apdu"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fe435806c197dfeaa5efcded5e623c4b8230fd28fdf1e91e7a86e40ef2acbf90"
+dependencies = [
+ "arrayref",
+ "no-std-compat",
+ "snafu 0.7.1",
+]
+
+[[package]]
+name = "ledger-transport"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1117f2143d92c157197785bf57711d7b02f2cfa101e162f8ca7900fb7f976321"
+dependencies = [
+ "async-trait",
+ "ledger-apdu",
+]
+
+[[package]]
+name = "ledger-transport-hid"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "45ba81a1f5f24396b37211478aff7fbcd605dd4544df8dbed07b9da3c2057aee"
+dependencies = [
+ "byteorder",
+ "cfg-if 1.0.0",
+ "hex",
+ "hidapi",
+ "ledger-transport",
+ "libc",
+ "log",
+ "thiserror",
+]
+
 [[package]]
 name = "libc"
 version = "0.2.122"
@@ -2689,6 +2731,14 @@ dependencies = [
 "cfg-if 1.0.0",
 ]

+[[package]]
+name = "logging"
+version = "0.1.0"
+dependencies = [
+ "log",
+ "pretty_env_logger",
+]
+
 [[package]]
 name = "loom"
 version = "0.5.4"
@@ -2807,13 +2857,15 @@ dependencies = [
 name = "mixnet-contract-common"
 version = "0.1.0"
 dependencies = [
- "az",
+ "bs58",
 "contracts-common",
 "cosmwasm-std",
- "fixed",
+ "humantime-serde",
 "log",
+ "rand_chacha 0.3.1",
 "schemars",
 "serde",
+ "serde_json",
 "serde_repr",
 "thiserror",
 "time 0.3.14",
@@ -2914,6 +2966,12 @@ dependencies = [
 "url",
 ]

+[[package]]
+name = "no-std-compat"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b93853da6d84c2e3c7d730d6473e8817692dd89be387eb01b94d7f108ecb5b8c"
+
 [[package]]
 name = "nom"
 version = "7.1.1"
@@ -2995,6 +3053,21 @@ dependencies = [
 "libc",
 ]

+[[package]]
+name = "nym-bity-integration"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "cosmrs",
+ "eyre",
+ "k256",
+ "nym-cli-commands",
+ "serde",
+ "serde_json",
+ "thiserror",
+ "validator-client",
+]
+
 [[package]]
 name = "nym-cli"
 version = "1.0.0"
@@ -3008,6 +3081,7 @@ dependencies = [
 "clap_complete_fig",
 "dotenv",
 "log",
+ "logging",
 "network-defaults",
 "nym-cli-commands",
 "pretty_env_logger",
@@ -3053,6 +3127,7 @@ dependencies = [
 "clap 3.2.8",
 "client-core",
 "coconut-interface",
+ "completions",
 "config",
 "credential-storage",
 "credentials",
@@ -3062,6 +3137,7 @@ dependencies = [
 "gateway-client",
 "gateway-requests",
 "log",
+ "logging",
 "network-defaults",
 "nymsphinx",
 "pemstore",
@@ -3071,6 +3147,7 @@ dependencies = [
 "serde_json",
 "sled",
 "task",
+ "thiserror",
 "tokio",
 "tokio-tungstenite 0.14.0",
 "topology",
@@ -3092,6 +3169,7 @@ dependencies = [
 "clap 3.2.8",
 "coconut-interface",
 "colored",
+ "completions",
 "config",
 "credentials",
 "crypto",
@@ -3102,6 +3180,7 @@ dependencies = [
 "gateway-requests",
 "humantime-serde",
 "log",
+ "logging",
 "mixnet-client",
 "mixnode-common",
 "network-defaults",
@@ -3134,6 +3213,7 @@ dependencies = [
 "bs58",
 "clap 3.2.8",
 "colored",
+ "completions",
 "config",
 "crypto",
 "cupid",
@@ -3143,6 +3223,7 @@ dependencies = [
 "humantime-serde",
 "lazy_static",
 "log",
+ "logging",
 "mixnet-client",
 "mixnode-common",
 "nonexhaustive-delayqueue",
@@ -3172,10 +3253,12 @@ version = "1.0.2"
 dependencies = [
 "async-trait",
 "clap 3.2.8",
+ "completions",
 "dirs",
 "futures",
 "ipnetwork 0.20.0",
 "log",
+ "logging",
 "network-defaults",
 "nymsphinx",
 "ordered-buffer",
@@ -3201,6 +3284,7 @@ version = "1.0.2"
 dependencies = [
 "dirs",
 "log",
+ "logging",
 "pretty_env_logger",
 "rocket",
 "serde",
@@ -3217,6 +3301,7 @@ dependencies = [
 "clap 3.2.8",
 "client-core",
 "coconut-interface",
+ "completions",
 "config",
 "credential-storage",
 "credentials",
@@ -3226,6 +3311,7 @@ dependencies = [
 "gateway-client",
 "gateway-requests",
 "log",
+ "logging",
 "network-defaults",
 "nymsphinx",
 "ordered-buffer",
@@ -3235,9 +3321,10 @@ dependencies = [
 "proxy-helpers",
 "rand 0.7.3",
 "serde",
- "snafu",
+ "snafu 0.6.10",
 "socks5-requests",
 "task",
+ "thiserror",
 "tokio",
 "topology",
 "url",
@@ -3284,6 +3371,7 @@ dependencies = [
 "coconut-interface",
 "config",
 "console-subscriber",
+ "contracts-common",
 "cosmwasm-std",
 "credential-storage",
 "credentials",
@@ -3298,6 +3386,7 @@ dependencies = [
 "humantime-serde",
 "inclusion-probability",
 "log",
+ "logging",
 "mixnet-contract-common",
 "multisig-contract-common",
 "nymcoconut",
@@ -3337,7 +3426,9 @@ dependencies = [
 "config",
 "cosmrs",
 "cosmwasm-std",
+ "hex-literal",
 "mixnet-contract-common",
+ "network-defaults",
 "nym-types",
 "serde",
 "serde_json",
@@ -4839,7 +4930,7 @@ version = "0.11.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2bef2ebfde456fb76bbcf9f59315333decc4fda0b2b44b420243c11e0f5ec1f5"
 dependencies = [
- "half 1.8.2",
+ "half",
 "serde",
 ]

@@ -5076,7 +5167,17 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "eab12d3c261b2308b0d80c26fffb58d17eba81a4be97890101f416b478c79ca7"
 dependencies = [
 "doc-comment",
- "snafu-derive",
+ "snafu-derive 0.6.10",
+]
+
+[[package]]
+name = "snafu"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5177903bf45656592d9eb5c0e22f408fc023aae51dbe2088889b71633ba451f2"
+dependencies = [
+ "doc-comment",
+ "snafu-derive 0.7.1",
 ]

 [[package]]
@@ -5090,6 +5191,18 @@ dependencies = [
 "syn",
 ]

+[[package]]
+name = "snafu-derive"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "410b26ed97440d90ced3e2488c868d56a86e2064f5d7d6f417909b286afe25e5"
+dependencies = [
+ "heck 0.4.0",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "socket2"
 version = "0.4.4"
@@ -6278,6 +6391,7 @@ dependencies = [
 "bs58",
 "coconut-interface",
 "cosmrs",
+ "cosmwasm-std",
 "getset",
 "mixnet-contract-common",
 "schemars",
@@ -6296,6 +6410,7 @@ dependencies = [
 "coconut-interface",
 "colored",
 "config",
+ "contracts-common",
 "cosmrs",
 "cosmwasm-std",
 "cw3",
@@ -6382,14 +6497,16 @@ checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"

 [[package]]
 name = "vesting-contract"
-version = "1.0.2"
+version = "1.1.0"
 dependencies = [
+ "contracts-common",
 "cosmwasm-std",
 "cw-storage-plus",
 "mixnet-contract-common",
 "schemars",
 "serde",
 "thiserror",
+ "vergen 5.1.17",
 "vesting-contract-common",
 ]

@@ -6397,7 +6514,9 @@ dependencies = [
 name = "vesting-contract-common"
 version = "0.1.0"
 dependencies = [
+ "contracts-common",
 "cosmwasm-std",
+ "log",
 "mixnet-contract-common",
 "schemars",
 "serde",
@@ -40,6 +40,8 @@ members = [
    "common/crypto/dkg",
    "common/execute",
    "common/inclusion-probability",
+    "common/ledger",
+    "common/logging",
    "common/mixnode-common",
    "common/network-defaults",
    "common/nonexhaustive-delayqueue",
@@ -62,9 +64,11 @@ members = [
    "common/topology",
    "common/types",
    "common/wasm-utils",
+    "common/completions",
    "explorer-api",
    "gateway",
    "gateway/gateway-requests",
+    "integrations/bity",
    "mixnode",
    "service-providers/network-requester",
    "service-providers/network-statistics",
@@ -2,12 +2,12 @@ test: clippy-all cargo-test wasm fmt
 test-all: test cargo-test-expensive
 no-clippy: build cargo-test wasm fmt
 happy: fmt clippy-happy test
-clippy-all: clippy-main clippy-coconut clippy-all-contracts clippy-all-wallet clippy-all-connect
+clippy-all: clippy-main clippy-coconut clippy-all-contracts clippy-all-wallet clippy-all-connect clippy-all-wasm-client
 clippy-happy: clippy-happy-main clippy-happy-contracts clippy-happy-wallet clippy-happy-connect
-cargo-test: test-main test-contracts test-wallet test-connect test-coconut
+cargo-test: test-main test-contracts test-wallet test-connect test-coconut test-wasm-client
 cargo-test-expensive: test-main-expensive test-contracts-expensive test-wallet-expensive test-connect-expensive test-coconut-expensive
-build: build-contracts build-wallet build-main build-connect
-fmt: fmt-main fmt-contracts fmt-wallet fmt-connect
+build: build-contracts build-wallet build-main build-connect build-wasm-client
+fmt: fmt-main fmt-contracts fmt-wallet fmt-connect fmt-wasm-client

 clippy-happy-main:
 	cargo clippy
@@ -40,6 +40,9 @@ clippy-all-wallet:
 clippy-all-connect:
 	cargo clippy --workspace --manifest-path nym-connect/Cargo.toml --all-features -- -D warnings

+clippy-all-wasm-client:
+	cargo clippy --workspace --manifest-path clients/webassembly/Cargo.toml --all-features --target wasm32-unknown-unknown -- -D warnings
+
 test-main:
 	cargo test --workspace

@@ -68,6 +71,9 @@ test-wallet:
 test-wallet-expensive:
 	cargo test --manifest-path nym-wallet/Cargo.toml --all-features -- --ignored

+test-wasm-client:
+	cargo test --workspace --manifest-path clients/webassembly/Cargo.toml --all-features
+
 test-connect:
 	cargo test --manifest-path nym-connect/Cargo.toml --all-features

@@ -86,6 +92,9 @@ build-wallet:
 build-connect:
 	cargo build --manifest-path nym-connect/Cargo.toml --workspace

+build-wasm-client:
+	cargo build --manifest-path clients/webassembly/Cargo.toml --workspace --target wasm32-unknown-unknown
+
 build-nym-cli:
 	cargo build --release --manifest-path tools/nym-cli/Cargo.toml

@@ -101,9 +110,18 @@ fmt-wallet:
 fmt-connect:
 	cargo fmt --manifest-path nym-connect/Cargo.toml --all

+fmt-wasm-client:
+	cargo fmt --manifest-path clients/webassembly/Cargo.toml --all
+
 wasm:
 	RUSTFLAGS='-C link-arg=-s' cargo build --manifest-path contracts/Cargo.toml --release --target wasm32-unknown-unknown

+mixnet-opt: wasm
+	cd contracts/mixnet && make opt
+
 generate-typescript:
 	cd tools/ts-rs-cli && cargo run && cd ../..
 	yarn types:lint:fix
+
+run-validator-tests:
+	cd validator-api/tests/functional_test && yarn test
@@ -16,6 +16,7 @@ use rand::{rngs::OsRng, CryptoRng, Rng};
 use std::pin::Pin;
 use std::sync::Arc;
 use std::time::Duration;
+use tokio::sync::mpsc::error::TrySendError;

 #[cfg(not(target_arch = "wasm32"))]
 use tokio::time;
@@ -163,7 +164,7 @@ impl LoopCoverTrafficStream<OsRng> {
        let cover_message = generate_loop_cover_packet(
            &mut self.rng,
            topology_ref,
-            &*self.ack_key,
+            &self.ack_key,
            &self.our_full_destination,
            self.average_ack_delay,
            self.average_packet_delay,
@@ -171,11 +172,18 @@ impl LoopCoverTrafficStream<OsRng> {
        )
        .expect("Somehow failed to generate a loop cover message with a valid topology");

-        // if this one fails, there's no retrying because it means that either:
-        // - we run out of memory
-        // - the receiver channel is closed
-        // in either case there's no recovery and we can only panic
-        self.mix_tx.unbounded_send(vec![cover_message]).unwrap();
+        if let Err(err) = self.mix_tx.try_send(vec![cover_message]) {
+            match err {
+                TrySendError::Full(_) => {
+                    // This isn't a problem, if the channel is full means we're already sending the
+                    // max amount of messages downstream can handle.
+                    log::debug!("Failed to send cover message - channel full");
+                }
+                TrySendError::Closed(_) => {
+                    log::warn!("Failed to send cover message - channel closed");
+                }
+            }
+        }

        // TODO: I'm not entirely sure whether this is really required, because I'm not 100%
        // sure how `yield_now()` works - whether it just notifies the scheduler or whether it
@@ -2,15 +2,15 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::spawn_future;
-use futures::channel::mpsc;
-use futures::StreamExt;
 use gateway_client::GatewayClient;
 use log::*;
 use nymsphinx::forwarding::packet::MixPacket;

-pub type BatchMixMessageSender = mpsc::UnboundedSender<Vec<MixPacket>>;
-pub type BatchMixMessageReceiver = mpsc::UnboundedReceiver<Vec<MixPacket>>;
+pub type BatchMixMessageSender = tokio::sync::mpsc::Sender<Vec<MixPacket>>;
+pub type BatchMixMessageReceiver = tokio::sync::mpsc::Receiver<Vec<MixPacket>>;

+// We remind ourselves that 32 x 32kb = 1024kb, a reasonable size for a network buffer.
+pub const MIX_MESSAGE_RECEIVER_BUFFER_SIZE: usize = 32;
 const MAX_FAILURE_COUNT: usize = 100;

 pub struct MixTrafficController {
@@ -25,15 +25,17 @@ pub struct MixTrafficController {
 }

 impl MixTrafficController {
-    pub fn new(
-        mix_rx: BatchMixMessageReceiver,
-        gateway_client: GatewayClient,
-    ) -> MixTrafficController {
-        MixTrafficController {
-            gateway_client,
-            mix_rx,
-            consecutive_gateway_failure_count: 0,
-        }
+    pub fn new(gateway_client: GatewayClient) -> (MixTrafficController, BatchMixMessageSender) {
+        let (sphinx_message_sender, sphinx_message_receiver) =
+            tokio::sync::mpsc::channel(MIX_MESSAGE_RECEIVER_BUFFER_SIZE);
+        (
+            MixTrafficController {
+                gateway_client,
+                mix_rx: sphinx_message_receiver,
+                consecutive_gateway_failure_count: 0,
+            },
+            sphinx_message_sender,
+        )
    }

    async fn on_messages(&mut self, mut mix_packets: Vec<MixPacket>) {
@@ -72,7 +74,7 @@ impl MixTrafficController {

            while !shutdown.is_shutdown() {
                tokio::select! {
-                    mix_packets = self.mix_rx.next() => match mix_packets {
+                    mix_packets = self.mix_rx.recv() => match mix_packets {
                        Some(mix_packets) => {
                            self.on_messages(mix_packets).await;
                        },
@@ -96,7 +98,7 @@ impl MixTrafficController {
        spawn_future(async move {
            debug!("Started MixTrafficController without graceful shutdown support");

-            while let Some(mix_packets) = self.mix_rx.next().await {
+            while let Some(mix_packets) = self.mix_rx.recv().await {
                self.on_messages(mix_packets).await;
            }
        })
@@ -13,6 +13,7 @@ use nymsphinx::addressing::clients::Recipient;
 use nymsphinx::chunking::fragment::FragmentIdentifier;
 use nymsphinx::cover::generate_loop_cover_packet;
 use nymsphinx::forwarding::packet::MixPacket;
+use nymsphinx::params::PacketSize;
 use nymsphinx::utils::sample_poisson_duration;
 use rand::{CryptoRng, Rng};
 use std::collections::VecDeque;
@@ -20,13 +21,29 @@ use std::pin::Pin;
 use std::sync::Arc;
 use std::time::Duration;

-use nymsphinx::params::PacketSize;
 #[cfg(not(target_arch = "wasm32"))]
 use tokio::time;

 #[cfg(target_arch = "wasm32")]
 use wasm_timer;

+// The minimum time between increasing the average delay between packets. If we hit the ceiling in
+// the available buffer space we want to take somewhat swift action, but we still need to give a
+// short time to give the channel a chance reduce pressure.
+const INCREASE_DELAY_MIN_CHANGE_INTERVAL_SECS: u64 = 1;
+// The minimum time between decreasing the average delay between packets. We don't want to change
+// to quickly to keep things somewhat stable. Also there are buffers downstreams meaning we need to
+// wait a little to see the effect before we decrease further.
+const DECREASE_DELAY_MIN_CHANGE_INTERVAL_SECS: u64 = 30;
+// If we enough time passes without any sign of backpressure in the channel, we can consider
+// lowering the average delay. The goal is to keep somewhat stable, rather than maxing out
+// bandwidth at all times.
+const ACCEPTABLE_TIME_WITHOUT_BACKPRESSURE_SECS: u64 = 30;
+// The maximum multiplier we apply to the base average Poisson delay.
+const MAX_DELAY_MULTIPLIER: u32 = 6;
+// The minium multiplier we apply to the base average Poisson delay.
+const MIN_DELAY_MULTIPLIER: u32 = 1;
+
 /// Configurable parameters of the `OutQueueControl`
 pub(crate) struct Config {
    /// Average delay an acknowledgement packet is going to get delay at a single mixnode.
@@ -68,6 +85,101 @@ impl Config {
    }
 }

+struct SendingDelayController {
+    /// Multiply the average sending delay.
+    /// This is normally set to unity, but if we detect backpressure we increase this
+    /// multiplier. We use discrete steps.
+    current_multiplier: u32,
+
+    /// Maximum delay multiplier
+    upper_bound: u32,
+
+    /// Minimum delay multiplier
+    lower_bound: u32,
+
+    /// To make sure we don't change the multiplier to fast, we limit a change to some duration
+    #[cfg(not(target_arch = "wasm32"))]
+    time_when_changed: time::Instant,
+
+    #[cfg(target_arch = "wasm32")]
+    time_when_changed: wasm_timer::Instant,
+
+    /// If we have a long enough time without any backpressure detected we try reducing the sending
+    /// delay multiplier
+    #[cfg(not(target_arch = "wasm32"))]
+    time_when_backpressure_detected: time::Instant,
+
+    #[cfg(target_arch = "wasm32")]
+    time_when_backpressure_detected: wasm_timer::Instant,
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+fn get_time_now() -> time::Instant {
+    time::Instant::now()
+}
+
+#[cfg(target_arch = "wasm32")]
+fn get_time_now() -> wasm_timer::Instant {
+    wasm_timer::Instant::now()
+}
+
+impl SendingDelayController {
+    fn new(lower_bound: u32, upper_bound: u32) -> Self {
+        assert!(lower_bound <= upper_bound);
+        let now = get_time_now();
+        SendingDelayController {
+            current_multiplier: MIN_DELAY_MULTIPLIER,
+            upper_bound,
+            lower_bound,
+            time_when_changed: now,
+            time_when_backpressure_detected: now,
+        }
+    }
+
+    fn current_multiplier(&self) -> u32 {
+        self.current_multiplier
+    }
+
+    fn increase_delay_multiplier(&mut self) {
+        self.current_multiplier =
+            (self.current_multiplier + 1).clamp(self.lower_bound, self.upper_bound);
+        self.time_when_changed = get_time_now();
+        log::debug!(
+            "Increasing sending delay multiplier to: {}",
+            self.current_multiplier
+        );
+    }
+
+    fn decrease_delay_multiplier(&mut self) {
+        self.current_multiplier =
+            (self.current_multiplier - 1).clamp(self.lower_bound, self.upper_bound);
+        self.time_when_changed = get_time_now();
+        log::debug!(
+            "Decreasing sending delay multiplier to: {}",
+            self.current_multiplier
+        );
+    }
+
+    fn record_backpressure_detected(&mut self) {
+        self.time_when_backpressure_detected = get_time_now();
+    }
+
+    fn not_increased_delay_recently(&self) -> bool {
+        get_time_now()
+            > self.time_when_changed + Duration::from_secs(INCREASE_DELAY_MIN_CHANGE_INTERVAL_SECS)
+    }
+
+    fn is_sending_reliable(&self) -> bool {
+        let now = get_time_now();
+        let delay_change_interval = Duration::from_secs(DECREASE_DELAY_MIN_CHANGE_INTERVAL_SECS);
+        let acceptable_time_without_backpressure =
+            Duration::from_secs(ACCEPTABLE_TIME_WITHOUT_BACKPRESSURE_SECS);
+
+        now > self.time_when_backpressure_detected + acceptable_time_without_backpressure
+            && now > self.time_when_changed + delay_change_interval
+    }
+}
+
 pub(crate) struct OutQueueControl<R>
 where
    R: CryptoRng + Rng,
@@ -89,6 +201,10 @@ where
    #[cfg(target_arch = "wasm32")]
    next_delay: Option<Pin<Box<wasm_timer::Delay>>>,

+    // To make sure we don't overload the mix_tx channel, we limit the rate we are pushing
+    // messages.
+    sending_rate_controller: SendingDelayController,
+
    /// Channel used for sending prepared sphinx packets to `MixTrafficController` that sends them
    /// out to the network without any further delays.
    mix_tx: BatchMixMessageSender,
@@ -156,6 +272,10 @@ where
            ack_key,
            sent_notifier,
            next_delay: None,
+            sending_rate_controller: SendingDelayController::new(
+                MIN_DELAY_MULTIPLIER,
+                MAX_DELAY_MULTIPLIER,
+            ),
            mix_tx,
            real_receiver,
            our_full_destination,
@@ -176,7 +296,7 @@ where
    async fn on_message(&mut self, next_message: StreamMessage) {
        trace!("created new message");

-        let next_message = match next_message {
+        let (next_message, fragment_id) = match next_message {
            StreamMessage::Cover => {
                // TODO for way down the line: in very rare cases (during topology update) we might have
                // to wait a really tiny bit before actually obtaining the permit hence messing with our
@@ -195,32 +315,35 @@ where
                }
                let topology_ref = topology_ref_option.unwrap();

-                generate_loop_cover_packet(
-                    &mut self.rng,
-                    topology_ref,
-                    &*self.ack_key,
-                    &self.our_full_destination,
-                    self.config.average_ack_delay,
-                    self.config.average_packet_delay,
-                    self.config.cover_packet_size,
+                (
+                    generate_loop_cover_packet(
+                        &mut self.rng,
+                        topology_ref,
+                        &self.ack_key,
+                        &self.our_full_destination,
+                        self.config.average_ack_delay,
+                        self.config.average_packet_delay,
+                        self.config.cover_packet_size,
+                    )
+                    .expect(
+                        "Somehow failed to generate a loop cover message with a valid topology",
+                    ),
+                    None,
                )
-                .expect("Somehow failed to generate a loop cover message with a valid topology")
            }
            StreamMessage::Real(real_message) => {
-                self.sent_notify(real_message.fragment_id);
-                real_message.mix_packet
+                (real_message.mix_packet, Some(real_message.fragment_id))
            }
        };

-        // if this one fails, there's no retrying because it means that either:
-        // - we run out of memory
-        // - the receiver channel is closed
-        // in either case there's no recovery and we can only panic
-        if let Err(err) = self.mix_tx.unbounded_send(vec![next_message]) {
-            log::warn!(
-                "Failed to send {} packets (possible process shutdown?)",
-                err.into_inner().len()
-            );
+        if let Err(err) = self.mix_tx.send(vec![next_message]).await {
+            log::error!("Failed to send - channel closed: {}", err);
+        }
+
+        // notify ack controller about sending our message only after we actually managed to push it
+        // through the channel
+        if let Some(fragment_id) = fragment_id {
+            self.sent_notify(fragment_id);
        }

        // JS: Not entirely sure why or how it fixes stuff, but without the yield call,
@@ -234,7 +357,44 @@ where
        tokio::task::yield_now().await;
    }

+    fn current_average_message_sending_delay(&self) -> Duration {
+        self.config.average_message_sending_delay
+            * self.sending_rate_controller.current_multiplier()
+    }
+
+    fn adjust_current_average_message_sending_delay(&mut self) {
+        let used_slots = self.mix_tx.max_capacity() - self.mix_tx.capacity();
+        log::trace!(
+            "used_slots: {used_slots}, current_multiplier: {}",
+            self.sending_rate_controller.current_multiplier()
+        );
+
+        // Even just a single used slot is enough to signal backpressure
+        if used_slots > 0 {
+            log::trace!("Backpressure detected");
+            self.sending_rate_controller.record_backpressure_detected();
+        }
+
+        // If the buffer is running out, slow down the sending rate
+        if self.mix_tx.capacity() == 0
+            && self.sending_rate_controller.not_increased_delay_recently()
+        {
+            self.sending_rate_controller.increase_delay_multiplier();
+        }
+
+        // Very carefully step up the sending rate in case it seems like we can solidly handle the
+        // current rate.
+        if self.sending_rate_controller.is_sending_reliable() {
+            self.sending_rate_controller.decrease_delay_multiplier();
+        }
+    }
+
    fn poll_poisson(&mut self, cx: &mut Context<'_>) -> Poll<Option<StreamMessage>> {
+        // The average delay could change depending on if backpressure in the downstream channel
+        // (mix_tx) was detected.
+        self.adjust_current_average_message_sending_delay();
+        let avg_delay = self.current_average_message_sending_delay();
+
        if let Some(ref mut next_delay) = &mut self.next_delay {
            // it is not yet time to return a message
            if next_delay.as_mut().poll(cx).is_pending() {
@@ -243,7 +403,6 @@ where

            // we know it's time to send a message, so let's prepare delay for the next one
            // Get the `now` by looking at the current `delay` deadline
-            let avg_delay = self.config.average_message_sending_delay;
            let next_poisson_delay = sample_poisson_duration(&mut self.rng, avg_delay);

            // The next interval value is `next_poisson_delay` after the one that just
@@ -12,7 +12,7 @@ use std::sync::Arc;
 use std::time;
 use std::time::Duration;
 use tokio::sync::{RwLock, RwLockReadGuard};
-use topology::{nym_topology_from_bonds, NymTopology};
+use topology::{nym_topology_from_detailed, NymTopology};
 use url::Url;

 // I'm extremely curious why compiler NEVER complained about lack of Debug here before
@@ -57,24 +57,15 @@ impl<'a> TopologyReadPermit<'a> {
    ) -> Option<&'a NymTopology> {
        // Note: implicit deref with Deref for TopologyReadPermit is happening here
        let topology_ref_option = self.permit.as_ref();
-        match topology_ref_option {
-            None => None,
-            Some(topology_ref) => {
-                // see if it's possible to route the packet to both gateways
-                if !topology_ref.can_construct_path_through(DEFAULT_NUM_MIX_HOPS)
-                    || !topology_ref.gateway_exists(ack_recipient.gateway())
-                    || if let Some(packet_recipient) = packet_recipient {
-                        !topology_ref.gateway_exists(packet_recipient.gateway())
-                    } else {
-                        false
-                    }
-                {
-                    None
+        topology_ref_option.as_ref().filter(|topology_ref| {
+            !(!topology_ref.can_construct_path_through(DEFAULT_NUM_MIX_HOPS)
+                || !topology_ref.gateway_exists(ack_recipient.gateway())
+                || if let Some(packet_recipient) = packet_recipient {
+                    !topology_ref.gateway_exists(packet_recipient.gateway())
                } else {
-                    Some(topology_ref)
-                }
-            }
-        }
+                    false
+                })
+        })
    }
 }

@@ -265,8 +256,8 @@ impl TopologyRefresher {
        };

        let mixnodes_count = mixnodes.len();
-        let topology =
-            nym_topology_from_bonds(mixnodes, gateways).filter_system_version(&self.client_version);
+        let topology = nym_topology_from_detailed(mixnodes, gateways)
+            .filter_system_version(&self.client_version);

        if !self.check_layer_distribution(&topology, mixnodes_count) {
            warn!("The current filtered active topology has extremely skewed layer distribution. It cannot be used.");
@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0

 use config::NymConfig;
+use nymsphinx::params::PacketSize;
 use serde::{Deserialize, Serialize};
 use std::marker::PhantomData;
 use std::path::PathBuf;
@@ -247,8 +248,8 @@ impl<T: NymConfig> Config<T> {
        self.debug.disable_main_poisson_packet_distribution
    }

-    pub fn get_use_extended_packet_size(&self) -> bool {
-        self.debug.use_extended_packet_size
+    pub fn get_use_extended_packet_size(&self) -> Option<ExtendedPacketSize> {
+        self.debug.use_extended_packet_size.clone()
    }

    pub fn get_version(&self) -> &str {
@@ -470,8 +471,16 @@ pub struct Debug {
    /// poisson distribution.
    pub disable_main_poisson_packet_distribution: bool,

-    /// Controls whether the sent sphinx packet use the NON-DEFAULT bigger size.
-    pub use_extended_packet_size: bool,
+    /// Controls whether the sent sphinx packet use a NON-DEFAULT bigger size.
+    pub use_extended_packet_size: Option<ExtendedPacketSize>,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "lowercase")]
+pub enum ExtendedPacketSize {
+    Extended8,
+    Extended16,
+    Extended32,
 }

 impl Default for Debug {
@@ -488,7 +497,17 @@ impl Default for Debug {
            topology_resolution_timeout: DEFAULT_TOPOLOGY_RESOLUTION_TIMEOUT,
            disable_loop_cover_traffic_stream: false,
            disable_main_poisson_packet_distribution: false,
-            use_extended_packet_size: false,
+            use_extended_packet_size: None,
+        }
+    }
+}
+
+impl From<ExtendedPacketSize> for PacketSize {
+    fn from(size: ExtendedPacketSize) -> PacketSize {
+        match size {
+            ExtendedPacketSize::Extended8 => PacketSize::ExtendedPacket8,
+            ExtendedPacketSize::Extended16 => PacketSize::ExtendedPacket16,
+            ExtendedPacketSize::Extended32 => PacketSize::ExtendedPacket32,
        }
    }
 }
@@ -24,4 +24,6 @@ pub enum ClientCoreError {
    ListOfValidatorApisIsEmpty,
    #[error("Could not load existing gateway configuration: {0}")]
    CouldNotLoadExistingGatewayConfiguration(std::io::Error),
+    #[error("The current network topology seem to be insufficient to route any packets through")]
+    InsufficientNetworkTopology,
 }
@@ -9,7 +9,7 @@ edition = "2021"
 async-trait = "0.1.52"
 bip39 = "1.0.1"
 cfg-if = "0.1"
-clap = { version = "3.0.10", features = ["cargo", "derive"] }
+clap = { version = "3.2", features = ["cargo", "derive"] }
 pickledb = "0.4.1"
 rand = "0.7.3"
 serde = { version = "1.0", features = ["derive"] }
@@ -19,6 +19,7 @@ tokio = { version = "1.21.2", features = ["rt-multi-thread", "net", "signal", "m

 coconut-interface = { path = "../../common/coconut-interface" }
 config = { path = "../../common/config" }
+completions = { path = "../../common/completions" }
 credentials = { path = "../../common/credentials" }
 credential-storage = { path = "../../common/credential-storage" }
 crypto = { path = "../../common/crypto", features = ["rand", "asymmetric", "symmetric", "aes", "hashing"] }
@@ -3,6 +3,7 @@

 use async_trait::async_trait;
 use clap::{Args, Subcommand};
+use completions::ArgShell;
 use pickledb::PickleDb;
 use rand::rngs::OsRng;
 use std::str::FromStr;
@@ -28,6 +29,12 @@ pub(crate) enum Commands {
    ListDeposits(ListDeposits),
    /// Get a credential for a given deposit
    GetCredential(GetCredential),
+
+    /// Generate shell completions
+    Completions(ArgShell),
+
+    /// Generate Fig specification
+    GenerateFigSpec,
 }

 #[async_trait]
@@ -12,6 +12,8 @@ cfg_if::cfg_if! {
        use commands::{Commands, Execute};
        use error::Result;
        use network_defaults::setup_env;
+        use clap::CommandFactory;
+        use completions::fig_generate;

        use clap::Parser;
        use pickledb::{PickleDb, PickleDbDumpPolicy, SerializationMethod};
@@ -52,10 +54,14 @@ cfg_if::cfg_if! {
                ),
            };

+            let bin_name = "nym-credential-client";
+
            match &args.command {
                Commands::Deposit(m) => m.execute(&mut db, shared_storage).await?,
                Commands::ListDeposits(m) => m.execute(&mut db, shared_storage).await?,
                Commands::GetCredential(m) => m.execute(&mut db, shared_storage).await?,
+                Commands::Completions(s) => s.generate(&mut crate::Cli::into_app(), bin_name),
+                Commands::GenerateFigSpec => fig_generate(&mut crate::Cli::into_app(), bin_name)
            }

            Ok(())
@@ -20,13 +20,14 @@ futures = "0.3" # bunch of futures stuff, however, now that I think about it, it
 # and the single instance of abortable we have should really be refactored anyway
 url = "2.2"

-clap = { version = "3.2.8", features = ["cargo", "derive"] }
+clap = { version = "3.2", features = ["cargo", "derive"] }
 dirs = "4.0"
 log = "0.4" # self explanatory
 pretty_env_logger = "0.4" # for formatting log messages
 rand = { version = "0.7.3", features = ["wasm-bindgen"] } # rng-related traits + some rng implementation to use
 serde = { version = "1.0.104", features = ["derive"] } # for config serialization/deserialization
 sled = "0.34" # for storage of replySURB decryption keys
+thiserror = "1.0.34"
 tokio = { version = "1.21.2", features = ["rt-multi-thread", "net", "signal"] } # async runtime
 tokio-tungstenite = "0.14" # websocket

@@ -34,9 +35,11 @@ tokio-tungstenite = "0.14" # websocket
 client-core = { path = "../client-core" }
 coconut-interface = { path = "../../common/coconut-interface", optional = true }
 config = { path = "../../common/config" }
+completions = { path = "../../common/completions" }
 credential-storage = { path = "../../common/credential-storage" }
 credentials = { path = "../../common/credentials", optional = true }
 crypto = { path = "../../common/crypto" }
+logging = { path = "../../common/logging"}
 gateway-client = { path = "../../common/client-libs/gateway-client" }
 gateway-requests = { path = "../../gateway/gateway-requests" }
 network-defaults = { path = "../../common/network-defaults" }
@@ -6,9 +6,7 @@ use client_core::client::inbound_messages::{
    InputMessage, InputMessageReceiver, InputMessageSender,
 };
 use client_core::client::key_manager::KeyManager;
-use client_core::client::mix_traffic::{
-    BatchMixMessageReceiver, BatchMixMessageSender, MixTrafficController,
-};
+use client_core::client::mix_traffic::{BatchMixMessageSender, MixTrafficController};
 use client_core::client::real_messages_control;
 use client_core::client::real_messages_control::RealMessagesController;
 use client_core::client::received_buffer::{
@@ -20,6 +18,7 @@ use client_core::client::topology_control::{
    TopologyAccessor, TopologyRefresher, TopologyRefresherConfig,
 };
 use client_core::config::persistence::key_pathfinder::ClientKeyPathfinder;
+use client_core::error::ClientCoreError;
 use crypto::asymmetric::identity;
 use futures::channel::mpsc;
 use gateway_client::bandwidth::BandwidthController;
@@ -31,11 +30,11 @@ use log::*;
 use nymsphinx::addressing::clients::Recipient;
 use nymsphinx::addressing::nodes::NodeIdentity;
 use nymsphinx::anonymous_replies::ReplySurb;
-use nymsphinx::params::PacketSize;
 use nymsphinx::receiver::ReconstructedMessage;
 use task::{wait_for_signal, ShutdownListener, ShutdownNotifier};

 use crate::client::config::{Config, SocketType};
+use crate::error::ClientError;
 use crate::websocket;

 pub(crate) mod config;
@@ -103,8 +102,9 @@ impl NymClient {
            topology_accessor,
        );

-        if self.config.get_base().get_use_extended_packet_size() {
-            stream.set_custom_packet_size(PacketSize::ExtendedPacket)
+        if let Some(size) = self.config.get_base().get_use_extended_packet_size() {
+            log::debug!("Setting extended packet size: {:?}", size);
+            stream.set_custom_packet_size(size.into());
        }

        stream.start_with_shutdown(shutdown);
@@ -132,8 +132,9 @@ impl NymClient {
            self.as_mix_recipient(),
        );

-        if self.config.get_base().get_use_extended_packet_size() {
-            controller_config.set_custom_packet_size(PacketSize::ExtendedPacket)
+        if let Some(size) = self.config.get_base().get_use_extended_packet_size() {
+            log::debug!("Setting extended packet size: {:?}", size);
+            controller_config.set_custom_packet_size(size.into());
        }

        info!("Starting real traffic stream...");
@@ -233,7 +234,7 @@ impl NymClient {
        &mut self,
        topology_accessor: TopologyAccessor,
        shutdown: ShutdownListener,
-    ) {
+    ) -> Result<(), ClientError> {
        let topology_refresher_config = TopologyRefresherConfig::new(
            self.config.get_base().get_validator_api_endpoints(),
            self.config.get_base().get_topology_refresh_rate(),
@@ -248,14 +249,16 @@ impl NymClient {

        // TODO: a slightly more graceful termination here
        if !topology_refresher.is_topology_routable().await {
-            panic!(
-                "The current network topology seem to be insufficient to route any packets through\
+            log::error!(
+                "The current network topology seem to be insufficient to route any packets through \
                - check if enough nodes and a gateway are online"
            );
+            return Err(ClientCoreError::InsufficientNetworkTopology.into());
        }

        info!("Starting topology refresher...");
        topology_refresher.start_with_shutdown(shutdown);
+        Ok(())
    }

    // controller for sending sphinx packets to mixnet (either real traffic or cover traffic)
@@ -263,13 +266,13 @@ impl NymClient {
    // over it. Perhaps GatewayClient needs to be thread-shareable or have some channel for
    // requests?
    fn start_mix_traffic_controller(
-        &mut self,
-        mix_rx: BatchMixMessageReceiver,
        gateway_client: GatewayClient,
        shutdown: ShutdownListener,
-    ) {
+    ) -> BatchMixMessageSender {
        info!("Starting mix traffic controller...");
-        MixTrafficController::new(mix_rx, gateway_client).start_with_shutdown(shutdown);
+        let (mix_traffic_controller, mix_tx) = MixTrafficController::new(gateway_client);
+        mix_traffic_controller.start_with_shutdown(shutdown);
+        mix_tx
    }

    fn start_websocket_listener(
@@ -329,8 +332,8 @@ impl NymClient {
    }

    /// blocking version of `start` method. Will run forever (or until SIGINT is sent)
-    pub async fn run_forever(&mut self) {
-        let shutdown = self.start().await;
+    pub async fn run_forever(&mut self) -> Result<(), ClientError> {
+        let shutdown = self.start().await?;
        wait_for_signal().await;

        println!(
@@ -347,20 +350,16 @@ impl NymClient {
        //shutdown.wait_for_shutdown().await;

        log::info!("Stopping nym-client");
+        Ok(())
    }

-    pub async fn start(&mut self) -> ShutdownNotifier {
+    pub async fn start(&mut self) -> Result<ShutdownNotifier, ClientError> {
        info!("Starting nym client");
        // channels for inter-component communication
        // TODO: make the channels be internally created by the relevant components
        // rather than creating them here, so say for example the buffer controller would create the request channels
        // and would allow anyone to clone the sender channel

-        // sphinx_message_sender is the transmitter for any component generating sphinx packets that are to be sent to the mixnet
-        // they are used by cover traffic stream and real traffic stream
-        // sphinx_message_receiver is the receiver used by MixTrafficController that sends the actual traffic
-        let (sphinx_message_sender, sphinx_message_receiver) = mpsc::unbounded();
-
        // unwrapped_sphinx_sender is the transmitter of mixnet messages received from the gateway
        // unwrapped_sphinx_receiver is the receiver for said messages - used by ReceivedMessagesBuffer
        let (mixnet_messages_sender, mixnet_messages_receiver) = mpsc::unbounded();
@@ -385,7 +384,7 @@ impl NymClient {
        // the components are started in very specific order. Unless you know what you are doing,
        // do not change that.
        self.start_topology_refresher(shared_topology_accessor.clone(), shutdown.subscribe())
-            .await;
+            .await?;
        self.start_received_messages_buffer_controller(
            received_buffer_request_receiver,
            mixnet_messages_receiver,
@@ -397,11 +396,13 @@ impl NymClient {
            .start_gateway_client(mixnet_messages_sender, ack_sender, shutdown.subscribe())
            .await;

-        self.start_mix_traffic_controller(
-            sphinx_message_receiver,
-            gateway_client,
-            shutdown.subscribe(),
-        );
+        // The sphinx_message_sender is the transmitter for any component generating sphinx packets
+        // that are to be sent to the mixnet. They are used by cover traffic stream and real
+        // traffic stream.
+        // The MixTrafficController then sends the actual traffic
+        let sphinx_message_sender =
+            Self::start_mix_traffic_controller(gateway_client, shutdown.subscribe());
+
        self.start_real_traffic_controller(
            shared_topology_accessor.clone(),
            reply_key_storage,
@@ -447,6 +448,6 @@ impl NymClient {
        info!("Client startup finished!");
        info!("The address of this client is: {}", self.as_mix_recipient());

-        shutdown
+        Ok(shutdown)
    }
 }
@@ -2,7 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::client::config::{Config, SocketType};
+use crate::error::ClientError;
+use clap::CommandFactory;
 use clap::{Parser, Subcommand};
+use completions::{fig_generate, ArgShell};

 pub(crate) mod init;
 pub(crate) mod run;
@@ -62,6 +65,12 @@ pub(crate) enum Commands {
    Run(run::Run),
    /// Try to upgrade the client
    Upgrade(upgrade::Upgrade),
+
+    /// Generate shell completions
+    Completions(ArgShell),
+
+    /// Generate Fig specification
+    GenerateFigSpec,
 }

 // Configuration that can be overridden.
@@ -75,12 +84,17 @@ pub(crate) struct OverrideConfig {
    enabled_credentials_mode: bool,
 }

-pub(crate) async fn execute(args: &Cli) {
+pub(crate) async fn execute(args: &Cli) -> Result<(), ClientError> {
+    let bin_name = "nym-native-client";
+
    match &args.command {
        Commands::Init(m) => init::execute(m).await,
-        Commands::Run(m) => run::execute(m).await,
+        Commands::Run(m) => run::execute(m).await?,
        Commands::Upgrade(m) => upgrade::execute(m),
+        Commands::Completions(s) => s.generate(&mut Cli::into_app(), bin_name),
+        Commands::GenerateFigSpec => fig_generate(&mut Cli::into_app(), bin_name),
    }
+    Ok(())
 }

 pub(crate) fn override_config(mut config: Config, args: OverrideConfig) -> Config {
@@ -4,6 +4,7 @@
 use crate::{
    client::{config::Config, NymClient},
    commands::{override_config, OverrideConfig},
+    error::ClientError,
 };

 use clap::Args;
@@ -73,14 +74,14 @@ fn version_check(cfg: &Config) -> bool {
    }
 }

-pub(crate) async fn execute(args: &Run) {
+pub(crate) async fn execute(args: &Run) -> Result<(), ClientError> {
    let id = &args.id;

    let mut config = match Config::load_from_file(Some(id)) {
        Ok(cfg) => cfg,
        Err(err) => {
            error!("Failed to load config for {}. Are you sure you have run `init` before? (Error was: {})", id, err);
-            return;
+            return Err(ClientError::FailedToLoadConfig(id.to_string()));
        }
    };

@@ -89,8 +90,8 @@ pub(crate) async fn execute(args: &Run) {

    if !version_check(&config) {
        error!("failed the local version check");
-        return;
+        return Err(ClientError::FailedLocalVersionCheck);
    }

-    NymClient::new(config).run_forever().await;
+    NymClient::new(config).run_forever().await
 }
@@ -103,7 +103,7 @@ fn minor_0_12_upgrade(
        Version::new(0, 12, 0)
    };

-    print_start_upgrade(&config_version, &to_version);
+    print_start_upgrade(config_version, &to_version);

    config
        .get_base_mut()
@@ -111,7 +111,7 @@ fn minor_0_12_upgrade(

    config.save_to_file(None).unwrap_or_else(|err| {
        eprintln!("failed to overwrite config file! - {:?}", err);
-        print_failed_upgrade(&config_version, &to_version);
+        print_failed_upgrade(config_version, &to_version);
        process::exit(1);
    });

@@ -0,0 +1,23 @@
+use client_core::error::ClientCoreError;
+use crypto::asymmetric::identity::Ed25519RecoveryError;
+use gateway_client::error::GatewayClientError;
+use validator_client::ValidatorClientError;
+
+#[derive(thiserror::Error, Debug)]
+pub enum ClientError {
+    #[error("I/O error: {0}")]
+    IoError(#[from] std::io::Error),
+    #[error("Gateway client error: {0}")]
+    GatewayClientError(#[from] GatewayClientError),
+    #[error("Ed25519 error: {0}")]
+    Ed25519RecoveryError(#[from] Ed25519RecoveryError),
+    #[error("Validator client error: {0}")]
+    ValidatorClientError(#[from] ValidatorClientError),
+    #[error("client-core error: {0}")]
+    ClientCoreError(#[from] ClientCoreError),
+
+    #[error("Failed to load config for: {0}")]
+    FailedToLoadConfig(String),
+    #[error("Failed local version check, client and config mismatch")]
+    FailedLocalVersionCheck,
+}
@@ -2,4 +2,5 @@
 // SPDX-License-Identifier: Apache-2.0

 pub mod client;
+pub mod error;
 pub mod websocket;
@@ -2,20 +2,23 @@
 // SPDX-License-Identifier: Apache-2.0

 use clap::{crate_version, Parser};
+use error::ClientError;
+use logging::setup_logging;
 use network_defaults::setup_env;

 pub mod client;
 pub mod commands;
+pub mod error;
 pub mod websocket;

 #[tokio::main]
-async fn main() {
+async fn main() -> Result<(), ClientError> {
    setup_logging();
    println!("{}", banner());

    let args = commands::Cli::parse();
    setup_env(args.config_env_file.clone());
-    commands::execute(&args).await;
+    commands::execute(&args).await
 }

 fn banner() -> String {
@@ -34,25 +37,3 @@ fn banner() -> String {
        crate_version!()
    )
 }
-
-fn setup_logging() {
-    let mut log_builder = pretty_env_logger::formatted_timed_builder();
-    if let Ok(s) = ::std::env::var("RUST_LOG") {
-        log_builder.parse_filters(&s);
-    } else {
-        // default to 'Info'
-        log_builder.filter(None, log::LevelFilter::Info);
-    }
-
-    log_builder
-        .filter_module("hyper", log::LevelFilter::Warn)
-        .filter_module("tokio_reactor", log::LevelFilter::Warn)
-        .filter_module("reqwest", log::LevelFilter::Warn)
-        .filter_module("mio", log::LevelFilter::Warn)
-        .filter_module("want", log::LevelFilter::Warn)
-        .filter_module("tungstenite", log::LevelFilter::Warn)
-        .filter_module("tokio_tungstenite", log::LevelFilter::Warn)
-        .filter_module("handlebars", log::LevelFilter::Warn)
-        .filter_module("sled", log::LevelFilter::Warn)
-        .init();
-}
@@ -11,7 +11,7 @@ name = "nym_socks5"
 path = "src/lib.rs"

 [dependencies]
-clap = { version = "3.2.8", features = ["cargo", "derive"] }
+clap = { version = "3.2", features = ["cargo", "derive"] }
 dirs = "4.0"
 futures = "0.3"
 log = "0.4"
@@ -20,6 +20,7 @@ pretty_env_logger = "0.4"
 rand = { version = "0.7.3", features = ["wasm-bindgen"] }
 serde = { version = "1.0", features = ["derive"] } # for config serialization/deserialization
 snafu = "0.6"
+thiserror = "1.0.34"
 tokio = { version = "1.21.2", features = ["rt-multi-thread", "net", "signal"] }
 url = "2.2"

@@ -27,9 +28,11 @@ url = "2.2"
 client-core = { path = "../client-core" }
 coconut-interface = { path = "../../common/coconut-interface", optional = true }
 config = { path = "../../common/config" }
+completions = { path = "../../common/completions" }
 credential-storage = { path = "../../common/credential-storage" }
 credentials = { path = "../../common/credentials", optional = true }
 crypto = { path = "../../common/crypto" }
+logging = { path = "../../common/logging"}
 gateway-client = { path = "../../common/client-libs/gateway-client" }
 gateway-requests = { path = "../../gateway/gateway-requests" }
 network-defaults = { path = "../../common/network-defaults" }
@@ -3,14 +3,18 @@

 use std::sync::atomic::Ordering;

+use crate::client::config::Config;
+use crate::error::Socks5ClientError;
+use crate::socks::{
+    authentication::{AuthenticationMethods, Authenticator, User},
+    server::SphinxSocksServer,
+};
 use client_core::client::cover_traffic_stream::LoopCoverTrafficStream;
 use client_core::client::inbound_messages::{
    InputMessage, InputMessageReceiver, InputMessageSender,
 };
 use client_core::client::key_manager::KeyManager;
-use client_core::client::mix_traffic::{
-    BatchMixMessageReceiver, BatchMixMessageSender, MixTrafficController,
-};
+use client_core::client::mix_traffic::{BatchMixMessageSender, MixTrafficController};
 use client_core::client::real_messages_control::RealMessagesController;
 use client_core::client::received_buffer::{
    ReceivedBufferRequestReceiver, ReceivedBufferRequestSender, ReceivedMessagesBufferController,
@@ -20,6 +24,7 @@ use client_core::client::topology_control::{
    TopologyAccessor, TopologyRefresher, TopologyRefresherConfig,
 };
 use client_core::config::persistence::key_pathfinder::ClientKeyPathfinder;
+use client_core::error::ClientCoreError;
 use crypto::asymmetric::identity;
 use futures::channel::mpsc;
 use futures::StreamExt;
@@ -31,15 +36,8 @@ use gateway_client::{
 use log::*;
 use nymsphinx::addressing::clients::Recipient;
 use nymsphinx::addressing::nodes::NodeIdentity;
-use nymsphinx::params::PacketSize;
 use task::{wait_for_signal, ShutdownListener, ShutdownNotifier};

-use crate::client::config::Config;
-use crate::socks::{
-    authentication::{AuthenticationMethods, Authenticator, User},
-    server::SphinxSocksServer,
-};
-
 pub mod config;

 // Channels used to control the main task from outside
@@ -104,8 +102,9 @@ impl NymClient {
            topology_accessor,
        );

-        if self.config.get_base().get_use_extended_packet_size() {
-            stream.set_custom_packet_size(PacketSize::ExtendedPacket)
+        if let Some(size) = self.config.get_base().get_use_extended_packet_size() {
+            log::debug!("Setting extended packet size: {:?}", size);
+            stream.set_custom_packet_size(size.into());
        }

        stream.start_with_shutdown(shutdown);
@@ -133,8 +132,9 @@ impl NymClient {
            self.as_mix_recipient(),
        );

-        if self.config.get_base().get_use_extended_packet_size() {
-            controller_config.set_custom_packet_size(PacketSize::ExtendedPacket)
+        if let Some(size) = self.config.get_base().get_use_extended_packet_size() {
+            log::debug!("Setting extended packet size: {:?}", size);
+            controller_config.set_custom_packet_size(size.into());
        }

        info!("Starting real traffic stream...");
@@ -234,7 +234,7 @@ impl NymClient {
        &mut self,
        topology_accessor: TopologyAccessor,
        shutdown: ShutdownListener,
-    ) {
+    ) -> Result<(), Socks5ClientError> {
        let topology_refresher_config = TopologyRefresherConfig::new(
            self.config.get_base().get_validator_api_endpoints(),
            self.config.get_base().get_topology_refresh_rate(),
@@ -249,14 +249,16 @@ impl NymClient {

        // TODO: a slightly more graceful termination here
        if !topology_refresher.is_topology_routable().await {
-            panic!(
-                "The current network topology seem to be insufficient to route any packets through\
+            log::error!(
+                "The current network topology seem to be insufficient to route any packets through \
                - check if enough nodes and a gateway are online"
            );
+            return Err(ClientCoreError::InsufficientNetworkTopology.into());
        }

        info!("Starting topology refresher...");
        topology_refresher.start_with_shutdown(shutdown);
+        Ok(())
    }

    // controller for sending sphinx packets to mixnet (either real traffic or cover traffic)
@@ -264,13 +266,13 @@ impl NymClient {
    // over it. Perhaps GatewayClient needs to be thread-shareable or have some channel for
    // requests?
    fn start_mix_traffic_controller(
-        &mut self,
-        mix_rx: BatchMixMessageReceiver,
        gateway_client: GatewayClient,
        shutdown: ShutdownListener,
-    ) {
+    ) -> BatchMixMessageSender {
        info!("Starting mix traffic controller...");
-        MixTrafficController::new(mix_rx, gateway_client).start_with_shutdown(shutdown);
+        let (mix_traffic_controller, mix_tx) = MixTrafficController::new(gateway_client);
+        mix_traffic_controller.start_with_shutdown(shutdown);
+        mix_tx
    }

    fn start_socks5_listener(
@@ -295,8 +297,8 @@ impl NymClient {
    }

    /// blocking version of `start` method. Will run forever (or until SIGINT is sent)
-    pub async fn run_forever(&mut self) {
-        let mut shutdown = self.start().await;
+    pub async fn run_forever(&mut self) -> Result<(), Socks5ClientError> {
+        let mut shutdown = self.start().await?;
        wait_for_signal().await;

        log::info!("Sending shutdown");
@@ -307,11 +309,15 @@ impl NymClient {
        shutdown.wait_for_shutdown().await;

        log::info!("Stopping nym-socks5-client");
+        Ok(())
    }

    // Variant of `run_forever` that listends for remote control messages
-    pub async fn run_and_listen(&mut self, mut receiver: Socks5ControlMessageReceiver) {
-        let mut shutdown = self.start().await;
+    pub async fn run_and_listen(
+        &mut self,
+        mut receiver: Socks5ControlMessageReceiver,
+    ) -> Result<(), Socks5ClientError> {
+        let mut shutdown = self.start().await?;
        tokio::select! {
            message = receiver.next() => {
                log::debug!("Received message: {:?}", message);
@@ -337,20 +343,16 @@ impl NymClient {
        shutdown.wait_for_shutdown().await;

        log::info!("Stopping nym-socks5-client");
+        Ok(())
    }

-    pub async fn start(&mut self) -> ShutdownNotifier {
+    pub async fn start(&mut self) -> Result<ShutdownNotifier, Socks5ClientError> {
        info!("Starting nym client");
        // channels for inter-component communication
        // TODO: make the channels be internally created by the relevant components
        // rather than creating them here, so say for example the buffer controller would create the request channels
        // and would allow anyone to clone the sender channel

-        // sphinx_message_sender is the transmitter for any component generating sphinx packets that are to be sent to the mixnet
-        // they are used by cover traffic stream and real traffic stream
-        // sphinx_message_receiver is the receiver used by MixTrafficController that sends the actual traffic
-        let (sphinx_message_sender, sphinx_message_receiver) = mpsc::unbounded();
-
        // unwrapped_sphinx_sender is the transmitter of mixnet messages received from the gateway
        // unwrapped_sphinx_receiver is the receiver for said messages - used by ReceivedMessagesBuffer
        let (mixnet_messages_sender, mixnet_messages_receiver) = mpsc::unbounded();
@@ -375,7 +377,7 @@ impl NymClient {
        // the components are started in very specific order. Unless you know what you are doing,
        // do not change that.
        self.start_topology_refresher(shared_topology_accessor.clone(), shutdown.subscribe())
-            .await;
+            .await?;
        self.start_received_messages_buffer_controller(
            received_buffer_request_receiver,
            mixnet_messages_receiver,
@@ -387,11 +389,13 @@ impl NymClient {
            .start_gateway_client(mixnet_messages_sender, ack_sender, shutdown.subscribe())
            .await;

-        self.start_mix_traffic_controller(
-            sphinx_message_receiver,
-            gateway_client,
-            shutdown.subscribe(),
-        );
+        // The sphinx_message_sender is the transmitter for any component generating sphinx packets
+        // that are to be sent to the mixnet. They are used by cover traffic stream and real
+        // traffic stream.
+        // The MixTrafficController then sends the actual traffic
+        let sphinx_message_sender =
+            Self::start_mix_traffic_controller(gateway_client, shutdown.subscribe());
+
        self.start_real_traffic_controller(
            shared_topology_accessor.clone(),
            reply_key_storage,
@@ -422,6 +426,6 @@ impl NymClient {
        info!("Client startup finished!");
        info!("The address of this client is: {}", self.as_mix_recipient());

-        shutdown
+        Ok(shutdown)
    }
 }
@@ -2,7 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::client::config::Config;
+use crate::error::Socks5ClientError;
+use clap::CommandFactory;
 use clap::{Parser, Subcommand};
+use completions::{fig_generate, ArgShell};
 use config::parse_validators;

 pub mod init;
@@ -63,6 +66,12 @@ pub(crate) enum Commands {
    Run(run::Run),
    /// Try to upgrade the client
    Upgrade(upgrade::Upgrade),
+
+    /// Generate shell completions
+    Completions(ArgShell),
+
+    /// Generate Fig specification
+    GenerateFigSpec,
 }

 // Configuration that can be overridden.
@@ -75,12 +84,17 @@ pub(crate) struct OverrideConfig {
    enabled_credentials_mode: bool,
 }

-pub(crate) async fn execute(args: &Cli) {
+pub(crate) async fn execute(args: &Cli) -> Result<(), Socks5ClientError> {
+    let bin_name = "nym-socks5-client";
+
    match &args.command {
        Commands::Init(m) => init::execute(m).await,
-        Commands::Run(m) => run::execute(m).await,
+        Commands::Run(m) => run::execute(m).await?,
        Commands::Upgrade(m) => upgrade::execute(m),
+        Commands::Completions(s) => s.generate(&mut Cli::into_app(), bin_name),
+        Commands::GenerateFigSpec => fig_generate(&mut Cli::into_app(), bin_name),
    }
+    Ok(())
 }

 pub(crate) fn override_config(mut config: Config, args: OverrideConfig) -> Config {
@@ -4,6 +4,7 @@
 use crate::{
    client::{config::Config, NymClient},
    commands::{override_config, OverrideConfig},
+    error::Socks5ClientError,
 };

 use clap::Args;
@@ -80,14 +81,14 @@ fn version_check(cfg: &Config) -> bool {
    }
 }

-pub(crate) async fn execute(args: &Run) {
+pub(crate) async fn execute(args: &Run) -> Result<(), Socks5ClientError> {
    let id = &args.id;

    let mut config = match Config::load_from_file(Some(id)) {
        Ok(cfg) => cfg,
        Err(err) => {
            error!("Failed to load config for {}. Are you sure you have run `init` before? (Error was: {})", id, err);
-            return;
+            return Err(Socks5ClientError::FailedToLoadConfig(id.to_string()));
        }
    };

@@ -96,8 +97,8 @@ pub(crate) async fn execute(args: &Run) {

    if !version_check(&config) {
        error!("failed the local version check");
-        return;
+        return Err(Socks5ClientError::FailedLocalVersionCheck);
    }

-    NymClient::new(config).run_forever().await;
+    NymClient::new(config).run_forever().await
 }
@@ -102,7 +102,7 @@ fn minor_0_12_upgrade(
        Version::new(0, 12, 0)
    };

-    print_start_upgrade(&config_version, &to_version);
+    print_start_upgrade(config_version, &to_version);

    config
        .get_base_mut()
@@ -110,7 +110,7 @@ fn minor_0_12_upgrade(

    config.save_to_file(None).unwrap_or_else(|err| {
        eprintln!("failed to overwrite config file! - {:?}", err);
-        print_failed_upgrade(&config_version, &to_version);
+        print_failed_upgrade(config_version, &to_version);
        process::exit(1);
    });

@@ -0,0 +1,23 @@
+use client_core::error::ClientCoreError;
+use crypto::asymmetric::identity::Ed25519RecoveryError;
+use gateway_client::error::GatewayClientError;
+use validator_client::ValidatorClientError;
+
+#[derive(thiserror::Error, Debug)]
+pub enum Socks5ClientError {
+    #[error("I/O error: {0}")]
+    IoError(#[from] std::io::Error),
+    #[error("Gateway client error: {0}")]
+    GatewayClientError(#[from] GatewayClientError),
+    #[error("Ed25519 error: {0}")]
+    Ed25519RecoveryError(#[from] Ed25519RecoveryError),
+    #[error("Validator client error: {0}")]
+    ValidatorClientError(#[from] ValidatorClientError),
+    #[error("client-core error: {0}")]
+    ClientCoreError(#[from] ClientCoreError),
+
+    #[error("Failed to load config for: {0}")]
+    FailedToLoadConfig(String),
+    #[error("Failed local version check, client and config mismatch")]
+    FailedLocalVersionCheck,
+}
@@ -2,4 +2,5 @@
 // SPDX-License-Identifier: Apache-2.0

 pub mod client;
+pub mod error;
 pub mod socks;
@@ -2,20 +2,23 @@
 // SPDX-License-Identifier: Apache-2.0

 use clap::{crate_version, Parser};
+use error::Socks5ClientError;
+use logging::setup_logging;
 use network_defaults::setup_env;

 pub mod client;
 mod commands;
+pub mod error;
 pub mod socks;

 #[tokio::main]
-async fn main() {
+async fn main() -> Result<(), Socks5ClientError> {
    setup_logging();
    println!("{}", banner());

    let args = commands::Cli::parse();
    setup_env(args.config_env_file.clone());
-    commands::execute(&args).await;
+    commands::execute(&args).await
 }

 fn banner() -> String {
@@ -34,23 +37,3 @@ fn banner() -> String {
        crate_version!()
    )
 }
-
-fn setup_logging() {
-    let mut log_builder = pretty_env_logger::formatted_timed_builder();
-    if let Ok(s) = ::std::env::var("RUST_LOG") {
-        log_builder.parse_filters(&s);
-    } else {
-        // default to 'Info'
-        log_builder.filter(None, log::LevelFilter::Info);
-    }
-
-    log_builder
-        .filter_module("hyper", log::LevelFilter::Warn)
-        .filter_module("tokio_reactor", log::LevelFilter::Warn)
-        .filter_module("reqwest", log::LevelFilter::Warn)
-        .filter_module("mio", log::LevelFilter::Warn)
-        .filter_module("want", log::LevelFilter::Warn)
-        .filter_module("tungstenite", log::LevelFilter::Warn)
-        .filter_module("tokio_tungstenite", log::LevelFilter::Warn)
-        .init();
-}
@@ -55,10 +55,8 @@ wee_alloc = { version = "0.4", optional = true }
 wasm-bindgen-test = "0.3"

 [package.metadata.wasm-pack.profile.release]
-wasm-opt = true 
+wasm-opt = true

 [profile.release]
 lto = true
-opt-level = 'z'
-
-
+opt-level = 'z'
@@ -36,4 +36,4 @@
  "dependencies": {
    "@nymproject/nym-client-wasm": "file:../pkg"
  }
-}
+}
@@ -27,6 +27,7 @@ module.exports = {
        },
      ],
    }),
+
  ],
  experiments: { syncWebAssembly: true },
 };
@@ -17,7 +17,7 @@ importScripts('nym_client_wasm.js');
 console.log('Initializing worker');

 // wasm_bindgen creates a global variable (with the exports attached) that is in scope after `importScripts`
-const { default_debug, get_gateway, NymClient, set_panic_hook, Config, GatewayEndpoint } = wasm_bindgen;
+const { default_debug, get_gateway, NymClient, set_panic_hook, Config } = wasm_bindgen;

 class ClientWrapper {
  constructor(config, onMessageHandler) {
@@ -61,12 +61,19 @@ async function main() {
  // sets up better stack traces in case of in-rust panics
  set_panic_hook();

+  console.error("the current mainnet is not compatible with v2! - either use the pre-merge branch or explicitly set the client to use one of V2 QA networks")
+  return
+
  // validator server we will use to get topology from
+  // MAINNET (V1):
  const validator = 'https://validator.nymtech.net/api'; //"http://localhost:8081";
  const preferredGateway = 'E3mvZTHQCdBvhfr178Swx9g4QG3kkRUun7YnToLMcMbM';
+  // QA (V2):
+  // const validator = 'https://qa-validator-api.nymtech.net/api'; //"http://localhost:8081";
+  // const preferredGateway = 'CgQrYP8etksSBf4nALNqp93SHPpgFwEUyTsjBNNLj5WM';

-  var gatewayEndpoint = await get_gateway(validator, preferredGateway);
-  gatewayEndpoint.gateway_listener = "wss://gateway1.nymtech.net:443";
+  const gatewayEndpoint = await get_gateway(validator, preferredGateway);
+  gatewayEndpoint.gateway_listener = "wss://gateway1.nymtech.net:443"; // this is needed if we want it to work on the web. However this gateway is a v1 gateway, we will need to change for v2 once we get there

  // only really useful if you want to adjust some settings like traffic rate
  // (if not needed you can just pass a null)
@@ -1,7 +1,10 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use client_core::config::{Debug as ConfigDebug, GatewayEndpoint};
+// due to expansion of #[wasm_bindgen] macro on `Debug` Config struct
+#![allow(clippy::drop_non_drop)]
+
+use client_core::config::{Debug as ConfigDebug, ExtendedPacketSize, GatewayEndpoint};
 use std::time::Duration;
 use url::Url;
 use wasm_bindgen::prelude::*;
@@ -104,6 +107,11 @@ pub struct Debug {

 impl From<Debug> for ConfigDebug {
    fn from(debug: Debug) -> Self {
+        // For now we just always use the (older) 32kb extended size
+        let use_extended_packet_size = debug
+            .use_extended_packet_size
+            .then(|| ExtendedPacketSize::Extended32);
+
        ConfigDebug {
            average_packet_delay: Duration::from_millis(debug.average_packet_delay_ms),
            average_ack_delay: Duration::from_millis(debug.average_ack_delay_ms),
@@ -123,7 +131,7 @@ impl From<Debug> for ConfigDebug {
            disable_loop_cover_traffic_stream: debug.disable_loop_cover_traffic_stream,
            disable_main_poisson_packet_distribution: debug
                .disable_main_poisson_packet_distribution,
-            use_extended_packet_size: debug.use_extended_packet_size,
+            use_extended_packet_size,
        }
    }
 }
@@ -145,7 +153,7 @@ impl From<ConfigDebug> for Debug {
            disable_loop_cover_traffic_stream: debug.disable_loop_cover_traffic_stream,
            disable_main_poisson_packet_distribution: debug
                .disable_main_poisson_packet_distribution,
-            use_extended_packet_size: debug.use_extended_packet_size,
+            use_extended_packet_size: debug.use_extended_packet_size.is_some(),
        }
    }
 }
@@ -6,7 +6,7 @@ use client_core::client::{
    cover_traffic_stream::LoopCoverTrafficStream,
    inbound_messages::{InputMessage, InputMessageReceiver, InputMessageSender},
    key_manager::KeyManager,
-    mix_traffic::{BatchMixMessageReceiver, BatchMixMessageSender, MixTrafficController},
+    mix_traffic::{BatchMixMessageSender, MixTrafficController},
    real_messages_control::{self, RealMessagesController},
    received_buffer::{
        ReceivedBufferMessage, ReceivedBufferRequestReceiver, ReceivedBufferRequestSender,
@@ -22,7 +22,6 @@ use gateway_client::{
    MixnetMessageSender,
 };
 use nymsphinx::addressing::clients::Recipient;
-use nymsphinx::params::PacketSize;
 use rand::rngs::OsRng;
 use wasm_bindgen::prelude::*;
 use wasm_bindgen_futures::spawn_local;
@@ -110,8 +109,8 @@ impl NymClient {
            topology_accessor,
        );

-        if self.config.debug.use_extended_packet_size {
-            stream.set_custom_packet_size(PacketSize::ExtendedPacket)
+        if let Some(size) = &self.config.debug.use_extended_packet_size {
+            stream.set_custom_packet_size(size.clone().into());
        }

        stream.start();
@@ -135,8 +134,8 @@ impl NymClient {
            self.as_mix_recipient(),
        );

-        if self.config.debug.use_extended_packet_size {
-            controller_config.set_custom_packet_size(PacketSize::ExtendedPacket)
+        if let Some(size) = &self.config.debug.use_extended_packet_size {
+            controller_config.set_custom_packet_size(size.clone().into());
        }

        console_log!("Starting real traffic stream...");
@@ -253,13 +252,11 @@ impl NymClient {
    // TODO: if we want to send control messages to gateway_client, this CAN'T take the ownership
    // over it. Perhaps GatewayClient needs to be thread-shareable or have some channel for
    // requests?
-    fn start_mix_traffic_controller(
-        &mut self,
-        mix_rx: BatchMixMessageReceiver,
-        gateway_client: GatewayClient,
-    ) {
+    fn start_mix_traffic_controller(gateway_client: GatewayClient) -> BatchMixMessageSender {
        console_log!("Starting mix traffic controller...");
-        MixTrafficController::new(mix_rx, gateway_client).start();
+        let (mix_traffic_controller, mix_tx) = MixTrafficController::new(gateway_client);
+        mix_traffic_controller.start();
+        mix_tx
    }

    // TODO: this procedure is extremely overcomplicated, because it's based off native client's behaviour
@@ -307,11 +304,6 @@ impl NymClient {
        // rather than creating them here, so say for example the buffer controller would create the request channels
        // and would allow anyone to clone the sender channel

-        // sphinx_message_sender is the transmitter for any component generating sphinx packets that are to be sent to the mixnet
-        // they are used by cover traffic stream and real traffic stream
-        // sphinx_message_receiver is the receiver used by MixTrafficController that sends the actual traffic
-        let (sphinx_message_sender, sphinx_message_receiver) = mpsc::unbounded();
-
        // unwrapped_sphinx_sender is the transmitter of mixnet messages received from the gateway
        // unwrapped_sphinx_receiver is the receiver for said messages - used by ReceivedMessagesBuffer
        let (mixnet_messages_sender, mixnet_messages_receiver) = mpsc::unbounded();
@@ -339,7 +331,12 @@ impl NymClient {
            .start_gateway_client(mixnet_messages_sender, ack_sender)
            .await;

-        self.start_mix_traffic_controller(sphinx_message_receiver, gateway_client);
+        // The sphinx_message_sender is the transmitter for any component generating sphinx packets
+        // that are to be sent to the mixnet. They are used by cover traffic stream and real
+        // traffic stream.
+        // The MixTrafficController then sends the actual traffic
+        let sphinx_message_sender = Self::start_mix_traffic_controller(gateway_client);
+
        self.start_real_traffic_controller(
            shared_topology_accessor.clone(),
            ack_receiver,
@@ -0,0 +1,2 @@
+allow-unwrap-in-tests = true
+allow-expect-in-tests = true
@@ -62,9 +62,19 @@ impl PacketRouter {
                trace!("routing regular packet");
                received_messages.push(received_packet);
            } else if received_packet.len()
-                == PacketSize::ExtendedPacket.plaintext_size() - ack_overhead
+                == PacketSize::ExtendedPacket8.plaintext_size() - ack_overhead
            {
-                trace!("routing extended packet");
+                trace!("routing extended8 packet");
+                received_messages.push(received_packet);
+            } else if received_packet.len()
+                == PacketSize::ExtendedPacket16.plaintext_size() - ack_overhead
+            {
+                trace!("routing extended16 packet");
+                received_messages.push(received_packet);
+            } else if received_packet.len()
+                == PacketSize::ExtendedPacket32.plaintext_size() - ack_overhead
+            {
+                trace!("routing extended32 packet");
                received_messages.push(received_packet);
            } else {
                // this can happen if other clients are not padding their messages
@@ -23,6 +23,7 @@ pub struct Config {
    maximum_reconnection_backoff: Duration,
    initial_connection_timeout: Duration,
    maximum_connection_buffer_size: usize,
+    use_legacy_version: bool,
 }

 impl Config {
@@ -31,12 +32,14 @@ impl Config {
        maximum_reconnection_backoff: Duration,
        initial_connection_timeout: Duration,
        maximum_connection_buffer_size: usize,
+        use_legacy_version: bool,
    ) -> Self {
        Config {
            initial_reconnection_backoff,
            maximum_reconnection_backoff,
            initial_connection_timeout,
            maximum_connection_buffer_size,
+            use_legacy_version,
        }
    }
 }
@@ -186,7 +189,7 @@ impl Client {
                address.into(),
                receiver,
                initial_connection_timeout,
-                &*current_reconnection_attempt,
+                &current_reconnection_attempt,
            )
            .await
        });
@@ -201,7 +204,8 @@ impl SendWithoutResponse for Client {
        packet_mode: PacketMode,
    ) -> io::Result<()> {
        trace!("Sending packet to {:?}", address);
-        let framed_packet = FramedSphinxPacket::new(packet, packet_mode);
+        let framed_packet =
+            FramedSphinxPacket::new(packet, packet_mode, self.config.use_legacy_version);

        if let Some(sender) = self.conn_new.get_mut(&address) {
            if let Err(err) = sender.channel.try_send(framed_packet) {
@@ -259,6 +263,7 @@ mod tests {
            maximum_reconnection_backoff: Duration::from_millis(300_000),
            initial_connection_timeout: Duration::from_millis(1_500),
            maximum_connection_buffer_size: 128,
+            use_legacy_version: false,
        })
    }

@@ -24,12 +24,14 @@ impl PacketForwarder {
        maximum_reconnection_backoff: Duration,
        initial_connection_timeout: Duration,
        maximum_connection_buffer_size: usize,
+        use_legacy_version: bool,
    ) -> (PacketForwarder, MixForwardingSender) {
        let client_config = Config::new(
            initial_reconnection_backoff,
            maximum_reconnection_backoff,
            initial_connection_timeout,
            maximum_connection_buffer_size,
+            use_legacy_version,
        );

        let (packet_sender, packet_receiver) = mpsc::unbounded();
@@ -13,6 +13,7 @@ colored = "2.0"
 cw3 = "0.13.1"
 mixnet-contract-common = { path= "../../cosmwasm-smart-contracts/mixnet-contract" }
 vesting-contract-common = { path= "../../cosmwasm-smart-contracts/vesting-contract" }
+contracts-common = { path = "../../cosmwasm-smart-contracts/contracts-common" }
 coconut-bandwidth-contract-common = { path= "../../cosmwasm-smart-contracts/coconut-bandwidth-contract" }
 multisig-contract-common = { path = "../../cosmwasm-smart-contracts/multisig-contract" }
 vesting-contract = { path = "../../../contracts/vesting" }
@@ -2,35 +2,33 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::{validator_api, ValidatorClientError};
-use mixnet_contract_common::{GatewayBond, IdentityKeyRef, MixNodeBond};
+use mixnet_contract_common::mixnode::MixNodeDetails;
+use mixnet_contract_common::MixId;
+use mixnet_contract_common::{GatewayBond, IdentityKeyRef};
 use url::Url;
 use validator_api_requests::coconut::{
    BlindSignRequestBody, BlindedSignatureResponse, CosmosAddressResponse, VerificationKeyResponse,
    VerifyCredentialBody, VerifyCredentialResponse,
 };
 use validator_api_requests::models::{
-    CoreNodeStatusResponse, MixnodeStatusResponse, RewardEstimationResponse,
-    StakeSaturationResponse,
+    GatewayCoreStatusResponse, MixnodeCoreStatusResponse, MixnodeStatusResponse,
+    RewardEstimationResponse, StakeSaturationResponse,
 };

 #[cfg(feature = "nymd-client")]
-use validator_api_requests::models::{MixNodeBondAnnotated, UptimeResponse};
-
+use crate::nymd::traits::MixnetQueryClient;
 #[cfg(feature = "nymd-client")]
-use crate::nymd::{
-    self, error::NymdError, CosmWasmClient, NymdClient, QueryNymdClient, SigningNymdClient,
-};
-
+use crate::nymd::{self, CosmWasmClient, NymdClient, QueryNymdClient, SigningNymdClient};
 #[cfg(feature = "nymd-client")]
 use mixnet_contract_common::{
-    mixnode::DelegationEvent, ContractStateParams, Delegation, IdentityKey, Interval,
-    MixnetContractVersion, MixnodeRewardingStatusResponse, RewardedSetNodeStatus,
-    RewardedSetUpdateDetails,
+    mixnode::MixNodeBond,
+    pending_events::{PendingEpochEvent, PendingIntervalEvent},
+    Delegation, RewardedSetNodeStatus, UnbondedMixnode,
 };
 #[cfg(feature = "nymd-client")]
 use network_defaults::NymNetworkDetails;
 #[cfg(feature = "nymd-client")]
-use std::collections::{HashMap, HashSet};
+use validator_api_requests::models::MixNodeBondAnnotated;

 #[cfg(feature = "nymd-client")]
 #[must_use]
@@ -191,12 +189,9 @@ impl Client<QueryNymdClient> {
    }
 }

+// nymd wrappers
 #[cfg(feature = "nymd-client")]
 impl<C> Client<C> {
-    pub fn change_validator_api(&mut self, new_endpoint: Url) {
-        self.validator_api.change_url(new_endpoint)
-    }
-
    // use case: somebody initialised client without a contract in order to upload and initialise one
    // and now they want to actually use it without making new client
    pub fn set_mixnet_contract_address(&mut self, mixnet_contract_address: cosmrs::AccountId) {
@@ -208,203 +203,22 @@ impl<C> Client<C> {
        self.nymd.mixnet_contract_address().clone()
    }

-    pub async fn get_cached_mixnodes(&self) -> Result<Vec<MixNodeBond>, ValidatorClientError> {
-        Ok(self.validator_api.get_mixnodes().await?)
-    }
-
-    pub async fn get_cached_mixnodes_detailed(
-        &self,
-    ) -> Result<Vec<MixNodeBondAnnotated>, ValidatorClientError> {
-        Ok(self.validator_api.get_mixnodes_detailed().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_rewarded_mixnodes_detailed(
-        &self,
-    ) -> Result<Vec<MixNodeBondAnnotated>, ValidatorClientError> {
-        Ok(self.validator_api.get_rewarded_mixnodes_detailed().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_active_mixnodes_detailed(
-        &self,
-    ) -> Result<Vec<MixNodeBondAnnotated>, ValidatorClientError> {
-        Ok(self.validator_api.get_active_mixnodes_detailed().await?)
-    }
-
-    pub async fn get_cached_gateways(&self) -> Result<Vec<GatewayBond>, ValidatorClientError> {
-        Ok(self.validator_api.get_gateways().await?)
-    }
-
-    pub async fn get_contract_settings(&self) -> Result<ContractStateParams, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync,
-    {
-        Ok(self.nymd.get_contract_settings().await?)
-    }
-
-    pub async fn get_operator_rewards(&self, address: String) -> Result<u128, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync,
-    {
-        Ok(self.nymd.get_operator_rewards(address).await?.u128())
-    }
-
-    pub async fn get_delegator_rewards(
-        &self,
-        address: String,
-        mix_identity: IdentityKey,
-        proxy: Option<String>,
-    ) -> Result<u128, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync,
-    {
-        Ok(self
-            .nymd
-            .get_delegator_rewards(address, mix_identity, proxy)
-            .await?
-            .u128())
-    }
-
-    pub async fn get_pending_delegation_events(
-        &self,
-        owner_address: String,
-        proxy_address: Option<String>,
-    ) -> Result<Vec<DelegationEvent>, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync,
-    {
-        Ok(self
-            .nymd
-            .get_pending_delegation_events(owner_address, proxy_address)
-            .await?)
-    }
-
-    pub async fn get_current_epoch(&self) -> Result<Interval, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync,
-    {
-        Ok(self.nymd.get_current_epoch().await?)
-    }
-
-    pub async fn get_current_operator_cost(&self) -> Result<u64, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync,
-    {
-        Ok(self.nymd.get_current_operator_cost().await?)
-    }
-
-    pub async fn get_mixnet_contract_version(&self) -> Result<MixnetContractVersion, NymdError>
-    where
-        C: CosmWasmClient + Sync,
-    {
-        self.nymd.get_mixnet_contract_version().await
-    }
-
-    pub async fn get_rewarding_status(
-        &self,
-        mix_identity: mixnet_contract_common::IdentityKey,
-        rewarding_interval_nonce: u32,
-    ) -> Result<MixnodeRewardingStatusResponse, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync,
-    {
-        Ok(self
-            .nymd
-            .get_rewarding_status(mix_identity, rewarding_interval_nonce)
-            .await?)
-    }
-
-    pub async fn get_reward_pool(&self) -> Result<u128, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync,
-    {
-        Ok(self.nymd.get_reward_pool().await?.u128())
-    }
-
-    pub async fn get_circulating_supply(&self) -> Result<u128, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync,
-    {
-        Ok(self.nymd.get_circulating_supply().await?.u128())
-    }
-
-    pub async fn get_sybil_resistance_percent(&self) -> Result<u8, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync,
-    {
-        Ok(self.nymd.get_sybil_resistance_percent().await?)
-    }
-
-    pub async fn get_active_set_work_factor(&self) -> Result<u8, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync,
-    {
-        Ok(self.nymd.get_active_set_work_factor().await?)
-    }
-
-    pub async fn get_epochs_in_interval(&self) -> Result<u64, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync,
-    {
-        Ok(self.nymd.get_epochs_in_interval().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(
+    pub async fn get_all_nymd_rewarded_set_mixnodes(
        &self,
-    ) -> Result<Vec<(IdentityKey, RewardedSetNodeStatus)>, ValidatorClientError>
+    ) -> Result<Vec<(MixId, RewardedSetNodeStatus)>, ValidatorClientError>
    where
-        C: CosmWasmClient + Sync,
+        C: CosmWasmClient + Sync + Send,
    {
        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,
-                )
+                .get_rewarded_set_paged(start_after.take(), self.rewarded_set_page_limit)
                .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)
-            }
+            identities.append(&mut paged_response.nodes);

            if let Some(start_after_res) = paged_response.start_next_after {
                start_after = Some(start_after_res)
@@ -416,83 +230,122 @@ impl<C> Client<C> {
        Ok(identities)
    }

-    pub async fn get_nymd_rewarded_and_active_sets(
-        &self,
-    ) -> Result<Vec<(MixNodeBond, RewardedSetNodeStatus)>, ValidatorClientError>
+    pub async fn get_all_nymd_mixnode_bonds(&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()
-            .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,
+        C: CosmWasmClient + Sync + Send,
    {
        let mut mixnodes = Vec::new();
        let mut start_after = None;
        loop {
            let mut paged_response = self
                .nymd
-                .get_mixnodes_paged(start_after.take(), self.mixnode_page_limit)
+                .get_mixnode_bonds_paged(self.mixnode_page_limit, start_after.take())
+                .await?;
+            mixnodes.append(&mut paged_response.nodes);
+
+            if let Some(start_after_res) = paged_response.start_next_after {
+                start_after = Some(start_after_res)
+            } else {
+                break;
+            }
+        }
+
+        Ok(mixnodes)
+    }
+
+    pub async fn get_all_nymd_mixnodes_detailed(
+        &self,
+    ) -> Result<Vec<MixNodeDetails>, ValidatorClientError>
+    where
+        C: CosmWasmClient + Sync + Send,
+    {
+        let mut mixnodes = Vec::new();
+        let mut start_after = None;
+        loop {
+            let mut paged_response = self
+                .nymd
+                .get_mixnodes_detailed_paged(self.mixnode_page_limit, start_after.take())
+                .await?;
+            mixnodes.append(&mut paged_response.nodes);
+
+            if let Some(start_after_res) = paged_response.start_next_after {
+                start_after = Some(start_after_res)
+            } else {
+                break;
+            }
+        }
+
+        Ok(mixnodes)
+    }
+
+    pub async fn get_all_nymd_unbonded_mixnodes(
+        &self,
+    ) -> Result<Vec<(MixId, UnbondedMixnode)>, ValidatorClientError>
+    where
+        C: CosmWasmClient + Sync + Send,
+    {
+        let mut mixnodes = Vec::new();
+        let mut start_after = None;
+        loop {
+            let mut paged_response = self
+                .nymd
+                .get_unbonded_paged(self.mixnode_page_limit, start_after.take())
+                .await?;
+            mixnodes.append(&mut paged_response.nodes);
+
+            if let Some(start_after_res) = paged_response.start_next_after {
+                start_after = Some(start_after_res)
+            } else {
+                break;
+            }
+        }
+
+        Ok(mixnodes)
+    }
+
+    pub async fn get_all_nymd_unbonded_mixnodes_by_owner(
+        &self,
+        owner: &cosmrs::AccountId,
+    ) -> Result<Vec<(MixId, UnbondedMixnode)>, ValidatorClientError>
+    where
+        C: CosmWasmClient + Sync + Send,
+    {
+        let mut mixnodes = Vec::new();
+        let mut start_after = None;
+        loop {
+            let mut paged_response = self
+                .nymd
+                .get_unbonded_by_owner_paged(owner, self.mixnode_page_limit, start_after.take())
+                .await?;
+            mixnodes.append(&mut paged_response.nodes);
+
+            if let Some(start_after_res) = paged_response.start_next_after {
+                start_after = Some(start_after_res)
+            } else {
+                break;
+            }
+        }
+
+        Ok(mixnodes)
+    }
+
+    pub async fn get_all_nymd_unbonded_mixnodes_by_identity(
+        &self,
+        identity_key: String,
+    ) -> Result<Vec<(MixId, UnbondedMixnode)>, ValidatorClientError>
+    where
+        C: CosmWasmClient + Sync + Send,
+    {
+        let mut mixnodes = Vec::new();
+        let mut start_after = None;
+        loop {
+            let mut paged_response = self
+                .nymd
+                .get_unbonded_by_identity_paged(
+                    identity_key.clone(),
+                    self.mixnode_page_limit,
+                    start_after.take(),
+                )
                .await?;
            mixnodes.append(&mut paged_response.nodes);

@@ -508,7 +361,7 @@ impl<C> Client<C> {

    pub async fn get_all_nymd_gateways(&self) -> Result<Vec<GatewayBond>, ValidatorClientError>
    where
-        C: CosmWasmClient + Sync,
+        C: CosmWasmClient + Sync + Send,
    {
        let mut gateways = Vec::new();
        let mut start_after = None;
@@ -531,18 +384,18 @@ impl<C> Client<C> {

    pub async fn get_all_nymd_single_mixnode_delegations(
        &self,
-        identity: IdentityKey,
+        mix_id: MixId,
    ) -> Result<Vec<Delegation>, ValidatorClientError>
    where
-        C: CosmWasmClient + Sync,
+        C: CosmWasmClient + Sync + Send,
    {
        let mut delegations = Vec::new();
        let mut start_after = None;
        loop {
            let mut paged_response = self
                .nymd
-                .get_mix_delegations_paged(
-                    identity.clone(),
+                .get_mixnode_delegations_paged(
+                    mix_id,
                    start_after.take(),
                    self.mixnode_delegations_page_limit,
                )
@@ -564,7 +417,7 @@ impl<C> Client<C> {
        delegation_owner: &cosmrs::AccountId,
    ) -> Result<Vec<Delegation>, ValidatorClientError>
    where
-        C: CosmWasmClient + Sync,
+        C: CosmWasmClient + Sync + Send,
    {
        let mut delegations = Vec::new();
        let mut start_after = None;
@@ -589,10 +442,128 @@ impl<C> Client<C> {
        Ok(delegations)
    }

-    pub async fn get_mixnode_avg_uptimes(
+    pub async fn get_all_network_delegations(&self) -> Result<Vec<Delegation>, ValidatorClientError>
+    where
+        C: CosmWasmClient + Sync + Send,
+    {
+        let mut delegations = Vec::new();
+        let mut start_after = None;
+        loop {
+            let mut paged_response = self
+                .nymd
+                .get_all_network_delegations_paged(
+                    start_after.take(),
+                    self.mixnode_delegations_page_limit,
+                )
+                .await?;
+            delegations.append(&mut paged_response.delegations);
+
+            if let Some(start_after_res) = paged_response.start_next_after {
+                start_after = Some(start_after_res)
+            } else {
+                break;
+            }
+        }
+
+        Ok(delegations)
+    }
+
+    pub async fn get_all_nymd_pending_epoch_events(
        &self,
-    ) -> Result<Vec<UptimeResponse>, ValidatorClientError> {
-        Ok(self.validator_api.get_mixnode_avg_uptimes().await?)
+    ) -> Result<Vec<PendingEpochEvent>, ValidatorClientError>
+    where
+        C: CosmWasmClient + Sync + Send,
+    {
+        let mut events = Vec::new();
+        let mut start_after = None;
+
+        loop {
+            let mut paged_response = self
+                .nymd
+                .get_pending_epoch_events_paged(start_after.take(), self.rewarded_set_page_limit)
+                .await?;
+            events.append(&mut paged_response.events);
+
+            if let Some(start_after_res) = paged_response.start_next_after {
+                start_after = Some(start_after_res)
+            } else {
+                break;
+            }
+        }
+
+        Ok(events)
+    }
+
+    pub async fn get_all_nymd_pending_interval_events(
+        &self,
+    ) -> Result<Vec<PendingIntervalEvent>, ValidatorClientError>
+    where
+        C: CosmWasmClient + Sync + Send,
+    {
+        let mut events = Vec::new();
+        let mut start_after = None;
+
+        loop {
+            let mut paged_response = self
+                .nymd
+                .get_pending_interval_events_paged(start_after.take(), self.rewarded_set_page_limit)
+                .await?;
+            events.append(&mut paged_response.events);
+
+            if let Some(start_after_res) = paged_response.start_next_after {
+                start_after = Some(start_after_res)
+            } else {
+                break;
+            }
+        }
+
+        Ok(events)
+    }
+}
+
+// validator-api wrappers
+#[cfg(feature = "nymd-client")]
+impl<C> Client<C> {
+    pub fn change_validator_api(&mut self, new_endpoint: Url) {
+        self.validator_api.change_url(new_endpoint)
+    }
+
+    pub async fn get_cached_mixnodes(&self) -> Result<Vec<MixNodeDetails>, ValidatorClientError> {
+        Ok(self.validator_api.get_mixnodes().await?)
+    }
+
+    pub async fn get_cached_mixnodes_detailed(
+        &self,
+    ) -> Result<Vec<MixNodeBondAnnotated>, ValidatorClientError> {
+        Ok(self.validator_api.get_mixnodes_detailed().await?)
+    }
+
+    pub async fn get_cached_rewarded_mixnodes(
+        &self,
+    ) -> Result<Vec<MixNodeDetails>, ValidatorClientError> {
+        Ok(self.validator_api.get_rewarded_mixnodes().await?)
+    }
+
+    pub async fn get_cached_rewarded_mixnodes_detailed(
+        &self,
+    ) -> Result<Vec<MixNodeBondAnnotated>, ValidatorClientError> {
+        Ok(self.validator_api.get_rewarded_mixnodes_detailed().await?)
+    }
+
+    pub async fn get_cached_active_mixnodes(
+        &self,
+    ) -> Result<Vec<MixNodeDetails>, ValidatorClientError> {
+        Ok(self.validator_api.get_active_mixnodes().await?)
+    }
+
+    pub async fn get_cached_active_mixnodes_detailed(
+        &self,
+    ) -> Result<Vec<MixNodeBondAnnotated>, ValidatorClientError> {
+        Ok(self.validator_api.get_active_mixnodes_detailed().await?)
+    }
+
+    pub async fn get_cached_gateways(&self) -> Result<Vec<GatewayBond>, ValidatorClientError> {
+        Ok(self.validator_api.get_gateways().await?)
    }

    pub async fn blind_sign(
@@ -630,17 +601,17 @@ impl ApiClient {

    pub async fn get_cached_active_mixnodes(
        &self,
-    ) -> Result<Vec<MixNodeBond>, ValidatorClientError> {
+    ) -> Result<Vec<MixNodeDetails>, ValidatorClientError> {
        Ok(self.validator_api.get_active_mixnodes().await?)
    }

    pub async fn get_cached_rewarded_mixnodes(
        &self,
-    ) -> Result<Vec<MixNodeBond>, ValidatorClientError> {
+    ) -> Result<Vec<MixNodeDetails>, ValidatorClientError> {
        Ok(self.validator_api.get_rewarded_mixnodes().await?)
    }

-    pub async fn get_cached_mixnodes(&self) -> Result<Vec<MixNodeBond>, ValidatorClientError> {
+    pub async fn get_cached_mixnodes(&self) -> Result<Vec<MixNodeDetails>, ValidatorClientError> {
        Ok(self.validator_api.get_mixnodes().await?)
    }

@@ -652,7 +623,7 @@ impl ApiClient {
        &self,
        identity: IdentityKeyRef<'_>,
        since: Option<i64>,
-    ) -> Result<CoreNodeStatusResponse, ValidatorClientError> {
+    ) -> Result<GatewayCoreStatusResponse, ValidatorClientError> {
        Ok(self
            .validator_api
            .get_gateway_core_status_count(identity, since)
@@ -661,39 +632,39 @@ impl ApiClient {

    pub async fn get_mixnode_core_status_count(
        &self,
-        identity: IdentityKeyRef<'_>,
+        mix_id: MixId,
        since: Option<i64>,
-    ) -> Result<CoreNodeStatusResponse, ValidatorClientError> {
+    ) -> Result<MixnodeCoreStatusResponse, ValidatorClientError> {
        Ok(self
            .validator_api
-            .get_mixnode_core_status_count(identity, since)
+            .get_mixnode_core_status_count(mix_id, since)
            .await?)
    }

    pub async fn get_mixnode_status(
        &self,
-        identity: IdentityKeyRef<'_>,
+        mix_id: MixId,
    ) -> Result<MixnodeStatusResponse, ValidatorClientError> {
-        Ok(self.validator_api.get_mixnode_status(identity).await?)
+        Ok(self.validator_api.get_mixnode_status(mix_id).await?)
    }

    pub async fn get_mixnode_reward_estimation(
        &self,
-        identity: IdentityKeyRef<'_>,
+        mix_id: MixId,
    ) -> Result<RewardEstimationResponse, ValidatorClientError> {
        Ok(self
            .validator_api
-            .get_mixnode_reward_estimation(identity)
+            .get_mixnode_reward_estimation(mix_id)
            .await?)
    }

    pub async fn get_mixnode_stake_saturation(
        &self,
-        identity: IdentityKeyRef<'_>,
+        mix_id: MixId,
    ) -> Result<StakeSaturationResponse, ValidatorClientError> {
        Ok(self
            .validator_api
-            .get_mixnode_stake_saturation(identity)
+            .get_mixnode_stake_saturation(mix_id)
            .await?)
    }

@@ -1,11 +1,12 @@
 use crate::nymd::error::NymdError;
 use crate::nymd::{Config as ClientConfig, NymdClient, QueryNymdClient};
 use crate::ApiClient;
-use network_defaults::all::Network;

+use crate::nymd::traits::MixnetQueryClient;
 use colored::Colorize;
 use core::fmt;
 use itertools::Itertools;
+use network_defaults::NymNetworkDetails;
 use std::collections::HashMap;
 use std::hash::BuildHasher;
 use std::time::Duration;
@@ -17,12 +18,12 @@ const CONNECTION_TEST_TIMEOUT_SEC: u64 = 2;

 // Run connection tests for all specified nymd and api urls. These are all run concurrently.
 pub async fn run_validator_connection_test<H: BuildHasher + 'static>(
-    nymd_urls: impl Iterator<Item = (Network, Url)>,
-    api_urls: impl Iterator<Item = (Network, Url)>,
-    mixnet_contract_address: HashMap<Network, cosmrs::AccountId, H>,
+    nymd_urls: impl Iterator<Item = (NymNetworkDetails, Url)>,
+    api_urls: impl Iterator<Item = (NymNetworkDetails, Url)>,
+    mixnet_contract_address: HashMap<NymNetworkDetails, cosmrs::AccountId, H>,
 ) -> (
-    HashMap<Network, Vec<(Url, bool)>>,
-    HashMap<Network, Vec<(Url, bool)>>,
+    HashMap<NymNetworkDetails, Vec<(Url, bool)>>,
+    HashMap<NymNetworkDetails, Vec<(Url, bool)>>,
 ) {
    // Setup all the clients for the connection tests
    let connection_test_clients =
@@ -45,16 +46,16 @@ pub async fn run_validator_connection_test<H: BuildHasher + 'static>(
 }

 fn setup_connection_tests<H: BuildHasher + 'static>(
-    nymd_urls: impl Iterator<Item = (Network, Url)>,
-    api_urls: impl Iterator<Item = (Network, Url)>,
-    mixnet_contract_address: HashMap<Network, cosmrs::AccountId, H>,
+    nymd_urls: impl Iterator<Item = (NymNetworkDetails, Url)>,
+    api_urls: impl Iterator<Item = (NymNetworkDetails, Url)>,
+    mixnet_contract_address: HashMap<NymNetworkDetails, cosmrs::AccountId, H>,
 ) -> impl Iterator<Item = ClientForConnectionTest> {
    let nymd_connection_test_clients = nymd_urls.filter_map(move |(network, url)| {
        let address = mixnet_contract_address
            .get(&network)
            .expect("No configured contract address")
            .clone();
-        let config = ClientConfig::try_from_nym_network_details(&network.details())
+        let config = ClientConfig::try_from_nym_network_details(&network)
            .expect("failed to create valid nymd client config");

        if let Ok(mut client) = NymdClient::<QueryNymdClient>::connect(config, url.as_str()) {
@@ -80,7 +81,7 @@ fn setup_connection_tests<H: BuildHasher + 'static>(
 fn extract_and_collect_results_into_map(
    connection_results: &[ConnectionResult],
    url_type: &UrlType,
-) -> HashMap<Network, Vec<(Url, bool)>> {
+) -> HashMap<NymNetworkDetails, Vec<(Url, bool)>> {
    connection_results
        .iter()
        .filter(|c| &c.url_type() == url_type)
@@ -92,7 +93,7 @@ fn extract_and_collect_results_into_map(
 }

 async fn test_nymd_connection(
-    network: Network,
+    network: NymNetworkDetails,
    url: &Url,
    client: &NymdClient<QueryNymdClient>,
 ) -> ConnectionResult {
@@ -104,56 +105,47 @@ async fn test_nymd_connection(
    {
        Ok(Err(NymdError::TendermintError(e))) => {
            // If we get a tendermint-rpc error, we classify the node as not contactable
-            log::debug!(
-                "Checking: nymd_url: {network}: {url}: {}: {}",
-                "failed".red(),
-                e
-            );
+            log::debug!("Checking: nymd_url: {url}: {}: {}", "failed".red(), e);
            false
        }
        Ok(Err(NymdError::AbciError(code, log))) => {
            // We accept the mixnet contract not found as ok from a connection standpoint. This happens
            // for example on a pre-launch network.
            log::debug!(
-                "Checking: nymd_url: {network}: {url}: {}, but with abci error: {code}: {log}",
+                "Checking: nymd_url: {url}: {}, but with abci error: {code}: {log}",
                "success".green()
            );
            code == 18
        }
        Ok(Err(error @ NymdError::NoContractAddressAvailable)) => {
-            log::debug!(
-                "Checking: nymd_url: {network}: {url}: {}: {error}",
-                "failed".red()
-            );
+            log::debug!("Checking: nymd_url: {url}: {}: {error}", "failed".red());
            false
        }
        Ok(Err(e)) => {
            // For any other error, we're optimistic and just try anyway.
            log::debug!(
-                "Checking: nymd_url: {network}: {url}: {}, but with error: {e}",
+                "Checking: nymd_url: {url}: {}, but with error: {e}",
                "success".green()
            );
            true
        }
        Ok(Ok(_)) => {
-            log::debug!(
-                "Checking: nymd_url: {network}: {url}: {}",
-                "success".green()
-            );
+            log::debug!("Checking: nymd_url: {url}: {}", "success".green());
            true
        }
        Err(e) => {
-            log::debug!(
-                "Checking: nymd_url: {network}: {url}: {}: {e}",
-                "failed".red()
-            );
+            log::debug!("Checking: nymd_url: {url}: {}: {e}", "failed".red());
            false
        }
    };
    ConnectionResult::Nymd(network, url.clone(), result)
 }

-async fn test_api_connection(network: Network, url: &Url, client: &ApiClient) -> ConnectionResult {
+async fn test_api_connection(
+    network: NymNetworkDetails,
+    url: &Url,
+    client: &ApiClient,
+) -> ConnectionResult {
    let result = match timeout(
        Duration::from_secs(CONNECTION_TEST_TIMEOUT_SEC),
        client.get_cached_mixnodes(),
@@ -161,21 +153,15 @@ async fn test_api_connection(network: Network, url: &Url, client: &ApiClient) ->
    .await
    {
        Ok(Ok(_)) => {
-            log::debug!("Checking: api_url: {network}: {url}: {}", "success".green());
+            log::debug!("Checking: api_url: {url}: {}", "success".green());
            true
        }
        Ok(Err(e)) => {
-            log::debug!(
-                "Checking: api_url: {network}: {url}: {}: {e}",
-                "failed".red()
-            );
+            log::debug!("Checking: api_url: {url}: {}: {e}", "failed".red());
            false
        }
        Err(e) => {
-            log::debug!(
-                "Checking: api_url: {network}: {url}: {}: {e}",
-                "failed".red()
-            );
+            log::debug!("Checking: api_url: {url}: {}: {e}", "failed".red());
            false
        }
    };
@@ -183,8 +169,8 @@ async fn test_api_connection(network: Network, url: &Url, client: &ApiClient) ->
 }

 enum ClientForConnectionTest {
-    Nymd(Network, Url, Box<NymdClient<QueryNymdClient>>),
-    Api(Network, Url, ApiClient),
+    Nymd(NymNetworkDetails, Url, Box<NymdClient<QueryNymdClient>>),
+    Api(NymNetworkDetails, Url, ApiClient),
 }

 impl ClientForConnectionTest {
@@ -217,12 +203,12 @@ impl fmt::Display for UrlType {

 #[derive(Debug)]
 enum ConnectionResult {
-    Nymd(Network, Url, bool),
-    Api(Network, Url, bool),
+    Nymd(NymNetworkDetails, Url, bool),
+    Api(NymNetworkDetails, Url, bool),
 }

 impl ConnectionResult {
-    fn result(&self) -> (&Network, &Url, &bool) {
+    fn result(&self) -> (&NymNetworkDetails, &Url, &bool) {
        match self {
            ConnectionResult::Nymd(network, url, result)
            | ConnectionResult::Api(network, url, result) => (network, url, result),
@@ -239,11 +225,8 @@ impl ConnectionResult {

 impl fmt::Display for ConnectionResult {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let (network, url, result) = self.result();
+        let (_network, url, result) = self.result();
        let url_type = self.url_type();
-        write!(
-            f,
-            "{network}: {url}: {url_type}: connection is successful: {result}"
-        )
+        write!(f, "{url}: {url_type}: connection is successful: {result}")
    }
 }
@@ -0,0 +1,388 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+pub use crate::nymd::cosmwasm_client::client::CosmWasmClient;
+use crate::nymd::error::NymdError;
+use crate::nymd::NymdClient;
+use async_trait::async_trait;
+use cosmrs::AccountId;
+use mixnet_contract_common::delegation::{MixNodeDelegationResponse, OwnerProxySubKey};
+use mixnet_contract_common::mixnode::{
+    MixNodeDetails, MixnodeRewardingDetailsResponse, PagedMixnodesDetailsResponse,
+    PagedUnbondedMixnodesResponse, StakeSaturationResponse, UnbondedMixnodeResponse,
+};
+use mixnet_contract_common::reward_params::{Performance, RewardingParams};
+use mixnet_contract_common::rewarding::{
+    EstimatedCurrentEpochRewardResponse, PendingRewardResponse,
+};
+use mixnet_contract_common::{
+    delegation, ContractBuildInformation, ContractState, ContractStateParams,
+    CurrentIntervalResponse, EpochEventId, GatewayBondResponse, GatewayOwnershipResponse,
+    IdentityKey, IntervalEventId, LayerDistribution, MixId, MixOwnershipResponse,
+    MixnodeDetailsResponse, PagedAllDelegationsResponse, PagedDelegatorDelegationsResponse,
+    PagedGatewayResponse, PagedMixNodeDelegationsResponse, PagedMixnodeBondsResponse,
+    PagedRewardedSetResponse, PendingEpochEventsResponse, PendingIntervalEventsResponse,
+    QueryMsg as MixnetQueryMsg,
+};
+use serde::Deserialize;
+
+#[async_trait]
+pub trait MixnetQueryClient {
+    async fn query_mixnet_contract<T>(&self, query: MixnetQueryMsg) -> Result<T, NymdError>
+    where
+        for<'a> T: Deserialize<'a>;
+
+    // state/sys-params-related
+
+    async fn get_mixnet_contract_version(&self) -> Result<ContractBuildInformation, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetContractVersion {})
+            .await
+    }
+
+    async fn get_rewarding_validator_address(&self) -> Result<AccountId, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetRewardingValidatorAddress {})
+            .await
+    }
+
+    async fn get_mixnet_contract_settings(&self) -> Result<ContractStateParams, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetStateParams {})
+            .await
+    }
+
+    async fn get_mixnet_contract_state(&self) -> Result<ContractState, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetState {})
+            .await
+    }
+
+    async fn get_rewarding_parameters(&self) -> Result<RewardingParams, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetRewardingParams {})
+            .await
+    }
+
+    async fn get_current_interval_details(&self) -> Result<CurrentIntervalResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetCurrentIntervalDetails {})
+            .await
+    }
+
+    async fn get_rewarded_set_paged(
+        &self,
+        start_after: Option<MixId>,
+        limit: Option<u32>,
+    ) -> Result<PagedRewardedSetResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetRewardedSet { limit, start_after })
+            .await
+    }
+
+    // mixnode-related:
+
+    async fn get_mixnode_bonds_paged(
+        &self,
+        limit: Option<u32>,
+        start_after: Option<MixId>,
+    ) -> Result<PagedMixnodeBondsResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetMixNodeBonds { limit, start_after })
+            .await
+    }
+
+    async fn get_mixnodes_detailed_paged(
+        &self,
+        limit: Option<u32>,
+        start_after: Option<MixId>,
+    ) -> Result<PagedMixnodesDetailsResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetMixNodesDetailed { limit, start_after })
+            .await
+    }
+
+    async fn get_unbonded_paged(
+        &self,
+        limit: Option<u32>,
+        start_after: Option<MixId>,
+    ) -> Result<PagedUnbondedMixnodesResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetUnbondedMixNodes { limit, start_after })
+            .await
+    }
+
+    async fn get_unbonded_by_owner_paged(
+        &self,
+        owner: &AccountId,
+        limit: Option<u32>,
+        start_after: Option<MixId>,
+    ) -> Result<PagedUnbondedMixnodesResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetUnbondedMixNodesByOwner {
+            owner: owner.to_string(),
+            limit,
+            start_after,
+        })
+        .await
+    }
+
+    async fn get_unbonded_by_identity_paged(
+        &self,
+        identity_key: String,
+        limit: Option<u32>,
+        start_after: Option<MixId>,
+    ) -> Result<PagedUnbondedMixnodesResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetUnbondedMixNodesByIdentityKey {
+            identity_key,
+            limit,
+            start_after,
+        })
+        .await
+    }
+
+    async fn get_owned_mixnode(
+        &self,
+        address: &AccountId,
+    ) -> Result<MixOwnershipResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetOwnedMixnode {
+            address: address.to_string(),
+        })
+        .await
+    }
+
+    async fn get_mixnode_details(
+        &self,
+        mix_id: MixId,
+    ) -> Result<MixnodeDetailsResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetMixnodeDetails { mix_id })
+            .await
+    }
+
+    async fn get_mixnode_rewarding_details(
+        &self,
+        mix_id: MixId,
+    ) -> Result<MixnodeRewardingDetailsResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetMixnodeRewardingDetails { mix_id })
+            .await
+    }
+
+    async fn get_mixnode_stake_saturation(
+        &self,
+        mix_id: MixId,
+    ) -> Result<StakeSaturationResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetStakeSaturation { mix_id })
+            .await
+    }
+
+    async fn get_unbonded_mixnode_information(
+        &self,
+        mix_id: MixId,
+    ) -> Result<UnbondedMixnodeResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetUnbondedMixNodeInformation { mix_id })
+            .await
+    }
+
+    async fn get_layer_distribution(&self) -> Result<LayerDistribution, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetLayerDistribution {})
+            .await
+    }
+
+    // gateway-related:
+
+    async fn get_gateways_paged(
+        &self,
+        start_after: Option<IdentityKey>,
+        limit: Option<u32>,
+    ) -> Result<PagedGatewayResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetGateways { start_after, limit })
+            .await
+    }
+
+    /// Checks whether there is a bonded gateway associated with the provided identity key
+    async fn get_gateway_bond(
+        &self,
+        identity: IdentityKey,
+    ) -> Result<GatewayBondResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetGatewayBond { identity })
+            .await
+    }
+
+    /// Checks whether there is a bonded gateway associated with the provided client's address
+    async fn get_owned_gateway(
+        &self,
+        address: &AccountId,
+    ) -> Result<GatewayOwnershipResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetOwnedGateway {
+            address: address.to_string(),
+        })
+        .await
+    }
+
+    // delegation-related:
+
+    /// Gets list of all delegations towards particular mixnode on particular page.
+    async fn get_mixnode_delegations_paged(
+        &self,
+        mix_id: MixId,
+        start_after: Option<String>,
+        limit: Option<u32>,
+    ) -> Result<PagedMixNodeDelegationsResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetMixnodeDelegations {
+            mix_id,
+            start_after,
+            limit,
+        })
+        .await
+    }
+
+    /// Gets list of all the mixnodes to which a particular address delegated.
+    async fn get_delegator_delegations_paged(
+        &self,
+        delegator: String,
+        start_after: Option<(MixId, OwnerProxySubKey)>,
+        limit: Option<u32>,
+    ) -> Result<PagedDelegatorDelegationsResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetDelegatorDelegations {
+            delegator,
+            start_after,
+            limit,
+        })
+        .await
+    }
+
+    /// Checks value of delegation of given client towards particular mixnode.
+    async fn get_delegation_details(
+        &self,
+        mix_id: MixId,
+        delegator: &AccountId,
+        proxy: Option<String>,
+    ) -> Result<MixNodeDelegationResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetDelegationDetails {
+            mix_id,
+            delegator: delegator.to_string(),
+            proxy,
+        })
+        .await
+    }
+
+    /// Gets all the delegations on the entire network
+    async fn get_all_network_delegations_paged(
+        &self,
+        start_after: Option<delegation::StorageKey>,
+        limit: Option<u32>,
+    ) -> Result<PagedAllDelegationsResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetAllDelegations { start_after, limit })
+            .await
+    }
+
+    // rewards related
+    async fn get_pending_operator_reward(
+        &self,
+        operator: &AccountId,
+    ) -> Result<PendingRewardResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetPendingOperatorReward {
+            address: operator.to_string(),
+        })
+        .await
+    }
+
+    async fn get_pending_mixnode_operator_reward(
+        &self,
+        mix_id: MixId,
+    ) -> Result<PendingRewardResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetPendingMixNodeOperatorReward { mix_id })
+            .await
+    }
+
+    async fn get_pending_delegator_reward(
+        &self,
+        delegator: &AccountId,
+        mix_id: MixId,
+        proxy: Option<String>,
+    ) -> Result<PendingRewardResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetPendingDelegatorReward {
+            address: delegator.to_string(),
+            mix_id,
+            proxy,
+        })
+        .await
+    }
+
+    // given the provided performance, estimate the reward at the end of the current epoch
+    async fn get_estimated_current_epoch_operator_reward(
+        &self,
+        mix_id: MixId,
+        estimated_performance: Performance,
+    ) -> Result<EstimatedCurrentEpochRewardResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetEstimatedCurrentEpochOperatorReward {
+            mix_id,
+            estimated_performance,
+        })
+        .await
+    }
+
+    // given the provided performance, estimate the reward at the end of the current epoch
+    async fn get_estimated_current_epoch_delegator_reward(
+        &self,
+        delegator: &AccountId,
+        mix_id: MixId,
+        proxy: Option<String>,
+        estimated_performance: Performance,
+    ) -> Result<EstimatedCurrentEpochRewardResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetEstimatedCurrentEpochDelegatorReward {
+            address: delegator.to_string(),
+            mix_id,
+            proxy,
+            estimated_performance,
+        })
+        .await
+    }
+
+    // interval-related
+
+    async fn get_pending_epoch_events_paged(
+        &self,
+        start_after: Option<EpochEventId>,
+        limit: Option<u32>,
+    ) -> Result<PendingEpochEventsResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetPendingEpochEvents { start_after, limit })
+            .await
+    }
+
+    async fn get_pending_interval_events_paged(
+        &self,
+        start_after: Option<IntervalEventId>,
+        limit: Option<u32>,
+    ) -> Result<PendingIntervalEventsResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetPendingIntervalEvents { start_after, limit })
+            .await
+    }
+
+    async fn get_mixnode_details_by_identity(
+        &self,
+        mix_identity: IdentityKey,
+    ) -> Result<Option<MixNodeDetails>, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetBondedMixnodeDetailsByIdentity {
+            mix_identity,
+        })
+        .await
+    }
+}
+
+#[async_trait]
+impl<C> MixnetQueryClient for NymdClient<C>
+where
+    C: CosmWasmClient + Sync + Send,
+{
+    async fn query_mixnet_contract<T>(&self, query: MixnetQueryMsg) -> Result<T, NymdError>
+    where
+        for<'a> T: Deserialize<'a>,
+    {
+        self.client
+            .query_contract_smart(self.mixnet_contract_address(), &query)
+            .await
+    }
+}
+
+#[async_trait]
+impl<C> MixnetQueryClient for crate::Client<C>
+where
+    C: CosmWasmClient + Sync + Send,
+{
+    async fn query_mixnet_contract<T>(&self, query: MixnetQueryMsg) -> Result<T, NymdError>
+    where
+        for<'a> T: Deserialize<'a>,
+    {
+        self.nymd.query_mixnet_contract(query).await
+    }
+}
@@ -0,0 +1,496 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::nymd::coin::Coin;
+pub use crate::nymd::cosmwasm_client::client::CosmWasmClient;
+use crate::nymd::cosmwasm_client::types::ExecuteResult;
+use crate::nymd::error::NymdError;
+use crate::nymd::{Fee, NymdClient, SigningCosmWasmClient};
+use async_trait::async_trait;
+use cosmrs::AccountId;
+use mixnet_contract_common::mixnode::{MixNodeConfigUpdate, MixNodeCostParams};
+use mixnet_contract_common::reward_params::{IntervalRewardingParamsUpdate, Performance};
+use mixnet_contract_common::{
+    ContractStateParams, ExecuteMsg as MixnetExecuteMsg, Gateway, MixId, MixNode,
+};
+
+#[async_trait]
+pub trait MixnetSigningClient {
+    async fn execute_mixnet_contract(
+        &self,
+        fee: Option<Fee>,
+        msg: MixnetExecuteMsg,
+        funds: Vec<Coin>,
+    ) -> Result<ExecuteResult, NymdError>;
+
+    // state/sys-params-related
+
+    async fn update_rewarding_validator_address(
+        &self,
+        address: AccountId,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::UpdateRewardingValidatorAddress {
+                address: address.to_string(),
+            },
+            vec![],
+        )
+        .await
+    }
+
+    async fn update_contract_state_params(
+        &self,
+        updated_parameters: ContractStateParams,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::UpdateContractStateParams { updated_parameters },
+            vec![],
+        )
+        .await
+    }
+
+    async fn update_active_set_size(
+        &self,
+        active_set_size: u32,
+        force_immediately: bool,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::UpdateActiveSetSize {
+                active_set_size,
+                force_immediately,
+            },
+            vec![],
+        )
+        .await
+    }
+
+    async fn update_rewarding_parameters(
+        &self,
+        updated_params: IntervalRewardingParamsUpdate,
+        force_immediately: bool,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::UpdateRewardingParams {
+                updated_params,
+                force_immediately,
+            },
+            vec![],
+        )
+        .await
+    }
+
+    async fn update_interval_config(
+        &self,
+        epochs_in_interval: u32,
+        epoch_duration_secs: u64,
+        force_immediately: bool,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::UpdateIntervalConfig {
+                epochs_in_interval,
+                epoch_duration_secs,
+                force_immediately,
+            },
+            vec![],
+        )
+        .await
+    }
+
+    async fn advance_current_epoch(
+        &self,
+        new_rewarded_set: Vec<MixId>,
+        expected_active_set_size: u32,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::AdvanceCurrentEpoch {
+                new_rewarded_set,
+                expected_active_set_size,
+            },
+            vec![],
+        )
+        .await
+    }
+
+    async fn reconcile_epoch_events(
+        &self,
+        limit: Option<u32>,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::ReconcileEpochEvents { limit },
+            vec![],
+        )
+        .await
+    }
+
+    // mixnode-related:
+
+    async fn bond_mixnode(
+        &self,
+        mix_node: MixNode,
+        cost_params: MixNodeCostParams,
+        owner_signature: String,
+        pledge: Coin,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::BondMixnode {
+                mix_node,
+                cost_params,
+                owner_signature,
+            },
+            vec![pledge],
+        )
+        .await
+    }
+
+    async fn bond_mixnode_on_behalf(
+        &self,
+        owner: AccountId,
+        mix_node: MixNode,
+        cost_params: MixNodeCostParams,
+        owner_signature: String,
+        pledge: Coin,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::BondMixnodeOnBehalf {
+                mix_node,
+                cost_params,
+                owner_signature,
+                owner: owner.to_string(),
+            },
+            vec![pledge],
+        )
+        .await
+    }
+
+    async fn unbond_mixnode(&self, fee: Option<Fee>) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(fee, MixnetExecuteMsg::UnbondMixnode {}, vec![])
+            .await
+    }
+
+    async fn unbond_mixnode_on_behalf(
+        &self,
+        owner: AccountId,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::UnbondMixnodeOnBehalf {
+                owner: owner.to_string(),
+            },
+            vec![],
+        )
+        .await
+    }
+
+    async fn update_mixnode_cost_params(
+        &self,
+        new_costs: MixNodeCostParams,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::UpdateMixnodeCostParams { new_costs },
+            vec![],
+        )
+        .await
+    }
+
+    async fn update_mixnode_cost_params_on_behalf(
+        &self,
+        owner: AccountId,
+        new_costs: MixNodeCostParams,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::UpdateMixnodeCostParamsOnBehalf {
+                new_costs,
+                owner: owner.to_string(),
+            },
+            vec![],
+        )
+        .await
+    }
+
+    async fn update_mixnode_config(
+        &self,
+        new_config: MixNodeConfigUpdate,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::UpdateMixnodeConfig { new_config },
+            vec![],
+        )
+        .await
+    }
+
+    async fn update_mixnode_config_on_behalf(
+        &self,
+        owner: AccountId,
+        new_config: MixNodeConfigUpdate,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::UpdateMixnodeConfigOnBehalf {
+                new_config,
+                owner: owner.to_string(),
+            },
+            vec![],
+        )
+        .await
+    }
+
+    // gateway-related:
+
+    async fn bond_gateway(
+        &self,
+        gateway: Gateway,
+        owner_signature: String,
+        pledge: Coin,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::BondGateway {
+                gateway,
+                owner_signature,
+            },
+            vec![pledge],
+        )
+        .await
+    }
+
+    async fn bond_gateway_on_behalf(
+        &self,
+        owner: AccountId,
+        gateway: Gateway,
+        owner_signature: String,
+        pledge: Coin,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::BondGatewayOnBehalf {
+                gateway,
+                owner_signature,
+                owner: owner.to_string(),
+            },
+            vec![pledge],
+        )
+        .await
+    }
+
+    async fn unbond_gateway(&self, fee: Option<Fee>) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(fee, MixnetExecuteMsg::UnbondGateway {}, vec![])
+            .await
+    }
+
+    async fn unbond_gateway_on_behalf(
+        &self,
+        owner: AccountId,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::UnbondGatewayOnBehalf {
+                owner: owner.to_string(),
+            },
+            vec![],
+        )
+        .await
+    }
+
+    // delegation-related:
+
+    async fn delegate_to_mixnode(
+        &self,
+        mix_id: MixId,
+        amount: Coin,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::DelegateToMixnode { mix_id },
+            vec![amount],
+        )
+        .await
+    }
+
+    async fn delegate_to_mixnode_on_behalf(
+        &self,
+        delegate: AccountId,
+        mix_id: MixId,
+        amount: Coin,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::DelegateToMixnodeOnBehalf {
+                mix_id,
+                delegate: delegate.to_string(),
+            },
+            vec![amount],
+        )
+        .await
+    }
+
+    async fn undelegate_from_mixnode(
+        &self,
+        mix_id: MixId,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::UndelegateFromMixnode { mix_id },
+            vec![],
+        )
+        .await
+    }
+
+    async fn undelegate_to_mixnode_on_behalf(
+        &self,
+        delegate: AccountId,
+        mix_id: MixId,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::UndelegateFromMixnodeOnBehalf {
+                mix_id,
+                delegate: delegate.to_string(),
+            },
+            vec![],
+        )
+        .await
+    }
+
+    // reward-related
+
+    async fn reward_mixnode(
+        &self,
+        mix_id: MixId,
+        performance: Performance,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::RewardMixnode {
+                mix_id,
+                performance,
+            },
+            vec![],
+        )
+        .await
+    }
+
+    async fn withdraw_operator_reward(&self, fee: Option<Fee>) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(fee, MixnetExecuteMsg::WithdrawOperatorReward {}, vec![])
+            .await
+    }
+
+    async fn withdraw_operator_reward_on_behalf(
+        &self,
+        owner: AccountId,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::WithdrawOperatorRewardOnBehalf {
+                owner: owner.to_string(),
+            },
+            vec![],
+        )
+        .await
+    }
+
+    async fn withdraw_delegator_reward(
+        &self,
+        mix_id: MixId,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::WithdrawDelegatorReward { mix_id },
+            vec![],
+        )
+        .await
+    }
+
+    async fn withdraw_delegator_reward_on_behalf(
+        &self,
+        owner: AccountId,
+        mix_id: MixId,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::WithdrawDelegatorRewardOnBehalf {
+                mix_id,
+                owner: owner.to_string(),
+            },
+            vec![],
+        )
+        .await
+    }
+}
+
+#[async_trait]
+impl<C> MixnetSigningClient for NymdClient<C>
+where
+    C: SigningCosmWasmClient + Sync + Send,
+{
+    async fn execute_mixnet_contract(
+        &self,
+        fee: Option<Fee>,
+        msg: MixnetExecuteMsg,
+        funds: Vec<Coin>,
+    ) -> Result<ExecuteResult, NymdError> {
+        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier)));
+        let memo = msg.default_memo();
+        self.client
+            .execute(
+                self.address(),
+                self.mixnet_contract_address(),
+                &msg,
+                fee,
+                memo,
+                funds,
+            )
+            .await
+    }
+}
+
+#[async_trait]
+impl<C> MixnetSigningClient for crate::Client<C>
+where
+    C: SigningCosmWasmClient + Sync + Send,
+{
+    async fn execute_mixnet_contract(
+        &self,
+        fee: Option<Fee>,
+        msg: MixnetExecuteMsg,
+        funds: Vec<Coin>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.nymd.execute_mixnet_contract(fee, msg, funds).await
+    }
+}
@@ -1,8 +1,10 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2021-2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

 mod coconut_bandwidth_query_client;
 mod coconut_bandwidth_signing_client;
+mod mixnet_query_client;
+mod mixnet_signing_client;
 mod multisig_query_client;
 mod multisig_signing_client;
 mod vesting_query_client;
@@ -10,6 +12,8 @@ mod vesting_signing_client;

 pub use coconut_bandwidth_query_client::CoconutBandwidthQueryClient;
 pub use coconut_bandwidth_signing_client::CoconutBandwidthSigningClient;
+pub use mixnet_query_client::MixnetQueryClient;
+pub use mixnet_signing_client::MixnetSigningClient;
 pub use multisig_query_client::MultisigQueryClient;
 pub use multisig_signing_client::MultisigSigningClient;
 pub use vesting_query_client::VestingQueryClient;
@@ -6,8 +6,10 @@ pub use crate::nymd::cosmwasm_client::client::CosmWasmClient;
 use crate::nymd::error::NymdError;
 use crate::nymd::NymdClient;
 use async_trait::async_trait;
+use contracts_common::ContractBuildInformation;
 use cosmwasm_std::{Coin as CosmWasmCoin, Timestamp};
-use mixnet_contract_common::IdentityKey;
+use mixnet_contract_common::MixId;
+use serde::Deserialize;
 use vesting_contract::vesting::Account;
 use vesting_contract_common::{
    messages::QueryMsg as VestingQueryMsg, AllDelegationsResponse, DelegationTimesResponse,
@@ -16,6 +18,15 @@ use vesting_contract_common::{

 #[async_trait]
 pub trait VestingQueryClient {
+    async fn query_vesting_contract<T>(&self, query: VestingQueryMsg) -> Result<T, NymdError>
+    where
+        for<'a> T: Deserialize<'a>;
+
+    async fn get_vesting_contract_version(&self) -> Result<ContractBuildInformation, NymdError> {
+        self.query_vesting_contract(VestingQueryMsg::GetContractVersion {})
+            .await
+    }
+
    async fn locked_coins(
        &self,
        address: &str,
@@ -76,12 +87,12 @@ pub trait VestingQueryClient {
    async fn get_delegation_timestamps(
        &self,
        address: &str,
-        mix_identity: String,
+        mix_id: MixId,
    ) -> Result<DelegationTimesResponse, NymdError>;

    async fn get_all_vesting_delegations_paged(
        &self,
-        start_after: Option<(u32, IdentityKey, u64)>,
+        start_after: Option<(u32, MixId, u64)>,
        limit: Option<u32>,
    ) -> Result<AllDelegationsResponse, NymdError>;

@@ -107,6 +118,15 @@ pub trait VestingQueryClient {

 #[async_trait]
 impl<C: CosmWasmClient + Sync + Send> VestingQueryClient for NymdClient<C> {
+    async fn query_vesting_contract<T>(&self, query: VestingQueryMsg) -> Result<T, NymdError>
+    where
+        for<'a> T: Deserialize<'a>,
+    {
+        self.client
+            .query_contract_smart(self.vesting_contract_address(), &query)
+            .await
+    }
+
    async fn locked_coins(
        &self,
        vesting_account_address: &str,
@@ -269,11 +289,11 @@ impl<C: CosmWasmClient + Sync + Send> VestingQueryClient for NymdClient<C> {
    async fn get_delegation_timestamps(
        &self,
        address: &str,
-        mix_identity: String,
+        mix_id: MixId,
    ) -> Result<DelegationTimesResponse, NymdError> {
        let request = VestingQueryMsg::GetDelegationTimes {
            address: address.to_string(),
-            mix_identity,
+            mix_id,
        };
        self.client
            .query_contract_smart(self.vesting_contract_address(), &request)
@@ -282,7 +302,7 @@ impl<C: CosmWasmClient + Sync + Send> VestingQueryClient for NymdClient<C> {

    async fn get_all_vesting_delegations_paged(
        &self,
-        start_after: Option<(u32, IdentityKey, u64)>,
+        start_after: Option<(u32, MixId, u64)>,
        limit: Option<u32>,
    ) -> Result<AllDelegationsResponse, NymdError> {
        let request = VestingQueryMsg::GetAllDelegations { start_after, limit };
@@ -6,14 +6,29 @@ use crate::nymd::cosmwasm_client::types::ExecuteResult;
 use crate::nymd::error::NymdError;
 use crate::nymd::{Coin, Fee, NymdClient};
 use async_trait::async_trait;
-use mixnet_contract_common::{Gateway, IdentityKey, IdentityKeyRef, MixNode};
+use mixnet_contract_common::mixnode::{MixNodeConfigUpdate, MixNodeCostParams};
+use mixnet_contract_common::{Gateway, MixId, MixNode};
 use vesting_contract_common::messages::{ExecuteMsg as VestingExecuteMsg, VestingSpecification};
+use vesting_contract_common::PledgeCap;

 #[async_trait]
 pub trait VestingSigningClient {
+    async fn execute_vesting_contract(
+        &self,
+        fee: Option<Fee>,
+        msg: VestingExecuteMsg,
+        funds: Vec<Coin>,
+    ) -> Result<ExecuteResult, NymdError>;
+
+    async fn vesting_update_mixnode_cost_params(
+        &self,
+        new_costs: MixNodeCostParams,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError>;
+
    async fn vesting_update_mixnode_config(
        &self,
-        profix_margin_percent: u8,
+        new_config: MixNodeConfigUpdate,
        fee: Option<Fee>,
    ) -> Result<ExecuteResult, NymdError>;

@@ -43,10 +58,12 @@ pub trait VestingSigningClient {
    async fn vesting_bond_mixnode(
        &self,
        mix_node: MixNode,
+        cost_params: MixNodeCostParams,
        owner_signature: &str,
        pledge: Coin,
        fee: Option<Fee>,
    ) -> Result<ExecuteResult, NymdError>;
+
    async fn vesting_unbond_mixnode(&self, fee: Option<Fee>) -> Result<ExecuteResult, NymdError>;

    async fn vesting_track_unbond_mixnode(
@@ -65,21 +82,21 @@ pub trait VestingSigningClient {
    async fn vesting_track_undelegation(
        &self,
        address: &str,
-        mix_identity: IdentityKey,
+        mix_id: MixId,
        amount: Coin,
        fee: Option<Fee>,
    ) -> Result<ExecuteResult, NymdError>;

-    async fn vesting_delegate_to_mixnode<'a>(
+    async fn vesting_delegate_to_mixnode(
        &self,
-        mix_identity: IdentityKeyRef<'a>,
+        mix_id: MixId,
        amount: Coin,
        fee: Option<Fee>,
    ) -> Result<ExecuteResult, NymdError>;

-    async fn vesting_undelegate_from_mixnode<'a>(
+    async fn vesting_undelegate_from_mixnode(
        &self,
-        mix_identity: IdentityKeyRef<'a>,
+        mix_id: MixId,
        fee: Option<Fee>,
    ) -> Result<ExecuteResult, NymdError>;

@@ -89,21 +106,53 @@ pub trait VestingSigningClient {
        staking_address: Option<String>,
        vesting_spec: Option<VestingSpecification>,
        amount: Coin,
+        cap: Option<PledgeCap>,
        fee: Option<Fee>,
    ) -> Result<ExecuteResult, NymdError>;
 }

 #[async_trait]
 impl<C: SigningCosmWasmClient + Sync + Send> VestingSigningClient for NymdClient<C> {
+    async fn execute_vesting_contract(
+        &self,
+        fee: Option<Fee>,
+        msg: VestingExecuteMsg,
+        funds: Vec<Coin>,
+    ) -> Result<ExecuteResult, NymdError> {
+        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier)));
+        let memo = msg.name().to_string();
+        self.client
+            .execute(
+                self.address(),
+                self.vesting_contract_address(),
+                &msg,
+                fee,
+                memo,
+                funds,
+            )
+            .await
+    }
+
+    async fn vesting_update_mixnode_cost_params(
+        &self,
+        new_costs: MixNodeCostParams,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_vesting_contract(
+            fee,
+            VestingExecuteMsg::UpdateMixnodeCostParams { new_costs },
+            vec![],
+        )
+        .await
+    }
+
    async fn vesting_update_mixnode_config(
        &self,
-        profit_margin_percent: u8,
+        new_config: MixNodeConfigUpdate,
        fee: Option<Fee>,
    ) -> Result<ExecuteResult, NymdError> {
        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier)));
-        let req = VestingExecuteMsg::UpdateMixnodeConfig {
-            profit_margin_percent,
-        };
+        let req = VestingExecuteMsg::UpdateMixnodeConfig { new_config };
        self.client
            .execute(
                self.address(),
@@ -203,26 +252,22 @@ impl<C: SigningCosmWasmClient + Sync + Send> VestingSigningClient for NymdClient
    async fn vesting_bond_mixnode(
        &self,
        mix_node: MixNode,
+        cost_params: MixNodeCostParams,
        owner_signature: &str,
        pledge: Coin,
        fee: Option<Fee>,
    ) -> Result<ExecuteResult, NymdError> {
-        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier)));
-        let req = VestingExecuteMsg::BondMixnode {
-            mix_node,
-            owner_signature: owner_signature.to_string(),
-            amount: pledge.into(),
-        };
-        self.client
-            .execute(
-                self.address(),
-                self.vesting_contract_address(),
-                &req,
-                fee,
-                "VestingContract::BondMixnode",
-                vec![],
-            )
-            .await
+        self.execute_vesting_contract(
+            fee,
+            VestingExecuteMsg::BondMixnode {
+                mix_node,
+                cost_params,
+                owner_signature: owner_signature.to_string(),
+                amount: pledge.into(),
+            },
+            vec![],
+        )
+        .await
    }

    async fn vesting_unbond_mixnode(&self, fee: Option<Fee>) -> Result<ExecuteResult, NymdError> {
@@ -262,6 +307,7 @@ impl<C: SigningCosmWasmClient + Sync + Send> VestingSigningClient for NymdClient
            )
            .await
    }
+
    async fn withdraw_vested_coins(
        &self,
        amount: Coin,
@@ -282,72 +328,54 @@ impl<C: SigningCosmWasmClient + Sync + Send> VestingSigningClient for NymdClient
            )
            .await
    }
+
    async fn vesting_track_undelegation(
        &self,
        address: &str,
-        mix_identity: IdentityKey,
+        mix_id: MixId,
        amount: Coin,
        fee: Option<Fee>,
    ) -> Result<ExecuteResult, NymdError> {
-        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier)));
-        let req = VestingExecuteMsg::TrackUndelegation {
-            owner: address.to_string(),
-            mix_identity,
-            amount: amount.into(),
-        };
-        self.client
-            .execute(
-                self.address(),
-                self.vesting_contract_address(),
-                &req,
-                fee,
-                "VestingContract::TrackUndelegation",
-                vec![],
-            )
-            .await
-    }
-    async fn vesting_delegate_to_mixnode<'a>(
-        &self,
-        mix_identity: IdentityKeyRef<'a>,
-        amount: Coin,
-        fee: Option<Fee>,
-    ) -> Result<ExecuteResult, NymdError> {
-        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier)));
-        let req = VestingExecuteMsg::DelegateToMixnode {
-            mix_identity: mix_identity.into(),
-            amount: amount.into(),
-        };
-        self.client
-            .execute(
-                self.address(),
-                self.vesting_contract_address(),
-                &req,
-                fee,
-                "VestingContract::DelegateToMixnode",
-                vec![],
-            )
-            .await
+        self.execute_vesting_contract(
+            fee,
+            VestingExecuteMsg::TrackUndelegation {
+                owner: address.to_string(),
+                mix_id,
+                amount: amount.into(),
+            },
+            vec![],
+        )
+        .await
    }

-    async fn vesting_undelegate_from_mixnode<'a>(
+    async fn vesting_delegate_to_mixnode(
        &self,
-        mix_identity: IdentityKeyRef<'a>,
+        mix_id: MixId,
+        amount: Coin,
        fee: Option<Fee>,
    ) -> Result<ExecuteResult, NymdError> {
-        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier)));
-        let req = VestingExecuteMsg::UndelegateFromMixnode {
-            mix_identity: mix_identity.into(),
-        };
-        self.client
-            .execute(
-                self.address(),
-                self.vesting_contract_address(),
-                &req,
-                fee,
-                "VestingContract::UndelegateFromMixnode",
-                vec![],
-            )
-            .await
+        self.execute_vesting_contract(
+            fee,
+            VestingExecuteMsg::DelegateToMixnode {
+                mix_id,
+                amount: amount.into(),
+            },
+            vec![],
+        )
+        .await
+    }
+
+    async fn vesting_undelegate_from_mixnode(
+        &self,
+        mix_id: MixId,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_vesting_contract(
+            fee,
+            VestingExecuteMsg::UndelegateFromMixnode { mix_id },
+            vec![],
+        )
+        .await
    }

    async fn create_periodic_vesting_account(
@@ -356,6 +384,7 @@ impl<C: SigningCosmWasmClient + Sync + Send> VestingSigningClient for NymdClient
        staking_address: Option<String>,
        vesting_spec: Option<VestingSpecification>,
        amount: Coin,
+        cap: Option<PledgeCap>,
        fee: Option<Fee>,
    ) -> Result<ExecuteResult, NymdError> {
        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier)));
@@ -363,6 +392,7 @@ impl<C: SigningCosmWasmClient + Sync + Send> VestingSigningClient for NymdClient
            owner_address: owner_address.to_string(),
            staking_address,
            vesting_spec,
+            cap,
        };
        self.client
            .execute(
@@ -72,7 +72,7 @@ impl DirectSecp256k1HdWallet {
    }

    fn derive_keypair(&self, hd_path: &DerivationPath) -> Result<Secp256k1Keypair, NymdError> {
-        let extended_private_key = XPrv::derive_from_path(&self.seed, hd_path)?;
+        let extended_private_key = XPrv::derive_from_path(self.seed, hd_path)?;

        let private_key: SigningKey = extended_private_key.into();
        let public_key = private_key.public_key();
@@ -207,8 +207,9 @@ impl DirectSecp256k1HdWalletBuilder {

 #[cfg(test)]
 mod tests {
+    use network_defaults::NymNetworkDetails;
+
    use super::*;
-    use network_defaults::all::Network::*;

    #[test]
    fn generating_account_addresses() {
@@ -218,7 +219,9 @@ mod tests {
            "acquire rebel spot skin gun such erupt pull swear must define ill chief turtle today flower chunk truth battle claw rigid detail gym feel",
            "step income throw wheat mobile ship wave drink pool sudden upset jaguar bar globe rifle spice frost bless glimpse size regular carry aspect ball"
        ];
-        let prefix = MAINNET.bech32_prefix();
+        let prefix = NymNetworkDetails::new_mainnet()
+            .chain_details
+            .bech32_account_prefix;

        let addrs = vec![
            "n1jw6mp7d5xqc7w6xm79lha27glmd0vdt3l9artf",
@@ -1,4 +1,5 @@
 use thiserror::Error;
+use validator_api_requests::models::RequestError;

 #[derive(Error, Debug)]
 pub enum ValidatorAPIError {
@@ -10,4 +11,7 @@ pub enum ValidatorAPIError {

    #[error("Request failed with error message - {0}")]
    GenericRequestFailure(String),
+
+    #[error("The validator API has failed to resolve our request. It returned status code {status} and additional error message: {}", error.message())]
+    ApiRequestFailure { status: u16, error: RequestError },
 }
@@ -3,17 +3,20 @@

 use crate::validator_api::error::ValidatorAPIError;
 use crate::validator_api::routes::{CORE_STATUS_COUNT, SINCE_ARG};
-use mixnet_contract_common::{GatewayBond, IdentityKeyRef, MixNodeBond};
+use mixnet_contract_common::mixnode::MixNodeDetails;
+use mixnet_contract_common::{GatewayBond, IdentityKeyRef, MixId};
+use reqwest::Response;
 use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
 use url::Url;
 use validator_api_requests::coconut::{
    BlindSignRequestBody, BlindedSignatureResponse, CosmosAddressResponse, VerificationKeyResponse,
    VerifyCredentialBody, VerifyCredentialResponse,
 };
 use validator_api_requests::models::{
-    CoreNodeStatusResponse, InclusionProbabilityResponse, MixNodeBondAnnotated,
-    MixnodeStatusResponse, RewardEstimationResponse, StakeSaturationResponse, UptimeResponse,
+    GatewayCoreStatusResponse, GatewayStatusReportResponse, GatewayUptimeHistoryResponse,
+    InclusionProbabilityResponse, MixNodeBondAnnotated, MixnodeCoreStatusResponse,
+    MixnodeStatusReportResponse, MixnodeStatusResponse, MixnodeUptimeHistoryResponse, RequestError,
+    RewardEstimationResponse, StakeSaturationResponse, UptimeResponse,
 };

 pub mod error;
@@ -46,6 +49,19 @@ impl Client {
        &self.url
    }

+    async fn send_get_request<K, V>(
+        &self,
+        path: PathSegments<'_>,
+        params: Params<'_, K, V>,
+    ) -> Result<Response, ValidatorAPIError>
+    where
+        K: AsRef<str>,
+        V: AsRef<str>,
+    {
+        let url = create_api_url(&self.url, path, params);
+        Ok(self.reqwest_client.get(url).send().await?)
+    }
+
    async fn query_validator_api<T, K, V>(
        &self,
        path: PathSegments<'_>,
@@ -56,8 +72,36 @@ impl Client {
        K: AsRef<str>,
        V: AsRef<str>,
    {
-        let url = create_api_url(&self.url, path, params);
-        Ok(self.reqwest_client.get(url).send().await?.json().await?)
+        let res = self.send_get_request(path, params).await?;
+        if res.status().is_success() {
+            Ok(res.json().await?)
+        } else {
+            Err(ValidatorAPIError::GenericRequestFailure(res.text().await?))
+        }
+    }
+
+    // This works for endpoints returning Result<Json<T>, ErrorResponse>
+    async fn query_validator_api_fallible<T, K, V>(
+        &self,
+        path: PathSegments<'_>,
+        params: Params<'_, K, V>,
+    ) -> Result<T, ValidatorAPIError>
+    where
+        for<'a> T: Deserialize<'a>,
+        K: AsRef<str>,
+        V: AsRef<str>,
+    {
+        let res = self.send_get_request(path, params).await?;
+        let status = res.status();
+        if res.status().is_success() {
+            Ok(res.json().await?)
+        } else {
+            let request_error: RequestError = res.json().await?;
+            Err(ValidatorAPIError::ApiRequestFailure {
+                status: status.as_u16(),
+                error: request_error,
+            })
+        }
    }

    async fn post_validator_api<B, T, K, V>(
@@ -83,7 +127,7 @@ impl Client {
        }
    }

-    pub async fn get_mixnodes(&self) -> Result<Vec<MixNodeBond>, ValidatorAPIError> {
+    pub async fn get_mixnodes(&self) -> Result<Vec<MixNodeDetails>, ValidatorAPIError> {
        self.query_validator_api(&[routes::API_VERSION, routes::MIXNODES], NO_PARAMS)
            .await
    }
@@ -103,7 +147,7 @@ impl Client {
            .await
    }

-    pub async fn get_active_mixnodes(&self) -> Result<Vec<MixNodeBond>, ValidatorAPIError> {
+    pub async fn get_active_mixnodes(&self) -> Result<Vec<MixNodeDetails>, ValidatorAPIError> {
        self.query_validator_api(
            &[routes::API_VERSION, routes::MIXNODES, routes::ACTIVE],
            NO_PARAMS,
@@ -126,7 +170,7 @@ impl Client {
        .await
    }

-    pub async fn get_rewarded_mixnodes(&self) -> Result<Vec<MixNodeBond>, ValidatorAPIError> {
+    pub async fn get_rewarded_mixnodes(&self) -> Result<Vec<MixNodeDetails>, ValidatorAPIError> {
        self.query_validator_api(
            &[routes::API_VERSION, routes::MIXNODES, routes::REWARDED],
            NO_PARAMS,
@@ -134,6 +178,74 @@ impl Client {
        .await
    }

+    pub async fn get_mixnode_report(
+        &self,
+        mix_id: MixId,
+    ) -> Result<MixnodeStatusReportResponse, ValidatorAPIError> {
+        self.query_validator_api(
+            &[
+                routes::API_VERSION,
+                routes::STATUS,
+                routes::MIXNODE,
+                &mix_id.to_string(),
+                routes::REPORT,
+            ],
+            NO_PARAMS,
+        )
+        .await
+    }
+
+    pub async fn get_gateway_report(
+        &self,
+        identity: IdentityKeyRef<'_>,
+    ) -> Result<GatewayStatusReportResponse, ValidatorAPIError> {
+        self.query_validator_api(
+            &[
+                routes::API_VERSION,
+                routes::STATUS,
+                routes::GATEWAY,
+                identity,
+                routes::REPORT,
+            ],
+            NO_PARAMS,
+        )
+        .await
+    }
+
+    pub async fn get_mixnode_history(
+        &self,
+        mix_id: MixId,
+    ) -> Result<MixnodeUptimeHistoryResponse, ValidatorAPIError> {
+        self.query_validator_api(
+            &[
+                routes::API_VERSION,
+                routes::STATUS,
+                routes::MIXNODE,
+                &mix_id.to_string(),
+                routes::HISTORY,
+            ],
+            NO_PARAMS,
+        )
+        .await
+    }
+
+    pub async fn get_gateway_history(
+        &self,
+        identity: IdentityKeyRef<'_>,
+    ) -> Result<GatewayUptimeHistoryResponse, ValidatorAPIError> {
+        self.query_validator_api(
+            &[
+                routes::API_VERSION,
+                routes::STATUS,
+                routes::GATEWAY,
+                identity,
+                routes::HISTORY,
+            ],
+            NO_PARAMS,
+        )
+        .await
+    }
+
    pub async fn get_rewarded_mixnodes_detailed(
        &self,
    ) -> Result<Vec<MixNodeBondAnnotated>, ValidatorAPIError> {
@@ -149,28 +261,11 @@ impl Client {
        .await
    }

-    pub async fn get_probs_mixnode_rewarded(
-        &self,
-        mixnode_id: &str,
-    ) -> Result<HashMap<String, f32>, ValidatorAPIError> {
-        self.query_validator_api(
-            &[
-                routes::API_VERSION,
-                routes::MIXNODES,
-                routes::REWARDED,
-                routes::INCLUSION_CHANCE,
-                mixnode_id,
-            ],
-            NO_PARAMS,
-        )
-        .await
-    }
-
    pub async fn get_gateway_core_status_count(
        &self,
        identity: IdentityKeyRef<'_>,
        since: Option<i64>,
-    ) -> Result<CoreNodeStatusResponse, ValidatorAPIError> {
+    ) -> Result<GatewayCoreStatusResponse, ValidatorAPIError> {
        if let Some(since) = since {
            self.query_validator_api(
                &[
@@ -199,16 +294,16 @@ impl Client {

    pub async fn get_mixnode_core_status_count(
        &self,
-        identity: IdentityKeyRef<'_>,
+        mix_id: MixId,
        since: Option<i64>,
-    ) -> Result<CoreNodeStatusResponse, ValidatorAPIError> {
+    ) -> Result<MixnodeCoreStatusResponse, ValidatorAPIError> {
        if let Some(since) = since {
            self.query_validator_api(
                &[
                    routes::API_VERSION,
                    routes::STATUS_ROUTES,
                    routes::MIXNODE,
-                    identity,
+                    &mix_id.to_string(),
                    CORE_STATUS_COUNT,
                ],
                &[(SINCE_ARG, since.to_string())],
@@ -220,7 +315,8 @@ impl Client {
                    routes::API_VERSION,
                    routes::STATUS_ROUTES,
                    routes::MIXNODE,
-                    identity,
+                    &mix_id.to_string(),
+                    CORE_STATUS_COUNT,
                ],
                NO_PARAMS,
            )
@@ -230,14 +326,14 @@ impl Client {

    pub async fn get_mixnode_status(
        &self,
-        identity: IdentityKeyRef<'_>,
+        mix_id: MixId,
    ) -> Result<MixnodeStatusResponse, ValidatorAPIError> {
        self.query_validator_api(
            &[
                routes::API_VERSION,
                routes::STATUS_ROUTES,
                routes::MIXNODE,
-                identity,
+                &mix_id.to_string(),
                routes::STATUS,
            ],
            NO_PARAMS,
@@ -247,14 +343,14 @@ impl Client {

    pub async fn get_mixnode_reward_estimation(
        &self,
-        identity: IdentityKeyRef<'_>,
+        mix_id: MixId,
    ) -> Result<RewardEstimationResponse, ValidatorAPIError> {
-        self.query_validator_api(
+        self.query_validator_api_fallible(
            &[
                routes::API_VERSION,
                routes::STATUS_ROUTES,
                routes::MIXNODE,
-                identity,
+                &mix_id.to_string(),
                routes::REWARD_ESTIMATION,
            ],
            NO_PARAMS,
@@ -264,14 +360,14 @@ impl Client {

    pub async fn get_mixnode_stake_saturation(
        &self,
-        identity: IdentityKeyRef<'_>,
+        mix_id: MixId,
    ) -> Result<StakeSaturationResponse, ValidatorAPIError> {
-        self.query_validator_api(
+        self.query_validator_api_fallible(
            &[
                routes::API_VERSION,
                routes::STATUS_ROUTES,
                routes::MIXNODE,
-                identity,
+                &mix_id.to_string(),
                routes::STAKE_SATURATION,
            ],
            NO_PARAMS,
@@ -281,14 +377,14 @@ impl Client {

    pub async fn get_mixnode_inclusion_probability(
        &self,
-        identity: IdentityKeyRef<'_>,
+        mix_id: MixId,
    ) -> Result<InclusionProbabilityResponse, ValidatorAPIError> {
-        self.query_validator_api(
+        self.query_validator_api_fallible(
            &[
                routes::API_VERSION,
                routes::STATUS_ROUTES,
                routes::MIXNODE,
-                identity,
+                &mix_id.to_string(),
                routes::INCLUSION_CHANCE,
            ],
            NO_PARAMS,
@@ -298,27 +394,14 @@ impl Client {

    pub async fn get_mixnode_avg_uptime(
        &self,
-        identity: IdentityKeyRef<'_>,
+        mix_id: MixId,
    ) -> Result<UptimeResponse, ValidatorAPIError> {
-        self.query_validator_api(
+        self.query_validator_api_fallible(
            &[
                routes::API_VERSION,
                routes::STATUS_ROUTES,
                routes::MIXNODE,
-                identity,
-                routes::AVG_UPTIME,
-            ],
-            NO_PARAMS,
-        )
-        .await
-    }
-
-    pub async fn get_mixnode_avg_uptimes(&self) -> Result<Vec<UptimeResponse>, ValidatorAPIError> {
-        self.query_validator_api(
-            &[
-                routes::API_VERSION,
-                routes::STATUS_ROUTES,
-                routes::MIXNODES,
+                &mix_id.to_string(),
                routes::AVG_UPTIME,
            ],
            NO_PARAMS,
@@ -10,7 +10,6 @@ pub const GATEWAYS: &str = "gateways";
 pub const DETAILED: &str = "detailed";
 pub const ACTIVE: &str = "active";
 pub const REWARDED: &str = "rewarded";
-
 pub const COCONUT_ROUTES: &str = "coconut";
 pub const BANDWIDTH: &str = "bandwidth";

@@ -28,6 +27,8 @@ pub const CORE_STATUS_COUNT: &str = "core-status-count";
 pub const SINCE_ARG: &str = "since";

 pub const STATUS: &str = "status";
+pub const REPORT: &str = "report";
+pub const HISTORY: &str = "history";
 pub const REWARD_ESTIMATION: &str = "reward-estimation";
 pub const AVG_UPTIME: &str = "avg_uptime";
 pub const STAKE_SATURATION: &str = "stake-saturation";
@@ -28,6 +28,11 @@ pub fn pretty_cosmwasm_coin(coin: &CosmWasmCoin) -> String {
    format!("{} {}", amount, denom)
 }

+pub fn pretty_decimal_with_denom(value: Decimal, denom: &str) -> String {
+    // TODO: we might have to truncate the value here (that's why I moved it to separate function)
+    format!("{} {}", value, denom)
+}
+
 pub fn show_error<E>(e: E)
 where
    E: Display,
@@ -51,7 +51,7 @@ pub async fn query_balance(
                return;
            }

-            let denom = args.denom.unwrap_or_else(|| "".to_string());
+            let denom = args.denom.unwrap_or_default();

            for coin in coins {
                if denom.is_empty() || denom.eq_ignore_ascii_case(&coin.denom) {
@@ -4,12 +4,16 @@
 use crate::context::SigningClient;
 use clap::Parser;
 use log::info;
-use mixnet_contract_common::Coin;
+use mixnet_contract_common::{Coin, MixId};
+use validator_client::nymd::traits::{MixnetQueryClient, MixnetSigningClient};

 #[derive(Debug, Parser)]
 pub struct Args {
    #[clap(long)]
-    pub identity_key: String,
+    pub mix_id: Option<MixId>,
+
+    #[clap(long)]
+    pub identity_key: Option<String>,

    #[clap(long)]
    pub amount: u128,
@@ -20,10 +24,25 @@ pub async fn delegate_to_mixnode(args: Args, client: SigningClient) {

    info!("Starting delegation to mixnode");

+    let mix_id = match args.mix_id {
+        Some(mix_id) => mix_id,
+        None => {
+            let identity_key = args
+                .identity_key
+                .expect("either mix_id or mix_identity has to be specified");
+            let node_details = client
+                .get_mixnode_details_by_identity(identity_key)
+                .await
+                .expect("contract query failed")
+                .expect("mixnode with the specified identity doesnt exist");
+            node_details.mix_id()
+        }
+    };
+
    let coin = Coin::new(args.amount, denom);

    let res = client
-        .delegate_to_mixnode(&*args.identity_key, coin.into(), None)
+        .delegate_to_mixnode(mix_id, coin.into(), None)
        .await
        .expect("failed to delegate to mixnode!");

@@ -8,8 +8,8 @@ use crate::context::SigningClientWithValidatorAPI;
 use crate::utils::{pretty_cosmwasm_coin, show_error_passthrough};

 use comfy_table::Table;
-use mixnet_contract_common::mixnode::DelegationEvent;
-use mixnet_contract_common::Delegation;
+use cosmwasm_std::Addr;
+use mixnet_contract_common::{Delegation, PendingEpochEvent, PendingEpochEventKind};

 #[derive(Debug, Parser)]
 pub struct Args {}
@@ -26,19 +26,7 @@ pub async fn execute(_args: Args, client: SigningClientWithValidatorAPI) {
        .map_err(show_error_passthrough);

    let mixnet_contract_events = client
-        .nymd
-        .get_pending_delegation_events(client.nymd.address().to_string(), None)
-        .await
-        .map_err(show_error_passthrough);
-
-    let vesting_contract = client.nymd.vesting_contract_address();
-
-    let vesting_contract_events = client
-        .nymd
-        .get_pending_delegation_events(
-            client.nymd.address().to_string(),
-            Some(vesting_contract.to_string()),
-        )
+        .get_all_nymd_pending_epoch_events()
        .await
        .map_err(show_error_passthrough);

@@ -58,13 +46,6 @@ pub async fn execute(_args: Args, client: SigningClientWithValidatorAPI) {
            print_delegation_events(res, &client).await;
        }
    }
-    if let Ok(res) = vesting_contract_events {
-        if !res.is_empty() {
-            println!();
-            println!("Pending delegations (locked tokens):");
-            print_delegation_events(res, &client).await;
-        }
-    }
 }

 async fn to_iso_timestamp(block_height: u32, client: &SigningClientWithValidatorAPI) -> String {
@@ -77,14 +58,17 @@ async fn to_iso_timestamp(block_height: u32, client: &SigningClientWithValidator
 async fn print_delegations(delegations: Vec<Delegation>, client: &SigningClientWithValidatorAPI) {
    let mut table = Table::new();

-    table.set_header(vec!["Timestamp", "Identity Key", "Delegation", "Proxy"]);
+    table.set_header(vec!["Timestamp", "Mix Id", "Delegation", "Proxy"]);

    for delegation in delegations {
        table.add_row(vec![
-            to_iso_timestamp(delegation.block_height as u32, client).await,
-            delegation.node_identity.to_string(),
+            to_iso_timestamp(delegation.height as u32, client).await,
+            delegation.mix_id.to_string(),
            pretty_cosmwasm_coin(&delegation.amount),
-            format!("{:?}", delegation.proxy),
+            delegation
+                .proxy
+                .map(Addr::into_string)
+                .unwrap_or_else(|| "-".into()),
        ]);
    }

@@ -92,36 +76,53 @@ async fn print_delegations(delegations: Vec<Delegation>, client: &SigningClientW
 }

 async fn print_delegation_events(
-    events: Vec<DelegationEvent>,
+    events: Vec<PendingEpochEvent>,
    client: &SigningClientWithValidatorAPI,
 ) {
    let mut table = Table::new();

    table.set_header(vec![
        "Timestamp",
-        "Identity Key",
+        "Mix id",
        "Delegation",
        "Event Type",
+        "Proxy",
    ]);

    for event in events {
-        match event {
-            DelegationEvent::Delegate(delegation) => {
-                table.add_row(vec![
-                    to_iso_timestamp(delegation.block_height as u32, client).await,
-                    delegation.node_identity.to_string(),
-                    pretty_cosmwasm_coin(&delegation.amount),
-                    "Delegate".to_string(),
-                ]);
+        match event.event.kind {
+            PendingEpochEventKind::Delegate {
+                owner,
+                mix_id,
+                amount,
+                proxy,
+            } => {
+                if owner.as_str() == client.nymd.address().as_ref() {
+                    table.add_row(vec![
+                        "not-sure-if-applicable".into(),
+                        mix_id.to_string(),
+                        pretty_cosmwasm_coin(&amount),
+                        "Delegate".to_string(),
+                        proxy.map(Addr::into_string).unwrap_or_else(|| "-".into()),
+                    ]);
+                }
            }
-            DelegationEvent::Undelegate(undelegate) => {
-                table.add_row(vec![
-                    to_iso_timestamp(undelegate.block_height() as u32, client).await,
-                    undelegate.mix_identity().to_string(),
-                    "-".to_string(),
-                    "Undelegate".to_string(),
-                ]);
+            PendingEpochEventKind::Undelegate {
+                owner,
+                mix_id,
+                proxy,
+            } => {
+                if owner.as_str() == client.nymd.address().as_ref() {
+                    table.add_row(vec![
+                        "not-sure-if-applicable".into(),
+                        mix_id.to_string(),
+                        "-".to_string(),
+                        "Undelegate".to_string(),
+                        proxy.map(Addr::into_string).unwrap_or_else(|| "-".into()),
+                    ]);
+                }
            }
+            _ => {}
        }
    }

@@ -4,18 +4,38 @@
 use crate::context::SigningClient;
 use clap::Parser;
 use log::info;
+use mixnet_contract_common::MixId;
+use validator_client::nymd::traits::{MixnetQueryClient, MixnetSigningClient};

 #[derive(Debug, Parser)]
 pub struct Args {
    #[clap(long)]
-    pub identity_key: String,
+    pub mix_id: Option<MixId>,
+
+    #[clap(long)]
+    pub identity_key: Option<String>,
 }

 pub async fn claim_delegator_reward(args: Args, client: SigningClient) {
    info!("Claim delegator reward");

+    let mix_id = match args.mix_id {
+        Some(mix_id) => mix_id,
+        None => {
+            let identity_key = args
+                .identity_key
+                .expect("either mix_id or mix_identity has to be specified");
+            let node_details = client
+                .get_mixnode_details_by_identity(identity_key)
+                .await
+                .expect("contract query failed")
+                .expect("mixnode with the specified identity doesnt exist");
+            node_details.mix_id()
+        }
+    };
+
    let res = client
-        .execute_claim_delegator_reward(args.identity_key, None)
+        .withdraw_delegator_reward(mix_id, None)
        .await
        .expect("failed to claim delegator-reward");

@@ -4,18 +4,38 @@
 use crate::context::SigningClient;
 use clap::Parser;
 use log::info;
+use mixnet_contract_common::MixId;
+use validator_client::nymd::traits::{MixnetQueryClient, MixnetSigningClient};

 #[derive(Debug, Parser)]
 pub struct Args {
    #[clap(long)]
-    pub identity: String,
+    pub mix_id: Option<MixId>,
+
+    #[clap(long)]
+    pub identity_key: Option<String>,
 }

 pub async fn vesting_claim_delegator_reward(args: Args, client: SigningClient) {
    info!("Claim vesting delegator reward");

+    let mix_id = match args.mix_id {
+        Some(mix_id) => mix_id,
+        None => {
+            let identity_key = args
+                .identity_key
+                .expect("either mix_id or mix_identity has to be specified");
+            let node_details = client
+                .get_mixnode_details_by_identity(identity_key)
+                .await
+                .expect("contract query failed")
+                .expect("mixnode with the specified identity doesnt exist");
+            node_details.mix_id()
+        }
+    };
+
    let res = client
-        .execute_vesting_claim_delegator_reward(args.identity, None)
+        .withdraw_delegator_reward_on_behalf(client.address().clone(), mix_id, None)
        .await
        .expect("failed to claim vesting delegator-reward");

@@ -4,18 +4,38 @@
 use crate::context::SigningClient;
 use clap::Parser;
 use log::info;
+use mixnet_contract_common::MixId;
+use validator_client::nymd::traits::{MixnetQueryClient, MixnetSigningClient};

 #[derive(Debug, Parser)]
 pub struct Args {
    #[clap(long)]
-    pub identity_key: String,
+    pub mix_id: Option<MixId>,
+
+    #[clap(long)]
+    pub identity_key: Option<String>,
 }

 pub async fn undelegate_from_mixnode(args: Args, client: SigningClient) {
    info!("removing stake from mix-node");

+    let mix_id = match args.mix_id {
+        Some(mix_id) => mix_id,
+        None => {
+            let identity_key = args
+                .identity_key
+                .expect("either mix_id or mix_identity has to be specified");
+            let node_details = client
+                .get_mixnode_details_by_identity(identity_key)
+                .await
+                .expect("contract query failed")
+                .expect("mixnode with the specified identity doesnt exist");
+            node_details.mix_id()
+        }
+    };
+
    let res = client
-        .remove_mixnode_delegation(&*args.identity_key, None)
+        .undelegate_from_mixnode(mix_id, None)
        .await
        .expect("failed to remove stake from mixnode!");

@@ -4,7 +4,8 @@
 use clap::Parser;
 use log::info;

-use mixnet_contract_common::Coin;
+use mixnet_contract_common::{Coin, MixId};
+use validator_client::nymd::traits::MixnetQueryClient;
 use validator_client::nymd::VestingSigningClient;

 use crate::context::SigningClient;
@@ -12,7 +13,10 @@ use crate::context::SigningClient;
 #[derive(Debug, Parser)]
 pub struct Args {
    #[clap(long)]
-    pub identity_key: String,
+    pub mix_id: Option<MixId>,
+
+    #[clap(long)]
+    pub identity_key: Option<String>,

    #[clap(long)]
    pub amount: u128,
@@ -23,10 +27,25 @@ pub async fn vesting_delegate_to_mixnode(args: Args, client: SigningClient) {

    info!("Starting vesting delegation to mixnode");

+    let mix_id = match args.mix_id {
+        Some(mix_id) => mix_id,
+        None => {
+            let identity_key = args
+                .identity_key
+                .expect("either mix_id or mix_identity has to be specified");
+            let node_details = client
+                .get_mixnode_details_by_identity(identity_key)
+                .await
+                .expect("contract query failed")
+                .expect("mixnode with the specified identity doesnt exist");
+            node_details.mix_id()
+        }
+    };
+
    let coin = Coin::new(args.amount, denom);

    let res = client
-        .vesting_delegate_to_mixnode(&*args.identity_key, coin.into(), None)
+        .vesting_delegate_to_mixnode(mix_id, coin.into(), None)
        .await
        .expect("failed to delegate to mixnode!");

@@ -3,7 +3,8 @@

 use clap::Parser;
 use log::info;
-
+use mixnet_contract_common::MixId;
+use validator_client::nymd::traits::MixnetQueryClient;
 use validator_client::nymd::VestingSigningClient;

 use crate::context::SigningClient;
@@ -11,14 +12,32 @@ use crate::context::SigningClient;
 #[derive(Debug, Parser)]
 pub struct Args {
    #[clap(long)]
-    pub identity_key: String,
+    pub mix_id: Option<MixId>,
+
+    #[clap(long)]
+    pub identity_key: Option<String>,
 }

 pub async fn vesting_undelegate_from_mixnode(args: Args, client: SigningClient) {
    info!("removing stake from vesting mix-node");

+    let mix_id = match args.mix_id {
+        Some(mix_id) => mix_id,
+        None => {
+            let identity_key = args
+                .identity_key
+                .expect("either mix_id or mix_identity has to be specified");
+            let node_details = client
+                .get_mixnode_details_by_identity(identity_key)
+                .await
+                .expect("contract query failed")
+                .expect("mixnode with the specified identity doesnt exist");
+            node_details.mix_id()
+        }
+    };
+
    let res = client
-        .vesting_undelegate_from_mixnode(&*args.identity_key, None)
+        .vesting_undelegate_from_mixnode(mix_id, None)
        .await
        .expect("failed to remove stake from vesting account on mixnode!");

@@ -6,6 +6,7 @@ use clap::Parser;
 use log::{info, warn};
 use mixnet_contract_common::Coin;
 use network_defaults::{DEFAULT_CLIENT_LISTENING_PORT, DEFAULT_MIX_LISTENING_PORT};
+use validator_client::nymd::traits::MixnetSigningClient;

 #[derive(Debug, Parser)]
 pub struct Args {
@@ -4,6 +4,7 @@
 use crate::context::SigningClient;
 use clap::Parser;
 use log::info;
+use validator_client::nymd::traits::MixnetSigningClient;

 #[derive(Debug, Parser)]
 pub struct Args {}
@@ -68,7 +68,7 @@ pub async fn vesting_bond_gateway(client: SigningClient, args: Args, denom: &str
    let coin = Coin::new(args.amount, denom);

    let res = client
-        .vesting_bond_gateway(gateway, &*args.signature, coin.into(), None)
+        .vesting_bond_gateway(gateway, &args.signature, coin.into(), None)
        .await
        .expect("failed to bond gateway!");

@@ -4,6 +4,7 @@
 use crate::context::SigningClient;
 use clap::Parser;
 use log::info;
+use validator_client::nymd::traits::MixnetSigningClient;

 #[derive(Debug, Parser)]
 pub struct Args {}
@@ -2,12 +2,15 @@
 // SPDX-License-Identifier: Apache-2.0

 use clap::Parser;
+use cosmwasm_std::Uint128;
 use log::{info, warn};

-use mixnet_contract_common::Coin;
+use mixnet_contract_common::{Coin, MixNodeCostParams, Percent};
 use network_defaults::{
    DEFAULT_HTTP_API_LISTENING_PORT, DEFAULT_MIX_LISTENING_PORT, DEFAULT_VERLOC_LISTENING_PORT,
 };
+use validator_client::nymd::traits::MixnetSigningClient;
+use validator_client::nymd::CosmWasmCoin;

 use crate::context::SigningClient;

@@ -40,6 +43,12 @@ pub struct Args {
    #[clap(long)]
    pub profit_margin_percent: Option<u8>,

+    #[clap(
+        long,
+        help = "operating cost in current DENOMINATION (so it would be 'unym', rather than 'nym')"
+    )]
+    pub interval_operating_cost: Option<u128>,
+
    #[clap(
        long,
        help = "bonding amount in current DENOMINATION (so it would be 'unym', rather than 'nym')"
@@ -71,13 +80,23 @@ pub async fn bond_mixnode(args: Args, client: SigningClient) {
        sphinx_key: args.sphinx_key,
        identity_key: args.identity_key,
        version: args.version,
-        profit_margin_percent: args.profit_margin_percent.unwrap_or(10),
    };

    let coin = Coin::new(args.amount, denom);

+    let cost_params = MixNodeCostParams {
+        profit_margin_percent: Percent::from_percentage_value(
+            args.profit_margin_percent.unwrap_or(10) as u64,
+        )
+        .unwrap(),
+        interval_operating_cost: CosmWasmCoin {
+            denom: denom.into(),
+            amount: Uint128::new(args.interval_operating_cost.unwrap_or(40_000_000)),
+        },
+    };
+
    let res = client
-        .bond_mixnode(mixnode, args.signature, coin.into(), None)
+        .bond_mixnode(mixnode, cost_params, args.signature, coin.into(), None)
        .await
        .expect("failed to bond mixnode!");

@@ -4,6 +4,7 @@
 use crate::context::SigningClient;
 use clap::Parser;
 use log::info;
+use validator_client::nymd::traits::MixnetSigningClient;

 #[derive(Debug, Parser)]
 pub struct Args {}
@@ -12,7 +13,7 @@ pub async fn claim_operator_reward(_args: Args, client: SigningClient) {
    info!("Claim operator reward");

    let res = client
-        .execute_claim_operator_reward(None)
+        .withdraw_operator_reward(None)
        .await
        .expect("failed to claim operator reward");

@@ -4,6 +4,7 @@
 use crate::context::SigningClient;
 use clap::Parser;
 use log::info;
+use validator_client::nymd::traits::MixnetSigningClient;

 #[derive(Debug, Parser)]
 pub struct Args {
@@ -15,7 +16,7 @@ pub async fn vesting_claim_operator_reward(client: SigningClient) {
    info!("Claim vesting operator reward");

    let res = client
-        .execute_vesting_claim_operator_reward(None)
+        .withdraw_operator_reward_on_behalf(client.address().clone(), None)
        .await
        .expect("failed to claim vesting operator reward");

@@ -3,8 +3,8 @@

 use clap::{Args, Subcommand};

-pub mod update_profit_percent;
-pub mod vesting_update_profit_percent;
+pub mod update_config;
+pub mod vesting_update_config;

 #[derive(Debug, Args)]
 #[clap(args_conflicts_with_subcommands = true, subcommand_required = true)]
@@ -15,8 +15,12 @@ pub struct MixnetOperatorsMixnodeSettings {

 #[derive(Debug, Subcommand)]
 pub enum MixnetOperatorsMixnodeSettingsCommands {
-    /// Update profit percentage
-    UpdateProfitPercentage(update_profit_percent::Args),
-    /// Update profit percentage for a mixnode bonded with locked tokens
-    VestingUpdateProfitPercentage(vesting_update_profit_percent::Args),
+    /// Update mixnode configuration
+    UpdateConfig(update_config::Args),
+    /// Update mixnode configuration for a mixnode bonded with locked tokens
+    VestingUpdateConfig(vesting_update_config::Args),
+    /// Update mixnode cost parameters
+    UpdateCostParameters,
+    /// Update mixnode cost parameters for a mixnode bonded with locked tokens
+    VestingUpdateCostParameters,
 }
@@ -0,0 +1,68 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::context::SigningClient;
+use clap::Parser;
+use log::info;
+use mixnet_contract_common::MixNodeConfigUpdate;
+use validator_client::nymd::traits::{MixnetQueryClient, MixnetSigningClient};
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(long)]
+    pub host: Option<String>,
+
+    #[clap(long)]
+    pub mix_port: Option<u16>,
+
+    #[clap(long)]
+    pub verloc_port: Option<u16>,
+
+    #[clap(long)]
+    pub http_api_port: Option<u16>,
+
+    #[clap(long)]
+    pub version: Option<String>,
+}
+
+pub async fn update_config(args: Args, client: SigningClient) {
+    info!("Update mix node config!");
+
+    let current_details = match client
+        .get_owned_mixnode(client.address())
+        .await
+        .expect("failed to query the chain for mixnode details")
+        .mixnode_details
+    {
+        Some(details) => details,
+        None => {
+            log::warn!("this operator does not own a mixnode to update");
+            return;
+        }
+    };
+
+    let update = MixNodeConfigUpdate {
+        host: args
+            .host
+            .unwrap_or(current_details.bond_information.mix_node.host),
+        mix_port: args
+            .mix_port
+            .unwrap_or(current_details.bond_information.mix_node.mix_port),
+        verloc_port: args
+            .verloc_port
+            .unwrap_or(current_details.bond_information.mix_node.verloc_port),
+        http_api_port: args
+            .http_api_port
+            .unwrap_or(current_details.bond_information.mix_node.http_api_port),
+        version: args
+            .version
+            .unwrap_or(current_details.bond_information.mix_node.version),
+    };
+
+    let res = client
+        .update_mixnode_config(update, None)
+        .await
+        .expect("updating mix-node config");
+
+    info!("mixnode config updated: {:?}", res)
+}
@@ -1,24 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::context::SigningClient;
-use clap::Parser;
-use log::info;
-
-#[derive(Debug, Parser)]
-pub struct Args {
-    #[clap(long)]
-    pub profit_percent: u8,
-}
-
-pub async fn update_profit_percent(args: Args, client: SigningClient) {
-    info!("Update mix node profit percent - get those rewards!");
-
-    //profit percent between 1-100
-    let res = client
-        .update_mixnode_config(args.profit_percent, None)
-        .await
-        .expect("updating mix-node profit percent");
-
-    info!("profit percentage updated: {:?}", res)
-}
@@ -0,0 +1,69 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::context::SigningClient;
+use clap::Parser;
+use log::info;
+use mixnet_contract_common::MixNodeConfigUpdate;
+use validator_client::nymd::traits::MixnetQueryClient;
+use validator_client::nymd::VestingSigningClient;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(long)]
+    pub host: Option<String>,
+
+    #[clap(long)]
+    pub mix_port: Option<u16>,
+
+    #[clap(long)]
+    pub verloc_port: Option<u16>,
+
+    #[clap(long)]
+    pub http_api_port: Option<u16>,
+
+    #[clap(long)]
+    pub version: Option<String>,
+}
+
+pub async fn vesting_update_config(client: SigningClient, args: Args) {
+    info!("Update vesting mix node config!");
+
+    let current_details = match client
+        .get_owned_mixnode(client.address())
+        .await
+        .expect("failed to query the chain for mixnode details")
+        .mixnode_details
+    {
+        Some(details) => details,
+        None => {
+            log::warn!("this operator does not own a mixnode to update");
+            return;
+        }
+    };
+
+    let update = MixNodeConfigUpdate {
+        host: args
+            .host
+            .unwrap_or(current_details.bond_information.mix_node.host),
+        mix_port: args
+            .mix_port
+            .unwrap_or(current_details.bond_information.mix_node.mix_port),
+        verloc_port: args
+            .verloc_port
+            .unwrap_or(current_details.bond_information.mix_node.verloc_port),
+        http_api_port: args
+            .http_api_port
+            .unwrap_or(current_details.bond_information.mix_node.http_api_port),
+        version: args
+            .version
+            .unwrap_or(current_details.bond_information.mix_node.version),
+    };
+
+    let res = client
+        .vesting_update_mixnode_config(update, None)
+        .await
+        .expect("updating vesting mix-node config");
+
+    info!("mixnode config updated: {:?}", res)
+}
@@ -1,28 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::context::SigningClient;
-use clap::Parser;
-use log::info;
-use validator_client::nymd::VestingSigningClient;
-
-#[derive(Debug, Parser)]
-pub struct Args {
-    #[clap(long)]
-    pub profit_percent: u8,
-
-    #[clap(long)]
-    pub gas: Option<u64>,
-}
-
-pub async fn vesting_update_profit_percent(client: SigningClient, args: Args) {
-    info!("Update vesting mix node profit percent - get those rewards!");
-
-    //profit percent between 1-100
-    let res = client
-        .vesting_update_mixnode_config(args.profit_percent, None)
-        .await
-        .expect("updating vesting mix-node profit percent");
-
-    info!("profit percentage updated: {:?}", res)
-}
@@ -3,6 +3,7 @@

 use clap::Parser;
 use log::info;
+use validator_client::nymd::traits::MixnetSigningClient;

 use crate::context::SigningClient;

@@ -3,13 +3,14 @@

 use crate::context::SigningClient;
 use clap::Parser;
+use cosmwasm_std::Uint128;
 use log::{info, warn};
-use mixnet_contract_common::Coin;
-use mixnet_contract_common::MixNode;
+use mixnet_contract_common::{Coin, MixNodeCostParams};
+use mixnet_contract_common::{MixNode, Percent};
 use network_defaults::{
    DEFAULT_HTTP_API_LISTENING_PORT, DEFAULT_MIX_LISTENING_PORT, DEFAULT_VERLOC_LISTENING_PORT,
 };
-use validator_client::nymd::VestingSigningClient;
+use validator_client::nymd::{CosmWasmCoin, VestingSigningClient};

 #[derive(Debug, Parser)]
 pub struct Args {
@@ -40,6 +41,12 @@ pub struct Args {
    #[clap(long)]
    pub profit_margin_percent: Option<u8>,

+    #[clap(
+        long,
+        help = "operating cost in current DENOMINATION (so it would be 'unym', rather than 'nym')"
+    )]
+    pub interval_operating_cost: Option<u128>,
+
    #[clap(
        long,
        help = "bonding amount in current DENOMINATION (so it would be 'unym', rather than 'nym')"
@@ -72,13 +79,23 @@ pub async fn vesting_bond_mixnode(client: SigningClient, args: Args, denom: &str
        sphinx_key: args.sphinx_key,
        identity_key: args.identity_key,
        version: args.version,
-        profit_margin_percent: args.profit_margin_percent.unwrap_or(10),
    };

    let coin = Coin::new(args.amount, denom);

+    let cost_params = MixNodeCostParams {
+        profit_margin_percent: Percent::from_percentage_value(
+            args.profit_margin_percent.unwrap_or(10) as u64,
+        )
+        .unwrap(),
+        interval_operating_cost: CosmWasmCoin {
+            denom: denom.into(),
+            amount: Uint128::new(args.interval_operating_cost.unwrap_or(40_000_000)),
+        },
+    };
+
    let res = client
-        .vesting_bond_mixnode(mixnode, &*args.signature, coin.into(), None)
+        .vesting_bond_mixnode(mixnode, cost_params, &args.signature, coin.into(), None)
        .await
        .expect("failed to bond vesting mixnode!");

@@ -5,7 +5,7 @@ use clap::Parser;
 use comfy_table::Table;

 use crate::context::QueryClientWithValidatorAPI;
-use crate::utils::{pretty_cosmwasm_coin, show_error};
+use crate::utils::{pretty_decimal_with_denom, show_error};

 #[derive(Debug, Parser)]
 pub struct Args {
@@ -19,7 +19,8 @@ pub async fn query(args: Args, client: &QueryClientWithValidatorAPI) {
        Ok(res) => match args.identity_key {
            Some(identity_key) => {
                let node = res.iter().find(|node| {
-                    node.mix_node
+                    node.bond_information
+                        .mix_node
                        .identity_key
                        .to_string()
                        .eq_ignore_ascii_case(&identity_key)
@@ -33,6 +34,7 @@ pub async fn query(args: Args, client: &QueryClientWithValidatorAPI) {
                let mut table = Table::new();

                table.set_header(vec![
+                    "Mix id",
                    "Identity Key",
                    "Owner",
                    "Host",
@@ -41,13 +43,15 @@ pub async fn query(args: Args, client: &QueryClientWithValidatorAPI) {
                    "Version",
                ]);
                for node in res {
+                    let denom = &node.bond_information.original_pledge().denom;
                    table.add_row(vec![
-                        node.mix_node.identity_key.to_string(),
-                        node.owner.to_string(),
-                        node.mix_node.host.to_string(),
-                        pretty_cosmwasm_coin(&node.pledge_amount),
-                        pretty_cosmwasm_coin(&node.total_delegation()),
-                        node.mix_node.version,
+                        node.mix_id().to_string(),
+                        node.bond_information.mix_node.identity_key.clone(),
+                        node.bond_information.owner.clone().into_string(),
+                        node.bond_information.mix_node.host.clone(),
+                        pretty_decimal_with_denom(node.rewarding_details.operator, denom),
+                        pretty_decimal_with_denom(node.rewarding_details.delegates, denom),
+                        node.bond_information.mix_node.version,
                    ]);
                }

@@ -5,6 +5,9 @@ use thiserror::Error;

 #[derive(Error, Debug)]
 pub enum Errors {
+    #[error("account id does not match")]
+    AccountIdError,
+
    #[error("signature error - {0}")]
    SignatureError(#[from] k256::ecdsa::signature::Error),

@@ -21,12 +21,22 @@ pub fn secp256k1_verify_with_public_key_json(
    public_key_as_json: String,
    signature_as_hex: String,
    message: String,
+    account_id: String,
+    account_prefix: &str,
 ) -> Result<(), Errors> {
    let public_key = PublicKey::from_json(&public_key_as_json)?;
-    let verifying_key = VerifyingKey::from_sec1_bytes(&public_key.to_bytes())?;
-    let signature = Signature::from_str(&signature_as_hex)?;
-    let message_as_bytes = message.into_bytes();
-    Ok(verifying_key.verify(&message_as_bytes, &signature)?)
+    match public_key.account_id(account_prefix) {
+        Ok(derived_account_id) => {
+            if derived_account_id.to_string() != account_id {
+                return Err(Errors::AccountIdError);
+            }
+            let verifying_key = VerifyingKey::from_sec1_bytes(&public_key.to_bytes())?;
+            let signature = Signature::from_str(&signature_as_hex)?;
+            let message_as_bytes = message.into_bytes();
+            Ok(verifying_key.verify(&message_as_bytes, &signature)?)
+        }
+        Err(e) => Err(Errors::CosmrsError(e)),
+    }
 }

 #[cfg(test)]
@@ -69,9 +79,16 @@ mod test_secp256k1 {
        let json_public_key = r#"{"@type":"/cosmos.crypto.secp256k1.PubKey","key":"A4FdhUMasPmNhRZjtpKlmjNbq7EEUgPxfdI+E3vSajvc"}"#.to_string();
        let signature_as_hex = "E3AA5AC0DA1B7DEBB7808000F719D8ACB9A0BE10AFA2756A788516268EB246A1257EC1097C5E364EF916145B01641DEDFE955994CB340BDAFA99A65BCA3F6F28".to_string();
        let message = "test 1234".to_string();
+        let account_id = "n1lntkptzz8grf2w4yht4szxktzwsucgv4s7vv9g".to_string();
+        let account_prefix = "n";

-        let result =
-            secp256k1_verify_with_public_key_json(json_public_key, signature_as_hex, message);
+        let result = secp256k1_verify_with_public_key_json(
+            json_public_key,
+            signature_as_hex,
+            message,
+            account_id,
+            account_prefix,
+        );

        assert!(result.is_ok());
    }
@@ -81,9 +98,16 @@ mod test_secp256k1 {
        let bad_json_public_key = r#"This is not JSON ☠️"#.to_string();
        let signature_as_hex = "E3AA5AC0DA1B7DEBB7808000F719D8ACB9A0BE10AFA2756A788516268EB246A1257EC1097C5E364EF916145B01641DEDFE955994CB340BDAFA99A65BCA3F6F28".to_string();
        let message = "abcdef".to_string();
+        let account_id = "".to_string();
+        let account_prefix = "n";

-        let result =
-            secp256k1_verify_with_public_key_json(bad_json_public_key, signature_as_hex, message);
+        let result = secp256k1_verify_with_public_key_json(
+            bad_json_public_key,
+            signature_as_hex,
+            message,
+            account_id,
+            account_prefix,
+        );

        assert!(result.is_err());
    }
@@ -12,6 +12,7 @@ use validator_client::nymd::AccountId;
 use validator_client::nymd::VestingSigningClient;
 use validator_client::nymd::{CosmosCoin, Denom};
 use vesting_contract_common::messages::VestingSpecification;
+use vesting_contract_common::PledgeCap;

 use crate::context::SigningClient;

@@ -34,6 +35,12 @@ pub struct Args {

    #[clap(long)]
    pub staking_address: Option<String>,
+
+    #[clap(
+        long,
+        help = "Pledge cap as either absolute uNYM value or percentage, floats need to be in the 0.0 to 1.0 range and will be parsed as percentages, integers will be parsed as uNYM"
+    )]
+    pub pledge_cap: Option<PledgeCap>,
 }

 pub async fn create(args: Args, client: SigningClient, network_details: &NymNetworkDetails) {
@@ -51,10 +58,11 @@ pub async fn create(args: Args, client: SigningClient, network_details: &NymNetw

    let res = client
        .create_periodic_vesting_account(
-            &*args.address,
+            &args.address,
            args.staking_address,
            Some(vesting),
            coin.into(),
+            args.pledge_cap,
            None,
        )
        .await
@@ -70,7 +78,7 @@ pub async fn create(args: Args, client: SigningClient, network_details: &NymNetw

    let send_coin_response = client
        .send(
-            &AccountId::from_str(&*args.address).unwrap(),
+            &AccountId::from_str(&args.address).unwrap(),
            vec![coin.into()],
            "payment made :)",
            None,
@@ -0,0 +1,11 @@
+[package]
+name = "completions"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+clap = { version = "3.2", features = ["derive"] }
+clap_complete = "3.2"
+clap_complete_fig = "3.2"
@@ -0,0 +1,58 @@
+use clap::builder::Command;
+use clap::clap_derive::ArgEnum;
+use clap::Args;
+use clap_complete::generator::generate;
+use clap_complete::Shell as ClapShell;
+use std::io;
+
+pub fn fig_generate(command: &mut Command, name: &str) {
+    clap_complete::generate(
+        clap_complete_fig::Fig,
+        command,
+        name,
+        &mut std::io::stdout(),
+    )
+}
+
+#[derive(ArgEnum, Copy, Clone)]
+pub enum Shell {
+    Bash,
+    Elvish,
+    Fish,
+    PowerShell,
+    Zsh,
+}
+
+#[derive(Args, Copy, Clone)]
+pub struct ArgShell {
+    #[clap(arg_enum, value_name = "SHELL")]
+    shell: Shell,
+}
+
+impl ArgShell {
+    pub fn generate(&self, command: &mut Command, name: &str) {
+        self.shell.generate(command, name)
+    }
+}
+
+impl Shell {
+    pub fn generate(&self, command: &mut Command, name: &str) {
+        match &self {
+            Self::Bash => {
+                generate(ClapShell::Bash, command, name, &mut io::stdout());
+            }
+            Self::Elvish => {
+                generate(ClapShell::Elvish, command, name, &mut io::stdout());
+            }
+            Self::Fish => {
+                generate(ClapShell::Fish, command, name, &mut io::stdout());
+            }
+            Self::PowerShell => {
+                generate(ClapShell::PowerShell, command, name, &mut io::stdout());
+            }
+            Self::Zsh => {
+                generate(ClapShell::Zsh, command, name, &mut io::stdout());
+            }
+        }
+    }
+}
@@ -88,6 +88,7 @@ pub trait NymConfig: Default + Serialize + DeserializeOwned {

        let location = custom_location
            .unwrap_or_else(|| self.config_directory().join(Self::config_file_name()));
+        log::info!("Configuration file will be saved to {:?}", location);

        cfg_if::cfg_if! {
            if #[cfg(unix)] {
@@ -8,3 +8,9 @@ edition = "2021"

 [dependencies]
 cosmwasm-std = "1.0.0"
+serde = { version = "1.0", features = ["derive"] }
+schemars = "0.8"
+thiserror = "1"
+
+[dev-dependencies]
+serde_json = "1.0.0"
@@ -11,6 +11,8 @@ use cosmwasm_std::Event;
 /// * `event`: event to search through.
 /// * `key`: key associated with the particular attribute
 pub fn must_find_attribute(event: &Event, key: &str) -> String {
+    // due to how the function is supposed to work, the unwrap is fine in this instance
+    #[allow(clippy::unwrap_used)]
    may_find_attribute(event, key).unwrap()
 }

@@ -28,3 +30,26 @@ pub fn may_find_attribute(event: &Event, key: &str) -> Option<String> {
    }
    None
 }
+
+pub trait OptionallyAddAttribute {
+    fn add_optional_attribute(
+        self,
+        key: impl Into<String>,
+        value: Option<impl Into<String>>,
+    ) -> Self;
+}
+
+impl OptionallyAddAttribute for Event {
+    fn add_optional_attribute(
+        self,
+        key: impl Into<String>,
+        value: Option<impl Into<String>>,
+    ) -> Self {
+        if let Some(value) = value {
+            self.add_attribute(key, value)
+        } else {
+            // TODO: perhaps if value doesn't exist, we should emit explicit 'null'?
+            self
+        }
+    }
+}
@@ -1,4 +1,10 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

+#![warn(clippy::expect_used)]
+#![warn(clippy::unwrap_used)]
+
 pub mod events;
+pub mod types;
+
+pub use types::*;
@@ -0,0 +1,198 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use cosmwasm_std::Decimal;
+use cosmwasm_std::Uint128;
+use schemars::JsonSchema;
+use serde::de::Error;
+use serde::{Deserialize, Deserializer, Serialize};
+use std::fmt::{self, Display, Formatter};
+use std::ops::Mul;
+use std::str::FromStr;
+use thiserror::Error;
+
+pub fn truncate_decimal(amount: Decimal) -> Uint128 {
+    amount * Uint128::new(1)
+}
+
+#[derive(Error, Debug)]
+pub enum ContractsCommonError {
+    #[error("Provided percent value ({0}) is greater than 100%")]
+    InvalidPercent(Decimal),
+
+    #[error("{source}")]
+    StdErr {
+        #[from]
+        source: cosmwasm_std::StdError,
+    },
+}
+
+/// Percent represents a value between 0 and 100%
+/// (i.e. between 0.0 and 1.0)
+#[derive(
+    Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Serialize, Deserialize, JsonSchema,
+)]
+pub struct Percent(#[serde(deserialize_with = "de_decimal_percent")] Decimal);
+
+impl Percent {
+    pub fn new(value: Decimal) -> Result<Self, ContractsCommonError> {
+        if value > Decimal::one() {
+            Err(ContractsCommonError::InvalidPercent(value))
+        } else {
+            Ok(Percent(value))
+        }
+    }
+
+    pub fn is_zero(&self) -> bool {
+        self.0 == Decimal::zero()
+    }
+
+    pub fn zero() -> Self {
+        Self(Decimal::zero())
+    }
+
+    pub fn hundred() -> Self {
+        Self(Decimal::one())
+    }
+
+    pub fn from_percentage_value(value: u64) -> Result<Self, ContractsCommonError> {
+        Percent::new(Decimal::percent(value))
+    }
+
+    pub fn value(&self) -> Decimal {
+        self.0
+    }
+
+    pub fn round_to_integer(&self) -> u8 {
+        let hundred = Decimal::from_ratio(100u32, 1u32);
+        // we know the cast from u128 to u8 is a safe one since the internal value must be within 0 - 1 range
+        truncate_decimal(hundred * self.0).u128() as u8
+    }
+}
+
+impl Display for Percent {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        let adjusted = Decimal::from_ratio(100u32, 1u32) * self.0;
+        write!(f, "{}%", adjusted)
+    }
+}
+
+impl FromStr for Percent {
+    type Err = ContractsCommonError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Percent::new(Decimal::from_str(s)?)
+    }
+}
+
+impl Mul<Decimal> for Percent {
+    type Output = Decimal;
+
+    fn mul(self, rhs: Decimal) -> Self::Output {
+        self.0 * rhs
+    }
+}
+
+impl Mul<Percent> for Decimal {
+    type Output = Decimal;
+
+    fn mul(self, rhs: Percent) -> Self::Output {
+        rhs * self
+    }
+}
+
+impl Mul<Uint128> for Percent {
+    type Output = Uint128;
+
+    fn mul(self, rhs: Uint128) -> Self::Output {
+        self.0 * rhs
+    }
+}
+
+// implement custom Deserialize because we want to validate Percent has the correct range
+fn de_decimal_percent<'de, D>(deserializer: D) -> Result<Decimal, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let v = Decimal::deserialize(deserializer)?;
+    if v > Decimal::one() {
+        Err(D::Error::custom(
+            "provided decimal percent is larger than 100%",
+        ))
+    } else {
+        Ok(v)
+    }
+}
+
+// TODO: there's no reason this couldn't be used for proper binaries, but in that case
+// perhaps the struct should get renamed and moved to a "more" common crate
+#[derive(Debug, Serialize, Deserialize)]
+pub struct ContractBuildInformation {
+    // VERGEN_BUILD_TIMESTAMP
+    /// Provides the build timestamp, for example `2021-02-23T20:14:46.558472672+00:00`.
+    pub build_timestamp: String,
+
+    // VERGEN_BUILD_SEMVER
+    /// Provides the build version, for example `0.1.0-9-g46f83e1`.
+    pub build_version: String,
+
+    // VERGEN_GIT_SHA
+    /// Provides the hash of the commit that was used for the build, for example `46f83e112520533338245862d366f6a02cef07d4`.
+    pub commit_sha: String,
+
+    // VERGEN_GIT_COMMIT_TIMESTAMP
+    /// Provides the timestamp of the commit that was used for the build, for example `2021-02-23T08:08:02-05:00`.
+    pub commit_timestamp: String,
+
+    // VERGEN_GIT_BRANCH
+    /// Provides the name of the git branch that was used for the build, for example `master`.
+    pub commit_branch: String,
+
+    // VERGEN_RUSTC_SEMVER
+    /// Provides the rustc version that was used for the build, for example `1.52.0-nightly`.
+    pub rustc_version: String,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn percent_serde() {
+        let valid_value = Percent::from_percentage_value(80).unwrap();
+        let serialized = serde_json::to_string(&valid_value).unwrap();
+
+        let deserialized: Percent = serde_json::from_str(&serialized).unwrap();
+        assert_eq!(valid_value, deserialized);
+
+        let invalid_values = vec!["\"42\"", "\"1.1\"", "\"1.00000001\"", "\"foomp\"", "\"1a\""];
+        for invalid_value in invalid_values {
+            assert!(serde_json::from_str::<'_, Percent>(invalid_value).is_err())
+        }
+        assert_eq!(
+            serde_json::from_str::<'_, Percent>("\"0.95\"").unwrap(),
+            Percent::from_percentage_value(95).unwrap()
+        )
+    }
+
+    #[test]
+    fn percent_to_absolute_integer() {
+        let p = serde_json::from_str::<'_, Percent>("\"0.0001\"").unwrap();
+        assert_eq!(p.round_to_integer(), 0);
+
+        let p = serde_json::from_str::<'_, Percent>("\"0.0099\"").unwrap();
+        assert_eq!(p.round_to_integer(), 0);
+
+        let p = serde_json::from_str::<'_, Percent>("\"0.0199\"").unwrap();
+        assert_eq!(p.round_to_integer(), 1);
+
+        let p = serde_json::from_str::<'_, Percent>("\"0.45123\"").unwrap();
+        assert_eq!(p.round_to_integer(), 45);
+
+        let p = serde_json::from_str::<'_, Percent>("\"0.999999999\"").unwrap();
+        assert_eq!(p.round_to_integer(), 99);
+
+        let p = serde_json::from_str::<'_, Percent>("\"1.00\"").unwrap();
+        assert_eq!(p.round_to_integer(), 100);
+    }
+}
@@ -8,23 +8,26 @@ rust-version = "1.62"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [dependencies]
+bs58 = "0.4.0"
 cosmwasm-std = "1.0.0"
-
 serde = { version = "1.0", features = ["derive"] }
 serde_repr = "0.1"
 schemars = "0.8"
 thiserror = "1.0"
-fixed = { version = "1.1", features = ["serde"] }
-az = "1.1"
+contracts-common = { path = "../contracts-common" }
+serde_json = "1.0.0"
+humantime-serde = "1.1.1"
+
+# TO CHECK WHETHER STILL NEEDED:
 log = "0.4.14"
 time = { version = "0.3.6", features = ["parsing", "formatting"] }
-ts-rs = {version = "6.1.2", optional = true}
-
-contracts-common = { path = "../contracts-common" }
+ts-rs = { version = "6.1.2", optional = true }

 [dev-dependencies]
+rand_chacha = "0.3"
 time = { version = "0.3.5", features = ["serde", "macros"] }

 [features]
 default = []
+contract-testing = []
 generate-ts = ['ts-rs']
@@ -0,0 +1,27 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use cosmwasm_std::{Decimal, Uint128};
+
+pub const TOKEN_SUPPLY: Uint128 = Uint128::new(1_000_000_000_000_000);
+
+// I'm still not 100% sure how to feel about existence of this file
+// This is equivalent of representing our display coin with 6 decimal places.
+// I'm using this one as opposed to "Decimal::one()", as this provides us with higher accuracy
+// whilst providing no noticable drawbacks.
+pub const UNIT_DELEGATION_BASE: Decimal =
+    Decimal::raw(1_000_000_000 * 1_000_000_000_000_000_000u128);
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn unit_delegation_didnt_change() {
+        // a sanity check test to make sure Decimal's `DECIMAL_FRACTIONAL` internal implementation hasn't changed
+        assert_eq!(
+            UNIT_DELEGATION_BASE,
+            Decimal::one() * Decimal::from_atomics(1_000_000_000u32, 0).unwrap()
+        )
+    }
+}
@@ -1,151 +1,138 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2021-2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

 // due to code generated by JsonSchema
 #![allow(clippy::field_reassign_with_default)]

-use crate::{Addr, IdentityKey};
-use cosmwasm_std::{Coin, Uint128};
+use crate::constants::TOKEN_SUPPLY;
+use crate::helpers::IntoBaseDecimal;
+use crate::{Addr, MixId};
+use cosmwasm_std::{Coin, Decimal, StdResult};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use std::fmt::Display;
-use std::hash::{Hash, Hasher};

-type OwnerAddressBytes = Vec<u8>;
-type BlockHeight = u64;
+// just use a string representation of those so that we wouldn't need to bother with decoding bytes
+// and trying to figure out whether they're valid, etc
+pub type OwnerProxySubKey = String;
+pub type StorageKey = (MixId, OwnerProxySubKey);

-pub fn generate_storage_key(address: &Addr, proxy: Option<&Addr>) -> Vec<u8> {
+pub fn generate_owner_storage_subkey(address: &Addr, proxy: Option<&Addr>) -> String {
    if let Some(proxy) = &proxy {
-        address
+        let key_bytes = address
            .as_bytes()
            .iter()
            .zip(proxy.as_bytes())
            .map(|(x, y)| x ^ y)
-            .collect()
+            .collect::<Vec<_>>();
+        bs58::encode(key_bytes).into_string()
    } else {
-        address.as_bytes().to_vec()
+        address.clone().into_string()
    }
 }

 #[derive(Clone, Debug, Deserialize, Serialize, PartialEq, JsonSchema)]
 pub struct Delegation {
+    /// Address of the owner of this delegation.
    pub owner: Addr,
-    pub node_identity: IdentityKey,
+
+    /// Id of the MixNode that this delegation was performed against.
+    pub mix_id: MixId,
+
+    // Note to UI/UX devs: there's absolutely no point in displaying this value to the users,
+    // it would serve them no purpose. It's only used for calculating rewards
+    /// Value of the "unit delegation" associated with the mixnode at the time of delegation.
+    pub cumulative_reward_ratio: Decimal,
+
+    /// Original delegation amount. Note that it is never mutated as delegation accumulates rewards.
    pub amount: Coin,
-    pub block_height: u64,
-    pub proxy: Option<Addr>, // proxy address used to delegate the funds on behalf of another address
-}

-impl Eq for Delegation {}
+    /// Block height where this delegation occurred.
+    pub height: u64,

-#[allow(clippy::derive_hash_xor_eq)]
-impl Hash for Delegation {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.owner.hash(state);
-        self.node_identity.hash(state);
-        self.block_height.hash(state);
-        self.proxy.hash(state);
-    }
+    /// Proxy address used to delegate the funds on behalf of another address
+    pub proxy: Option<Addr>,
 }

 impl Delegation {
    pub fn new(
        owner: Addr,
-        node_identity: IdentityKey,
+        mix_id: MixId,
+        cumulative_reward_ratio: Decimal,
        amount: Coin,
-        block_height: BlockHeight,
+        height: u64,
        proxy: Option<Addr>,
    ) -> Self {
+        assert!(
+            amount.amount <= TOKEN_SUPPLY,
+            "delegation cannot be larger than the token supply"
+        );
+
        Delegation {
            owner,
-            node_identity,
+            mix_id,
+            cumulative_reward_ratio,
            amount,
-            block_height,
+            height,
            proxy,
        }
    }

-    pub fn storage_key(&self) -> (IdentityKey, OwnerAddressBytes, BlockHeight) {
-        (
-            self.node_identity(),
-            self.proxy_storage_key(),
-            self.block_height(),
-        )
+    pub fn generate_storage_key(
+        mix_id: MixId,
+        owner_address: &Addr,
+        proxy: Option<&Addr>,
+    ) -> StorageKey {
+        (mix_id, generate_owner_storage_subkey(owner_address, proxy))
    }

-    pub fn event_storage_key(&self) -> (OwnerAddressBytes, BlockHeight, IdentityKey) {
-        (
-            self.proxy_storage_key(),
-            self.block_height(),
-            self.node_identity(),
-        )
+    // this function might seem a bit redundant, but I'd rather explicitly keep it around in case
+    // some types change in the future
+    pub fn generate_storage_key_with_subkey(
+        mix_id: MixId,
+        owner_proxy_subkey: OwnerProxySubKey,
+    ) -> StorageKey {
+        (mix_id, owner_proxy_subkey)
    }

-    pub fn proxy_storage_key(&self) -> OwnerAddressBytes {
-        generate_storage_key(&self.owner, self.proxy.as_ref())
+    pub fn dec_amount(&self) -> StdResult<Decimal> {
+        self.amount.amount.into_base_decimal()
    }

-    pub fn proxy(&self) -> Option<&Addr> {
-        self.proxy.as_ref()
+    pub fn proxy_storage_key(&self) -> OwnerProxySubKey {
+        generate_owner_storage_subkey(&self.owner, self.proxy.as_ref())
    }

-    pub fn increment_amount(&mut self, amount: Uint128, at_height: Option<u64>) {
-        self.amount.amount += amount;
-        if let Some(at_height) = at_height {
-            self.block_height = at_height;
-        }
-    }
-
-    pub fn amount(&self) -> &Coin {
-        &self.amount
-    }
-
-    pub fn node_identity(&self) -> IdentityKey {
-        self.node_identity.clone()
-    }
-
-    pub fn owner(&self) -> Addr {
-        self.owner.clone()
-    }
-
-    pub fn block_height(&self) -> u64 {
-        self.block_height
+    pub fn storage_key(&self) -> StorageKey {
+        Self::generate_storage_key(self.mix_id, &self.owner, self.proxy.as_ref())
    }
 }

-impl Display for Delegation {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(
-            f,
-            "{} delegated towards {} by {} at block {}",
-            self.amount, self.node_identity, self.owner, self.block_height
-        )
-    }
-}
-
-#[derive(Clone, Debug, Deserialize, PartialEq, Eq, Serialize, JsonSchema)]
-pub struct PagedMixDelegationsResponse {
+#[derive(Clone, Debug, Deserialize, PartialEq, Serialize, JsonSchema)]
+pub struct PagedMixNodeDelegationsResponse {
    pub delegations: Vec<Delegation>,
-    pub start_next_after: Option<(String, u64)>,
+    pub start_next_after: Option<OwnerProxySubKey>,
 }

-impl PagedMixDelegationsResponse {
-    pub fn new(delegations: Vec<Delegation>, start_next_after: Option<(String, u64)>) -> Self {
-        PagedMixDelegationsResponse {
+impl PagedMixNodeDelegationsResponse {
+    pub fn new(delegations: Vec<Delegation>, start_next_after: Option<OwnerProxySubKey>) -> Self {
+        PagedMixNodeDelegationsResponse {
            delegations,
            start_next_after,
        }
    }
 }

-#[derive(Clone, Debug, Deserialize, PartialEq, Eq, Serialize, JsonSchema)]
+#[derive(Clone, Debug, Deserialize, PartialEq, Serialize, JsonSchema)]
 pub struct PagedDelegatorDelegationsResponse {
    pub delegations: Vec<Delegation>,
-    pub start_next_after: Option<IdentityKey>,
+    pub start_next_after: Option<(MixId, OwnerProxySubKey)>,
 }

 impl PagedDelegatorDelegationsResponse {
-    pub fn new(delegations: Vec<Delegation>, start_next_after: Option<IdentityKey>) -> Self {
+    pub fn new(
+        delegations: Vec<Delegation>,
+        start_next_after: Option<(MixId, OwnerProxySubKey)>,
+    ) -> Self {
        PagedDelegatorDelegationsResponse {
            delegations,
            start_next_after,
@@ -153,20 +140,32 @@ impl PagedDelegatorDelegationsResponse {
    }
 }

-#[derive(Clone, Debug, Deserialize, PartialEq, Eq, Serialize, JsonSchema)]
-pub struct PagedAllDelegationsResponse {
-    pub delegations: Vec<Delegation>,
-    pub start_next_after: Option<(IdentityKey, Vec<u8>, u64)>,
+#[derive(Clone, Debug, Deserialize, PartialEq, Serialize, JsonSchema)]
+pub struct MixNodeDelegationResponse {
+    pub delegation: Option<Delegation>,
+    pub mixnode_still_bonded: bool,
 }

-impl PagedAllDelegationsResponse {
-    pub fn new(
-        delegations: Vec<Delegation>,
-        start_next_after: Option<(IdentityKey, Vec<u8>, u64)>,
-    ) -> Self {
-        PagedAllDelegationsResponse {
-            delegations,
-            start_next_after: start_next_after.map(|(id, addr, height)| (id, addr, height)),
+impl MixNodeDelegationResponse {
+    pub fn new(delegation: Option<Delegation>, mixnode_still_bonded: bool) -> Self {
+        MixNodeDelegationResponse {
+            delegation,
+            mixnode_still_bonded,
+        }
+    }
+}
+
+#[derive(Clone, Debug, Deserialize, PartialEq, Serialize, JsonSchema)]
+pub struct PagedAllDelegationsResponse {
+    pub delegations: Vec<Delegation>,
+    pub start_next_after: Option<StorageKey>,
+}
+
+impl PagedAllDelegationsResponse {
+    pub fn new(delegations: Vec<Delegation>, start_next_after: Option<StorageKey>) -> Self {
+        PagedAllDelegationsResponse {
+            delegations,
+            start_next_after,
        }
    }
 }
@@ -1,23 +1,136 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::MixId;
+use cosmwasm_std::{Addr, Coin, Decimal};
 use thiserror::Error;

 #[derive(Error, Debug, PartialEq)]
 pub enum MixnetContractError {
-    #[error("Overflow Error")]
-    OverflowError(#[from] cosmwasm_std::OverflowError),
-    #[error("reward_blockstamp field not set, set_reward_blockstamp must be called before attempting to issue rewards")]
-    BlockstampNotSet,
-    #[error("{source}")]
-    TryFromIntError {
-        #[from]
-        source: std::num::TryFromIntError,
-    },
-    #[error("Error casting from U128")]
-    CastError,
    #[error("{source}")]
    StdErr {
        #[from]
        source: cosmwasm_std::StdError,
    },
-    #[error("Division by zero at {}", line!())]
-    DivisionByZero,
+
+    #[error("Attempted to subtract decimals with overflow ({minuend}.sub({subtrahend}))")]
+    OverflowDecimalSubtraction {
+        minuend: Decimal,
+        subtrahend: Decimal,
+    },
+
+    #[error("Attempted to subtract with overflow ({minuend}.sub({subtrahend}))")]
+    OverflowSubtraction { minuend: u64, subtrahend: u64 },
+
+    #[error("Not enough funds sent for node pledge. (received {received}, minimum {minimum})")]
+    InsufficientPledge { received: Coin, minimum: Coin },
+
+    #[error("Not enough funds sent for node delegation. (received {received}, minimum {minimum})")]
+    InsufficientDelegation { received: Coin, minimum: Coin },
+
+    #[error("Mixnode ({mix_id}) does not exist")]
+    MixNodeBondNotFound { mix_id: MixId },
+
+    #[error("{owner} does not seem to own any mixnodes")]
+    NoAssociatedMixNodeBond { owner: Addr },
+
+    #[error("{owner} does not seem to own any gateways")]
+    NoAssociatedGatewayBond { owner: Addr },
+
+    #[error("This address has already bonded a mixnode")]
+    AlreadyOwnsMixnode,
+
+    #[error("This address has already bonded a gateway")]
+    AlreadyOwnsGateway,
+
+    #[error("Gateway with this identity already exists. Its owner is {owner}")]
+    DuplicateGateway { owner: Addr },
+
+    #[error("Unauthorized")]
+    Unauthorized,
+
+    #[error("No tokens were sent for the bonding")]
+    NoBondFound,
+
+    #[error("No funds were provided for the delegation")]
+    EmptyDelegation,
+
+    #[error("Wrong coin denomination. Received: {received}, expected: {expected}")]
+    WrongDenom { received: String, expected: String },
+
+    #[error("Received multiple coin types during staking")]
+    MultipleDenoms,
+
+    #[error("Proxy address mismatch, expected {existing}, got {incoming}")]
+    ProxyMismatch { existing: String, incoming: String },
+
+    #[error("Failed to recover ed25519 public key from its base58 representation - {0}")]
+    MalformedEd25519IdentityKey(String),
+
+    #[error("Failed to recover ed25519 signature from its base58 representation - {0}")]
+    MalformedEd25519Signature(String),
+
+    #[error("Provided ed25519 signature did not verify correctly")]
+    InvalidEd25519Signature,
+
+    #[error("Can't perform the specified action as the current epoch is still progress. It started at {epoch_start} and finishes at {epoch_end}, while the current block time is {current_block_time}")]
+    EpochInProgress {
+        current_block_time: u64,
+        epoch_start: i64,
+        epoch_end: i64,
+    },
+
+    #[error("Mixnode {mix_id} has already been rewarded during the current rewarding epoch ({absolute_epoch_id})")]
+    MixnodeAlreadyRewarded {
+        mix_id: MixId,
+        absolute_epoch_id: u32,
+    },
+
+    #[error("Mixnode {mix_id} hasn't been selected to the rewarding set in this epoch ({absolute_epoch_id})")]
+    MixnodeNotInRewardedSet {
+        mix_id: MixId,
+        absolute_epoch_id: u32,
+    },
+
+    #[error("Mixnode {mix_id} is currently in the process of unbonding")]
+    MixnodeIsUnbonding { mix_id: MixId },
+
+    #[error("Mixnode {mix_id} has already unbonded")]
+    MixnodeHasUnbonded { mix_id: MixId },
+
+    #[error("The contract has ended up in a state that was deemed impossible: {comment}")]
+    InconsistentState { comment: String },
+
+    #[error(
+        "Could not find any delegation information associated with mixnode {mix_id} for {address} (proxy: {proxy:?})"
+    )]
+    NoMixnodeDelegationFound {
+        mix_id: MixId,
+        address: String,
+        proxy: Option<String>,
+    },
+
+    #[error("Provided message to update rewarding params did not contain any updates")]
+    EmptyParamsChangeMsg,
+
+    #[error("Provided active set size is bigger than the rewarded set")]
+    InvalidActiveSetSize,
+
+    #[error("Provided rewarded set size is smaller than the active set")]
+    InvalidRewardedSetSize,
+
+    #[error("Provided active set size is zero")]
+    ZeroActiveSet,
+
+    #[error("Provided rewarded set size is zero")]
+    ZeroRewardedSet,
+
+    #[error("Received unexpected value for the active set. Got: {received}, expected: {expected}")]
+    UnexpectedActiveSetSize { received: u32, expected: u32 },
+
+    #[error("Received unexpected value for the rewarded set. Got: {received}, expected at most: {expected}")]
+    UnexpectedRewardedSetSize { received: u32, expected: u32 },
+
+    #[error("Mixnode {mix_id} appears multiple times in the provided rewarded set update!")]
+    DuplicateRewardedSetNode { mix_id: MixId },
 }
@@ -1,32 +1,90 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
-use crate::mixnode::NodeRewardResult;
-use crate::{ContractStateParams, IdentityKeyRef, Interval, Layer};
-use cosmwasm_std::{Addr, Coin, Event, Uint128};

+use crate::mixnode::{MixNodeConfigUpdate, MixNodeCostParams};
+use crate::reward_params::{IntervalRewardParams, IntervalRewardingParamsUpdate};
+use crate::rewarding::RewardDistribution;
+use crate::{BlockHeight, ContractStateParams, IdentityKeyRef, Interval, Layer, MixId};
 pub use contracts_common::events::*;
-// FIXME: This should becoma an Enum
-// event types
-pub const DELEGATION_EVENT_TYPE: &str = "delegation";
-pub const PENDING_DELEGATION_EVENT_TYPE: &str = "pending_delegation";
-pub const RECONCILE_DELEGATION_EVENT_TYPE: &str = "reconcile_delegation";
-pub const UNDELEGATION_EVENT_TYPE: &str = "undelegation";
-pub const PENDING_UNDELEGATION_EVENT_TYPE: &str = "pending_undelegation";
-pub const GATEWAY_BONDING_EVENT_TYPE: &str = "gateway_bonding";
-pub const GATEWAY_UNBONDING_EVENT_TYPE: &str = "gateway_unbonding";
-pub const MIXNODE_BONDING_EVENT_TYPE: &str = "mixnode_bonding";
-pub const MIXNODE_UNBONDING_EVENT_TYPE: &str = "mixnode_unbonding";
-pub const SETTINGS_UPDATE_EVENT_TYPE: &str = "settings_update";
-pub const OPERATOR_REWARDING_EVENT_TYPE: &str = "mix_rewarding";
-pub const MIX_DELEGATORS_REWARDING_EVENT_TYPE: &str = "mix_delegators_rewarding";
-pub const CHANGE_REWARDED_SET_EVENT_TYPE: &str = "change_rewarded_set";
-pub const ADVANCE_INTERVAL_EVENT_TYPE: &str = "advance_interval";
-pub const ADVANCE_EPOCH_EVENT_TYPE: &str = "advance_epoch";
-pub const COMPOUND_DELEGATOR_REWARD_EVENT_TYPE: &str = "compound_delegator_reward";
-pub const CLAIM_DELEGATOR_REWARD_EVENT_TYPE: &str = "claim_delegator_reward";
-pub const COMPOUND_OPERATOR_REWARD_EVENT_TYPE: &str = "compound_operator_reward";
-pub const CLAIM_OPERATOR_REWARD_EVENT_TYPE: &str = "claim_operator_reward";
-pub const SNAPSHOT_MIXNODES_EVENT: &str = "snapshot_mixnodes";
+use cosmwasm_std::{Addr, Coin, Decimal, Event};
+
+pub const EVENT_VERSION_PREFIX: &str = "v2_";
+
+pub enum MixnetEventType {
+    MixnodeBonding,
+    GatewayBonding,
+    GatewayUnbonding,
+    PendingMixnodeUnbonding,
+    MixnodeUnbonding,
+    MixnodeConfigUpdate,
+    PendingMixnodeCostParamsUpdate,
+    MixnodeCostParamsUpdate,
+    MixnodeRewarding,
+    WithdrawDelegatorReward,
+    WithdrawOperatorReward,
+    PendingActiveSetUpdate,
+    ActiveSetUpdate,
+    PendingIntervalRewardingParamsUpdate,
+    IntervalRewardingParamsUpdate,
+    PendingDelegation,
+    PendingUndelegation,
+    Delegation,
+    DelegationOnUnbonding,
+    Undelegation,
+    ContractSettingsUpdate,
+    RewardingValidatorUpdate,
+    AdvanceEpoch,
+    ExecutePendingEpochEvents,
+    ExecutePendingIntervalEvents,
+    ReconcilePendingEvents,
+    PendingIntervalConfigUpdate,
+    IntervalConfigUpdate,
+}
+
+impl From<MixnetEventType> for String {
+    fn from(typ: MixnetEventType) -> Self {
+        typ.to_string()
+    }
+}
+
+impl ToString for MixnetEventType {
+    fn to_string(&self) -> String {
+        let event_name = match self {
+            MixnetEventType::MixnodeBonding => "mixnode_bonding",
+            MixnetEventType::GatewayBonding => "gateway_bonding",
+            MixnetEventType::GatewayUnbonding => "gateway_unbonding",
+            MixnetEventType::PendingMixnodeUnbonding => "pending_mixnode_unbonding",
+            MixnetEventType::MixnodeConfigUpdate => "mixnode_config_update",
+            MixnetEventType::MixnodeUnbonding => "mixnode_unbonding",
+            MixnetEventType::PendingMixnodeCostParamsUpdate => "pending_mixnode_cost_params_update",
+            MixnetEventType::MixnodeCostParamsUpdate => "mixnode_cost_params_update",
+            MixnetEventType::MixnodeRewarding => "mix_rewarding",
+            MixnetEventType::WithdrawDelegatorReward => "withdraw_delegator_reward",
+            MixnetEventType::WithdrawOperatorReward => "withdraw_operator_reward",
+            MixnetEventType::PendingActiveSetUpdate => "pending_active_set_update",
+            MixnetEventType::ActiveSetUpdate => "active_set_update",
+            MixnetEventType::PendingIntervalRewardingParamsUpdate => {
+                "pending_interval_rewarding_params_update"
+            }
+            MixnetEventType::IntervalRewardingParamsUpdate => "interval_rewarding_params_update",
+            MixnetEventType::PendingDelegation => "pending_delegation",
+            MixnetEventType::PendingUndelegation => "pending_undelegation",
+            MixnetEventType::Delegation => "delegation",
+            MixnetEventType::Undelegation => "undelegation",
+            MixnetEventType::ContractSettingsUpdate => "settings_update",
+            MixnetEventType::RewardingValidatorUpdate => "rewarding_validator_address_update",
+            MixnetEventType::AdvanceEpoch => "advance_epoch",
+            MixnetEventType::ExecutePendingEpochEvents => "execute_pending_epoch_events",
+            MixnetEventType::ExecutePendingIntervalEvents => "execute_pending_interval_events",
+            MixnetEventType::ReconcilePendingEvents => "reconcile_pending_events",
+            MixnetEventType::PendingIntervalConfigUpdate => "pending_interval_config_update",
+            MixnetEventType::IntervalConfigUpdate => "interval_config_update",
+            MixnetEventType::DelegationOnUnbonding => "delegation_on_unbonding_node",
+        };
+
+        format!("{}{}", EVENT_VERSION_PREFIX, event_name)
+    }
+}

 // attributes that are used in multiple places
 pub const OWNER_KEY: &str = "owner";
@@ -38,198 +96,194 @@ pub const PROXY_KEY: &str = "proxy";
 // delegation/undelegation
 pub const DELEGATOR_KEY: &str = "delegator";
 pub const DELEGATION_TARGET_KEY: &str = "delegation_target";
-pub const DELEGATION_HEIGHT_KEY: &str = "delegation_latest_block_height";
+pub const UNIT_REWARD_KEY: &str = "unit_reward";

 // bonding/unbonding
+pub const MIX_ID_KEY: &str = "mix_id";
 pub const NODE_IDENTITY_KEY: &str = "identity";
 pub const ASSIGNED_LAYER_KEY: &str = "assigned_layer";

 // settings change
 pub const OLD_MINIMUM_MIXNODE_PLEDGE_KEY: &str = "old_minimum_mixnode_pledge";
 pub const OLD_MINIMUM_GATEWAY_PLEDGE_KEY: &str = "old_minimum_gateway_pledge";
-pub const OLD_MIXNODE_REWARDED_SET_SIZE_KEY: &str = "old_mixnode_rewarded_set_size";
-pub const OLD_MIXNODE_ACTIVE_SET_SIZE_KEY: &str = "old_mixnode_active_set_size";
-pub const OLD_ACTIVE_SET_WORK_FACTOR_KEY: &str = "old_active_set_work_factor";
+pub const OLD_MINIMUM_DELEGATION_KEY: &str = "old_minimum_delegation";

 pub const NEW_MINIMUM_MIXNODE_PLEDGE_KEY: &str = "new_minimum_mixnode_pledge";
 pub const NEW_MINIMUM_GATEWAY_PLEDGE_KEY: &str = "new_minimum_gateway_pledge";
-pub const NEW_MIXNODE_REWARDED_SET_SIZE_KEY: &str = "new_mixnode_rewarded_set_size";
-pub const NEW_MIXNODE_ACTIVE_SET_SIZE_KEY: &str = "new_mixnode_active_set_size";
+pub const NEW_MINIMUM_DELEGATION_KEY: &str = "new_minimum_delegation";
+
+pub const OLD_REWARDING_VALIDATOR_ADDRESS_KEY: &str = "old_rewarding_validator_address";
+pub const NEW_REWARDING_VALIDATOR_ADDRESS_KEY: &str = "new_rewarding_validator_address";
+
+pub const UPDATED_MIXNODE_CONFIG_KEY: &str = "updated_mixnode_config";
+pub const UPDATED_MIXNODE_COST_PARAMS_KEY: &str = "updated_mixnode_cost_params";

 // rewarding
-pub const INTERVAL_ID_KEY: &str = "interval_id";
-pub const TOTAL_MIXNODE_REWARD_KEY: &str = "total_node_reward";
+pub const INTERVAL_KEY: &str = "interval_details";
 pub const OPERATOR_REWARD_KEY: &str = "operator_reward";
-pub const TOTAL_PLEDGE_KEY: &str = "pledge";
-pub const TOTAL_DELEGATIONS_KEY: &str = "delegated";
-pub const LAMBDA_KEY: &str = "lambda";
-pub const SIGMA_KEY: &str = "sigma";
-pub const DISTRIBUTED_DELEGATION_REWARDS_KEY: &str = "distributed_delegation_rewards";
-pub const FURTHER_DELEGATIONS_TO_REWARD_KEY: &str = "further_delegations";
+pub const DELEGATES_REWARD_KEY: &str = "delegates_reward";
+pub const APPROXIMATE_TIME_LEFT_SECS_KEY: &str = "approximate_time_left_secs";
+pub const INTERVAL_REWARDING_PARAMS_UPDATE_KEY: &str = "interval_rewarding_params_update";
+pub const UPDATED_INTERVAL_REWARDING_PARAMS_KEY: &str = "updated_interval_rewarding_params";
+pub const PRIOR_DELEGATES_KEY: &str = "prior_delegates";
+pub const PRIOR_UNIT_REWARD_KEY: &str = "prior_unit_reward";
+
 pub const NO_REWARD_REASON_KEY: &str = "no_reward_reason";
 pub const BOND_NOT_FOUND_VALUE: &str = "bond_not_found";
-pub const BOND_TOO_FRESH_VALUE: &str = "bond_too_fresh";
-pub const ZERO_UPTIME_VALUE: &str = "zero_uptime";
+pub const ZERO_PERFORMANCE_VALUE: &str = "zero_performance";

 // rewarded set update
 pub const ACTIVE_SET_SIZE_KEY: &str = "active_set_size";
-pub const REWARDED_SET_SIZE_KEY: &str = "rewarded_set_size";
-pub const NODES_IN_REWARDED_SET_KEY: &str = "nodes_in_rewarded_set";
-pub const CURRENT_INTERVAL_ID_KEY: &str = "current_interval";

-pub const NEW_CURRENT_INTERVAL_KEY: &str = "new_current_interval";
 pub const NEW_CURRENT_EPOCH_KEY: &str = "new_current_epoch";
-pub const BLOCK_HEIGHT_KEY: &str = "block_height";
-pub const CHECKPOINT_MIXNODES_EVENT: &str = "checkpoint_mixnodes";
-pub const RECONCILIATION_ERROR_EVENT: &str = "reconciliation_error";

-pub fn new_checkpoint_mixnodes_event(block_height: u64) -> Event {
-    Event::new(CHECKPOINT_MIXNODES_EVENT)
-        .add_attribute(BLOCK_HEIGHT_KEY, format!("{}", block_height))
-}
-
-pub fn new_error_event(err: String) -> Event {
-    Event::new(RECONCILIATION_ERROR_EVENT).add_attribute("error", err)
-}
+// interval
+pub const EVENTS_EXECUTED_KEY: &str = "number_of_events_executed";
+pub const EVENT_CREATION_HEIGHT_KEY: &str = "created_at";
+pub const REWARDED_SET_NODES_KEY: &str = "rewarded_set_nodes";
+pub const NEW_EPOCHS_DURATION_SECS_KEY: &str = "new_epoch_durations_secs";
+pub const NEW_EPOCHS_IN_INTERVAL: &str = "new_epochs_in_interval";

 pub fn new_delegation_event(
+    created_at: BlockHeight,
    delegator: &Addr,
    proxy: &Option<Addr>,
    amount: &Coin,
-    mix_identity: IdentityKeyRef<'_>,
+    mix_id: MixId,
+    unit_reward: Decimal,
 ) -> Event {
-    let mut event = Event::new(DELEGATION_EVENT_TYPE).add_attribute(DELEGATOR_KEY, delegator);
-
-    if let Some(proxy) = proxy {
-        event = event.add_attribute(PROXY_KEY, proxy)
-    }
-
-    // coin implements Display trait and we use that implementation here
-    event
+    Event::new(MixnetEventType::Delegation)
+        .add_attribute(EVENT_CREATION_HEIGHT_KEY, created_at.to_string())
+        .add_attribute(DELEGATOR_KEY, delegator)
+        .add_optional_attribute(PROXY_KEY, proxy.as_ref())
        .add_attribute(AMOUNT_KEY, amount.to_string())
-        .add_attribute(DELEGATION_TARGET_KEY, mix_identity)
+        .add_attribute(DELEGATION_TARGET_KEY, mix_id.to_string())
+        .add_attribute(UNIT_REWARD_KEY, unit_reward.to_string())
+}
+
+pub fn new_delegation_on_unbonded_node_event(
+    delegator: &Addr,
+    proxy: &Option<Addr>,
+    mix_id: MixId,
+) -> Event {
+    Event::new(MixnetEventType::Delegation)
+        .add_attribute(DELEGATOR_KEY, delegator)
+        .add_optional_attribute(PROXY_KEY, proxy.as_ref())
+        .add_attribute(DELEGATION_TARGET_KEY, mix_id.to_string())
 }

 pub fn new_pending_delegation_event(
    delegator: &Addr,
    proxy: &Option<Addr>,
    amount: &Coin,
-    mix_identity: IdentityKeyRef<'_>,
+    mix_id: MixId,
 ) -> Event {
-    let mut event =
-        Event::new(PENDING_DELEGATION_EVENT_TYPE).add_attribute(DELEGATOR_KEY, delegator);
-
-    if let Some(proxy) = proxy {
-        event = event.add_attribute(PROXY_KEY, proxy)
-    }
-
-    // coin implements Display trait and we use that implementation here
-    event
-        .add_attribute(AMOUNT_KEY, amount.to_string())
-        .add_attribute(DELEGATION_TARGET_KEY, mix_identity)
-}
-
-pub fn new_reconcile_delegation_event(
-    delegator: &Addr,
-    proxy: &Option<Addr>,
-    amount: &Coin,
-    mix_identity: IdentityKeyRef<'_>,
-) -> Event {
-    let mut event =
-        Event::new(RECONCILE_DELEGATION_EVENT_TYPE).add_attribute(DELEGATOR_KEY, delegator);
-
-    if let Some(proxy) = proxy {
-        event = event.add_attribute(PROXY_KEY, proxy)
-    }
-
-    // coin implements Display trait and we use that implementation here
-    event
-        .add_attribute(AMOUNT_KEY, amount.to_string())
-        .add_attribute(DELEGATION_TARGET_KEY, mix_identity)
-}
-
-pub fn new_compound_operator_reward_event(owner: &Addr, amount: Uint128) -> Event {
-    let event = Event::new(COMPOUND_OPERATOR_REWARD_EVENT_TYPE).add_attribute(OWNER_KEY, owner);
-    event.add_attribute(AMOUNT_KEY, amount.to_string())
-}
-
-pub fn new_claim_operator_reward_event(owner: &Addr, amount: Uint128) -> Event {
-    let event = Event::new(CLAIM_OPERATOR_REWARD_EVENT_TYPE).add_attribute(OWNER_KEY, owner);
-    event.add_attribute(AMOUNT_KEY, amount.to_string())
-}
-
-pub fn new_compound_delegator_reward_event(
-    delegator: &Addr,
-    proxy: &Option<Addr>,
-    amount: Uint128,
-    mix_identity: IdentityKeyRef<'_>,
-) -> Event {
-    let mut event =
-        Event::new(COMPOUND_DELEGATOR_REWARD_EVENT_TYPE).add_attribute(DELEGATOR_KEY, delegator);
-
-    if let Some(proxy) = proxy {
-        event = event.add_attribute(PROXY_KEY, proxy)
-    }
-
-    // coin implements Display trait and we use that implementation here
-    event
-        .add_attribute(AMOUNT_KEY, amount.to_string())
-        .add_attribute(DELEGATION_TARGET_KEY, mix_identity)
+    Event::new(MixnetEventType::PendingDelegation)
        .add_attribute(DELEGATOR_KEY, delegator)
+        .add_optional_attribute(PROXY_KEY, proxy.as_ref())
+        .add_attribute(AMOUNT_KEY, amount.to_string())
+        .add_attribute(DELEGATION_TARGET_KEY, mix_id.to_string())
 }

-pub fn new_claim_delegator_reward_event(
+pub fn new_withdraw_operator_reward_event(
+    owner: &Addr,
+    proxy: &Option<Addr>,
+    amount: Coin,
+    mix_id: MixId,
+) -> Event {
+    Event::new(MixnetEventType::WithdrawOperatorReward)
+        .add_attribute(OWNER_KEY, owner.as_str())
+        .add_optional_attribute(PROXY_KEY, proxy.as_ref())
+        .add_attribute(AMOUNT_KEY, amount.to_string())
+        .add_attribute(MIX_ID_KEY, mix_id.to_string())
+}
+
+pub fn new_withdraw_delegator_reward_event(
    delegator: &Addr,
    proxy: &Option<Addr>,
-    amount: Uint128,
-    mix_identity: IdentityKeyRef<'_>,
+    amount: Coin,
+    mix_id: MixId,
 ) -> Event {
-    let mut event =
-        Event::new(CLAIM_DELEGATOR_REWARD_EVENT_TYPE).add_attribute(DELEGATOR_KEY, delegator);
-
-    if let Some(proxy) = proxy {
-        event = event.add_attribute(PROXY_KEY, proxy)
-    }
-
-    // coin implements Display trait and we use that implementation here
-    event
-        .add_attribute(AMOUNT_KEY, amount.to_string())
-        .add_attribute(DELEGATION_TARGET_KEY, mix_identity)
+    Event::new(MixnetEventType::WithdrawDelegatorReward)
        .add_attribute(DELEGATOR_KEY, delegator)
+        .add_optional_attribute(PROXY_KEY, proxy.as_ref())
+        .add_attribute(AMOUNT_KEY, amount.to_string())
+        .add_attribute(DELEGATION_TARGET_KEY, mix_id.to_string())
+}
+
+pub fn new_active_set_update_event(created_at: BlockHeight, new_size: u32) -> Event {
+    Event::new(MixnetEventType::ActiveSetUpdate)
+        .add_attribute(EVENT_CREATION_HEIGHT_KEY, created_at.to_string())
+        .add_attribute(ACTIVE_SET_SIZE_KEY, new_size.to_string())
+}
+
+pub fn new_pending_active_set_update_event(
+    new_size: u32,
+    approximate_time_remaining_secs: i64,
+) -> Event {
+    Event::new(MixnetEventType::PendingActiveSetUpdate)
+        .add_attribute(ACTIVE_SET_SIZE_KEY, new_size.to_string())
+        .add_attribute(
+            APPROXIMATE_TIME_LEFT_SECS_KEY,
+            approximate_time_remaining_secs.to_string(),
+        )
+}
+
+pub fn new_rewarding_params_update_event(
+    created_at: BlockHeight,
+
+    update: IntervalRewardingParamsUpdate,
+    updated: IntervalRewardParams,
+) -> Event {
+    Event::new(MixnetEventType::IntervalRewardingParamsUpdate)
+        .add_attribute(EVENT_CREATION_HEIGHT_KEY, created_at.to_string())
+        .add_attribute(
+            INTERVAL_REWARDING_PARAMS_UPDATE_KEY,
+            update.to_inline_json(),
+        )
+        .add_attribute(
+            UPDATED_INTERVAL_REWARDING_PARAMS_KEY,
+            updated.to_inline_json(),
+        )
+}
+
+pub fn new_pending_rewarding_params_update_event(
+    update: IntervalRewardingParamsUpdate,
+    approximate_time_remaining_secs: i64,
+) -> Event {
+    Event::new(MixnetEventType::PendingIntervalRewardingParamsUpdate)
+        .add_attribute(
+            INTERVAL_REWARDING_PARAMS_UPDATE_KEY,
+            update.to_inline_json(),
+        )
+        .add_attribute(
+            APPROXIMATE_TIME_LEFT_SECS_KEY,
+            approximate_time_remaining_secs.to_string(),
+        )
 }

 pub fn new_undelegation_event(
+    created_at: BlockHeight,
    delegator: &Addr,
    proxy: &Option<Addr>,
-    mix_identity: IdentityKeyRef<'_>,
-    amount: Uint128,
+    mix_id: MixId,
 ) -> Event {
-    let mut event = Event::new(UNDELEGATION_EVENT_TYPE).add_attribute(DELEGATOR_KEY, delegator);
-
-    if let Some(proxy) = proxy {
-        event = event.add_attribute(PROXY_KEY, proxy)
-    }
-
-    // coin implements Display trait and we use that implementation here
-    event
-        .add_attribute(AMOUNT_KEY, amount.to_string())
-        .add_attribute(DELEGATION_TARGET_KEY, mix_identity)
+    Event::new(MixnetEventType::Undelegation)
+        .add_attribute(EVENT_CREATION_HEIGHT_KEY, created_at.to_string())
+        .add_attribute(DELEGATOR_KEY, delegator)
+        .add_optional_attribute(PROXY_KEY, proxy.as_ref())
+        .add_attribute(MIX_ID_KEY, mix_id.to_string())
 }

 pub fn new_pending_undelegation_event(
    delegator: &Addr,
    proxy: &Option<Addr>,
-    mix_identity: IdentityKeyRef<'_>,
+    mix_id: MixId,
 ) -> Event {
-    let mut event =
-        Event::new(PENDING_UNDELEGATION_EVENT_TYPE).add_attribute(DELEGATOR_KEY, delegator);
-
-    if let Some(proxy) = proxy {
-        event = event.add_attribute(PROXY_KEY, proxy)
-    }
-
-    // coin implements Display trait and we use that implementation here
-    event.add_attribute(DELEGATION_TARGET_KEY, mix_identity)
+    Event::new(MixnetEventType::PendingUndelegation)
+        .add_attribute(DELEGATOR_KEY, delegator)
+        .add_optional_attribute(PROXY_KEY, proxy.as_ref())
+        .add_attribute(MIX_ID_KEY, mix_id.to_string())
 }

 pub fn new_gateway_bonding_event(
@@ -238,16 +292,11 @@ pub fn new_gateway_bonding_event(
    amount: &Coin,
    identity: IdentityKeyRef<'_>,
 ) -> Event {
-    let mut event = Event::new(GATEWAY_BONDING_EVENT_TYPE)
+    Event::new(MixnetEventType::GatewayBonding)
        .add_attribute(OWNER_KEY, owner)
-        .add_attribute(NODE_IDENTITY_KEY, identity);
-
-    if let Some(proxy) = proxy {
-        event = event.add_attribute(PROXY_KEY, proxy)
-    }
-
-    // coin implements Display trait and we use that implementation here
-    event.add_attribute(AMOUNT_KEY, amount.to_string())
+        .add_attribute(NODE_IDENTITY_KEY, identity)
+        .add_optional_attribute(PROXY_KEY, proxy.as_ref())
+        .add_attribute(AMOUNT_KEY, amount.to_string())
 }

 pub fn new_gateway_unbonding_event(
@@ -256,16 +305,11 @@ pub fn new_gateway_unbonding_event(
    amount: &Coin,
    identity: IdentityKeyRef<'_>,
 ) -> Event {
-    let mut event = Event::new(GATEWAY_UNBONDING_EVENT_TYPE)
+    Event::new(MixnetEventType::GatewayUnbonding)
        .add_attribute(OWNER_KEY, owner)
-        .add_attribute(NODE_IDENTITY_KEY, identity);
-
-    if let Some(proxy) = proxy {
-        event = event.add_attribute(PROXY_KEY, proxy)
-    }
-
-    // coin implements Display trait and we use that implementation here
-    event.add_attribute(AMOUNT_KEY, amount.to_string())
+        .add_attribute(NODE_IDENTITY_KEY, identity)
+        .add_optional_attribute(PROXY_KEY, proxy.as_ref())
+        .add_attribute(AMOUNT_KEY, amount.to_string())
 }

 pub fn new_mixnode_bonding_event(
@@ -273,55 +317,96 @@ pub fn new_mixnode_bonding_event(
    proxy: &Option<Addr>,
    amount: &Coin,
    identity: IdentityKeyRef<'_>,
+    mix_id: MixId,
    assigned_layer: Layer,
 ) -> Event {
-    let mut event = Event::new(MIXNODE_BONDING_EVENT_TYPE)
-        .add_attribute(OWNER_KEY, owner)
-        .add_attribute(NODE_IDENTITY_KEY, identity);
-
-    if let Some(proxy) = proxy {
-        event = event.add_attribute(PROXY_KEY, proxy)
-    }
-
    // coin implements Display trait and we use that implementation here
-    event
+    Event::new(MixnetEventType::MixnodeBonding)
+        .add_attribute(MIX_ID_KEY, mix_id.to_string())
+        .add_attribute(NODE_IDENTITY_KEY, identity)
+        .add_attribute(OWNER_KEY, owner)
+        .add_optional_attribute(PROXY_KEY, proxy.as_ref())
        .add_attribute(ASSIGNED_LAYER_KEY, assigned_layer)
        .add_attribute(AMOUNT_KEY, amount.to_string())
 }

-pub fn new_mixnode_unbonding_event(
+pub fn new_mixnode_unbonding_event(created_at: BlockHeight, mix_id: MixId) -> Event {
+    Event::new(MixnetEventType::MixnodeUnbonding)
+        .add_attribute(EVENT_CREATION_HEIGHT_KEY, created_at.to_string())
+        .add_attribute(MIX_ID_KEY, mix_id.to_string())
+}
+
+pub fn new_pending_mixnode_unbonding_event(
    owner: &Addr,
    proxy: &Option<Addr>,
-    amount: &Coin,
    identity: IdentityKeyRef<'_>,
+    mix_id: MixId,
 ) -> Event {
-    let mut event = Event::new(MIXNODE_UNBONDING_EVENT_TYPE)
+    Event::new(MixnetEventType::PendingMixnodeUnbonding)
+        .add_attribute(MIX_ID_KEY, mix_id.to_string())
+        .add_attribute(NODE_IDENTITY_KEY, identity)
        .add_attribute(OWNER_KEY, owner)
-        .add_attribute(NODE_IDENTITY_KEY, identity);
+        .add_optional_attribute(PROXY_KEY, proxy.as_ref())
+}

-    if let Some(proxy) = proxy {
-        event = event.add_attribute(PROXY_KEY, proxy)
-    }
+pub fn new_mixnode_config_update_event(
+    mix_id: MixId,
+    owner: &Addr,
+    proxy: &Option<Addr>,
+    update: &MixNodeConfigUpdate,
+) -> Event {
+    Event::new(MixnetEventType::MixnodeConfigUpdate)
+        .add_attribute(MIX_ID_KEY, mix_id.to_string())
+        .add_attribute(OWNER_KEY, owner)
+        .add_optional_attribute(PROXY_KEY, proxy.as_ref())
+        .add_attribute(UPDATED_MIXNODE_CONFIG_KEY, update.to_inline_json())
+}

-    // coin implements Display trait and we use that implementation here
-    event.add_attribute(AMOUNT_KEY, amount.to_string())
+pub fn new_mixnode_pending_cost_params_update_event(
+    mix_id: MixId,
+    owner: &Addr,
+    proxy: &Option<Addr>,
+    new_costs: &MixNodeCostParams,
+) -> Event {
+    Event::new(MixnetEventType::PendingMixnodeCostParamsUpdate)
+        .add_attribute(MIX_ID_KEY, mix_id.to_string())
+        .add_attribute(OWNER_KEY, owner)
+        .add_optional_attribute(PROXY_KEY, proxy.as_ref())
+        .add_attribute(UPDATED_MIXNODE_COST_PARAMS_KEY, new_costs.to_inline_json())
+}
+
+pub fn new_mixnode_cost_params_update_event(
+    created_at: BlockHeight,
+    mix_id: MixId,
+    new_costs: &MixNodeCostParams,
+) -> Event {
+    Event::new(MixnetEventType::MixnodeCostParamsUpdate)
+        .add_attribute(EVENT_CREATION_HEIGHT_KEY, created_at.to_string())
+        .add_attribute(MIX_ID_KEY, mix_id.to_string())
+        .add_attribute(UPDATED_MIXNODE_COST_PARAMS_KEY, new_costs.to_inline_json())
+}
+
+pub fn new_rewarding_validator_address_update_event(old: Addr, new: Addr) -> Event {
+    Event::new(MixnetEventType::RewardingValidatorUpdate)
+        .add_attribute(OLD_REWARDING_VALIDATOR_ADDRESS_KEY, old)
+        .add_attribute(NEW_REWARDING_VALIDATOR_ADDRESS_KEY, new)
 }

 pub fn new_settings_update_event(
    old_params: &ContractStateParams,
    new_params: &ContractStateParams,
 ) -> Event {
-    let mut event = Event::new(SETTINGS_UPDATE_EVENT_TYPE);
+    let mut event = Event::new(MixnetEventType::ContractSettingsUpdate);

    if old_params.minimum_mixnode_pledge != new_params.minimum_mixnode_pledge {
        event = event
            .add_attribute(
                OLD_MINIMUM_MIXNODE_PLEDGE_KEY,
-                old_params.minimum_mixnode_pledge,
+                old_params.minimum_mixnode_pledge.to_string(),
            )
            .add_attribute(
                NEW_MINIMUM_MIXNODE_PLEDGE_KEY,
-                new_params.minimum_mixnode_pledge,
+                new_params.minimum_mixnode_pledge.to_string(),
            )
    }

@@ -329,128 +414,130 @@ pub fn new_settings_update_event(
        event = event
            .add_attribute(
                OLD_MINIMUM_GATEWAY_PLEDGE_KEY,
-                old_params.minimum_gateway_pledge,
+                old_params.minimum_gateway_pledge.to_string(),
            )
            .add_attribute(
                NEW_MINIMUM_GATEWAY_PLEDGE_KEY,
-                new_params.minimum_gateway_pledge,
+                new_params.minimum_gateway_pledge.to_string(),
            )
    }

-    if old_params.mixnode_rewarded_set_size != new_params.mixnode_rewarded_set_size {
-        event = event
-            .add_attribute(
-                OLD_MIXNODE_REWARDED_SET_SIZE_KEY,
-                old_params.mixnode_rewarded_set_size.to_string(),
-            )
-            .add_attribute(
-                NEW_MIXNODE_REWARDED_SET_SIZE_KEY,
-                new_params.mixnode_rewarded_set_size.to_string(),
-            )
-    }
-
-    if old_params.mixnode_active_set_size != new_params.mixnode_active_set_size {
-        event = event
-            .add_attribute(
-                OLD_MIXNODE_ACTIVE_SET_SIZE_KEY,
-                old_params.mixnode_active_set_size.to_string(),
-            )
-            .add_attribute(
-                NEW_MIXNODE_ACTIVE_SET_SIZE_KEY,
-                new_params.mixnode_active_set_size.to_string(),
-            )
+    if old_params.minimum_mixnode_delegation != new_params.minimum_mixnode_delegation {
+        if let Some(ref old) = old_params.minimum_mixnode_delegation {
+            event = event.add_attribute(OLD_MINIMUM_DELEGATION_KEY, old.to_string())
+        } else {
+            event = event.add_attribute(OLD_MINIMUM_DELEGATION_KEY, "None")
+        }
+        if let Some(ref new) = new_params.minimum_mixnode_delegation {
+            event = event.add_attribute(NEW_MINIMUM_DELEGATION_KEY, new.to_string())
+        } else {
+            event = event.add_attribute(NEW_MINIMUM_DELEGATION_KEY, "None")
+        }
    }

    event
 }

-pub fn new_not_found_mix_operator_rewarding_event(
-    interval_id: u32,
-    identity: IdentityKeyRef<'_>,
-) -> Event {
-    Event::new(OPERATOR_REWARDING_EVENT_TYPE)
-        .add_attribute(INTERVAL_ID_KEY, interval_id.to_string())
-        .add_attribute(NODE_IDENTITY_KEY, identity)
+pub fn new_not_found_mix_operator_rewarding_event(interval: Interval, mix_id: MixId) -> Event {
+    Event::new(MixnetEventType::MixnodeRewarding)
+        .add_attribute(
+            INTERVAL_KEY,
+            interval.current_epoch_absolute_id().to_string(),
+        )
+        .add_attribute(MIX_ID_KEY, mix_id.to_string())
        .add_attribute(NO_REWARD_REASON_KEY, BOND_NOT_FOUND_VALUE)
 }

-pub fn new_too_fresh_bond_mix_operator_rewarding_event(
-    interval_id: u32,
-    identity: IdentityKeyRef<'_>,
-) -> Event {
-    Event::new(OPERATOR_REWARDING_EVENT_TYPE)
-        .add_attribute(INTERVAL_ID_KEY, interval_id.to_string())
-        .add_attribute(NODE_IDENTITY_KEY, identity)
-        .add_attribute(NO_REWARD_REASON_KEY, BOND_TOO_FRESH_VALUE)
-}
-
-pub fn new_zero_uptime_mix_operator_rewarding_event(
-    interval_id: u32,
-    identity: IdentityKeyRef<'_>,
-) -> Event {
-    Event::new(OPERATOR_REWARDING_EVENT_TYPE)
-        .add_attribute(INTERVAL_ID_KEY, interval_id.to_string())
-        .add_attribute(NODE_IDENTITY_KEY, identity)
-        .add_attribute(NO_REWARD_REASON_KEY, ZERO_UPTIME_VALUE)
-}
-
-#[allow(clippy::too_many_arguments)]
-pub fn new_mix_operator_rewarding_event(
-    interval_id: u32,
-    identity: IdentityKeyRef<'_>,
-    node_reward_result: NodeRewardResult,
-    node_pledge: Uint128,
-    node_delegation: Uint128,
-) -> Event {
-    Event::new(OPERATOR_REWARDING_EVENT_TYPE)
-        .add_attribute(INTERVAL_ID_KEY, interval_id.to_string())
-        .add_attribute(NODE_IDENTITY_KEY, identity)
-        .add_attribute(TOTAL_PLEDGE_KEY, node_pledge)
-        .add_attribute(TOTAL_DELEGATIONS_KEY, node_delegation)
+pub fn new_zero_uptime_mix_operator_rewarding_event(interval: Interval, mix_id: MixId) -> Event {
+    Event::new(MixnetEventType::MixnodeRewarding)
        .add_attribute(
-            TOTAL_MIXNODE_REWARD_KEY,
-            node_reward_result.reward().to_string(),
+            INTERVAL_KEY,
+            interval.current_epoch_absolute_id().to_string(),
        )
-        .add_attribute(LAMBDA_KEY, node_reward_result.lambda().to_string())
-        .add_attribute(SIGMA_KEY, node_reward_result.sigma().to_string())
+        .add_attribute(MIX_ID_KEY, mix_id.to_string())
+        .add_attribute(NO_REWARD_REASON_KEY, ZERO_PERFORMANCE_VALUE)
 }

-pub fn new_mix_delegators_rewarding_event(
-    interval_id: u32,
-    identity: IdentityKeyRef<'_>,
-    delegation_rewards_distributed: Uint128,
-    further_delegations: bool,
+pub fn new_mix_rewarding_event(
+    interval: Interval,
+    mix_id: MixId,
+    reward_distribution: RewardDistribution,
+    prior_delegates: Decimal,
+    prior_unit_reward: Decimal,
 ) -> Event {
-    Event::new(MIX_DELEGATORS_REWARDING_EVENT_TYPE)
-        .add_attribute(INTERVAL_ID_KEY, interval_id.to_string())
-        .add_attribute(NODE_IDENTITY_KEY, identity)
+    Event::new(MixnetEventType::MixnodeRewarding)
        .add_attribute(
-            DISTRIBUTED_DELEGATION_REWARDS_KEY,
-            delegation_rewards_distributed,
+            INTERVAL_KEY,
+            interval.current_epoch_absolute_id().to_string(),
+        )
+        .add_attribute(PRIOR_DELEGATES_KEY, prior_delegates.to_string())
+        .add_attribute(PRIOR_UNIT_REWARD_KEY, prior_unit_reward.to_string())
+        .add_attribute(MIX_ID_KEY, mix_id.to_string())
+        .add_attribute(
+            OPERATOR_REWARD_KEY,
+            reward_distribution.operator.to_string(),
        )
        .add_attribute(
-            FURTHER_DELEGATIONS_TO_REWARD_KEY,
-            further_delegations.to_string(),
+            DELEGATES_REWARD_KEY,
+            reward_distribution.delegates.to_string(),
        )
 }

-// note that when this event is emitted, we'll know the current block height
-pub fn new_change_rewarded_set_event(
-    active_set_size: u32,
-    rewarded_set_size: u32,
-    nodes_in_rewarded_set: u32,
+pub fn new_advance_epoch_event(interval: Interval, rewarded_nodes: u32) -> Event {
+    Event::new(MixnetEventType::AdvanceEpoch)
+        .add_attribute(
+            NEW_CURRENT_EPOCH_KEY,
+            interval.current_epoch_absolute_id().to_string(),
+        )
+        .add_attribute(REWARDED_SET_NODES_KEY, rewarded_nodes.to_string())
+}
+
+pub fn new_pending_epoch_events_execution_event(executed: u32) -> Event {
+    Event::new(MixnetEventType::ExecutePendingEpochEvents)
+        .add_attribute(EVENTS_EXECUTED_KEY, executed.to_string())
+}
+
+pub fn new_pending_interval_events_execution_event(executed: u32) -> Event {
+    Event::new(MixnetEventType::ExecutePendingIntervalEvents)
+        .add_attribute(EVENTS_EXECUTED_KEY, executed.to_string())
+}
+
+pub fn new_reconcile_pending_events() -> Event {
+    Event::new(MixnetEventType::ReconcilePendingEvents)
+}
+
+pub fn new_interval_config_update_event(
+    created_at: BlockHeight,
+    epochs_in_interval: u32,
+    epoch_duration_secs: u64,
+    updated_rewarding_params: IntervalRewardParams,
 ) -> Event {
-    Event::new(CHANGE_REWARDED_SET_EVENT_TYPE)
-        .add_attribute(ACTIVE_SET_SIZE_KEY, active_set_size.to_string())
-        .add_attribute(REWARDED_SET_SIZE_KEY, rewarded_set_size.to_string())
-        .add_attribute(NODES_IN_REWARDED_SET_KEY, nodes_in_rewarded_set.to_string())
+    Event::new(MixnetEventType::IntervalConfigUpdate)
+        .add_attribute(EVENT_CREATION_HEIGHT_KEY, created_at.to_string())
+        .add_attribute(
+            NEW_EPOCHS_DURATION_SECS_KEY,
+            epoch_duration_secs.to_string(),
+        )
+        .add_attribute(NEW_EPOCHS_IN_INTERVAL, epochs_in_interval.to_string())
+        .add_attribute(
+            UPDATED_INTERVAL_REWARDING_PARAMS_KEY,
+            updated_rewarding_params.to_inline_json(),
+        )
 }

-pub fn new_advance_interval_event(interval: Interval) -> Event {
-    Event::new(ADVANCE_INTERVAL_EVENT_TYPE)
-        .add_attribute(NEW_CURRENT_INTERVAL_KEY, interval.to_string())
-}
-
-pub fn new_advance_epoch_event(interval: Interval) -> Event {
-    Event::new(ADVANCE_EPOCH_EVENT_TYPE).add_attribute(NEW_CURRENT_EPOCH_KEY, interval.to_string())
+pub fn new_pending_interval_config_update_event(
+    epochs_in_interval: u32,
+    epoch_duration_secs: u64,
+    approximate_time_remaining_secs: i64,
+) -> Event {
+    Event::new(MixnetEventType::PendingIntervalConfigUpdate)
+        .add_attribute(
+            NEW_EPOCHS_DURATION_SECS_KEY,
+            epoch_duration_secs.to_string(),
+        )
+        .add_attribute(NEW_EPOCHS_IN_INTERVAL, epochs_in_interval.to_string())
+        .add_attribute(
+            APPROXIMATE_TIME_LEFT_SECS_KEY,
+            approximate_time_remaining_secs.to_string(),
+        )
 }
--- a/Show More
+++ b/Show More