Merge pull request #1095 from nymtech/bug-fix/mainnet-blocks-url

create custom urls for mainnet
2022-02-03 12:30:40 +00:00 · 2022-02-03 12:00:43 +00:00 · 2022-02-03 09:30:08 +00:00 · 2022-02-03 09:25:29 +00:00 · 2022-02-03 09:20:03 +00:00 · 2022-02-02 20:47:28 +01:00
597 changed files with 46625 additions and 43713 deletions
@@ -15,8 +15,8 @@
 * @futurechimp @mmsinclair

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

 # JS rules:
 *.js @mmsinclair @fmtabbara @Aid19801
@@ -0,0 +1,77 @@
+name: Publish Nym Wallet (MacOS)
+on:
+  release:
+    types: [created]
+
+defaults:
+  run:
+    working-directory: nym-wallet
+
+jobs:
+  publish-tauri:
+    strategy:
+      fail-fast: false
+      matrix:
+        platform: [macos-latest]
+
+    runs-on: ${{ matrix.platform }}
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Check the release tag starts with `nym-wallet-`
+        if: startsWith(github.ref, 'refs/tags/nym-wallet-') == false
+        uses: actions/github-script@v3
+        with:
+          script: |
+            core.setFailed('Release tag did not start with nym-wallet-...')
+
+      - name: Node v16
+        uses: actions/setup-node@v1
+        with:
+          node-version: 16.x
+      - name: Install Rust stable
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+      - name: Install the Apple developer certificate for code signing
+        env:
+          APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
+          APPLE_CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
+          KEYCHAIN_PASSWORD: ${{ secrets.KEYCHAIN_PASSWORD }}
+        run: |
+          # create variables
+          CERTIFICATE_PATH=$RUNNER_TEMP/build_certificate.p12
+          KEYCHAIN_PATH=$RUNNER_TEMP/app-signing.keychain-db
+
+          # import certificate and provisioning profile from secrets
+          echo -n "$APPLE_CERTIFICATE" | base64 --decode --output $CERTIFICATE_PATH
+
+          # create temporary keychain
+          security create-keychain -p "$KEYCHAIN_PASSWORD" $KEYCHAIN_PATH
+          security set-keychain-settings -lut 21600 $KEYCHAIN_PATH
+          security unlock-keychain -p "$KEYCHAIN_PASSWORD" $KEYCHAIN_PATH
+
+          # import certificate to keychain
+          security import $CERTIFICATE_PATH -P "$APPLE_CERTIFICATE_PASSWORD" -A -t cert -f pkcs12 -k $KEYCHAIN_PATH
+          security list-keychain -d user -s $KEYCHAIN_PATH
+
+      - name: Install app dependencies and build it
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          ENABLE_CODE_SIGNING: ${{ secrets.APPLE_CERTIFICATE }}
+          APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
+          APPLE_CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
+          APPLE_SIGNING_IDENTITY: ${{ secrets.APPLE_IDENTITY_ID }}
+          APPLE_ID: ${{ secrets.APPLE_ID }}
+          APPLE_PASSWORD: ${{ secrets.APPLE_PASSWORD }}
+        run: yarn && yarn build
+
+      - name: Upload to release based on tag name
+        uses: softprops/action-gh-release@v1
+        with:
+          files: nym-wallet/target/release/bundle/dmg/*.dmg
+
+      - name: Clean up keychain
+        if: ${{ always() }}
+        run: |
+          security delete-keychain $RUNNER_TEMP/app-signing.keychain-db
@@ -0,0 +1,46 @@
+name: Publish Nym Wallet (Ubuntu)
+on:
+  release:
+    types: [created]
+
+defaults:
+  run:
+    working-directory: nym-wallet
+
+jobs:
+  publish-tauri:
+    strategy:
+      fail-fast: false
+      matrix:
+        platform: [ubuntu-latest]
+
+    runs-on: ${{ matrix.platform }}
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Tauri dependencies
+        run: >
+          sudo apt-get update &&
+          sudo apt-get install -y webkit2gtk-4.0
+      - name: Check the release tag starts with `nym-wallet-`
+        if: startsWith(github.ref, 'refs/tags/nym-wallet-') == false
+        uses: actions/github-script@v3
+        with:
+          script: |
+            core.setFailed('Release tag did not start with nym-wallet-...')
+
+      - name: Node v16
+        uses: actions/setup-node@v1
+        with:
+          node-version: 16.x
+      - name: Install Rust stable
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+      - name: Install app dependencies and build it
+        run: yarn && yarn build
+
+      - name: Upload to release based on tag name
+        uses: softprops/action-gh-release@v1
+        with:
+          files: nym-wallet/target/release/bundle/appimage/*.AppImage
@@ -1,12 +0,0 @@
-name: Publish Nym Wallet
-on:
-  push:
-    tags:
-      - nym-wallet-*
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Run a one-line script
-        run: echo Hello, world!
@@ -19,30 +19,27 @@ jobs:
          override: true
          components: rustfmt, clippy

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

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

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

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

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

 [workspace]

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

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

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

-clippy-main:
+clippy-happy-main:
 	cargo clippy

-clippy-contracts:
-	cargo clippy --manifest-path contracts/Cargo.toml
+clippy-happy-contracts:
+	cargo clippy --manifest-path contracts/Cargo.toml --target wasm32-unknown-unknown

-clippy-wallet: 
+clippy-happy-wallet: 
 	cargo clippy --manifest-path nym-wallet/Cargo.toml

+clippy-all-main:
+	cargo clippy --all-features -- -D warnings 
+
+clippy-all-contracts:
+	cargo clippy --manifest-path contracts/Cargo.toml --all-features --target wasm32-unknown-unknown -- -D warnings
+
+clippy-all-wallet: 
+	cargo clippy --manifest-path nym-wallet/Cargo.toml --all-features -- -D warnings
+
 test-main:
-	cargo test
+	cargo test --all-features

 test-contracts:
-	cargo test --manifest-path contracts/Cargo.toml
+	cargo test --manifest-path contracts/Cargo.toml --all-features

 test-wallet:
-	cargo test --manifest-path nym-wallet/Cargo.toml
+	cargo test --manifest-path nym-wallet/Cargo.toml --all-features

 fmt-main:
 	cargo fmt --all
@@ -30,6 +41,5 @@ fmt-contracts:
 fmt-wallet:
 	cargo fmt --manifest-path nym-wallet/Cargo.toml --all

-
-
-
+wasm:
+	RUSTFLAGS='-C link-arg=-s' cargo build --manifest-path contracts/Cargo.toml --release --target wasm32-unknown-unknown
@@ -21,7 +21,8 @@ The platform is composed of multiple Rust crates. Top-level executable binary cr

 ### Building

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

 ### Developing

@@ -40,13 +41,13 @@ Node, node operator and delegator rewards are determined according to the princi
 |<img src="https://render.githubusercontent.com/render/math?math=R">|global share of rewards available, starts at 2% of the reward pool. 
 |<img src="https://render.githubusercontent.com/render/math?math=R_{i}">|node reward for mixnode `i`.
 |<img src="https://render.githubusercontent.com/render/math?math=\sigma_{i}">|ratio of total node stake (node bond + all delegations) to the token circulating supply.
-|<img src="https://render.githubusercontent.com/render/math?math=\lambda_{i}">|ratio of stake operator has plaged to their node to the token circulating supply.
-|<img src="https://render.githubusercontent.com/render/math?math=\omega_{i}">|fraction of total effort undertaken by node `i`, set to `1/k` in testnet Milhon.
-|<img src="https://render.githubusercontent.com/render/math?math=k">|number of nodes stakeholders are incentivised to create, set by the validators, a matter of governance. Currently determined by the `active set` size, and set to 5000 in testnet Milhon.
+|<img src="https://render.githubusercontent.com/render/math?math=\lambda_{i}">|ratio of stake operator has pledged to their node to the token circulating supply.
+|<img src="https://render.githubusercontent.com/render/math?math=\omega_{i}">|fraction of total effort undertaken by node `i`, set to `1/k`.
+|<img src="https://render.githubusercontent.com/render/math?math=k">|number of nodes stakeholders are incentivised to create, set by the validators, a matter of governance. Currently determined by the `reward set` size, and set to 720 in testnet Sandbox.
 |<img src="https://render.githubusercontent.com/render/math?math=\alpha">|Sybil attack resistance parameter - the higher this parameter is set the stronger the reduction in competitivness gets for a Sybil attacker.
-|<img src="https://render.githubusercontent.com/render/math?math=PM_{i}">|declared profit margin of operator `i`, defaults to 10% in testnet Milhon.
+|<img src="https://render.githubusercontent.com/render/math?math=PM_{i}">|declared profit margin of operator `i`, defaults to 10% in.
 |<img src="https://render.githubusercontent.com/render/math?math=PF_{i}">|uptime of node `i`, scaled to 0 - 1, for the rewarding epoch
-|<img src="https://render.githubusercontent.com/render/math?math=PP_{i}">|cost of operating node `i` for the duration of the rewarding eopoch, set to 40 Nym for testnet Milhon.
+|<img src="https://render.githubusercontent.com/render/math?math=PP_{i}">|cost of operating node `i` for the duration of the rewarding eopoch, set to 40 NYMT.

 Node reward for node `i` is determined as:

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

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

@@ -13,7 +13,6 @@ use nymsphinx::utils::sample_poisson_duration;
 use rand::{rngs::OsRng, CryptoRng, Rng};
 use std::pin::Pin;
 use std::sync::Arc;
-use tokio::runtime::Handle;
 use tokio::task::JoinHandle;
 use tokio::time;

@@ -165,8 +164,8 @@ impl LoopCoverTrafficStream<OsRng> {
        }
    }

-    pub fn start(mut self, handle: &Handle) -> JoinHandle<()> {
-        handle.spawn(async move {
+    pub fn start(mut self) -> JoinHandle<()> {
+        tokio::spawn(async move {
            self.run().await;
        })
    }
@@ -79,9 +79,9 @@ impl KeyManager {
            ))?;

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

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

        // TODO: ack key is never stored so it is generated now. But perhaps it should be stored
        // after all for consistency sake?
@@ -6,7 +6,6 @@ use futures::StreamExt;
 use gateway_client::GatewayClient;
 use log::*;
 use nymsphinx::forwarding::packet::MixPacket;
-use tokio::runtime::Handle;
 use tokio::task::JoinHandle;

 pub type BatchMixMessageSender = mpsc::UnboundedSender<Vec<MixPacket>>;
@@ -72,8 +71,8 @@ impl MixTrafficController {
        }
    }

-    pub fn start(mut self, handle: &Handle) -> JoinHandle<()> {
-        handle.spawn(async move {
+    pub fn start(mut self) -> JoinHandle<()> {
+        tokio::spawn(async move {
            self.run().await;
        })
    }
@@ -22,7 +22,6 @@ use nymsphinx::addressing::clients::Recipient;
 use rand::{rngs::OsRng, CryptoRng, Rng};
 use std::sync::Arc;
 use std::time::Duration;
-use tokio::runtime::Handle;
 use tokio::task::JoinHandle;

 mod acknowledgement_control;
@@ -170,10 +169,8 @@ impl RealMessagesController<OsRng> {
        self.ack_control = Some(ack_control_fut.await.unwrap());
    }

-    // &Handle is only passed for consistency sake with other client modules, but I think
-    // when we get to refactoring, we should apply gateway approach and make it implicit
-    pub fn start(mut self, handle: &Handle) -> JoinHandle<Self> {
-        handle.spawn(async move {
+    pub fn start(mut self) -> JoinHandle<Self> {
+        tokio::spawn(async move {
            self.run().await;
            self
        })
@@ -15,7 +15,6 @@ use nymsphinx::params::{ReplySurbEncryptionAlgorithm, ReplySurbKeyDigestAlgorith
 use nymsphinx::receiver::{MessageReceiver, MessageRecoveryError, ReconstructedMessage};
 use std::collections::HashSet;
 use std::sync::Arc;
-use tokio::runtime::Handle;
 use tokio::task::JoinHandle;

 // Buffer Requests to say "hey, send any reconstructed messages to this channel"
@@ -291,8 +290,8 @@ impl RequestReceiver {
        }
    }

-    fn start(mut self, handle: &Handle) -> JoinHandle<()> {
-        handle.spawn(async move {
+    fn start(mut self) -> JoinHandle<()> {
+        tokio::spawn(async move {
            while let Some(request) = self.query_receiver.next().await {
                match request {
                    ReceivedBufferMessage::ReceiverAnnounce(sender) => {
@@ -322,8 +321,8 @@ impl FragmentedMessageReceiver {
            mixnet_packet_receiver,
        }
    }
-    fn start(mut self, handle: &Handle) -> JoinHandle<()> {
-        handle.spawn(async move {
+    fn start(mut self) -> JoinHandle<()> {
+        tokio::spawn(async move {
            while let Some(new_messages) = self.mixnet_packet_receiver.next().await {
                self.received_buffer.handle_new_received(new_messages).await;
            }
@@ -355,9 +354,9 @@ impl ReceivedMessagesBufferController {
        }
    }

-    pub fn start(self, handle: &Handle) {
+    pub fn start(self) {
        // TODO: should we do anything with JoinHandle(s) returned by start methods?
-        self.fragmented_message_receiver.start(handle);
-        self.request_receiver.start(handle);
+        self.fragmented_message_receiver.start();
+        self.request_receiver.start();
    }
 }
@@ -59,7 +59,7 @@ impl ReplyKeyStorage {
    ) -> Result<(), ReplyKeyStorageError> {
        let digest = encryption_key.compute_digest();

-        let insertion_result = match self.db.insert(digest.to_vec(), encryption_key.to_bytes()) {
+        let insertion_result = match self.db.insert(digest, encryption_key.to_bytes()) {
            Err(e) => Err(ReplyKeyStorageError::DbWriteError(e)),
            Ok(existing_key) => {
                if existing_key.is_some() {
@@ -79,7 +79,7 @@ impl ReplyKeyStorage {
        &self,
        key_digest: EncryptionKeyDigest,
    ) -> Result<Option<SurbEncryptionKey>, ReplyKeyStorageError> {
-        let removal_result = match self.db.remove(&key_digest.to_vec()) {
+        let removal_result = match self.db.remove(key_digest) {
            Err(e) => Err(ReplyKeyStorageError::DbReadError(e)),
            Ok(existing_key) => {
                Ok(existing_key.map(|existing_key| self.read_encryption_key(existing_key)))
@@ -10,7 +10,6 @@ use std::ops::Deref;
 use std::sync::Arc;
 use std::time;
 use std::time::Duration;
-use tokio::runtime::Handle;
 use tokio::sync::{RwLock, RwLockReadGuard};
 use tokio::task::JoinHandle;
 use topology::{nym_topology_from_bonds, NymTopology};
@@ -304,8 +303,8 @@ impl TopologyRefresher {
        self.topology_accessor.is_routable().await
    }

-    pub fn start(mut self, handle: &Handle) -> JoinHandle<()> {
-        handle.spawn(async move {
+    pub fn start(mut self) -> JoinHandle<()> {
+        tokio::spawn(async move {
            loop {
                tokio::time::sleep(self.refresh_rate).await;
                self.refresh().await;
@@ -117,6 +117,10 @@ impl<T: NymConfig> Config<T> {
        self.client.id = id;
    }

+    pub fn with_testnet_mode(&mut self, testnet_mode: bool) {
+        self.client.testnet_mode = testnet_mode;
+    }
+
    pub fn with_gateway_id<S: Into<String>>(&mut self, id: S) {
        self.client.gateway_id = id.into();
    }
@@ -153,6 +157,10 @@ impl<T: NymConfig> Config<T> {
        self.client.id.clone()
    }

+    pub fn get_testnet_mode(&self) -> bool {
+        self.client.testnet_mode
+    }
+
    pub fn get_nym_root_directory(&self) -> PathBuf {
        self.client.nym_root_directory.clone()
    }
@@ -273,6 +281,11 @@ pub struct Client<T> {
    /// ID specifies the human readable ID of this particular client.
    id: String,

+    /// Indicates whether this client is running in a testnet mode, thus attempting
+    /// to claim bandwidth without presenting bandwidth credentials.
+    #[serde(default)]
+    testnet_mode: bool,
+
    /// Addresses to APIs running on validator from which the client gets the view of the network.
    validator_api_urls: Vec<Url>,

@@ -335,6 +348,7 @@ impl<T: NymConfig> Default for Client<T> {
        Client {
            version: env!("CARGO_PKG_VERSION").to_string(),
            id: "".to_string(),
+            testnet_mode: false,
            validator_api_urls: default_api_endpoints(),
            private_identity_key_file: Default::default(),
            public_identity_key_file: Default::default(),
@@ -1,8 +1,8 @@
 [package]
 name = "nym-client"
-version = "0.11.0"
+version = "0.12.1"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>", "Jędrzej Stuczyński <andrew@nymtech.net>"]
-edition = "2018"
+edition = "2021"
 rust-version = "1.56"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -48,6 +48,10 @@ network-defaults = { path = "../../common/network-defaults" }

 [features]
 coconut = ["coconut-interface", "credentials", "gateway-requests/coconut", "gateway-client/coconut"]
+eth = []

 [dev-dependencies]
 serde_json = "1.0" # for the "textsend" example
+
+[build-dependencies]
+vergen = { version = "5", default-features = false, features = ["build", "git", "rustc", "cargo"] }
@@ -0,0 +1,8 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use vergen::{vergen, Config};
+
+fn main() {
+    vergen(Config::default()).expect("failed to extract build metadata")
+}
@@ -2441,9 +2441,9 @@
      }
    },
    "node_modules/follow-redirects": {
-      "version": "1.14.1",
-      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.14.1.tgz",
-      "integrity": "sha512-HWqDgT7ZEkqRzBvc2s64vSZ/hfOceEol3ac/7tKwzuvEyWx3/4UegXh5oBOIotkGsObyk3xznnSRVADBgWSQVg==",
+      "version": "1.14.7",
+      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.14.7.tgz",
+      "integrity": "sha512-+hbxoLbFMbRKDwohX8GkTataGqO6Jb7jGwpAlwgy2bIz25XtRm7KEzJM76R1WiNT5SwZkX4Y75SwBolkpmE7iQ==",
      "dev": true,
      "funding": [
        {
@@ -3806,9 +3806,9 @@
      "optional": true
    },
    "node_modules/nanoid": {
-      "version": "3.1.23",
-      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.1.23.tgz",
-      "integrity": "sha512-FiB0kzdP0FFVGDKlRLEQ1BgDzU87dy5NnzjeW9YZNt+/c3+q82EQDUwniSAUxp/F0gFNI1ZhKU1FqYsMuqZVnw==",
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.2.0.tgz",
+      "integrity": "sha512-fmsZYa9lpn69Ad5eDn7FMcnnSR+8R34W9qJEijxYhTbfOWzr22n1QxCMzXLK+ODyW2973V3Fux959iQoUxzUIA==",
      "dev": true,
      "peer": true,
      "bin": {
@@ -3943,9 +3943,9 @@
      }
    },
    "node_modules/nth-check": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/nth-check/-/nth-check-2.0.0.tgz",
-      "integrity": "sha512-i4sc/Kj8htBrAiH1viZ0TgU8Y5XqCaV/FziYK6TBczxmeKm3AEFWqqF3195yKudrarqy7Zu80Ra5dobFjn9X/Q==",
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/nth-check/-/nth-check-2.0.1.tgz",
+      "integrity": "sha512-it1vE95zF6dTT9lBsYbxvqh0Soy4SPowchj0UBGj/V6cTPnXXtQOPUbhZ6CmGzAD/rW22LQK6E96pcdJXk4A4w==",
      "dependencies": {
        "boolbase": "^1.0.0"
      },
@@ -6085,9 +6085,9 @@
      }
    },
    "node_modules/url-parse": {
-      "version": "1.5.1",
-      "resolved": "https://registry.npmjs.org/url-parse/-/url-parse-1.5.1.tgz",
-      "integrity": "sha512-HOfCOUJt7iSYzEx/UqgtwKRMC6EU91NFhsCHMv9oM03VJcVo2Qrp8T8kI9D7amFf1cu+/3CEhgb3rF9zL7k85Q==",
+      "version": "1.5.4",
+      "resolved": "https://registry.npmjs.org/url-parse/-/url-parse-1.5.4.tgz",
+      "integrity": "sha512-ITeAByWWoqutFClc/lRZnFplgXgEZr3WJ6XngMM/N9DMIm4K8zXPCZ1Jdu0rERwO84w1WC5wkle2ubwTA4NTBg==",
      "dev": true,
      "dependencies": {
        "querystringify": "^2.1.1",
@@ -8853,9 +8853,9 @@
      }
    },
    "follow-redirects": {
-      "version": "1.14.1",
-      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.14.1.tgz",
-      "integrity": "sha512-HWqDgT7ZEkqRzBvc2s64vSZ/hfOceEol3ac/7tKwzuvEyWx3/4UegXh5oBOIotkGsObyk3xznnSRVADBgWSQVg==",
+      "version": "1.14.7",
+      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.14.7.tgz",
+      "integrity": "sha512-+hbxoLbFMbRKDwohX8GkTataGqO6Jb7jGwpAlwgy2bIz25XtRm7KEzJM76R1WiNT5SwZkX4Y75SwBolkpmE7iQ==",
      "dev": true
    },
    "for-in": {
@@ -9871,9 +9871,9 @@
      "optional": true
    },
    "nanoid": {
-      "version": "3.1.23",
-      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.1.23.tgz",
-      "integrity": "sha512-FiB0kzdP0FFVGDKlRLEQ1BgDzU87dy5NnzjeW9YZNt+/c3+q82EQDUwniSAUxp/F0gFNI1ZhKU1FqYsMuqZVnw==",
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.2.0.tgz",
+      "integrity": "sha512-fmsZYa9lpn69Ad5eDn7FMcnnSR+8R34W9qJEijxYhTbfOWzr22n1QxCMzXLK+ODyW2973V3Fux959iQoUxzUIA==",
      "dev": true,
      "peer": true
    },
@@ -9984,9 +9984,9 @@
      }
    },
    "nth-check": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/nth-check/-/nth-check-2.0.0.tgz",
-      "integrity": "sha512-i4sc/Kj8htBrAiH1viZ0TgU8Y5XqCaV/FziYK6TBczxmeKm3AEFWqqF3195yKudrarqy7Zu80Ra5dobFjn9X/Q==",
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/nth-check/-/nth-check-2.0.1.tgz",
+      "integrity": "sha512-it1vE95zF6dTT9lBsYbxvqh0Soy4SPowchj0UBGj/V6cTPnXXtQOPUbhZ6CmGzAD/rW22LQK6E96pcdJXk4A4w==",
      "requires": {
        "boolbase": "^1.0.0"
      }
@@ -11733,9 +11733,9 @@
      }
    },
    "url-parse": {
-      "version": "1.5.1",
-      "resolved": "https://registry.npmjs.org/url-parse/-/url-parse-1.5.1.tgz",
-      "integrity": "sha512-HOfCOUJt7iSYzEx/UqgtwKRMC6EU91NFhsCHMv9oM03VJcVo2Qrp8T8kI9D7amFf1cu+/3CEhgb3rF9zL7k85Q==",
+      "version": "1.5.4",
+      "resolved": "https://registry.npmjs.org/url-parse/-/url-parse-1.5.4.tgz",
+      "integrity": "sha512-ITeAByWWoqutFClc/lRZnFplgXgEZr3WJ6XngMM/N9DMIm4K8zXPCZ1Jdu0rERwO84w1WC5wkle2ubwTA4NTBg==",
      "dev": true,
      "requires": {
        "querystringify": "^2.1.1",
@@ -35,7 +35,7 @@ async fn send_file_with_reply() {
    let (mut ws_stream, _) = connect_async(uri).await.unwrap();

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

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

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

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

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

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

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

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

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

    let send_request = json!({
        "type" : "send",
@@ -5,7 +5,7 @@ pub(crate) fn config_template() -> &'static str {
    // While using normal toml marshalling would have been way simpler with less overhead,
    // I think it's useful to have comments attached to the saved config file to explain behaviour of
    // particular fields.
-    // Note: any changes to the template must be reflected in the appropriate structs in verloc.
+    // Note: any changes to the template must be reflected in the appropriate structs.
    r#"
 # This is a TOML config file.
 # For more information, see https://github.com/toml-lang/toml
@@ -19,6 +19,10 @@ version = '{{ client.version }}'
 # Human readable ID of this particular client.
 id = '{{ client.id }}'

+# Indicates whether this client is running in a testnet mode, thus attempting
+# to claim bandwidth without presenting bandwidth credentials.
+testnet_mode = {{ client.testnet_mode }}
+
 # Addresses to APIs running on validator from which the client gets the view of the network.
 validator_api_urls = [
    {{#each client.validator_api_urls }}
@@ -32,7 +32,6 @@ use nymsphinx::addressing::clients::Recipient;
 use nymsphinx::addressing::nodes::NodeIdentity;
 use nymsphinx::anonymous_replies::ReplySurb;
 use nymsphinx::receiver::ReconstructedMessage;
-use tokio::runtime::Runtime;

 use crate::client::config::{Config, SocketType};
 use crate::websocket;
@@ -44,11 +43,6 @@ pub struct NymClient {
    /// key filepaths, etc.
    config: Config,

-    /// Tokio runtime used for futures execution.
-    // TODO: JS: Personally I think I prefer the implicit way of using it that we've done with the
-    // gateway.
-    runtime: Runtime,
-
    /// KeyManager object containing smart pointers to all relevant keys used by the client.
    key_manager: KeyManager,

@@ -68,7 +62,6 @@ impl NymClient {
        let key_manager = KeyManager::load_keys(&pathfinder).expect("failed to load stored keys");

        NymClient {
-            runtime: Runtime::new().unwrap(),
            config,
            key_manager,
            input_tx: None,
@@ -94,9 +87,6 @@ impl NymClient {
        mix_tx: BatchMixMessageSender,
    ) {
        info!("Starting loop cover traffic stream...");
-        // we need to explicitly enter runtime due to "next_delay: time::delay_for(Default::default())"
-        // set in the constructor which HAS TO be called within context of a tokio runtime
-        let _guard = self.runtime.enter();

        LoopCoverTrafficStream::new(
            self.key_manager.ack_key(),
@@ -109,7 +99,7 @@ impl NymClient {
            self.as_mix_recipient(),
            topology_accessor,
        )
-        .start(self.runtime.handle());
+        .start();
    }

    fn start_real_traffic_controller(
@@ -131,10 +121,6 @@ impl NymClient {
        );

        info!("Starting real traffic stream...");
-        // we need to explicitly enter runtime due to "next_delay: time::delay_for(Default::default())"
-        // set in the constructor [of OutQueueControl] which HAS TO be called within context of a tokio runtime
-        // When refactoring this restriction should definitely be removed.
-        let _guard = self.runtime.enter();

        RealMessagesController::new(
            controller_config,
@@ -144,7 +130,7 @@ impl NymClient {
            topology_accessor,
            reply_key_storage,
        )
-        .start(self.runtime.handle());
+        .start();
    }

    // buffer controlling all messages fetched from provider
@@ -162,10 +148,10 @@ impl NymClient {
            mixnet_receiver,
            reply_key_storage,
        )
-        .start(self.runtime.handle())
+        .start()
    }

-    fn start_gateway_client(
+    async fn start_gateway_client(
        &mut self,
        mixnet_message_sender: MixnetMessageSender,
        ack_sender: AcknowledgementSender,
@@ -182,43 +168,44 @@ impl NymClient {
        let gateway_identity = identity::PublicKey::from_base58_string(gateway_id)
            .expect("provided gateway id is invalid!");

-        self.runtime.block_on(async {
-            #[cfg(feature = "coconut")]
-            let bandwidth_controller = BandwidthController::new(
-                self.config.get_base().get_validator_api_endpoints(),
-                *self.key_manager.identity_keypair().public_key(),
-            );
-            #[cfg(not(feature = "coconut"))]
-            let bandwidth_controller = BandwidthController::new(
-                self.config.get_base().get_eth_endpoint(),
-                self.config.get_base().get_eth_private_key(),
-                self.config.get_base().get_backup_bandwidth_token_keys_dir(),
-            )
-            .expect("Could not create bandwidth controller");
+        #[cfg(feature = "coconut")]
+        let bandwidth_controller = BandwidthController::new(
+            self.config.get_base().get_validator_api_endpoints(),
+            *self.key_manager.identity_keypair().public_key(),
+        );
+        #[cfg(not(feature = "coconut"))]
+        let bandwidth_controller = BandwidthController::new(
+            self.config.get_base().get_eth_endpoint(),
+            self.config.get_base().get_eth_private_key(),
+            self.config.get_base().get_backup_bandwidth_token_keys_dir(),
+        )
+        .expect("Could not create bandwidth controller");

-            let mut gateway_client = GatewayClient::new(
-                gateway_address,
-                self.key_manager.identity_keypair(),
-                gateway_identity,
-                Some(self.key_manager.gateway_shared_key()),
-                mixnet_message_sender,
-                ack_sender,
-                self.config.get_base().get_gateway_response_timeout(),
-                Some(bandwidth_controller),
-            );
+        let mut gateway_client = GatewayClient::new(
+            gateway_address,
+            self.key_manager.identity_keypair(),
+            gateway_identity,
+            Some(self.key_manager.gateway_shared_key()),
+            mixnet_message_sender,
+            ack_sender,
+            self.config.get_base().get_gateway_response_timeout(),
+            Some(bandwidth_controller),
+        );

-            gateway_client
-                .authenticate_and_start()
-                .await
-                .expect("could not authenticate and start up the gateway connection");
+        if self.config.get_base().get_testnet_mode() {
+            gateway_client.set_testnet_mode(true)
+        }
+        gateway_client
+            .authenticate_and_start()
+            .await
+            .expect("could not authenticate and start up the gateway connection");

-            gateway_client
-        })
+        gateway_client
    }

    // future responsible for periodically polling directory server and updating
    // the current global view of topology
-    fn start_topology_refresher(&mut self, topology_accessor: TopologyAccessor) {
+    async fn start_topology_refresher(&mut self, topology_accessor: TopologyAccessor) {
        let topology_refresher_config = TopologyRefresherConfig::new(
            self.config.get_base().get_validator_api_endpoints(),
            self.config.get_base().get_topology_refresh_rate(),
@@ -229,13 +216,10 @@ impl NymClient {
        // before returning, block entire runtime to refresh the current network view so that any
        // components depending on topology would see a non-empty view
        info!("Obtaining initial network topology");
-        self.runtime.block_on(topology_refresher.refresh());
+        topology_refresher.refresh().await;

        // TODO: a slightly more graceful termination here
-        if !self
-            .runtime
-            .block_on(topology_refresher.is_topology_routable())
-        {
+        if !topology_refresher.is_topology_routable().await {
            panic!(
                "The current network topology seem to be insufficient to route any packets through\
                - check if enough nodes and a gateway are online"
@@ -243,7 +227,7 @@ impl NymClient {
        }

        info!("Starting topology refresher...");
-        topology_refresher.start(self.runtime.handle());
+        topology_refresher.start();
    }

    // controller for sending sphinx packets to mixnet (either real traffic or cover traffic)
@@ -256,7 +240,7 @@ impl NymClient {
        gateway_client: GatewayClient,
    ) {
        info!("Starting mix traffic controller...");
-        MixTrafficController::new(mix_rx, gateway_client).start(self.runtime.handle());
+        MixTrafficController::new(mix_rx, gateway_client).start();
    }

    fn start_websocket_listener(
@@ -269,8 +253,7 @@ impl NymClient {
        let websocket_handler =
            websocket::Handler::new(msg_input, buffer_requester, self.as_mix_recipient());

-        websocket::Listener::new(self.config.get_listening_port())
-            .start(self.runtime.handle(), websocket_handler);
+        websocket::Listener::new(self.config.get_listening_port()).start(websocket_handler);
    }

    /// EXPERIMENTAL DIRECT RUST API
@@ -317,9 +300,9 @@ impl NymClient {
    }

    /// blocking version of `start` method. Will run forever (or until SIGINT is sent)
-    pub fn run_forever(&mut self) {
-        self.start();
-        if let Err(e) = self.runtime.block_on(tokio::signal::ctrl_c()) {
+    pub async fn run_forever(&mut self) {
+        self.start().await;
+        if let Err(e) = tokio::signal::ctrl_c().await {
            error!(
                "There was an error while capturing SIGINT - {:?}. We will terminate regardless",
                e
@@ -331,7 +314,7 @@ impl NymClient {
        );
    }

-    pub fn start(&mut self) {
+    pub async fn start(&mut self) {
        info!("Starting nym client");
        // channels for inter-component communication
        // TODO: make the channels be internally created by the relevant components
@@ -363,14 +346,17 @@ impl NymClient {

        // the components are started in very specific order. Unless you know what you are doing,
        // do not change that.
-        self.start_topology_refresher(shared_topology_accessor.clone());
+        self.start_topology_refresher(shared_topology_accessor.clone())
+            .await;
        self.start_received_messages_buffer_controller(
            received_buffer_request_receiver,
            mixnet_messages_receiver,
            reply_key_storage.clone(),
        );

-        let gateway_client = self.start_gateway_client(mixnet_messages_sender, ack_sender);
+        let gateway_client = self
+            .start_gateway_client(mixnet_messages_sender, ack_sender)
+            .await;

        self.start_mix_traffic_controller(sphinx_message_receiver, gateway_client);
        self.start_real_traffic_controller(
@@ -31,6 +31,12 @@ use url::Url;

 use crate::client::config::Config;
 use crate::commands::override_config;
+#[cfg(feature = "eth")]
+#[cfg(not(feature = "coconut"))]
+use crate::commands::{
+    DEFAULT_ETH_ENDPOINT, DEFAULT_ETH_PRIVATE_KEY, ETH_ENDPOINT_ARG_NAME, ETH_PRIVATE_KEY_ARG_NAME,
+    TESTNET_MODE_ARG_NAME,
+};

 pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
    let app = App::new("init")
@@ -66,18 +72,28 @@ pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
            .hidden(true) // this will prevent this flag from being displayed in `--help`
            .help("Mostly debug-related option to increase default traffic rate so that you would not need to modify config post init")
        );
+    #[cfg(feature = "eth")]
    #[cfg(not(feature = "coconut"))]
        let app = app
-        .arg(Arg::with_name("eth_endpoint")
-            .long("eth_endpoint")
-            .help("URL of an Ethereum full node that we want to use for getting bandwidth tokens from ERC20 tokens")
+        .arg(
+            Arg::with_name(TESTNET_MODE_ARG_NAME)
+                .long(TESTNET_MODE_ARG_NAME)
+                .help("Set this client to work in a testnet mode that would attempt to use gateway without bandwidth credential requirement. If this value is set, --eth_endpoint and --eth_private_key don't need to be set.")
+                .conflicts_with_all(&[ETH_ENDPOINT_ARG_NAME, ETH_PRIVATE_KEY_ARG_NAME])
+        )
+        .arg(Arg::with_name(ETH_ENDPOINT_ARG_NAME)
+            .long(ETH_ENDPOINT_ARG_NAME)
+            .help("URL of an Ethereum full node that we want to use for getting bandwidth tokens from ERC20 tokens. If you don't want to set this value, use --testnet-mode instead")
            .takes_value(true)
+            .default_value_if(TESTNET_MODE_ARG_NAME, None, DEFAULT_ETH_ENDPOINT)
            .required(true))
-        .arg(Arg::with_name("eth_private_key")
-            .long("eth_private_key")
-            .help("Ethereum private key used for obtaining bandwidth tokens from ERC20 tokens")
+        .arg(Arg::with_name(ETH_PRIVATE_KEY_ARG_NAME)
+            .long(ETH_PRIVATE_KEY_ARG_NAME)
+            .help("Ethereum private key used for obtaining bandwidth tokens from ERC20 tokens. If you don't want to set this value, use --testnet-mode instead")
            .takes_value(true)
-            .required(true));
+            .default_value_if(TESTNET_MODE_ARG_NAME, None, DEFAULT_ETH_PRIVATE_KEY)
+            .required(true)
+        );

    app
 }
@@ -203,7 +219,7 @@ fn show_address(config: &Config) {
    println!("\nThe address of this client is: {}", client_recipient);
 }

-pub fn execute(matches: &ArgMatches) {
+pub async fn execute(matches: ArgMatches<'static>) {
    println!("Initialising client...");

    let id = matches.value_of("id").unwrap(); // required for now
@@ -221,7 +237,7 @@ pub fn execute(matches: &ArgMatches) {

    // TODO: ideally that should be the last thing that's being done to config.
    // However, we are later further overriding it with gateway id
-    config = override_config(config, matches);
+    config = override_config(config, &matches);
    if matches.is_present("fastmode") {
        config.get_base_mut().set_high_default_traffic_volume();
    }
@@ -234,26 +250,20 @@ pub fn execute(matches: &ArgMatches) {

        let chosen_gateway_id = matches.value_of("gateway");

-        let registration_fut = async {
-            let gate_details = gateway_details(
-                config.get_base().get_validator_api_endpoints(),
-                chosen_gateway_id,
-            )
-            .await;
-            config
-                .get_base_mut()
-                .with_gateway_id(gate_details.identity_key.to_base58_string());
-            let shared_keys =
-                register_with_gateway(&gate_details, key_manager.identity_keypair()).await;
-            (shared_keys, gate_details.clients_address())
-        };
-
-        // TODO: is there perhaps a way to make it work without having to spawn entire runtime?
-        let rt = tokio::runtime::Runtime::new().unwrap();
-        let (shared_keys, gateway_listener) = rt.block_on(registration_fut);
+        let gateway_details = gateway_details(
+            config.get_base().get_validator_api_endpoints(),
+            chosen_gateway_id,
+        )
+        .await;
        config
            .get_base_mut()
-            .with_gateway_listener(gateway_listener);
+            .with_gateway_id(gateway_details.identity_key.to_base58_string());
+        let shared_keys =
+            register_with_gateway(&gateway_details, key_manager.identity_keypair()).await;
+
+        config
+            .get_base_mut()
+            .with_gateway_listener(gateway_details.clients_address());
        key_manager.insert_gateway_shared_key(shared_keys);

        let pathfinder = ClientKeyPathfinder::new_from_config(config.get_base());
@@ -5,6 +5,18 @@ use crate::client::config::{Config, SocketType};
 use clap::ArgMatches;
 use url::Url;

+pub(crate) const TESTNET_MODE_ARG_NAME: &str = "testnet-mode";
+#[cfg(not(feature = "coconut"))]
+pub(crate) const ETH_ENDPOINT_ARG_NAME: &str = "eth_endpoint";
+#[cfg(not(feature = "coconut"))]
+pub(crate) const ETH_PRIVATE_KEY_ARG_NAME: &str = "eth_private_key";
+#[cfg(not(feature = "coconut"))]
+pub(crate) const DEFAULT_ETH_ENDPOINT: &str =
+    "https://rinkeby.infura.io/v3/00000000000000000000000000000000";
+#[cfg(not(feature = "coconut"))]
+pub(crate) const DEFAULT_ETH_PRIVATE_KEY: &str =
+    "0000000000000000000000000000000000000000000000000000000000000001";
+
 pub(crate) mod init;
 pub(crate) mod run;
 pub(crate) mod upgrade;
@@ -20,7 +32,7 @@ fn parse_validators(raw: &str) -> Vec<Url> {
        .collect()
 }

-pub(crate) fn override_config(mut config: Config, matches: &ArgMatches) -> Config {
+pub(crate) fn override_config(mut config: Config, matches: &ArgMatches<'_>) -> Config {
    if let Some(raw_validators) = matches.value_of("validators") {
        config
            .get_base_mut()
@@ -44,12 +56,24 @@ pub(crate) fn override_config(mut config: Config, matches: &ArgMatches) -> Confi
    }

    #[cfg(not(feature = "coconut"))]
-    if let Some(eth_endpoint) = matches.value_of("eth_endpoint") {
+    if let Some(eth_endpoint) = matches.value_of(ETH_ENDPOINT_ARG_NAME) {
        config.get_base_mut().with_eth_endpoint(eth_endpoint);
+    } else {
+        config
+            .get_base_mut()
+            .with_eth_endpoint(DEFAULT_ETH_ENDPOINT);
    }
    #[cfg(not(feature = "coconut"))]
-    if let Some(eth_private_key) = matches.value_of("eth_private_key") {
+    if let Some(eth_private_key) = matches.value_of(ETH_PRIVATE_KEY_ARG_NAME) {
        config.get_base_mut().with_eth_private_key(eth_private_key);
+    } else {
+        config
+            .get_base_mut()
+            .with_eth_private_key(DEFAULT_ETH_PRIVATE_KEY);
+    }
+
+    if !cfg!(feature = "eth") || matches.is_present(TESTNET_MODE_ARG_NAME) {
+        config.get_base_mut().with_testnet_mode(true)
    }

    config
@@ -4,6 +4,9 @@
 use crate::client::config::Config;
 use crate::client::NymClient;
 use crate::commands::override_config;
+#[cfg(feature = "eth")]
+#[cfg(not(feature = "coconut"))]
+use crate::commands::{ETH_ENDPOINT_ARG_NAME, ETH_PRIVATE_KEY_ARG_NAME, TESTNET_MODE_ARG_NAME};
 use clap::{App, Arg, ArgMatches};
 use config::NymConfig;
 use log::*;
@@ -39,15 +42,22 @@ pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
            .help("Port for the socket (if applicable) to listen on")
            .takes_value(true)
        );
+    #[cfg(feature = "eth")]
    #[cfg(not(feature = "coconut"))]
        let app = app
-        .arg(Arg::with_name("eth_endpoint")
-            .long("eth_endpoint")
-            .help("URL of an Ethereum full node that we want to use for getting bandwidth tokens from ERC20 tokens")
+        .arg(
+            Arg::with_name(TESTNET_MODE_ARG_NAME)
+                .long(TESTNET_MODE_ARG_NAME)
+                .help("Set this client to work in a testnet mode that would attempt to use gateway without bandwidth credential requirement. If this value is set, --eth_endpoint and --eth_private_key don't need to be set.")
+                .conflicts_with_all(&[ETH_ENDPOINT_ARG_NAME, ETH_PRIVATE_KEY_ARG_NAME])
+        )
+        .arg(Arg::with_name(ETH_ENDPOINT_ARG_NAME)
+            .long(ETH_ENDPOINT_ARG_NAME)
+            .help("URL of an Ethereum full node that we want to use for getting bandwidth tokens from ERC20 tokens. If you don't want to set this value, use --testnet-mode instead")
            .takes_value(true))
-        .arg(Arg::with_name("eth_private_key")
-            .long("eth_private_key")
-            .help("Ethereum private key used for obtaining bandwidth tokens from ERC20 tokens")
+        .arg(Arg::with_name(ETH_PRIVATE_KEY_ARG_NAME)
+            .long(ETH_PRIVATE_KEY_ARG_NAME)
+            .help("Ethereum private key used for obtaining bandwidth tokens from ERC20 tokens. If you don't want to set this value, use --testnet-mode instead")
            .takes_value(true));

    app
@@ -72,7 +82,7 @@ fn version_check(cfg: &Config) -> bool {
    }
 }

-pub fn execute(matches: &ArgMatches) {
+pub async fn execute(matches: ArgMatches<'static>) {
    let id = matches.value_of("id").unwrap();

    let mut config = match Config::load_from_file(Some(id)) {
@@ -83,12 +93,12 @@ pub fn execute(matches: &ArgMatches) {
        }
    };

-    config = override_config(config, matches);
+    config = override_config(config, &matches);

    if !version_check(&config) {
        error!("failed the local version check");
        return;
    }

-    NymClient::new(config).run_forever();
+    NymClient::new(config).run_forever().await;
 }
@@ -95,7 +95,7 @@ fn parse_package_version() -> Version {

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

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

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

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

    let id = matches.value_of("id").unwrap();
@@ -1,19 +1,21 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use clap::{App, ArgMatches};
+use clap::{crate_version, App, ArgMatches};

 pub mod client;
 pub mod commands;
 pub mod websocket;

-fn main() {
+#[tokio::main]
+async fn main() {
    dotenv::dotenv().ok();
    setup_logging();
    println!("{}", banner());

    let arg_matches = App::new("Nym Client")
-        .version(env!("CARGO_PKG_VERSION"))
+        .version(crate_version!())
+        .long_version(&*long_version())
        .author("Nymtech")
        .about("Implementation of the Nym Client")
        .subcommand(commands::init::command_args())
@@ -21,13 +23,13 @@ fn main() {
        .subcommand(commands::upgrade::command_args())
        .get_matches();

-    execute(arg_matches);
+    execute(arg_matches).await;
 }

-fn execute(matches: ArgMatches) {
+async fn execute(matches: ArgMatches<'static>) {
    match matches.subcommand() {
-        ("init", Some(m)) => commands::init::execute(m),
-        ("run", Some(m)) => commands::run::execute(m),
+        ("init", Some(m)) => commands::init::execute(m.clone()).await,
+        ("run", Some(m)) => commands::run::execute(m.clone()).await,
        ("upgrade", Some(m)) => commands::upgrade::execute(m),
        _ => println!("{}", usage()),
    }
@@ -50,7 +52,38 @@ fn banner() -> String {
             (client - version {:})

    "#,
-        env!("CARGO_PKG_VERSION")
+        crate_version!()
+    )
+}
+
+fn long_version() -> String {
+    format!(
+        r#"
+{:<20}{}
+{:<20}{}
+{:<20}{}
+{:<20}{}
+{:<20}{}
+{:<20}{}
+{:<20}{}
+{:<20}{}
+"#,
+        "Build Timestamp:",
+        env!("VERGEN_BUILD_TIMESTAMP"),
+        "Build Version:",
+        env!("VERGEN_BUILD_SEMVER"),
+        "Commit SHA:",
+        env!("VERGEN_GIT_SHA"),
+        "Commit Date:",
+        env!("VERGEN_GIT_COMMIT_TIMESTAMP"),
+        "Commit Branch:",
+        env!("VERGEN_GIT_BRANCH"),
+        "rustc Version:",
+        env!("VERGEN_RUSTC_SEMVER"),
+        "rustc Channel:",
+        env!("VERGEN_RUSTC_CHANNEL"),
+        "cargo Profile:",
+        env!("VERGEN_CARGO_PROFILE"),
    )
 }

@@ -5,7 +5,6 @@ use super::handler::Handler;
 use log::*;
 use std::{net::SocketAddr, process, sync::Arc};
 use tokio::io::AsyncWriteExt;
-use tokio::runtime;
 use tokio::{sync::Notify, task::JoinHandle};

 enum State {
@@ -87,9 +86,9 @@ impl Listener {
        }
    }

-    pub(crate) fn start(mut self, rt_handle: &runtime::Handle, handler: Handler) -> JoinHandle<()> {
+    pub(crate) fn start(mut self, handler: Handler) -> JoinHandle<()> {
        info!("Running websocket on {:?}", self.address.to_string());

-        rt_handle.spawn(async move { self.run(handler).await })
+        tokio::spawn(async move { self.run(handler).await })
    }
 }
@@ -2,7 +2,7 @@
 name = "websocket-requests"
 version = "0.1.0"
 authors = ["Jędrzej Stuczyński <andrew@nymtech.net>"]
-edition = "2018"
+edition = "2021"

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

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

 [lib]
@@ -43,3 +43,7 @@ network-defaults = { path = "../../common/network-defaults" }

 [features]
 coconut = ["coconut-interface", "credentials", "gateway-requests/coconut", "gateway-client/coconut"]
+eth = []
+
+[build-dependencies]
+vergen = { version = "5", default-features = false, features = ["build", "git", "rustc", "cargo"] }
@@ -0,0 +1,8 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use vergen::{vergen, Config};
+
+fn main() {
+    vergen(Config::default()).expect("failed to extract build metadata")
+}
@@ -5,7 +5,7 @@ pub(crate) fn config_template() -> &'static str {
    // While using normal toml marshalling would have been way simpler with less overhead,
    // I think it's useful to have comments attached to the saved config file to explain behaviour of
    // particular fields.
-    // Note: any changes to the template must be reflected in the appropriate structs in verloc.
+    // Note: any changes to the template must be reflected in the appropriate structs.
    r#"
 # This is a TOML config file.
 # For more information, see https://github.com/toml-lang/toml
@@ -19,6 +19,10 @@ version = '{{ client.version }}'
 # Human readable ID of this particular client.
 id = '{{ client.id }}'

+# Indicates whether this client is running in a testnet mode, thus attempting
+# to claim bandwidth without presenting bandwidth credentials.
+testnet_mode = {{ client.testnet_mode }}
+
 # Addresses to APIs running on validator from which the client gets the view of the network.
 validator_api_urls = [
    {{#each client.validator_api_urls }}
@@ -28,7 +28,6 @@ use gateway_client::{
 use log::*;
 use nymsphinx::addressing::clients::Recipient;
 use nymsphinx::addressing::nodes::NodeIdentity;
-use tokio::runtime::Runtime;

 use crate::client::config::Config;
 use crate::socks::{
@@ -43,11 +42,6 @@ pub struct NymClient {
    /// key filepaths, etc.
    config: Config,

-    /// Tokio runtime used for futures execution.
-    // TODO: JS: Personally I think I prefer the implicit way of using it that we've done with the
-    // gateway.
-    runtime: Runtime,
-
    /// KeyManager object containing smart pointers to all relevant keys used by the client.
    key_manager: KeyManager,
 }
@@ -58,7 +52,6 @@ impl NymClient {
        let key_manager = KeyManager::load_keys(&pathfinder).expect("failed to load stored keys");

        NymClient {
-            runtime: Runtime::new().unwrap(),
            config,
            key_manager,
        }
@@ -82,9 +75,6 @@ impl NymClient {
        mix_tx: BatchMixMessageSender,
    ) {
        info!("Starting loop cover traffic stream...");
-        // we need to explicitly enter runtime due to "next_delay: time::delay_for(Default::default())"
-        // set in the constructor which HAS TO be called within context of a tokio runtime
-        let _guard = self.runtime.enter();

        LoopCoverTrafficStream::new(
            self.key_manager.ack_key(),
@@ -97,7 +87,7 @@ impl NymClient {
            self.as_mix_recipient(),
            topology_accessor,
        )
-        .start(self.runtime.handle());
+        .start();
    }

    fn start_real_traffic_controller(
@@ -119,10 +109,6 @@ impl NymClient {
        );

        info!("Starting real traffic stream...");
-        // we need to explicitly enter runtime due to "next_delay: time::delay_for(Default::default())"
-        // set in the constructor [of OutQueueControl] which HAS TO be called within context of a tokio runtime
-        // When refactoring this restriction should definitely be removed.
-        let _guard = self.runtime.enter();

        RealMessagesController::new(
            controller_config,
@@ -132,7 +118,7 @@ impl NymClient {
            topology_accessor,
            reply_key_storage,
        )
-        .start(self.runtime.handle());
+        .start();
    }

    // buffer controlling all messages fetched from provider
@@ -150,10 +136,10 @@ impl NymClient {
            mixnet_receiver,
            reply_key_storage,
        )
-        .start(self.runtime.handle())
+        .start()
    }

-    fn start_gateway_client(
+    async fn start_gateway_client(
        &mut self,
        mixnet_message_sender: MixnetMessageSender,
        ack_sender: AcknowledgementSender,
@@ -170,43 +156,44 @@ impl NymClient {
        let gateway_identity = identity::PublicKey::from_base58_string(gateway_id)
            .expect("provided gateway id is invalid!");

-        self.runtime.block_on(async {
-            #[cfg(feature = "coconut")]
-            let bandwidth_controller = BandwidthController::new(
-                self.config.get_base().get_validator_api_endpoints(),
-                *self.key_manager.identity_keypair().public_key(),
-            );
-            #[cfg(not(feature = "coconut"))]
-            let bandwidth_controller = BandwidthController::new(
-                self.config.get_base().get_eth_endpoint(),
-                self.config.get_base().get_eth_private_key(),
-                self.config.get_base().get_backup_bandwidth_token_keys_dir(),
-            )
-            .expect("Could not create bandwidth controller");
+        #[cfg(feature = "coconut")]
+        let bandwidth_controller = BandwidthController::new(
+            self.config.get_base().get_validator_api_endpoints(),
+            *self.key_manager.identity_keypair().public_key(),
+        );
+        #[cfg(not(feature = "coconut"))]
+        let bandwidth_controller = BandwidthController::new(
+            self.config.get_base().get_eth_endpoint(),
+            self.config.get_base().get_eth_private_key(),
+            self.config.get_base().get_backup_bandwidth_token_keys_dir(),
+        )
+        .expect("Could not create bandwidth controller");

-            let mut gateway_client = GatewayClient::new(
-                gateway_address,
-                self.key_manager.identity_keypair(),
-                gateway_identity,
-                Some(self.key_manager.gateway_shared_key()),
-                mixnet_message_sender,
-                ack_sender,
-                self.config.get_base().get_gateway_response_timeout(),
-                Some(bandwidth_controller),
-            );
+        let mut gateway_client = GatewayClient::new(
+            gateway_address,
+            self.key_manager.identity_keypair(),
+            gateway_identity,
+            Some(self.key_manager.gateway_shared_key()),
+            mixnet_message_sender,
+            ack_sender,
+            self.config.get_base().get_gateway_response_timeout(),
+            Some(bandwidth_controller),
+        );

-            gateway_client
-                .authenticate_and_start()
-                .await
-                .expect("could not authenticate and start up the gateway connection");
+        if self.config.get_base().get_testnet_mode() {
+            gateway_client.set_testnet_mode(true)
+        }
+        gateway_client
+            .authenticate_and_start()
+            .await
+            .expect("could not authenticate and start up the gateway connection");

-            gateway_client
-        })
+        gateway_client
    }

    // future responsible for periodically polling directory server and updating
    // the current global view of topology
-    fn start_topology_refresher(&mut self, topology_accessor: TopologyAccessor) {
+    async fn start_topology_refresher(&mut self, topology_accessor: TopologyAccessor) {
        let topology_refresher_config = TopologyRefresherConfig::new(
            self.config.get_base().get_validator_api_endpoints(),
            self.config.get_base().get_topology_refresh_rate(),
@@ -217,13 +204,10 @@ impl NymClient {
        // before returning, block entire runtime to refresh the current network view so that any
        // components depending on topology would see a non-empty view
        info!("Obtaining initial network topology");
-        self.runtime.block_on(topology_refresher.refresh());
+        topology_refresher.refresh().await;

        // TODO: a slightly more graceful termination here
-        if !self
-            .runtime
-            .block_on(topology_refresher.is_topology_routable())
-        {
+        if !topology_refresher.is_topology_routable().await {
            panic!(
                "The current network topology seem to be insufficient to route any packets through\
                - check if enough nodes and a gateway are online"
@@ -231,7 +215,7 @@ impl NymClient {
        }

        info!("Starting topology refresher...");
-        topology_refresher.start(self.runtime.handle());
+        topology_refresher.start();
    }

    // controller for sending sphinx packets to mixnet (either real traffic or cover traffic)
@@ -244,7 +228,7 @@ impl NymClient {
        gateway_client: GatewayClient,
    ) {
        info!("Starting mix traffic controller...");
-        MixTrafficController::new(mix_rx, gateway_client).start(self.runtime.handle());
+        MixTrafficController::new(mix_rx, gateway_client).start();
    }

    fn start_socks5_listener(
@@ -263,14 +247,13 @@ impl NymClient {
            self.config.get_provider_mix_address(),
            self.as_mix_recipient(),
        );
-        self.runtime
-            .spawn(async move { sphinx_socks.serve(msg_input, buffer_requester).await });
+        tokio::spawn(async move { sphinx_socks.serve(msg_input, buffer_requester).await });
    }

    /// blocking version of `start` method. Will run forever (or until SIGINT is sent)
-    pub fn run_forever(&mut self) {
-        self.start();
-        if let Err(e) = self.runtime.block_on(tokio::signal::ctrl_c()) {
+    pub async fn run_forever(&mut self) {
+        self.start().await;
+        if let Err(e) = tokio::signal::ctrl_c().await {
            error!(
                "There was an error while capturing SIGINT - {:?}. We will terminate regardless",
                e
@@ -282,7 +265,7 @@ impl NymClient {
        );
    }

-    pub fn start(&mut self) {
+    pub async fn start(&mut self) {
        info!("Starting nym client");
        // channels for inter-component communication
        // TODO: make the channels be internally created by the relevant components
@@ -314,14 +297,17 @@ impl NymClient {

        // the components are started in very specific order. Unless you know what you are doing,
        // do not change that.
-        self.start_topology_refresher(shared_topology_accessor.clone());
+        self.start_topology_refresher(shared_topology_accessor.clone())
+            .await;
        self.start_received_messages_buffer_controller(
            received_buffer_request_receiver,
            mixnet_messages_receiver,
            reply_key_storage.clone(),
        );

-        let gateway_client = self.start_gateway_client(mixnet_messages_sender, ack_sender);
+        let gateway_client = self
+            .start_gateway_client(mixnet_messages_sender, ack_sender)
+            .await;

        self.start_mix_traffic_controller(sphinx_message_receiver, gateway_client);
        self.start_real_traffic_controller(
@@ -29,6 +29,12 @@ use url::Url;

 use crate::client::config::Config;
 use crate::commands::override_config;
+#[cfg(feature = "eth")]
+#[cfg(not(feature = "coconut"))]
+use crate::commands::{
+    DEFAULT_ETH_ENDPOINT, DEFAULT_ETH_PRIVATE_KEY, ETH_ENDPOINT_ARG_NAME, ETH_PRIVATE_KEY_ARG_NAME,
+    TESTNET_MODE_ARG_NAME,
+};

 pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
    let app = App::new("init")
@@ -66,18 +72,28 @@ pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
            .hidden(true) // this will prevent this flag from being displayed in `--help`
            .help("Mostly debug-related option to increase default traffic rate so that you would not need to modify config post init")
        );
+    #[cfg(feature = "eth")]
    #[cfg(not(feature = "coconut"))]
        let app = app
-        .arg(Arg::with_name("eth_endpoint")
-            .long("eth_endpoint")
-            .help("URL of an Ethereum full node that we want to use for getting bandwidth tokens from ERC20 tokens")
+        .arg(
+            Arg::with_name(TESTNET_MODE_ARG_NAME)
+                .long(TESTNET_MODE_ARG_NAME)
+                .help("Set this client to work in a testnet mode that would attempt to use gateway without bandwidth credential requirement. If this value is set, --eth_endpoint and --eth_private_key don't need to be set.")
+                .conflicts_with_all(&[ETH_ENDPOINT_ARG_NAME, ETH_PRIVATE_KEY_ARG_NAME])
+        )
+        .arg(Arg::with_name(ETH_ENDPOINT_ARG_NAME)
+            .long(ETH_ENDPOINT_ARG_NAME)
+            .help("URL of an Ethereum full node that we want to use for getting bandwidth tokens from ERC20 tokens. If you don't want to set this value, use --testnet-mode instead")
            .takes_value(true)
+            .default_value_if(TESTNET_MODE_ARG_NAME, None, DEFAULT_ETH_ENDPOINT)
            .required(true))
-        .arg(Arg::with_name("eth_private_key")
-            .long("eth_private_key")
-            .help("Ethereum private key used for obtaining bandwidth tokens from ERC20 tokens")
+        .arg(Arg::with_name(ETH_PRIVATE_KEY_ARG_NAME)
+            .long(ETH_PRIVATE_KEY_ARG_NAME)
+            .help("Ethereum private key used for obtaining bandwidth tokens from ERC20 tokens. If you don't want to set this value, use --testnet-mode instead")
            .takes_value(true)
-            .required(true));
+            .default_value_if(TESTNET_MODE_ARG_NAME, None, DEFAULT_ETH_PRIVATE_KEY)
+            .required(true)
+        );

    app
 }
@@ -203,7 +219,7 @@ fn show_address(config: &Config) {
    println!("\nThe address of this client is: {}", client_recipient);
 }

-pub fn execute(matches: &ArgMatches) {
+pub async fn execute(matches: ArgMatches<'static>) {
    println!("Initialising client...");

    let id = matches.value_of("id").unwrap(); // required for now
@@ -222,7 +238,7 @@ pub fn execute(matches: &ArgMatches) {

    // TODO: ideally that should be the last thing that's being done to config.
    // However, we are later further overriding it with gateway id
-    config = override_config(config, matches);
+    config = override_config(config, &matches);
    if matches.is_present("fastmode") {
        config.get_base_mut().set_high_default_traffic_volume();
    }
@@ -235,26 +251,20 @@ pub fn execute(matches: &ArgMatches) {

        let chosen_gateway_id = matches.value_of("gateway");

-        let registration_fut = async {
-            let gate_details = gateway_details(
-                config.get_base().get_validator_api_endpoints(),
-                chosen_gateway_id,
-            )
-            .await;
-            config
-                .get_base_mut()
-                .with_gateway_id(gate_details.identity_key.to_base58_string());
-            let shared_keys =
-                register_with_gateway(&gate_details, key_manager.identity_keypair()).await;
-            (shared_keys, gate_details.clients_address())
-        };
-
-        // TODO: is there perhaps a way to make it work without having to spawn entire runtime?
-        let rt = tokio::runtime::Runtime::new().unwrap();
-        let (shared_keys, gateway_listener) = rt.block_on(registration_fut);
+        let gateway_details = gateway_details(
+            config.get_base().get_validator_api_endpoints(),
+            chosen_gateway_id,
+        )
+        .await;
        config
            .get_base_mut()
-            .with_gateway_listener(gateway_listener);
+            .with_gateway_id(gateway_details.identity_key.to_base58_string());
+        let shared_keys =
+            register_with_gateway(&gateway_details, key_manager.identity_keypair()).await;
+
+        config
+            .get_base_mut()
+            .with_gateway_listener(gateway_details.clients_address());
        key_manager.insert_gateway_shared_key(shared_keys);

        let pathfinder = ClientKeyPathfinder::new_from_config(config.get_base());
@@ -9,6 +9,18 @@ pub(crate) mod init;
 pub(crate) mod run;
 pub(crate) mod upgrade;

+pub(crate) const TESTNET_MODE_ARG_NAME: &str = "testnet-mode";
+#[cfg(not(feature = "coconut"))]
+pub(crate) const ETH_ENDPOINT_ARG_NAME: &str = "eth_endpoint";
+#[cfg(not(feature = "coconut"))]
+pub(crate) const ETH_PRIVATE_KEY_ARG_NAME: &str = "eth_private_key";
+#[cfg(not(feature = "coconut"))]
+pub(crate) const DEFAULT_ETH_ENDPOINT: &str =
+    "https://rinkeby.infura.io/v3/00000000000000000000000000000000";
+#[cfg(not(feature = "coconut"))]
+pub(crate) const DEFAULT_ETH_PRIVATE_KEY: &str =
+    "0000000000000000000000000000000000000000000000000000000000000001";
+
 fn parse_validators(raw: &str) -> Vec<Url> {
    raw.split(',')
        .map(|raw_validator| {
@@ -20,7 +32,7 @@ fn parse_validators(raw: &str) -> Vec<Url> {
        .collect()
 }

-pub(crate) fn override_config(mut config: Config, matches: &ArgMatches) -> Config {
+pub(crate) fn override_config(mut config: Config, matches: &ArgMatches<'_>) -> Config {
    if let Some(raw_validators) = matches.value_of("validators") {
        config
            .get_base_mut()
@@ -40,12 +52,24 @@ pub(crate) fn override_config(mut config: Config, matches: &ArgMatches) -> Confi
    }

    #[cfg(not(feature = "coconut"))]
-    if let Some(eth_endpoint) = matches.value_of("eth_endpoint") {
+    if let Some(eth_endpoint) = matches.value_of(ETH_ENDPOINT_ARG_NAME) {
        config.get_base_mut().with_eth_endpoint(eth_endpoint);
+    } else {
+        config
+            .get_base_mut()
+            .with_eth_endpoint(DEFAULT_ETH_ENDPOINT);
    }
    #[cfg(not(feature = "coconut"))]
-    if let Some(eth_private_key) = matches.value_of("eth_private_key") {
+    if let Some(eth_private_key) = matches.value_of(ETH_PRIVATE_KEY_ARG_NAME) {
        config.get_base_mut().with_eth_private_key(eth_private_key);
+    } else {
+        config
+            .get_base_mut()
+            .with_eth_private_key(DEFAULT_ETH_PRIVATE_KEY);
+    }
+
+    if !cfg!(feature = "eth") || matches.is_present(TESTNET_MODE_ARG_NAME) {
+        config.get_base_mut().with_testnet_mode(true)
    }

    config
@@ -4,6 +4,9 @@
 use crate::client::config::Config;
 use crate::client::NymClient;
 use crate::commands::override_config;
+#[cfg(feature = "eth")]
+#[cfg(not(feature = "coconut"))]
+use crate::commands::{ETH_ENDPOINT_ARG_NAME, ETH_PRIVATE_KEY_ARG_NAME, TESTNET_MODE_ARG_NAME};
 use clap::{App, Arg, ArgMatches};
 use config::NymConfig;
 use log::*;
@@ -45,15 +48,22 @@ pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
            .help("Port for the socket to listen on")
            .takes_value(true)
        );
+    #[cfg(feature = "eth")]
    #[cfg(not(feature = "coconut"))]
    let app = app
-        .arg(Arg::with_name("eth_endpoint")
-            .long("eth_endpoint")
-            .help("URL of an Ethereum full node that we want to use for getting bandwidth tokens from ERC20 tokens")
+        .arg(
+            Arg::with_name(TESTNET_MODE_ARG_NAME)
+                .long(TESTNET_MODE_ARG_NAME)
+                .help("Set this client to work in a testnet mode that would attempt to use gateway without bandwidth credential requirement. If this value is set, --eth_endpoint and --eth_private_key don't need to be set.")
+                .conflicts_with_all(&[ETH_ENDPOINT_ARG_NAME, ETH_PRIVATE_KEY_ARG_NAME])
+        )
+        .arg(Arg::with_name(ETH_ENDPOINT_ARG_NAME)
+            .long(ETH_ENDPOINT_ARG_NAME)
+            .help("URL of an Ethereum full node that we want to use for getting bandwidth tokens from ERC20 tokens. If you don't want to set this value, use --testnet-mode instead")
            .takes_value(true))
-        .arg(Arg::with_name("eth_private_key")
-            .long("eth_private_key")
-            .help("Ethereum private key used for obtaining bandwidth tokens from ERC20 tokens")
+        .arg(Arg::with_name(ETH_PRIVATE_KEY_ARG_NAME)
+            .long(ETH_PRIVATE_KEY_ARG_NAME)
+            .help("Ethereum private key used for obtaining bandwidth tokens from ERC20 tokens. If you don't want to set this value, use --testnet-mode instead")
            .takes_value(true));

    app
@@ -78,7 +88,7 @@ fn version_check(cfg: &Config) -> bool {
    }
 }

-pub fn execute(matches: &ArgMatches) {
+pub async fn execute(matches: ArgMatches<'static>) {
    let id = matches.value_of("id").unwrap();

    let mut config = match Config::load_from_file(Some(id)) {
@@ -89,12 +99,12 @@ pub fn execute(matches: &ArgMatches) {
        }
    };

-    config = override_config(config, matches);
+    config = override_config(config, &matches);

    if !version_check(&config) {
        error!("failed the local version check");
        return;
    }

-    NymClient::new(config).run_forever();
+    NymClient::new(config).run_forever().await;
 }
@@ -95,7 +95,7 @@ fn parse_package_version() -> Version {

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

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

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

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

    let id = matches.value_of("id").unwrap();
@@ -1,13 +1,14 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use clap::{App, ArgMatches};
+use clap::{crate_version, App, ArgMatches};

 pub mod client;
 mod commands;
 pub mod socks;

-fn main() {
+#[tokio::main]
+async fn main() {
    dotenv::dotenv().ok();
    setup_logging();
    println!("{}", banner());
@@ -15,19 +16,20 @@ fn main() {
    let arg_matches = App::new("Nym Socks5 Proxy")
        .version(env!("CARGO_PKG_VERSION"))
        .author("Nymtech")
+        .long_version(&*long_version())
        .about("A Socks5 localhost proxy that converts incoming messages to Sphinx and sends them to a Nym address")
        .subcommand(commands::init::command_args())
        .subcommand(commands::run::command_args())
        .subcommand(commands::upgrade::command_args())
        .get_matches();

-    execute(arg_matches);
+    execute(arg_matches).await;
 }

-fn execute(matches: ArgMatches) {
+async fn execute(matches: ArgMatches<'static>) {
    match matches.subcommand() {
-        ("init", Some(m)) => commands::init::execute(m),
-        ("run", Some(m)) => commands::run::execute(m),
+        ("init", Some(m)) => commands::init::execute(m.clone()).await,
+        ("run", Some(m)) => commands::run::execute(m.clone()).await,
        ("upgrade", Some(m)) => commands::upgrade::execute(m),
        _ => println!("{}", usage()),
    }
@@ -50,7 +52,38 @@ fn banner() -> String {
             (socks5 proxy - version {:})

    "#,
-        env!("CARGO_PKG_VERSION")
+        crate_version!()
+    )
+}
+
+fn long_version() -> String {
+    format!(
+        r#"
+{:<20}{}
+{:<20}{}
+{:<20}{}
+{:<20}{}
+{:<20}{}
+{:<20}{}
+{:<20}{}
+{:<20}{}
+"#,
+        "Build Timestamp:",
+        env!("VERGEN_BUILD_TIMESTAMP"),
+        "Build Version:",
+        env!("VERGEN_BUILD_SEMVER"),
+        "Commit SHA:",
+        env!("VERGEN_GIT_SHA"),
+        "Commit Date:",
+        env!("VERGEN_GIT_COMMIT_TIMESTAMP"),
+        "Commit Branch:",
+        env!("VERGEN_GIT_BRANCH"),
+        "rustc Version:",
+        env!("VERGEN_RUSTC_SEMVER"),
+        "rustc Channel:",
+        env!("VERGEN_RUSTC_CHANNEL"),
+        "cargo Profile:",
+        env!("VERGEN_CARGO_PROFILE"),
    )
 }

@@ -6,7 +6,7 @@ authors = ["you"]
 license = ""
 repository = ""
 default-run = "app"
-edition = "2018"
+edition = "2021"
 build = "src/build.rs"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -1,41 +1,83 @@
 {
    "root": true,
-    "parser": "@typescript-eslint/parser",
-    "plugins": [
-        "@typescript-eslint"
-    ],
    "env": {
+        "browser": true,
        "es6": true,
-        "node": true,
-        "mocha": true
+        "node": true
    },
-    "extends": [
-        "eslint:recommended",
-        "plugin:@typescript-eslint/eslint-recommended",
-        "plugin:@typescript-eslint/recommended"
-    ],
    "parserOptions": {
-        "ecmaVersion": 2018,
+        "ecmaVersion": 2019,
        "sourceType": "module"
    },
+    "globals": {
+        "Atomics": "readonly",
+        "SharedArrayBuffer": "readonly"
+    },
+    "plugins": ["prettier", "mocha"],
+    "extends": [
+        "airbnb-base",
+        "airbnb-typescript/base",
+        "prettier"],
    "rules": {
-        "no-console": "off",
-        "linebreak-style": "off",
-        "quotes": [
-            "error",
-            "double",
-            {
-                "allowTemplateLiterals": true
-            }
-        ],
-        "keyword-spacing": [
+        "prettier/prettier": "error",
+        "import/prefer-default-export": "off",
+        "import/no-extraneous-dependencies": [
            "error",
            {
-                "before": true
+                "devDependencies": [
+                    "**/*.test.[jt]s",
+                    "**/*.spec.[jt]s"
+                ]
            }
        ],
-        "space-before-blocks": [
-            "error"
+        "import/extensions": [
+            "error",
+            "ignorePackages",
+            {
+                "ts": "never",
+                "js": "never"
+            }
        ]
-    }
-}
+    },
+    "overrides": [
+        {
+            "files": "**/*.ts",
+            "parser": "@typescript-eslint/parser",
+            "parserOptions": {
+                "project": "./tsconfig.json"
+            },
+            "plugins": ["@typescript-eslint/eslint-plugin"],
+            "extends": [
+                "plugin:@typescript-eslint/eslint-recommended",
+                "plugin:@typescript-eslint/recommended",
+                "prettier"
+            ],
+            "rules": {
+                "@typescript-eslint/explicit-function-return-type": "off",
+                "@typescript-eslint/no-explicit-any": "off",
+                "@typescript-eslint/no-var-requires": "off",
+                "no-use-before-define": [0],
+                "@typescript-eslint/no-use-before-define": [1],
+                "import/no-unresolved": 0,
+                "import/no-extraneous-dependencies": [
+                    "error",
+                    {
+                        "devDependencies": [
+                            "**/*.test.ts",
+                            "**/*.spec.ts"
+                        ]
+                    }
+                ],
+                "quotes": "off",
+                "@typescript-eslint/quotes": [
+                    2,
+                    "single",
+                    {
+                        "avoidEscape": true
+                    }
+                ],
+                "@typescript-eslint/no-unused-vars": [2, { "argsIgnorePattern": "^_" }]
+            }
+        }
+    ]
+}
@@ -0,0 +1,6 @@
+{
+  "trailingComma": "all",
+  "singleQuote": true,
+  "printWidth": 120,
+  "tabWidth": 2
+}
@@ -1,6 +1,6 @@
 {
  "name": "@nymproject/nym-validator-client",
-  "version": "0.18.0",
+  "version": "0.19.0",
  "description": "A TypeScript client for interacting with smart contracts in Nym validators",
  "repository": "https://github.com/nymtech/nym",
  "main": "./dist/index.js",
@@ -9,7 +9,8 @@
    "build": "tsc",
    "test": "ts-mocha tests/**/*.test.ts",
    "coverage": "nyc npm test",
-    "lint": "eslint \"**/*.ts\"",
+    "lint": "eslint src",
+    "lint:fix": "eslint src --fix",
    "docs": "typedoc --out docs src/index.ts"
  },
  "keywords": [],
@@ -23,22 +24,33 @@
    "@types/chai": "^4.2.15",
    "@types/expect": "^24.3.0",
    "@types/mocha": "^8.2.1",
-    "@typescript-eslint/eslint-plugin": "^4.14.0",
-    "@typescript-eslint/parser": "^4.14.0",
+    "@typescript-eslint/eslint-plugin": "^5.7.0",
+    "@typescript-eslint/parser": "^5.7.0",
    "chai": "^4.2.0",
    "eslint": "^7.18.0",
+    "eslint-config-airbnb": "^19.0.2",
+    "eslint-config-airbnb-typescript": "^16.1.0",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-import-resolver-root-import": "^1.0.4",
+    "eslint-plugin-import": "^2.25.3",
+    "eslint-plugin-mocha": "^10.0.3",
+    "eslint-plugin-prettier": "^4.0.0",
    "mocha": "^8.2.1",
    "moq.ts": "^7.2.0",
    "nyc": "^15.1.0",
+    "prettier": "^2.5.1",
    "ts-mocha": "^8.0.0",
    "typedoc": "^0.20.27",
    "typescript": "^4.1.3"
  },
  "dependencies": {
+    "@cosmjs/cosmwasm-stargate": "^0.27.0-rc2",
+    "@cosmjs/crypto": "^0.27.0-rc2",
+    "@cosmjs/math": "^0.27.0-rc2",
+    "@cosmjs/proto-signing": "^0.27.0-rc2",
+    "@cosmjs/stargate": "^0.27.0-rc2",
+    "@cosmjs/tendermint-rpc": "^0.27.0-rc2",
    "axios": "^0.21.1",
-    "@cosmjs/cosmwasm-stargate": "^0.25.5",
-    "@cosmjs/stargate": "^0.25.5",
-    "@cosmjs/math": "^0.25.5",
-    "@cosmjs/proto-signing": "^0.25.5"
+    "cosmjs-types": "^0.4.0"
  }
-}
+}
@@ -1,41 +0,0 @@
-{
-    "root": true,
-    "parser": "@typescript-eslint/parser",
-    "plugins": [
-        "@typescript-eslint"
-    ],
-    "env": {
-        "es6": true,
-        "node": true,
-        "mocha": true
-    },
-    "extends": [
-        "eslint:recommended",
-        "plugin:@typescript-eslint/eslint-recommended",
-        "plugin:@typescript-eslint/recommended"
-    ],
-    "parserOptions": {
-        "ecmaVersion": 2018,
-        "sourceType": "module"
-    },
-    "rules": {
-        "no-console": "off",
-        "linebreak-style": "off",
-        "quotes": [
-            "error",
-            "double",
-            {
-                "allowTemplateLiterals": true
-            }
-        ],
-        "keyword-spacing": [
-            "error",
-            {
-                "before": true
-            }
-        ],
-        "space-before-blocks": [
-            "error"
-        ]
-    }
-}
@@ -1 +0,0 @@
-15.0.1
@@ -1,59 +0,0 @@
-import {GatewayBond, PagedGatewayResponse} from "../types";
-import {INetClient} from "../net-client"
-import {IQueryClient} from "../query-client";
-import {VALIDATOR_API_GATEWAYS, VALIDATOR_API_PORT} from "../index";
-import axios from "axios";
-
-
-/**
- * There are serious limits in smart contract systems, but we need to keep track of
- * potentially thousands of nodes. GatewaysCache instances repeatedly make requests for
- * paged data about what gateways exist, and keep them locally in memory so that they're
- * available for querying.
- **/
-export default class GatewaysCache {
-    gateways: GatewayBond[]
-    client: INetClient | IQueryClient
-    perPage: number
-
-    constructor(client: INetClient | IQueryClient, perPage: number) {
-        this.client = client;
-        this.gateways = [];
-        this.perPage = perPage;
-    }
-
-    /// Makes repeated requests to assemble a full list of gateways.
-    /// Requests continue to be make as long as `shouldMakeAnotherRequest()`
-    /// returns true.
-    async refreshGateways(contractAddress: string): Promise<GatewayBond[]> {
-        let newGateways: GatewayBond[] = [];
-        let response: PagedGatewayResponse;
-        let next: string | undefined = undefined;
-        for (;;) {
-            response = await this.client.getGateways(contractAddress, this.perPage, next);
-            newGateways = newGateways.concat(response.nodes)
-            next = response.start_next_after;
-            // if `start_next_after` is not set, we're done
-            if (!next) {
-                break
-            }
-        }
-
-        this.gateways = newGateways
-        return newGateways;
-    }
-
-    /// Makes requests to assemble a full list of gateways from validator-api
-    async refreshValidatorAPIGateways(urls: string[]): Promise<GatewayBond[]> {
-        for (const url of urls) {
-            const validator_api_url = new URL(url);
-            validator_api_url.port = VALIDATOR_API_PORT;
-            validator_api_url.pathname += VALIDATOR_API_GATEWAYS;
-            const response = await axios.get(validator_api_url.toString());
-            if (response.status == 200) {
-                return response.data;
-            }
-        }
-        throw new Error("None of the provided validators seem to be alive")
-    }
-}
@@ -1,60 +0,0 @@
-import {MixNodeBond, PagedMixnodeResponse} from "../types";
-import { INetClient } from "../net-client"
-import {IQueryClient} from "../query-client";
-import {VALIDATOR_API_MIXNODES, VALIDATOR_API_PORT} from "../index";
-import axios from "axios";
-
-export { MixnodesCache };
-
-/**
- * There are serious limits in smart contract systems, but we need to keep track of
- * potentially thousands of nodes. MixnodeCache instances repeatedly make requests for
- *  paged data about what mixnodes exist, and keep them locally in memory so that they're
- *  available for querying.
- *  */
-export default class MixnodesCache {
-    mixNodes: MixNodeBond[]
-    client: INetClient | IQueryClient
-    perPage: number
-
-    constructor(client: INetClient | IQueryClient, perPage: number) {
-        this.client = client;
-        this.mixNodes = [];
-        this.perPage = perPage;
-    }
-
-    /// Makes repeated requests to assemble a full list of nodes. 
-    /// Requests continue to be make as long as `shouldMakeAnotherRequest()`
-    // returns true. 
-    async refreshMixNodes(contractAddress: string): Promise<MixNodeBond[]> {
-        let newMixnodes: MixNodeBond[] = [];
-        let response: PagedMixnodeResponse;
-        let next: string | undefined = undefined;
-        for (;;) {
-            response = await this.client.getMixNodes(contractAddress, this.perPage, next);
-            newMixnodes = newMixnodes.concat(response.nodes)
-            next = response.start_next_after;
-            // if `start_next_after` is not set, we're done
-            if (!next) {
-                break
-            }
-        }
-
-        this.mixNodes = newMixnodes
-        return this.mixNodes;
-    }
-
-    /// Makes  requests to assemble a full list of mixnodes from validator-api
-    async refreshValidatorAPIMixNodes(urls: string[]): Promise<MixNodeBond[]> {
-        for (const url of urls) {
-            const validator_api_url = new URL(url);
-            validator_api_url.port = VALIDATOR_API_PORT;
-            validator_api_url.pathname += VALIDATOR_API_MIXNODES;
-            const response = await axios.get(validator_api_url.toString());
-            if (response.status == 200) {
-                return response.data;
-            }
-        }
-        throw new Error("None of the provided validators seem to be alive")
-    }
-}
@@ -1,73 +1,68 @@
-import { Decimal } from "@cosmjs/math";
-import { Coin } from ".";
+import { Decimal } from '@cosmjs/math';
+import { Coin } from '@cosmjs/stargate';

 // NARROW NO-BREAK SPACE (U+202F)
-const thinSpace = "\u202F";
+const thinSpace = '\u202F';

 export function printableCoin(coin?: Coin): string {
-    if (!coin) {
-        return "0";
-    }
-    if (coin.denom.startsWith("u")) {
-        const ticker = coin.denom.slice(1).toUpperCase();
-        return Decimal.fromAtomics(coin.amount, 6).toString() + thinSpace + ticker;
-    } else {
-        return coin.amount + thinSpace + coin.denom;
-    }
+  if (!coin) {
+    return '0';
+  }
+  if (coin.denom.startsWith('u')) {
+    const ticker = coin.denom.slice(1).toUpperCase();
+    return Decimal.fromAtomics(coin.amount, 6).toString() + thinSpace + ticker;
+  }
+  return coin.amount + thinSpace + coin.denom;
 }

 export function printableBalance(balance?: readonly Coin[]): string {
-    if (!balance || balance.length === 0) return "–";
-    return balance.map(printableCoin).join(", ");
+  if (!balance || balance.length === 0) return '–';
+  return balance.map(printableCoin).join(', ');
 }

 // converts display amount, such as "12.0346" to its native token representation,
 // with 6 fractional digits. So in that case it would result in "12034600"
 // Basically does the same job as `displayAmountToNative` but without the requirement
 // of having the coinMap
-export function printableBalanceToNative(amountToDisplay: string): string  {
-    const decimalAmount = Decimal.fromUserInput(amountToDisplay, 6);
-    return decimalAmount.atomics;
+export function printableBalanceToNative(amountToDisplay: string): string {
+  const decimalAmount = Decimal.fromUserInput(amountToDisplay, 6);
+  return decimalAmount.atomics;
 }

 // reciprocal of `printableBalanceToNative`, takes, for example 10000000 and returns 10
 export function nativeToPrintable(nativeValue: string): string {
-    return Decimal.fromAtomics(nativeValue, 6).toString()
+  return Decimal.fromAtomics(nativeValue, 6).toString();
 }

 export interface MappedCoin {
-    readonly denom: string;
-    readonly fractionalDigits: number;
+  readonly denom: string;
+  readonly fractionalDigits: number;
 }

 export interface CoinMap {
-    readonly [key: string]: MappedCoin;
+  readonly [key: string]: MappedCoin;
 }

 export function nativeCoinToDisplay(coin: Coin, coinMap: CoinMap): Coin {
-    if (!coinMap) return coin;
+  if (!coinMap) return coin;

-    const coinToDisplay = coinMap[coin.denom];
-    if (!coinToDisplay) return coin;
+  const coinToDisplay = coinMap[coin.denom];
+  if (!coinToDisplay) return coin;

-    const amountToDisplay = Decimal.fromAtomics(coin.amount, coinToDisplay.fractionalDigits).toString();
+  const amountToDisplay = Decimal.fromAtomics(coin.amount, coinToDisplay.fractionalDigits).toString();

-    return { denom: coinToDisplay.denom, amount: amountToDisplay };
+  return { denom: coinToDisplay.denom, amount: amountToDisplay };
 }

 // display amount is eg "12.0346", return is in native tokens
 // with 6 fractional digits, this would be eg. "12034600"
-export function displayAmountToNative(
-    amountToDisplay: string,
-    coinMap: CoinMap,
-    nativeDenom: string,
-): string {
-    const fractionalDigits = coinMap[nativeDenom]?.fractionalDigits;
-    if (fractionalDigits) {
-        // use https://github.com/CosmWasm/cosmjs/blob/v0.22.2/packages/math/src/decimal.ts
-        const decimalAmount = Decimal.fromUserInput(amountToDisplay, fractionalDigits);
-        return decimalAmount.atomics;
-    }
+export function displayAmountToNative(amountToDisplay: string, coinMap: CoinMap, nativeDenom: string): string {
+  const fractionalDigits = coinMap[nativeDenom]?.fractionalDigits;
+  if (fractionalDigits) {
+    // use https://github.com/CosmWasm/cosmjs/blob/v0.22.2/packages/math/src/decimal.ts
+    const decimalAmount = Decimal.fromUserInput(amountToDisplay, fractionalDigits);
+    return decimalAmount.atomics;
+  }

-    return amountToDisplay;
+  return amountToDisplay;
 }
@@ -1,207 +0,0 @@
-import { SigningCosmWasmClient, SigningCosmWasmClientOptions } from "@cosmjs/cosmwasm-stargate";
-import {
-    Delegation,
-    GatewayOwnershipResponse,
-    MixOwnershipResponse, PagedGatewayDelegationsResponse,
-    PagedGatewayResponse, PagedMixDelegationsResponse,
-    PagedMixnodeResponse,
-    StateParams
-} from "./types";
-import { DirectSecp256k1HdWallet, EncodeObject } from "@cosmjs/proto-signing";
-import { Coin, StdFee } from "@cosmjs/stargate";
-import { BroadcastTxResponse } from "@cosmjs/stargate"
-import { nymGasLimits, nymGasPrice } from "./stargate-helper"
-import {
-    ExecuteResult,
-    InstantiateOptions,
-    InstantiateResult,
-    MigrateResult,
-    UploadMeta,
-    UploadResult
-} from "@cosmjs/cosmwasm-stargate";
-
-export interface INetClient {
-    clientAddress: string;
-
-    getBalance(address: string, denom: string): Promise<Coin | null>;
-
-    getMixNodes(contractAddress: string, limit: number, start_after?: string): Promise<PagedMixnodeResponse>;
-
-    getGateways(contractAddress: string, limit: number, start_after?: string): Promise<PagedGatewayResponse>;
-
-    getMixDelegations(contractAddress: string, mixIdentity: string, limit: number, start_after?: string): Promise<PagedMixDelegationsResponse>
-
-    getMixDelegation(contractAddress: string, mixIdentity: string, delegatorAddress: string): Promise<Delegation>
-
-    getGatewayDelegations(contractAddress: string, gatewayIdentity: string, limit: number, start_after?: string): Promise<PagedGatewayDelegationsResponse>
-
-    getGatewayDelegation(contractAddress: string, gatewayIdentity: string, delegatorAddress: string): Promise<Delegation>
-
-    ownsMixNode(contractAddress: string, address: string): Promise<MixOwnershipResponse>;
-
-    ownsGateway(contractAddress: string, address: string): Promise<GatewayOwnershipResponse>;
-
-    getStateParams(contractAddress: string): Promise<StateParams>;
-
-    signAndBroadcast(signerAddress: string, messages: readonly EncodeObject[], fee: StdFee, memo?: string): Promise<BroadcastTxResponse>;
-
-    executeContract(senderAddress: string, contractAddress: string, handleMsg: Record<string, unknown>, memo?: string, transferAmount?: readonly Coin[]): Promise<ExecuteResult>;
-
-    instantiate(senderAddress: string, codeId: number, initMsg: Record<string, unknown>, label: string, options?: InstantiateOptions): Promise<InstantiateResult>;
-
-    sendTokens(senderAddress: string, recipientAddress: string, transferAmount: readonly Coin[], memo?: string): Promise<BroadcastTxResponse>;
-
-    upload(senderAddress: string, wasmCode: Uint8Array, meta?: UploadMeta, memo?: string): Promise<UploadResult>;
-
-    changeValidator(newUrl: string): Promise<void>
-}
-
-/**
- * Takes care of network communication between this code and the validator.
- * Depends on `SigningCosmWasClient`, which signs all requests using keypairs
- * derived from on bech32 mnemonics.
- *
- * Wraps several methods from CosmWasmSigningClient so we can mock them for
- * unit testing.
- */
-export default class NetClient implements INetClient {
-    clientAddress: string;
-    private cosmClient: SigningCosmWasmClient;
-
-    // helpers for changing validators without having to remake the wallet
-    private readonly wallet: DirectSecp256k1HdWallet;
-    private readonly signerOptions: SigningCosmWasmClientOptions;
-
-    private constructor(clientAddress: string, cosmClient: SigningCosmWasmClient, wallet: DirectSecp256k1HdWallet, signerOptions: SigningCosmWasmClientOptions) {
-        this.clientAddress = clientAddress;
-        this.cosmClient = cosmClient;
-        this.wallet = wallet;
-        this.signerOptions = signerOptions;
-    }
-
-    public static async connect(wallet: DirectSecp256k1HdWallet, url: string, prefix: string): Promise<INetClient> {
-        const [{ address }] = await wallet.getAccounts();
-        const signerOptions: SigningCosmWasmClientOptions = {
-            gasPrice: nymGasPrice(prefix),
-            gasLimits: nymGasLimits,
-        };
-        const client = await SigningCosmWasmClient.connectWithSigner(url, wallet, signerOptions);
-        return new NetClient(address, client, wallet, signerOptions);
-    }
-
-    async changeValidator(url: string): Promise<void> {
-        this.cosmClient = await SigningCosmWasmClient.connectWithSigner(url, this.wallet, this.signerOptions);
-    }
-
-    public getMixNodes(contractAddress: string, limit: number, start_after?: string): Promise<PagedMixnodeResponse> {
-        if (start_after == undefined) { // TODO: check if we can take this out, I'm not sure what will happen if we send an "undefined" so I'm playing it safe here.
-            return this.cosmClient.queryContractSmart(contractAddress, { get_mix_nodes: { limit } });
-        } else {
-            return this.cosmClient.queryContractSmart(contractAddress, { get_mix_nodes: { limit, start_after } });
-        }
-    }
-
-    public getGateways(contractAddress: string, limit: number, start_after?: string): Promise<PagedGatewayResponse> {
-        if (start_after == undefined) { // TODO: check if we can take this out, I'm not sure what will happen if we send an "undefined" so I'm playing it safe here.
-            return this.cosmClient.queryContractSmart(contractAddress, { get_gateways: { limit } });
-        } else {
-            return this.cosmClient.queryContractSmart(contractAddress, { get_gateways: { limit, start_after } });
-        }
-    }
-
-    public getMixDelegations(contractAddress: string, mixIdentity: string, limit: number, start_after?: string): Promise<PagedMixDelegationsResponse> {
-        if (start_after == undefined) { // TODO: check if we can take this out, I'm not sure what will happen if we send an "undefined" so I'm playing it safe here.
-            return this.cosmClient.queryContractSmart(contractAddress, {
-                get_mix_delegations: {
-                    mix_identity: mixIdentity,
-                    limit
-                }
-            });
-        } else {
-            return this.cosmClient.queryContractSmart(contractAddress, {
-                get_mix_delegations: {
-                    mix_identity: mixIdentity,
-                    limit,
-                    start_after
-                }
-            });
-        }
-    }
-
-    public getMixDelegation(contractAddress: string, mixIdentity: string, delegatorAddress: string): Promise<Delegation> {
-        return this.cosmClient.queryContractSmart(contractAddress, {
-            get_mix_delegation: {
-                mix_identity: mixIdentity,
-                address: delegatorAddress
-            }
-        });
-    }
-
-    public getGatewayDelegations(contractAddress: string, gatewayIdentity: string, limit: number, start_after?: string): Promise<PagedGatewayDelegationsResponse> {
-        if (start_after == undefined) { // TODO: check if we can take this out, I'm not sure what will happen if we send an "undefined" so I'm playing it safe here.
-            return this.cosmClient.queryContractSmart(contractAddress, {
-                get_gateway_delegations: {
-                    gateway_identity: gatewayIdentity,
-                    limit
-                }
-            });
-        } else {
-            return this.cosmClient.queryContractSmart(contractAddress, {
-                get_gateway_delegations: {
-                    gateway_identity: gatewayIdentity,
-                    limit,
-                    start_after
-                }
-            });
-        }
-    }
-
-    public getGatewayDelegation(contractAddress: string, gatewayIdentity: string, delegatorAddress: string): Promise<Delegation> {
-        return this.cosmClient.queryContractSmart(contractAddress, {
-            get_gateway_delegation: {
-                gateway_identity: gatewayIdentity,
-                address: delegatorAddress
-            }
-        });
-    }
-
-    public ownsMixNode(contractAddress: string, address: string): Promise<MixOwnershipResponse> {
-        return this.cosmClient.queryContractSmart(contractAddress, { owns_mixnode: { address } });
-    }
-
-    public ownsGateway(contractAddress: string, address: string): Promise<GatewayOwnershipResponse> {
-        return this.cosmClient.queryContractSmart(contractAddress, { owns_gateway: { address } });
-    }
-
-    public getBalance(address: string, denom: string): Promise<Coin | null> {
-        return this.cosmClient.getBalance(address, denom);
-    }
-
-    public getStateParams(contractAddress: string): Promise<StateParams> {
-        return this.cosmClient.queryContractSmart(contractAddress, { contract_settings_params: {} });
-    }
-
-    public executeContract(senderAddress: string, contractAddress: string, handleMsg: Record<string, unknown>, memo?: string, transferAmount?: readonly Coin[]): Promise<ExecuteResult> {
-        return this.cosmClient.execute(senderAddress, contractAddress, handleMsg, memo, transferAmount);
-    }
-
-    public signAndBroadcast(signerAddress: string, messages: readonly EncodeObject[], fee: StdFee, memo?: string): Promise<BroadcastTxResponse> {
-        return this.cosmClient.signAndBroadcast(signerAddress, messages, fee, memo)
-    }
-
-    public sendTokens(senderAddress: string, recipientAddress: string, transferAmount: readonly Coin[], memo?: string): Promise<BroadcastTxResponse> {
-        return this.cosmClient.sendTokens(senderAddress, recipientAddress, transferAmount, memo);
-    }
-
-    public upload(senderAddress: string, wasmCode: Uint8Array, meta?: UploadMeta, memo?: string): Promise<UploadResult> {
-        return this.cosmClient.upload(senderAddress, wasmCode, meta, memo);
-    }
-
-    public instantiate(senderAddress: string, codeId: number, initMsg: Record<string, unknown>, label: string, options?: InstantiateOptions): Promise<InstantiateResult> {
-        return this.cosmClient.instantiate(senderAddress, codeId, initMsg, label, options);
-    }
-
-    public migrate(senderAddress: string, contractAddress: string, codeId: number, migrateMsg: Record<string, unknown>, memo?: string): Promise<MigrateResult> {
-        return this.cosmClient.migrate(senderAddress, contractAddress, codeId, migrateMsg, memo)
-    }
-}
@@ -0,0 +1,175 @@
+/*
+ * Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { JsonObject } from '@cosmjs/cosmwasm-stargate/build/queries';
+// eslint-disable-next-line import/no-cycle
+import { INymdQuery } from './query-client';
+import {
+  ContractStateParams,
+  Delegation,
+  GatewayOwnershipResponse,
+  LayerDistribution,
+  MixnetContractVersion,
+  MixOwnershipResponse,
+  PagedAllDelegationsResponse,
+  PagedDelegatorDelegationsResponse,
+  PagedGatewayResponse,
+  PagedMixDelegationsResponse,
+  PagedMixnodeResponse,
+  RewardingStatus,
+} from './types';
+
+interface SmartContractQuery {
+  queryContractSmart(address: string, queryMsg: Record<string, unknown>): Promise<JsonObject>;
+}
+
+export default class NymdQuerier implements INymdQuery {
+  client: SmartContractQuery;
+
+  constructor(client: SmartContractQuery) {
+    this.client = client;
+  }
+
+  getContractVersion(mixnetContractAddress: string): Promise<MixnetContractVersion> {
+    return this.client.queryContractSmart(mixnetContractAddress, {
+      get_contract_version: {},
+    });
+  }
+
+  getMixNodesPaged(mixnetContractAddress: string, limit?: number, startAfter?: string): Promise<PagedMixnodeResponse> {
+    return this.client.queryContractSmart(mixnetContractAddress, {
+      get_mix_nodes: {
+        limit,
+        start_after: startAfter,
+      },
+    });
+  }
+
+  getGatewaysPaged(mixnetContractAddress: string, limit?: number, startAfter?: string): Promise<PagedGatewayResponse> {
+    return this.client.queryContractSmart(mixnetContractAddress, {
+      get_gateways: {
+        limit,
+        start_after: startAfter,
+      },
+    });
+  }
+
+  ownsMixNode(mixnetContractAddress: string, address: string): Promise<MixOwnershipResponse> {
+    return this.client.queryContractSmart(mixnetContractAddress, {
+      owns_mixnode: {
+        address,
+      },
+    });
+  }
+
+  ownsGateway(mixnetContractAddress: string, address: string): Promise<GatewayOwnershipResponse> {
+    return this.client.queryContractSmart(mixnetContractAddress, {
+      owns_gateway: {
+        address,
+      },
+    });
+  }
+
+  getStateParams(mixnetContractAddress: string): Promise<ContractStateParams> {
+    return this.client.queryContractSmart(mixnetContractAddress, {
+      state_params: {},
+    });
+  }
+
+  getAllNetworkDelegationsPaged(
+    mixnetContractAddress: string,
+    limit?: number,
+    startAfter?: [string, string],
+  ): Promise<PagedAllDelegationsResponse> {
+    return this.client.queryContractSmart(mixnetContractAddress, {
+      get_all_network_delegations: {
+        start_after: startAfter,
+        limit,
+      },
+    });
+  }
+
+  getMixNodeDelegationsPaged(
+    mixnetContractAddress: string,
+    mixIdentity: string,
+    limit?: number,
+    startAfter?: string,
+  ): Promise<PagedMixDelegationsResponse> {
+    return this.client.queryContractSmart(mixnetContractAddress, {
+      get_mixnode_delegations: {
+        mix_identity: mixIdentity,
+        start_after: startAfter,
+        limit,
+      },
+    });
+  }
+
+  getDelegatorDelegationsPaged(
+    mixnetContractAddress: string,
+    delegator: string,
+    limit?: number,
+    startAfter?: string,
+  ): Promise<PagedDelegatorDelegationsResponse> {
+    return this.client.queryContractSmart(mixnetContractAddress, {
+      get_delegator_delegations: {
+        delegator,
+        start_after: startAfter,
+        limit,
+      },
+    });
+  }
+
+  getDelegationDetails(mixnetContractAddress: string, mixIdentity: string, delegator: string): Promise<Delegation> {
+    return this.client.queryContractSmart(mixnetContractAddress, {
+      get_delegation_details: {
+        mix_identity: mixIdentity,
+        delegator,
+      },
+    });
+  }
+
+  getLayerDistribution(mixnetContractAddress: string): Promise<LayerDistribution> {
+    return this.client.queryContractSmart(mixnetContractAddress, {
+      layer_distribution: {},
+    });
+  }
+
+  getRewardPool(mixnetContractAddress: string): Promise<string> {
+    return this.client.queryContractSmart(mixnetContractAddress, {
+      get_reward_pool: {},
+    });
+  }
+
+  getCirculatingSupply(mixnetContractAddress: string): Promise<string> {
+    return this.client.queryContractSmart(mixnetContractAddress, {
+      get_circulating_supply: {},
+    });
+  }
+
+  getIntervalRewardPercent(mixnetContractAddress: string): Promise<number> {
+    return this.client.queryContractSmart(mixnetContractAddress, {
+      get_interval_reward_percent: {},
+    });
+  }
+
+  getSybilResistancePercent(mixnetContractAddress: string): Promise<number> {
+    return this.client.queryContractSmart(mixnetContractAddress, {
+      get_sybil_resistance_percent: {},
+    });
+  }
+
+  getRewardingStatus(
+    mixnetContractAddress: string,
+    mixIdentity: string,
+    rewardingIntervalNonce: number,
+  ): Promise<RewardingStatus> {
+    return this.client.queryContractSmart(mixnetContractAddress, {
+      get_rewarding_status: {
+        mix_identity: mixIdentity,
+        rewarding_interval_nonce: rewardingIntervalNonce,
+      },
+    });
+  }
+}
@@ -1,147 +1,212 @@
-import { Coin } from "@cosmjs/stargate";
-import { CosmWasmClient } from "@cosmjs/cosmwasm-stargate";
+import { CosmWasmClient } from '@cosmjs/cosmwasm-stargate';
+import { Tendermint34Client } from '@cosmjs/tendermint-rpc';
 import {
-    Delegation,
-    GatewayOwnershipResponse,
-    MixOwnershipResponse, PagedGatewayDelegationsResponse,
-    PagedGatewayResponse, PagedMixDelegationsResponse,
-    PagedMixnodeResponse,
-    ContractSettingsParams
-} from "./types";
+  Account,
+  Block,
+  Coin,
+  DeliverTxResponse,
+  IndexedTx,
+  SearchTxFilter,
+  SearchTxQuery,
+  SequenceResponse,
+} from '@cosmjs/stargate';
+import { JsonObject } from '@cosmjs/cosmwasm-stargate/build/queries';
+import { Code, CodeDetails, Contract, ContractCodeHistoryEntry } from '@cosmjs/cosmwasm-stargate/build/cosmwasmclient';
+// eslint-disable-next-line import/no-cycle
+import NymdQuerier from './nymd-querier';
+import {
+  ContractStateParams,
+  Delegation,
+  GatewayBond,
+  GatewayOwnershipResponse,
+  LayerDistribution,
+  MixnetContractVersion,
+  MixNodeBond,
+  MixOwnershipResponse,
+  PagedAllDelegationsResponse,
+  PagedDelegatorDelegationsResponse,
+  PagedGatewayResponse,
+  PagedMixDelegationsResponse,
+  PagedMixnodeResponse,
+  RewardingStatus,
+} from './types';
+import ValidatorApiQuerier, { IValidatorApiQuery } from './validator-api-querier';

-export interface IQueryClient {
-    getBalance(address: string, stakeDenom: string): Promise<Coin | null>;
-
-    getMixNodes(contractAddress: string, limit: number, start_after?: string): Promise<PagedMixnodeResponse>;
-
-    getGateways(contractAddress: string, limit: number, start_after?: string): Promise<PagedGatewayResponse>;
-
-    getMixDelegations(contractAddress: string, mixIdentity: string, limit: number, start_after?: string): Promise<PagedMixDelegationsResponse>
-
-    getMixDelegation(contractAddress: string, mixIdentity: string, delegatorAddress: string): Promise<Delegation>
-
-    getGatewayDelegations(contractAddress: string, gatewayIdentity: string, limit: number, start_after?: string): Promise<PagedGatewayDelegationsResponse>
-
-    getGatewayDelegation(contractAddress: string, gatewayIdentity: string, delegatorAddress: string): Promise<Delegation>
-
-    ownsMixNode(contractAddress: string, address: string): Promise<MixOwnershipResponse>;
-
-    ownsGateway(contractAddress: string, address: string): Promise<GatewayOwnershipResponse>;
-
-    getStateParams(contractAddress: string): Promise<ContractSettingsParams>;
-
-    changeValidator(newUrl: string): Promise<void>
+export interface ICosmWasmQuery {
+  // methods exposed by `CosmWasmClient`
+  getChainId(): Promise<string>;
+  getHeight(): Promise<number>;
+  getAccount(searchAddress: string): Promise<Account | null>;
+  getSequence(address: string): Promise<SequenceResponse>;
+  getBlock(height?: number): Promise<Block>;
+  getBalance(address: string, searchDenom: string): Promise<Coin>;
+  getTx(id: string): Promise<IndexedTx | null>;
+  searchTx(query: SearchTxQuery, filter?: SearchTxFilter): Promise<readonly IndexedTx[]>;
+  disconnect(): void;
+  broadcastTx(tx: Uint8Array, timeoutMs?: number, pollIntervalMs?: number): Promise<DeliverTxResponse>;
+  getCodes(): Promise<readonly Code[]>;
+  getCodeDetails(codeId: number): Promise<CodeDetails>;
+  getContracts(codeId: number): Promise<readonly string[]>;
+  getContract(address: string): Promise<Contract>;
+  getContractCodeHistory(address: string): Promise<readonly ContractCodeHistoryEntry[]>;
+  queryContractRaw(address: string, key: Uint8Array): Promise<Uint8Array | null>;
+  queryContractSmart(address: string, queryMsg: Record<string, unknown>): Promise<JsonObject>;
 }

-/**
- * Takes care of network communication between this code and the validator.
- * Depends on `SigningCosmWasClient`, which signs all requests using keypairs
- * derived from on bech32 mnemonics.
- *
- * Wraps several methods from CosmWasmSigningClient so we can mock them for
- * unit testing.
- */
-export default class QueryClient implements IQueryClient {
-    private cosmClient: CosmWasmClient;
+export interface INymdQuery {
+  // nym-specific implemented inside NymQuerier
+  getContractVersion(mixnetContractAddress: string): Promise<MixnetContractVersion>;

-    private constructor(cosmClient: CosmWasmClient) {
-        this.cosmClient = cosmClient;
-    }
+  getMixNodesPaged(mixnetContractAddress: string, limit?: number, startAfter?: string): Promise<PagedMixnodeResponse>;
+  getGatewaysPaged(mixnetContractAddress: string, limit?: number, startAfter?: string): Promise<PagedGatewayResponse>;
+  ownsMixNode(mixnetContractAddress: string, address: string): Promise<MixOwnershipResponse>;
+  ownsGateway(mixnetContractAddress: string, address: string): Promise<GatewayOwnershipResponse>;
+  getStateParams(mixnetContractAddress: string): Promise<ContractStateParams>;

-    public static async connect(url: string): Promise<IQueryClient> {
-        const client = await CosmWasmClient.connect(url)
-        return new QueryClient(client)
-    }
+  getAllNetworkDelegationsPaged(
+    mixnetContractAddress: string,
+    limit?: number,
+    startAfter?: [string, string],
+  ): Promise<PagedAllDelegationsResponse>;
+  getMixNodeDelegationsPaged(
+    mixnetContractAddress: string,
+    mixIdentity: string,
+    limit?: number,
+    startAfter?: string,
+  ): Promise<PagedMixDelegationsResponse>;
+  getDelegatorDelegationsPaged(
+    mixnetContractAddress: string,
+    delegator: string,
+    limit?: number,
+    startAfter?: string,
+  ): Promise<PagedDelegatorDelegationsResponse>;
+  getDelegationDetails(mixnetContractAddress: string, mixIdentity: string, delegator: string): Promise<Delegation>;

-    async changeValidator(url: string): Promise<void> {
-        this.cosmClient = await CosmWasmClient.connect(url)
-    }
-
-    public getMixNodes(contractAddress: string, limit: number, start_after?: string): Promise<PagedMixnodeResponse> {
-        if (start_after == undefined) { // TODO: check if we can take this out, I'm not sure what will happen if we send an "undefined" so I'm playing it safe here.
-            return this.cosmClient.queryContractSmart(contractAddress, { get_mix_nodes: { limit } });
-        } else {
-            return this.cosmClient.queryContractSmart(contractAddress, { get_mix_nodes: { limit, start_after } });
-        }
-    }
-
-    public getGateways(contractAddress: string, limit: number, start_after?: string): Promise<PagedGatewayResponse> {
-        if (start_after == undefined) { // TODO: check if we can take this out, I'm not sure what will happen if we send an "undefined" so I'm playing it safe here.
-            return this.cosmClient.queryContractSmart(contractAddress, { get_gateways: { limit } });
-        } else {
-            return this.cosmClient.queryContractSmart(contractAddress, { get_gateways: { limit, start_after } });
-        }
-    }
-
-    public getMixDelegations(contractAddress: string, mixIdentity: string, limit: number, start_after?: string): Promise<PagedMixDelegationsResponse> {
-        if (start_after == undefined) { // TODO: check if we can take this out, I'm not sure what will happen if we send an "undefined" so I'm playing it safe here.
-            return this.cosmClient.queryContractSmart(contractAddress, {
-                get_mix_delegations: {
-                    mix_identity: mixIdentity,
-                    limit
-                }
-            });
-        } else {
-            return this.cosmClient.queryContractSmart(contractAddress, {
-                get_mix_delegations: {
-                    mix_identity: mixIdentity,
-                    limit,
-                    start_after
-                }
-            });
-        }
-    }
-
-    public getMixDelegation(contractAddress: string, mixIdentity: string, delegatorAddress: string): Promise<Delegation> {
-        return this.cosmClient.queryContractSmart(contractAddress, {
-            get_mix_delegation: {
-                mix_identity: mixIdentity,
-                address: delegatorAddress
-            }
-        });
-    }
-
-    public getGatewayDelegations(contractAddress: string, gatewayIdentity: string, limit: number, start_after?: string): Promise<PagedGatewayDelegationsResponse> {
-        if (start_after == undefined) { // TODO: check if we can take this out, I'm not sure what will happen if we send an "undefined" so I'm playing it safe here.
-            return this.cosmClient.queryContractSmart(contractAddress, {
-                get_gateway_delegations: {
-                    gateway_identity: gatewayIdentity,
-                    limit
-                }
-            });
-        } else {
-            return this.cosmClient.queryContractSmart(contractAddress, {
-                get_gateway_delegations: {
-                    gateway_identity: gatewayIdentity,
-                    limit,
-                    start_after
-                }
-            });
-        }
-    }
-
-    public getGatewayDelegation(contractAddress: string, gatewayIdentity: string, delegatorAddress: string): Promise<Delegation> {
-        return this.cosmClient.queryContractSmart(contractAddress, {
-            get_gateway_delegation: {
-                gateway_identity: gatewayIdentity,
-                address: delegatorAddress
-            }
-        });
-    }
-
-    public ownsMixNode(contractAddress: string, address: string): Promise<MixOwnershipResponse> {
-        return this.cosmClient.queryContractSmart(contractAddress, { owns_mixnode: { address } });
-    }
-
-    public ownsGateway(contractAddress: string, address: string): Promise<GatewayOwnershipResponse> {
-        return this.cosmClient.queryContractSmart(contractAddress, { owns_gateway: { address } });
-    }
-
-    public getBalance(address: string, stakeDenom: string): Promise<Coin | null> {
-        return this.cosmClient.getBalance(address, stakeDenom);
-    }
-
-    public getStateParams(contractAddress: string): Promise<ContractSettingsParams> {
-        return this.cosmClient.queryContractSmart(contractAddress, { contract_settings_params: {} });
-    }
+  getLayerDistribution(mixnetContractAddress: string): Promise<LayerDistribution>;
+  getRewardPool(mixnetContractAddress: string): Promise<string>;
+  getCirculatingSupply(mixnetContractAddress: string): Promise<string>;
+  getIntervalRewardPercent(mixnetContractAddress: string): Promise<number>;
+  getSybilResistancePercent(mixnetContractAddress: string): Promise<number>;
+  getRewardingStatus(
+    mixnetContractAddress: string,
+    mixIdentity: string,
+    rewardingIntervalNonce: number,
+  ): Promise<RewardingStatus>;
+}
+
+export interface IQueryClient extends ICosmWasmQuery, INymdQuery, IValidatorApiQuery {}
+
+export default class QueryClient extends CosmWasmClient implements IQueryClient {
+  private nymdQuerier: NymdQuerier;
+
+  private validatorApiQuerier: ValidatorApiQuerier;
+
+  private constructor(tmClient: Tendermint34Client, validatorApiUrl: string) {
+    super(tmClient);
+    this.nymdQuerier = new NymdQuerier(this);
+    this.validatorApiQuerier = new ValidatorApiQuerier(validatorApiUrl);
+  }
+
+  public static async connectWithNym(nymdUrl: string, validatorApiUrl: string): Promise<QueryClient> {
+    const tmClient = await Tendermint34Client.connect(nymdUrl);
+    return new QueryClient(tmClient, validatorApiUrl);
+  }
+
+  getContractVersion(mixnetContractAddress: string): Promise<MixnetContractVersion> {
+    return this.nymdQuerier.getContractVersion(mixnetContractAddress);
+  }
+
+  getMixNodesPaged(mixnetContractAddress: string, limit?: number, startAfter?: string): Promise<PagedMixnodeResponse> {
+    return this.nymdQuerier.getMixNodesPaged(mixnetContractAddress, limit, startAfter);
+  }
+
+  getGatewaysPaged(mixnetContractAddress: string, limit?: number, startAfter?: string): Promise<PagedGatewayResponse> {
+    return this.nymdQuerier.getGatewaysPaged(mixnetContractAddress, limit, startAfter);
+  }
+
+  ownsMixNode(mixnetContractAddress: string, address: string): Promise<MixOwnershipResponse> {
+    return this.nymdQuerier.ownsMixNode(mixnetContractAddress, address);
+  }
+
+  ownsGateway(mixnetContractAddress: string, address: string): Promise<GatewayOwnershipResponse> {
+    return this.nymdQuerier.ownsGateway(mixnetContractAddress, address);
+  }
+
+  getStateParams(mixnetContractAddress: string): Promise<ContractStateParams> {
+    return this.nymdQuerier.getStateParams(mixnetContractAddress);
+  }
+
+  getAllNetworkDelegationsPaged(
+    mixnetContractAddress: string,
+    limit?: number,
+    startAfter?: [string, string],
+  ): Promise<PagedAllDelegationsResponse> {
+    return this.nymdQuerier.getAllNetworkDelegationsPaged(mixnetContractAddress, limit, startAfter);
+  }
+
+  getMixNodeDelegationsPaged(
+    mixnetContractAddress: string,
+    mixIdentity: string,
+    limit?: number,
+    startAfter?: string,
+  ): Promise<PagedMixDelegationsResponse> {
+    return this.nymdQuerier.getMixNodeDelegationsPaged(mixnetContractAddress, mixIdentity, limit, startAfter);
+  }
+
+  getDelegatorDelegationsPaged(
+    mixnetContractAddress: string,
+    delegator: string,
+    limit?: number,
+    startAfter?: string,
+  ): Promise<PagedDelegatorDelegationsResponse> {
+    return this.nymdQuerier.getDelegatorDelegationsPaged(mixnetContractAddress, delegator, limit, startAfter);
+  }
+
+  getDelegationDetails(mixnetContractAddress: string, mixIdentity: string, delegator: string): Promise<Delegation> {
+    return this.nymdQuerier.getDelegationDetails(mixnetContractAddress, mixIdentity, delegator);
+  }
+
+  getLayerDistribution(mixnetContractAddress: string): Promise<LayerDistribution> {
+    return this.nymdQuerier.getLayerDistribution(mixnetContractAddress);
+  }
+
+  getRewardPool(mixnetContractAddress: string): Promise<string> {
+    return this.nymdQuerier.getRewardPool(mixnetContractAddress);
+  }
+
+  getCirculatingSupply(mixnetContractAddress: string): Promise<string> {
+    return this.nymdQuerier.getCirculatingSupply(mixnetContractAddress);
+  }
+
+  getIntervalRewardPercent(mixnetContractAddress: string): Promise<number> {
+    return this.nymdQuerier.getIntervalRewardPercent(mixnetContractAddress);
+  }
+
+  getSybilResistancePercent(mixnetContractAddress: string): Promise<number> {
+    return this.nymdQuerier.getSybilResistancePercent(mixnetContractAddress);
+  }
+
+  getRewardingStatus(
+    mixnetContractAddress: string,
+    mixIdentity: string,
+    rewardingIntervalNonce: number,
+  ): Promise<RewardingStatus> {
+    return this.nymdQuerier.getRewardingStatus(mixnetContractAddress, mixIdentity, rewardingIntervalNonce);
+  }
+
+  getCachedGateways(): Promise<GatewayBond[]> {
+    return this.validatorApiQuerier.getCachedGateways();
+  }
+
+  getCachedMixnodes(): Promise<MixNodeBond[]> {
+    return this.validatorApiQuerier.getCachedMixnodes();
+  }
+
+  getActiveMixnodes(): Promise<MixNodeBond[]> {
+    return this.validatorApiQuerier.getActiveMixnodes();
+  }
+
+  getRewardedMixnodes(): Promise<MixNodeBond[]> {
+    return this.validatorApiQuerier.getRewardedMixnodes();
+  }
 }
@@ -0,0 +1,483 @@
+import {
+  ExecuteResult,
+  InstantiateOptions,
+  InstantiateResult,
+  MigrateResult,
+  SigningCosmWasmClient,
+  SigningCosmWasmClientOptions,
+  UploadResult,
+} from '@cosmjs/cosmwasm-stargate';
+import { DirectSecp256k1HdWallet, EncodeObject } from '@cosmjs/proto-signing';
+import { Coin, DeliverTxResponse, SignerData, StdFee } from '@cosmjs/stargate';
+import { Tendermint34Client } from '@cosmjs/tendermint-rpc';
+import { ChangeAdminResult } from '@cosmjs/cosmwasm-stargate/build/signingcosmwasmclient';
+import { TxRaw } from 'cosmjs-types/cosmos/tx/v1beta1/tx';
+import { nymGasPrice } from './stargate-helper';
+import { IQueryClient } from './query-client';
+import NymdQuerier from './nymd-querier';
+import {
+  ContractStateParams,
+  Delegation,
+  Gateway,
+  GatewayBond,
+  GatewayOwnershipResponse,
+  LayerDistribution,
+  MixnetContractVersion,
+  MixNode,
+  MixNodeBond,
+  MixOwnershipResponse,
+  PagedAllDelegationsResponse,
+  PagedDelegatorDelegationsResponse,
+  PagedGatewayResponse,
+  PagedMixDelegationsResponse,
+  PagedMixnodeResponse,
+  RewardingStatus,
+} from './types';
+import ValidatorApiQuerier from './validator-api-querier';
+
+// methods exposed by `SigningCosmWasmClient`
+export interface ICosmWasmSigning {
+  simulate(signerAddress: string, messages: readonly EncodeObject[], memo: string | undefined): Promise<number>;
+
+  upload(
+    senderAddress: string,
+    wasmCode: Uint8Array,
+    fee: StdFee | 'auto' | number,
+    memo?: string,
+  ): Promise<UploadResult>;
+
+  instantiate(
+    senderAddress: string,
+    codeId: number,
+    msg: Record<string, unknown>,
+    label: string,
+    fee: StdFee | 'auto' | number,
+    options?: InstantiateOptions,
+  ): Promise<InstantiateResult>;
+
+  updateAdmin(
+    senderAddress: string,
+    contractAddress: string,
+    newAdmin: string,
+    fee: StdFee | 'auto' | number,
+    memo?: string,
+  ): Promise<ChangeAdminResult>;
+
+  clearAdmin(
+    senderAddress: string,
+    contractAddress: string,
+    fee: StdFee | 'auto' | number,
+    memo?: string,
+  ): Promise<ChangeAdminResult>;
+
+  migrate(
+    senderAddress: string,
+    contractAddress: string,
+    codeId: number,
+    migrateMsg: Record<string, unknown>,
+    fee: StdFee | 'auto' | number,
+    memo?: string,
+  ): Promise<MigrateResult>;
+
+  execute(
+    senderAddress: string,
+    contractAddress: string,
+    msg: Record<string, unknown>,
+    fee: StdFee | 'auto' | number,
+    memo?: string,
+    funds?: readonly Coin[],
+  ): Promise<ExecuteResult>;
+
+  sendTokens(
+    senderAddress: string,
+    recipientAddress: string,
+    amount: readonly Coin[],
+    fee: StdFee | 'auto' | number,
+    memo?: string,
+  ): Promise<DeliverTxResponse>;
+
+  delegateTokens(
+    delegatorAddress: string,
+    validatorAddress: string,
+    amount: Coin,
+    fee: StdFee | 'auto' | number,
+    memo?: string,
+  ): Promise<DeliverTxResponse>;
+
+  undelegateTokens(
+    delegatorAddress: string,
+    validatorAddress: string,
+    amount: Coin,
+    fee: StdFee | 'auto' | number,
+    memo?: string,
+  ): Promise<DeliverTxResponse>;
+
+  withdrawRewards(
+    delegatorAddress: string,
+    validatorAddress: string,
+    fee: StdFee | 'auto' | number,
+    memo?: string,
+  ): Promise<DeliverTxResponse>;
+
+  signAndBroadcast(
+    signerAddress: string,
+    messages: readonly EncodeObject[],
+    fee: StdFee | 'auto' | number,
+    memo?: string,
+  ): Promise<DeliverTxResponse>;
+
+  sign(
+    signerAddress: string,
+    messages: readonly EncodeObject[],
+    fee: StdFee,
+    memo: string,
+    explicitSignerData?: SignerData,
+  ): Promise<TxRaw>;
+}
+
+export interface INymSigning {
+  clientAddress: string;
+}
+
+export interface ISigningClient extends IQueryClient, ICosmWasmSigning, INymSigning {
+  bondMixNode(
+    mixnetContractAddress: string,
+    mixNode: MixNode,
+    ownerSignature: string,
+    pledge: Coin,
+    fee?: StdFee | 'auto' | number,
+    memo?: string,
+  ): Promise<ExecuteResult>;
+
+  unbondMixNode(mixnetContractAddress: string, fee?: StdFee | 'auto' | number, memo?: string): Promise<ExecuteResult>;
+
+  bondGateway(
+    mixnetContractAddress: string,
+    gateway: Gateway,
+    ownerSignature: string,
+    pledge: Coin,
+    fee?: StdFee | 'auto' | number,
+    memo?: string,
+  ): Promise<ExecuteResult>;
+
+  unbondGateway(mixnetContractAddress: string, fee?: StdFee | 'auto' | number, memo?: string): Promise<ExecuteResult>;
+
+  delegateToMixNode(
+    mixnetContractAddress: string,
+    mixIdentity: string,
+    amount: Coin,
+    fee?: StdFee | 'auto' | number,
+    memo?: string,
+  ): Promise<ExecuteResult>;
+
+  undelegateFromMixNode(
+    mixnetContractAddress: string,
+    mixIdentity: string,
+    fee?: StdFee | 'auto' | number,
+    memo?: string,
+  ): Promise<ExecuteResult>;
+
+  updateMixnodeConfig(
+    mixnetContractAddress: string,
+    mixIdentity: string,
+    profitMarginPercent: number,
+    fee: StdFee | 'auto' | number,
+  ): Promise<ExecuteResult>;
+
+  updateContractStateParams(
+    mixnetContractAddress: string,
+    newParams: ContractStateParams,
+    fee?: StdFee | 'auto' | number,
+    memo?: string,
+  ): Promise<ExecuteResult>;
+
+  // I don't see any point in exposing rewarding / vesting-related (INSIDE mixnet contract, like "BondMixnodeOnBehalf")
+  // functionalities in our typescript client. However, if for some reason, we find we need them
+  // they're rather trivial to add.
+}
+
+export default class SigningClient extends SigningCosmWasmClient implements ISigningClient {
+  private nymdQuerier: NymdQuerier;
+
+  private validatorApiQuerier: ValidatorApiQuerier;
+
+  clientAddress: string;
+
+  private constructor(
+    clientAddress: string,
+    validatorApiUrl: string,
+    tmClient: Tendermint34Client,
+    wallet: DirectSecp256k1HdWallet,
+    signerOptions: SigningCosmWasmClientOptions,
+  ) {
+    super(tmClient, wallet, signerOptions);
+    this.clientAddress = clientAddress;
+    this.nymdQuerier = new NymdQuerier(this);
+    this.validatorApiQuerier = new ValidatorApiQuerier(validatorApiUrl);
+  }
+
+  public static async connectWithNymSigner(
+    wallet: DirectSecp256k1HdWallet,
+    nymdUrl: string,
+    validatorApiUrl: string,
+    prefix: string,
+  ): Promise<SigningClient> {
+    const [{ address }] = await wallet.getAccounts();
+    const signerOptions: SigningCosmWasmClientOptions = {
+      gasPrice: nymGasPrice(prefix),
+    };
+    const tmClient = await Tendermint34Client.connect(nymdUrl);
+    return new SigningClient(address, validatorApiUrl, tmClient, wallet, signerOptions);
+  }
+
+  // query related:
+
+  getContractVersion(mixnetContractAddress: string): Promise<MixnetContractVersion> {
+    return this.nymdQuerier.getContractVersion(mixnetContractAddress);
+  }
+
+  getMixNodesPaged(mixnetContractAddress: string, limit?: number, startAfter?: string): Promise<PagedMixnodeResponse> {
+    return this.nymdQuerier.getMixNodesPaged(mixnetContractAddress, limit, startAfter);
+  }
+
+  getGatewaysPaged(mixnetContractAddress: string, limit?: number, startAfter?: string): Promise<PagedGatewayResponse> {
+    return this.nymdQuerier.getGatewaysPaged(mixnetContractAddress, limit, startAfter);
+  }
+
+  ownsMixNode(mixnetContractAddress: string, address: string): Promise<MixOwnershipResponse> {
+    return this.nymdQuerier.ownsMixNode(mixnetContractAddress, address);
+  }
+
+  ownsGateway(mixnetContractAddress: string, address: string): Promise<GatewayOwnershipResponse> {
+    return this.nymdQuerier.ownsGateway(mixnetContractAddress, address);
+  }
+
+  getStateParams(mixnetContractAddress: string): Promise<ContractStateParams> {
+    return this.nymdQuerier.getStateParams(mixnetContractAddress);
+  }
+
+  getAllNetworkDelegationsPaged(
+    mixnetContractAddress: string,
+    limit?: number,
+    startAfter?: [string, string],
+  ): Promise<PagedAllDelegationsResponse> {
+    return this.nymdQuerier.getAllNetworkDelegationsPaged(mixnetContractAddress, limit, startAfter);
+  }
+
+  getMixNodeDelegationsPaged(
+    mixnetContractAddress: string,
+    mixIdentity: string,
+    limit?: number,
+    startAfter?: string,
+  ): Promise<PagedMixDelegationsResponse> {
+    return this.nymdQuerier.getMixNodeDelegationsPaged(mixnetContractAddress, mixIdentity, limit, startAfter);
+  }
+
+  getDelegatorDelegationsPaged(
+    mixnetContractAddress: string,
+    delegator: string,
+    limit?: number,
+    startAfter?: string,
+  ): Promise<PagedDelegatorDelegationsResponse> {
+    return this.nymdQuerier.getDelegatorDelegationsPaged(mixnetContractAddress, delegator, limit, startAfter);
+  }
+
+  getDelegationDetails(mixnetContractAddress: string, mixIdentity: string, delegator: string): Promise<Delegation> {
+    return this.nymdQuerier.getDelegationDetails(mixnetContractAddress, mixIdentity, delegator);
+  }
+
+  getLayerDistribution(mixnetContractAddress: string): Promise<LayerDistribution> {
+    return this.nymdQuerier.getLayerDistribution(mixnetContractAddress);
+  }
+
+  getRewardPool(mixnetContractAddress: string): Promise<string> {
+    return this.nymdQuerier.getRewardPool(mixnetContractAddress);
+  }
+
+  getCirculatingSupply(mixnetContractAddress: string): Promise<string> {
+    return this.nymdQuerier.getCirculatingSupply(mixnetContractAddress);
+  }
+
+  getIntervalRewardPercent(mixnetContractAddress: string): Promise<number> {
+    return this.nymdQuerier.getIntervalRewardPercent(mixnetContractAddress);
+  }
+
+  getSybilResistancePercent(mixnetContractAddress: string): Promise<number> {
+    return this.nymdQuerier.getSybilResistancePercent(mixnetContractAddress);
+  }
+
+  getRewardingStatus(
+    mixnetContractAddress: string,
+    mixIdentity: string,
+    rewardingIntervalNonce: number,
+  ): Promise<RewardingStatus> {
+    return this.nymdQuerier.getRewardingStatus(mixnetContractAddress, mixIdentity, rewardingIntervalNonce);
+  }
+
+  getCachedGateways(): Promise<GatewayBond[]> {
+    return this.validatorApiQuerier.getCachedGateways();
+  }
+
+  getCachedMixnodes(): Promise<MixNodeBond[]> {
+    return this.validatorApiQuerier.getCachedMixnodes();
+  }
+
+  getActiveMixnodes(): Promise<MixNodeBond[]> {
+    return this.validatorApiQuerier.getActiveMixnodes();
+  }
+
+  getRewardedMixnodes(): Promise<MixNodeBond[]> {
+    return this.validatorApiQuerier.getRewardedMixnodes();
+  }
+
+  // signing related:
+
+  bondMixNode(
+    mixnetContractAddress: string,
+    mixNode: MixNode,
+    ownerSignature: string,
+    pledge: Coin,
+    fee: StdFee | 'auto' | number = 'auto',
+    memo = 'Default MixNode Bonding from Typescript',
+  ): Promise<ExecuteResult> {
+    return this.execute(
+      this.clientAddress,
+      mixnetContractAddress,
+      {
+        bond_mixnode: {
+          mix_node: mixNode,
+          owner_signature: ownerSignature,
+        },
+      },
+      fee,
+      memo,
+      [pledge],
+    );
+  }
+
+  unbondMixNode(
+    mixnetContractAddress: string,
+    fee: StdFee | 'auto' | number = 'auto',
+    memo = 'Default MixNode Unbonding from Typescript',
+  ): Promise<ExecuteResult> {
+    return this.execute(
+      this.clientAddress,
+      mixnetContractAddress,
+      {
+        unbond_mixnode: {},
+      },
+      fee,
+      memo,
+    );
+  }
+
+  bondGateway(
+    mixnetContractAddress: string,
+    gateway: Gateway,
+    ownerSignature: string,
+    pledge: Coin,
+    fee: StdFee | 'auto' | number = 'auto',
+    memo = 'Default Gateway Bonding from Typescript',
+  ): Promise<ExecuteResult> {
+    return this.execute(
+      this.clientAddress,
+      mixnetContractAddress,
+      {
+        bond_gateway: {
+          gateway,
+          owner_signature: ownerSignature,
+        },
+      },
+      fee,
+      memo,
+      [pledge],
+    );
+  }
+
+  unbondGateway(
+    mixnetContractAddress: string,
+    fee: StdFee | 'auto' | number = 'auto',
+    memo = 'Default Gateway Unbonding from Typescript',
+  ): Promise<ExecuteResult> {
+    return this.execute(
+      this.clientAddress,
+      mixnetContractAddress,
+      {
+        unbond_gateway: {},
+      },
+      fee,
+      memo,
+    );
+  }
+
+  delegateToMixNode(
+    mixnetContractAddress: string,
+    mixIdentity: string,
+    amount: Coin,
+    fee: StdFee | 'auto' | number = 'auto',
+    memo = 'Default MixNode Delegation from Typescript',
+  ): Promise<ExecuteResult> {
+    return this.execute(
+      this.clientAddress,
+      mixnetContractAddress,
+      {
+        delegate_to_mixnode: {
+          mix_identity: mixIdentity,
+        },
+      },
+      fee,
+      memo,
+      [amount],
+    );
+  }
+
+  undelegateFromMixNode(
+    mixnetContractAddress: string,
+    mixIdentity: string,
+    fee: StdFee | 'auto' | number = 'auto',
+    memo = 'Default MixNode Undelegation from Typescript',
+  ): Promise<ExecuteResult> {
+    return this.execute(
+      this.clientAddress,
+      mixnetContractAddress,
+      {
+        undelegate_from_mixnode: {
+          mix_identity: mixIdentity,
+        },
+      },
+      fee,
+      memo,
+    );
+  }
+
+  updateMixnodeConfig(
+    mixnetContractAddress: string,
+    mixIdentity: string,
+    profitMarginPercent: number,
+    fee: StdFee | 'auto' | number,
+  ): Promise<ExecuteResult> {
+    return this.execute(
+      this.clientAddress,
+      mixnetContractAddress,
+      { update_mixnode_config: { profit_margin_percent: profitMarginPercent, mix_identity: mixIdentity } },
+      fee,
+    );
+  }
+
+  updateContractStateParams(
+    mixnetContractAddress: string,
+    newParams: ContractStateParams,
+    fee: StdFee | 'auto' | number = 'auto',
+    memo = 'Default Contract State Params Update from Typescript',
+  ): Promise<ExecuteResult> {
+    return this.execute(
+      this.clientAddress,
+      mixnetContractAddress,
+      {
+        update_contract_state_params: newParams,
+      },
+      fee,
+      memo,
+    );
+  }
+}
@@ -1,26 +1,14 @@
-import axios from "axios";
-import { GasLimits, GasPrice } from "@cosmjs/stargate";
-import { CosmWasmFeeTable, defaultGasLimits } from "@cosmjs/cosmwasm-stargate";
-
-export const nymGasLimits: GasLimits<CosmWasmFeeTable> = {
-    ...defaultGasLimits,
-    upload: 2_500_000,
-    init: 500_000,
-    migrate: 200_000,
-    exec: 250_000,
-    send: 80_000,
-    changeAdmin: 80_000,
-};
+import axios from 'axios';
+import { GasPrice } from '@cosmjs/stargate';

 export function nymGasPrice(prefix: string): GasPrice {
-    return GasPrice.fromString(`0.025u${prefix}`); // TODO: ideally this ugly conversion shouldn't be hardcoded here.
+  return GasPrice.fromString(`0.025u${prefix}`); // TODO: ideally this ugly conversion shouldn't be hardcoded here.
 }

 export const downloadWasm = async (url: string): Promise<Uint8Array> => {
-    const r = await axios.get(url, {responseType: "arraybuffer"});
-    if (r.status !== 200) {
-        throw new Error(`Download error: ${r.status}`);
-    }
-    return r.data;
+  const r = await axios.get(url, { responseType: 'arraybuffer' });
+  if (r.status !== 200) {
+    throw new Error(`Download error: ${r.status}`);
+  }
+  return r.data;
 };
-
@@ -1,125 +1,157 @@
-import { Coin } from "@cosmjs/stargate";
+import { Coin } from '@cosmjs/stargate';

+// TODO: ideally we'd have re-exported those using that fancy crate that builds ts types from rust
+
+export type MixnetContractVersion = {
+  build_timestamp: string;
+  build_version: string;
+  commit_sha: string;
+  commit_timestamp: string;
+  commit_branch: string;
+  rustc_version: string;
+};

-/// One page of a possible multi-page set of mixnodes. The paging interface is quite
-/// inconvenient, as we don't have the two pieces of information we need to know
-/// in order to do paging nicely (namely `currentPage` and `totalPages` parameters).
-///
-/// Instead, we have only `start_next_page_after`, i.e. the key of the last record
-/// on this page. In order to get the *next* page, CosmWasm looks at that value,
-/// finds the next record, and builds the next page starting there. This happens
-/// **in series** rather than **in parallel** (!).
-///
-/// So we have some consistency problems:
-///
-/// * we can't make requests at a given block height, so the result set
-///    which we assemble over time may change while requests are being made.
-/// * at some point we will make a request for a `start_next_page_after` key
-///   which has just been deleted from the database.
-///
-/// TODO: more robust error handling on the "deleted key" case.
 export type PagedMixnodeResponse = {
-    nodes: MixNodeBond[],
-    per_page: number, // TODO: camelCase
-    start_next_after: string, // TODO: camelCase
-}
+  nodes: MixNodeBond[];
+  per_page: number;
+  start_next_after?: string;
+};

-// a temporary way of achieving the same paging behaviour for the gateways
-// the same points made for `PagedResponse` stand here.
 export type PagedGatewayResponse = {
-    nodes: GatewayBond[],
-    per_page: number, // TODO: camelCase
-    start_next_after: string, // TODO: camelCase
-}
+  nodes: GatewayBond[];
+  per_page: number;
+  start_next_after?: string;
+};

 export type MixOwnershipResponse = {
-    address: string,
-    has_node: boolean,
-}
+  address: string;
+  mixnode?: MixNodeBond;
+};

 export type GatewayOwnershipResponse = {
-    address: string,
-    has_gateway: boolean,
-}
+  address: string;
+  gateway?: GatewayBond;
+};

-export type ContractSettingsParams = {
-    epoch_length: number,
-    // ideally I'd want to define those as `number` rather than `string`, but
-    // rust-side they are defined as Uint128 and Decimal that don't have
-    // native javascript representations and therefore are interpreted as strings after deserialization
-    minimum_mixnode_bond: string,
-    minimum_gateway_bond: string,
-    mixnode_bond_reward_rate: string,
-    gateway_bond_reward_rate: string,
-    mixnode_delegation_reward_rate: string,
-    gateway_delegation_reward_rate: string,
-    mixnode_active_set_size: number,
-    gateway_active_set_size: number,
-}
+export type ContractStateParams = {
+  // ideally I'd want to define those as `number` rather than `string`, but
+  // rust-side they are defined as Uint128 and that don't have
+  // native javascript representations and therefore are interpreted as strings after deserialization
+  minimum_mixnode_pledge: string;
+  minimum_gateway_pledge: string;
+  mixnode_rewarded_set_size: number;
+  mixnode_active_set_size: number;
+};
+
+export type LayerDistribution = {
+  gateways: number;
+  layer1: number;
+  layer2: number;
+  layer3: number;
+};

 export type Delegation = {
-    owner: string,
-    amount: Coin,
-}
+  owner: string;
+  node_identity: string;
+  amount: Coin;
+  block_height: number;
+  proxy?: string;
+};

 export type PagedMixDelegationsResponse = {
-    node_owner: string,
-    delegations: Delegation[],
-    start_next_after: string
-}
+  delegations: Delegation[];
+  start_next_after?: string;
+};

-export type PagedGatewayDelegationsResponse = {
-    node_owner: string,
-    delegations: Delegation[],
-    start_next_after: string
-}
+export type PagedDelegatorDelegationsResponse = {
+  delegations: Delegation[];
+  start_next_after?: string;
+};

+export type PagedAllDelegationsResponse = {
+  delegations: Delegation[];
+  start_next_after?: [string, string];
+};
+
+export type RewardingResult = {
+  operator_reward: string;
+  total_delegator_reward: string;
+};
+
+export type NodeRewardParams = {
+  period_reward_pool: string;
+  k: string;
+  reward_blockstamp: number;
+  circulating_supply: string;
+  uptime: string;
+  sybil_resistance_percent: number;
+};
+
+export type DelegatorRewardParams = {
+  node_reward_params: NodeRewardParams;
+  sigma: number;
+  profit_margin: number;
+  node_profit: number;
+};
+
+export type PendingDelegatorRewarding = {
+  running_results: RewardingResult;
+  next_start: string;
+  rewarding_params: DelegatorRewardParams;
+};
+
+export type RewardingStatus = { Complete: RewardingResult } | { PendingNextDelegatorPage: PendingDelegatorRewarding };
+
+export type MixnodeRewardingStatusResponse = {
+  status?: RewardingStatus;
+};

 export enum Layer {
-    Gateway,
-    One,
-    Two,
-    Three,
+  Gateway,
+  One,
+  Two,
+  Three,
 }

-export type MixNodeBond = { // TODO: change name to MixNodeBond
-    owner: string,
-    mix_node: MixNode,    // TODO: camelCase this later once everything else works
-    layer: Layer,
-    bond_amount: Coin,
-    total_delegation: Coin,
-}
+export type MixNodeBond = {
+  owner: string;
+  mix_node: MixNode;
+  layer: Layer;
+  bond_amount: Coin;
+  total_delegation: Coin;
+};

 export type MixNode = {
-    host: string,
-    mix_port: number,
-    verloc_port: number,
-    http_api_port: number,
-    sphinx_key: string, // TODO: camelCase this later once everything else works
-    identity_key: string,
-    version: string,
-}
+  host: string;
+  mix_port: number;
+  verloc_port: number;
+  http_api_port: number;
+  sphinx_key: string;
+  identity_key: string;
+  version: string;
+  profit_margin_percent: number;
+};

 export type GatewayBond = {
-    owner: string
-    gateway: Gateway,
+  owner: string;
+  gateway: Gateway;

-    bond_amount: Coin,
-    total_delegation: Coin,
-}
+  bond_amount: Coin;
+  total_delegation: Coin;
+};

 export type Gateway = {
-    host: string,
-    mix_port: number,
-    clients_port: number,
-    location: string,
-    sphinx_key: string,
-    identity_key: string,
-    version: string
-}
+  host: string;
+  mix_port: number;
+  clients_port: number;
+  location: string;
+  sphinx_key: string;
+  identity_key: string;
+  version: string;
+};

 export type SendRequest = {
-    senderAddress: string,
-    recipientAddress: string,
-    transferAmount: readonly Coin[]
-}
+  senderAddress: string;
+  recipientAddress: string;
+  transferAmount: readonly Coin[];
+};
@@ -1,14 +1,18 @@
 // eslint-disable-next-line @typescript-eslint/no-explicit-any,@typescript-eslint/explicit-module-boundary-types
-import { Coin } from "@cosmjs/stargate";
-import { EncodeObject } from "@cosmjs/proto-signing";
+import { Coin } from '@cosmjs/stargate';
+import { EncodeObject } from '@cosmjs/proto-signing';

-export function makeBankMsgSend(senderAddress: string, recipientAddress: string, transferAmount: readonly Coin[]): EncodeObject {
-    return {
-        typeUrl: "/cosmos.bank.v1beta1.MsgSend",
-        value: {
-            fromAddress: senderAddress,
-            toAddress: recipientAddress,
-            amount: transferAmount,
-        },
-    };
-}
+export function makeBankMsgSend(
+  senderAddress: string,
+  recipientAddress: string,
+  transferAmount: readonly Coin[],
+): EncodeObject {
+  return {
+    typeUrl: '/cosmos.bank.v1beta1.MsgSend',
+    value: {
+      fromAddress: senderAddress,
+      toAddress: recipientAddress,
+      amount: transferAmount,
+    },
+  };
+}
@@ -0,0 +1,75 @@
+/*
+ * Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import axios from 'axios';
+import { GatewayBond, MixNodeBond } from './types';
+
+export const VALIDATOR_API_VERSION = '/v1';
+export const VALIDATOR_API_GATEWAYS_PATH = `${VALIDATOR_API_VERSION}/gateways`;
+export const VALIDATOR_API_MIXNODES_PATH = `${VALIDATOR_API_VERSION}/mixnodes`;
+export const VALIDATOR_API_ACTIVE_MIXNODES_PATH = `${VALIDATOR_API_VERSION}/mixnodes/active`;
+export const VALIDATOR_API_REWARDED_MIXNODES_PATH = `${VALIDATOR_API_VERSION}/mixnodes/rewarded`;
+
+export interface IValidatorApiQuery {
+  getCachedMixnodes(): Promise<MixNodeBond[]>;
+
+  getCachedGateways(): Promise<GatewayBond[]>;
+
+  getActiveMixnodes(): Promise<MixNodeBond[]>;
+
+  getRewardedMixnodes(): Promise<MixNodeBond[]>;
+}
+
+export default class ValidatorApiQuerier implements IValidatorApiQuery {
+  validatorApiUrl: string;
+
+  constructor(validatorApiUrl: string) {
+    this.validatorApiUrl = validatorApiUrl;
+  }
+
+  async getCachedMixnodes(): Promise<MixNodeBond[]> {
+    const url = new URL(this.validatorApiUrl);
+    url.pathname += VALIDATOR_API_MIXNODES_PATH;
+
+    const response = await axios.get(url.toString());
+    if (response.status === 200) {
+      return response.data;
+    }
+    throw new Error('None of the provided validator APIs seem to be alive');
+  }
+
+  async getCachedGateways(): Promise<GatewayBond[]> {
+    const url = new URL(this.validatorApiUrl);
+    url.pathname += VALIDATOR_API_GATEWAYS_PATH;
+
+    const response = await axios.get(url.toString());
+    if (response.status === 200) {
+      return response.data;
+    }
+    throw new Error('None of the provided validator APIs seem to be alive');
+  }
+
+  async getActiveMixnodes(): Promise<MixNodeBond[]> {
+    const url = new URL(this.validatorApiUrl);
+    url.pathname += VALIDATOR_API_ACTIVE_MIXNODES_PATH;
+
+    const response = await axios.get(url.toString());
+    if (response.status === 200) {
+      return response.data;
+    }
+    throw new Error('None of the provided validator APIs seem to be alive');
+  }
+
+  async getRewardedMixnodes(): Promise<MixNodeBond[]> {
+    const url = new URL(this.validatorApiUrl);
+    url.pathname += VALIDATOR_API_REWARDED_MIXNODES_PATH;
+
+    const response = await axios.get(url.toString());
+    if (response.status === 200) {
+      return response.data;
+    }
+    throw new Error('None of the provided validator APIs seem to be alive');
+  }
+}
@@ -1,100 +0,0 @@
-import { assert } from "chai";
-import INetClient from "../../src/net-client";
-import { Fixtures } from "../fixtures"
-import { Mock, Times } from "moq.ts";
-import GatewaysCache from "../../src/caches/gateways";
-
-describe("Caching gateways: when the validator returns", () => {
-    context("an empty list", () => {
-        it("Should return an empty list", async () => {
-            const perPage = 100;
-            const contractAddress = "mockContractAddress";
-            const emptyPromise = Promise.resolve(Fixtures.GatewaysResp.empty());
-            const mockClient = new Mock<INetClient>().setup(netClient => netClient.getGateways(contractAddress, perPage, undefined)).returns(emptyPromise);
-            const cache = new GatewaysCache(mockClient.object(), perPage);
-
-            await cache.refreshGateways(contractAddress);
-
-            mockClient.verify(netClient => netClient.getGateways(contractAddress, perPage, undefined), Times.Exactly(1));
-            assert.deepEqual([], cache.gateways);
-        });
-    })
-
-    context("a list of gatways that fits in a page", () => {
-        it("Should return that one page list", async () => {
-            const perPage = 2;
-            const contractAddress = "mockContractAddress";
-            const onePagePromise = Promise.resolve(Fixtures.GatewaysResp.onePage());
-            const mockClient = new Mock<INetClient>().setup(netClient => netClient.getGateways(contractAddress, perPage, undefined)).returns(onePagePromise);
-            const cache = new GatewaysCache(mockClient.object(), perPage);
-
-            await cache.refreshGateways(contractAddress);
-
-            mockClient.verify(netClient => netClient.getGateways(contractAddress, perPage, undefined), Times.Exactly(1));
-            assert.deepEqual(Fixtures.Gateways.list2(), cache.gateways);
-        })
-    })
-
-    context("a list of gateways that is longer than one page", () => {
-        it("Should return the full list assembled from all pages", async () => {
-            const perPage = 2; // we get back 2 per page
-            const contractAddress = "mockContractAddress";
-            const fullPageResult = Fixtures.GatewaysResp.page1of2();
-            const halfPageResult = Fixtures.GatewaysResp.halfPage2of2();
-            const mockClient = new Mock<INetClient>()
-            mockClient.setup(instance => instance.getGateways(contractAddress, perPage, undefined)).returns(Promise.resolve(fullPageResult));
-            mockClient.setup(instance => instance.getGateways(contractAddress, perPage, fullPageResult.start_next_after)).returns(Promise.resolve(halfPageResult));
-            const cache = new GatewaysCache(mockClient.object(), perPage);
-
-            await cache.refreshGateways(contractAddress); // should make multiple paginated requests because there are two pages in the response fixture
-            mockClient.verify(instance => instance.getGateways(contractAddress, perPage, undefined), Times.Exactly(1));
-            mockClient.verify(instance => instance.getGateways(contractAddress, perPage, fullPageResult.start_next_after), Times.Exactly(1));
-
-            assert.deepEqual(Fixtures.Gateways.list3(), cache.gateways); // there are a total of 3 nodes in the validator lists, we get them all back
-        })
-    })
-
-    context("a list of gateways that is two filled pages", () => {
-        it("Should return the full list assembled from all pages", async () => {
-            const perPage = 2; // we get back 2 per page
-            const contractAddress = "mockContractAddress";
-            const fullPageResult1 = Fixtures.GatewaysResp.page1of2();
-            const fullPageResult2 = Fixtures.GatewaysResp.fullPage2of2();
-            const mockClient = new Mock<INetClient>()
-            mockClient.setup(netClient => netClient.getGateways(contractAddress, perPage, undefined)).returns(Promise.resolve(fullPageResult1));
-            mockClient.setup(netClient => netClient.getGateways(contractAddress, perPage, fullPageResult1.start_next_after)).returns(Promise.resolve(fullPageResult2));
-
-            const cache = new GatewaysCache(mockClient.object(), perPage);
-
-            await cache.refreshGateways(contractAddress); // should make multiple paginated requests because there are two pages in the response fixture
-            mockClient.verify(netClient => netClient.getGateways(contractAddress, perPage, undefined), Times.Exactly(1));
-            mockClient.verify(netClient => netClient.getGateways(contractAddress, perPage, fullPageResult1.start_next_after), Times.Exactly(1));
-
-            assert.deepEqual(Fixtures.Gateways.list4(), cache.gateways); // there are a total of 3 nodes in the validator lists, we get them all back
-        })
-    })
-
-    context("refreshing the cache twice", () => {
-        it("returns one full list assembled from all pages", async () => {
-            const perPage = 2; // we get back 2 per page
-            const contractAddress = "mockContractAddress";
-            const fullPageResult1 = Fixtures.GatewaysResp.page1of2();
-            const fullPageResult2 = Fixtures.GatewaysResp.fullPage2of2();
-            const mockClient = new Mock<INetClient>()
-            mockClient.setup(netClient => netClient.getGateways(contractAddress, perPage, undefined)).returns(Promise.resolve(fullPageResult1));
-            mockClient.setup(netClient => netClient.getGateways(contractAddress, perPage, fullPageResult1.start_next_after)).returns(Promise.resolve(fullPageResult2));
-
-            const cache = new GatewaysCache(mockClient.object(), perPage);
-
-            await cache.refreshGateways(contractAddress); // should make multiple paginated requests because there are two pages in the response fixture
-            mockClient.verify(netClient => netClient.getGateways(contractAddress, perPage, undefined), Times.Exactly(1));
-            mockClient.verify(netClient => netClient.getGateways(contractAddress, perPage, fullPageResult1.start_next_after), Times.Exactly(1));
-
-            await cache.refreshGateways(contractAddress);
-            mockClient.verify(netClient => netClient.getGateways(contractAddress, perPage, undefined), Times.Exactly(2));
-            mockClient.verify(netClient => netClient.getGateways(contractAddress, perPage, fullPageResult1.start_next_after), Times.Exactly(2));
-
-            assert.deepEqual(Fixtures.Gateways.list4(), cache.gateways); // there are a total of 3 nodes in the validator lists, we get them all back
-        })
-    })
-});
@@ -1,96 +0,0 @@
-import { assert } from "chai";
-import INetClient from "../../src/net-client";
-import { Fixtures } from "../fixtures"
-import { Mock, Times } from "moq.ts";
-import { MixnodesCache } from "../../src/caches/mixnodes"
-
-describe("Caching mixnodes: when the validator returns", () => {
-    context("an empty list", () => {
-        it("Should return an empty list", async () => {
-            const perPage = 100;
-            const contractAddress = "mockContractAddress";
-            const emptyPromise = Promise.resolve(Fixtures.MixNodesResp.empty());
-            const mockClient = new Mock<INetClient>().setup(netClient => netClient.getMixNodes(contractAddress, perPage, undefined)).returns(emptyPromise);
-            const cache = new MixnodesCache(mockClient.object(), perPage);
-
-            await cache.refreshMixNodes(contractAddress);
-
-            mockClient.verify(netClient => netClient.getMixNodes(contractAddress, perPage, undefined), Times.Exactly(1));
-            assert.deepEqual([], cache.mixNodes);
-        });
-    })
-    context("a list of nodes that fits in a page", () => {
-        it("Should return that one page list", async () => {
-            const perPage = 2;
-            const contractAddress = "mockContractAddress";
-            const onePagePromise = Promise.resolve(Fixtures.MixNodesResp.onePage());
-            const mockClient = new Mock<INetClient>().setup(netClient => netClient.getMixNodes(contractAddress, perPage, undefined)).returns(onePagePromise);
-            const cache = new MixnodesCache(mockClient.object(), perPage);
-
-            await cache.refreshMixNodes(contractAddress);
-
-            mockClient.verify(netClient => netClient.getMixNodes(contractAddress, perPage, undefined), Times.Exactly(1));
-            assert.deepEqual(Fixtures.MixNodes.list2(), cache.mixNodes);
-        })
-    })
-
-    context("a list of nodes that is longer than one page", () => {
-        it("Should return the full list assembled from all pages", async () => {
-            const perPage = 2; // we get back 2 per page
-            const contractAddress = "mockContractAddress";
-            const fullPageResult = Fixtures.MixNodesResp.page1of2();
-            const halfPageResult = Fixtures.MixNodesResp.halfPage2of2();
-            const mockClient = new Mock<INetClient>()
-            mockClient.setup(instance => instance.getMixNodes(contractAddress, perPage, undefined)).returns(Promise.resolve(fullPageResult));
-            mockClient.setup(instance => instance.getMixNodes(contractAddress, perPage, fullPageResult.start_next_after)).returns(Promise.resolve(halfPageResult));
-            const cache = new MixnodesCache(mockClient.object(), perPage);
-
-            await cache.refreshMixNodes(contractAddress); // should make multiple paginated requests because there are two pages in the response fixture
-            mockClient.verify(instance => instance.getMixNodes(contractAddress, perPage, undefined), Times.Exactly(1));
-            mockClient.verify(instance => instance.getMixNodes(contractAddress, perPage, fullPageResult.start_next_after), Times.Exactly(1));
-
-            assert.deepEqual(Fixtures.MixNodes.list3(), cache.mixNodes); // there are a total of 3 nodes in the validator lists, we get them all back
-        })
-    })
-
-    context("a list of nodes that is two filled pages", () => {
-        it("Should return the full list assembled from all pages", async () => {
-            const perPage = 2; // we get back 2 per page
-            const contractAddress = "mockContractAddress";
-            const fullPageResult1 = Fixtures.MixNodesResp.page1of2();
-            const fullPageResult2 = Fixtures.MixNodesResp.fullPage2of2();
-            const mockClient = new Mock<INetClient>()
-            mockClient.setup(netClient => netClient.getMixNodes(contractAddress, perPage, undefined)).returns(Promise.resolve(fullPageResult1));
-            mockClient.setup(netClient => netClient.getMixNodes(contractAddress, perPage, fullPageResult1.start_next_after)).returns(Promise.resolve(fullPageResult2));
-
-            const cache = new MixnodesCache(mockClient.object(), perPage);
-
-            await cache.refreshMixNodes(contractAddress); // should make multiple paginated requests because there are two pages in the response fixture
-            mockClient.verify(netClient => netClient.getMixNodes(contractAddress, perPage, undefined), Times.Exactly(1));
-            mockClient.verify(netClient => netClient.getMixNodes(contractAddress, perPage, fullPageResult1.start_next_after), Times.Exactly(1));
-
-            assert.deepEqual(Fixtures.MixNodes.list4(), cache.mixNodes); // there are a total of 3 nodes in the validator lists, we get them all back
-        })
-    })
-
-    context("refreshing the cache twice", () => {
-        it("returns one full list assembled from all pages", async () => {
-            const perPage = 2; // we get back 2 per page
-            const contractAddress = "mockContractAddress";
-            const fullPageResult1 = Fixtures.MixNodesResp.page1of2();
-            const fullPageResult2 = Fixtures.MixNodesResp.fullPage2of2();
-            const mockClient = new Mock<INetClient>()
-            mockClient.setup(netClient => netClient.getMixNodes(contractAddress, perPage, undefined)).returns(Promise.resolve(fullPageResult1));
-            mockClient.setup(netClient => netClient.getMixNodes(contractAddress, perPage, fullPageResult1.start_next_after)).returns(Promise.resolve(fullPageResult2));
-
-            const cache = new MixnodesCache(mockClient.object(), perPage);
-
-            await cache.refreshMixNodes(contractAddress); // should make multiple paginated requests because there are two pages in the response fixture
-            await cache.refreshMixNodes(contractAddress);
-            // mockClient.verify(netClient => netClient.getMixNodes(contractAddress, perPage, undefined), Times.Exactly(1));
-            // mockClient.verify(netClient => netClient.getMixNodes(contractAddress, perPage, fullPageResult1.start_next_after), Times.Exactly(1));
-
-            assert.deepEqual(Fixtures.MixNodes.list4(), cache.mixNodes); // there are a total of 3 nodes in the validator lists, we get them all back
-        })
-    })
-});
@@ -1,156 +0,0 @@
-import { coins } from "@cosmjs/launchpad";
-import {PagedGatewayResponse, PagedMixnodeResponse} from "../src/net-client";
-import {GatewayBond, MixNodeBond} from "../src/types"
-
-export namespace Fixtures {
-    export class MixNodes {
-        static single(): MixNodeBond {
-            return {
-                amount: coins(666, "unym"),
-                owner: "bob",
-                mix_node: {
-                    host: "1.1.1.1",
-                    layer: 1,
-                    location: "London, UK",
-                    sphinx_key: "foo",
-                    version: "0.10.0",
-                }
-            };
-        }
-
-        static list1(): MixNodeBond[] {
-            return [MixNodes.single()]
-        }
-
-        static list2(): MixNodeBond[] {
-            return [MixNodes.single(), MixNodes.single()]
-        }
-
-        static list3(): MixNodeBond[] {
-            return [MixNodes.single(), MixNodes.single(), MixNodes.single()]
-        }
-
-        static list4(): MixNodeBond[] {
-            return [MixNodes.single(), MixNodes.single(), MixNodes.single(), MixNodes.single()]
-        }
-    }
-
-    export class MixNodesResp {
-        static empty(): PagedResponse {
-            return {
-                nodes: [],
-                per_page: 2,
-                start_next_after: null,
-            }
-        }
-
-        static onePage(): PagedResponse {
-            return {
-                nodes: MixNodes.list2(),
-                per_page: 2,
-                start_next_after: null
-            }
-        }
-
-        static page1of2(): PagedResponse {
-            return {
-                nodes: MixNodes.list2(),
-                per_page: 2,
-                start_next_after: "2"
-            }
-        }
-
-        static halfPage2of2(): PagedResponse {
-            return {
-                nodes: MixNodes.list1(),
-                per_page: 2,
-                start_next_after: null
-
-            }
-        }
-
-        static fullPage2of2(): PagedResponse {
-            return {
-                nodes: MixNodes.list2(),
-                per_page: 2,
-                start_next_after: null,
-            }
-        }
-    }
-
-    export class Gateways {
-        static single(): GatewayBond {
-            return {
-                amount: coins(666, "unym"),
-                owner: "bob",
-                gateway: {
-                    mix_host: "1.1.1.1:1234",
-                    clients_host: "ws://1.1.1.1:1235",
-                    location: "London, UK",
-                    identity_key: "bar",
-                    sphinx_key: "foo",
-                    version: "0.10.0",
-                }
-            };
-        }
-
-        static list1(): GatewayBond[] {
-            return [Gateways.single()]
-        }
-
-        static list2(): GatewayBond[] {
-            return [Gateways.single(), Gateways.single()]
-        }
-
-        static list3(): GatewayBond[] {
-            return [Gateways.single(), Gateways.single(), Gateways.single()]
-        }
-
-        static list4(): GatewayBond[] {
-            return [Gateways.single(), Gateways.single(), Gateways.single(), Gateways.single()]
-        }
-    }
-
-    export class GatewaysResp {
-        static empty(): PagedGatewayResponse {
-            return {
-                nodes: [],
-                per_page: 2,
-                start_next_after: "",
-            }
-        }
-
-        static onePage(): PagedGatewayResponse {
-            return {
-                nodes: Gateways.list2(),
-                per_page: 2,
-                start_next_after: "",
-            }
-        }
-
-        static page1of2(): PagedGatewayResponse {
-            return {
-                nodes: Gateways.list2(),
-                per_page: 2,
-                start_next_after: "2"
-            }
-        }
-
-        static halfPage2of2(): PagedGatewayResponse {
-            return {
-                nodes: Gateways.list1(),
-                per_page: 2,
-                start_next_after: "",
-
-            }
-        }
-
-        static fullPage2of2(): PagedGatewayResponse {
-            return {
-                nodes: Gateways.list2(),
-                per_page: 2,
-                start_next_after: "",
-            }
-        }
-    }
-}
@@ -1,8 +1,8 @@
 [package]
 name = "nym-client-wasm"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>", "Jedrzej Stuczynski <andrew@nymtech.net>"]
-version = "0.11.0"
-edition = "2018"
+version = "0.12.0"
+edition = "2021"
 keywords = ["nym", "sphinx", "wasm", "webassembly", "privacy", "client"]
 license = "Apache-2.0"
 repository = "https://github.com/nymtech/nym"
@@ -20,7 +20,7 @@ coconut = ["coconut-interface", "credentials", "gateway-client/coconut"]
 [dependencies]
 futures = "0.3"
 serde = { version = "1.0", features = ["derive"] }
-wasm-bindgen = { version = "0.2", features = ["serde-serialize"]  }
+wasm-bindgen = { version = "=0.2.78", features = ["serde-serialize"]  }
 wasm-bindgen-futures = "0.4"
 js-sys = "0.3"
 rand = { version = "0.7.3", features = ["wasm-bindgen"] }
@@ -32,7 +32,7 @@ credentials = { path = "../../common/credentials", optional = true }
 crypto = { path = "../../common/crypto" }
 nymsphinx = { path = "../../common/nymsphinx" }
 topology = { path = "../../common/topology" }
-gateway-client = { path = "../../common/client-libs/gateway-client" }
+gateway-client = { path = "../../common/client-libs/gateway-client", default-features = false, features = ["wasm"] }
 validator-client = { path = "../../common/client-libs/validator-client", default-features = false }
 wasm-utils = { path = "../../common/wasm-utils" }

@@ -3,7 +3,6 @@

 use crypto::asymmetric::{encryption, identity};
 use futures::channel::mpsc;
-use gateway_client::bandwidth::BandwidthController;
 use gateway_client::GatewayClient;
 use nymsphinx::acknowledgements::AckKey;
 use nymsphinx::addressing::clients::Recipient;
@@ -27,6 +26,7 @@ const DEFAULT_GATEWAY_RESPONSE_TIMEOUT: Duration = Duration::from_millis(1_500);
 #[wasm_bindgen]
 pub struct NymClient {
    validator_server: Url,
+    testnet_mode: bool,

    // TODO: technically this doesn't need to be an Arc since wasm is run on a single thread
    // however, once we eventually combine this code with the native-client's, it will make things
@@ -72,6 +72,7 @@ impl NymClient {

            on_message: None,
            on_gateway_connect: None,
+            testnet_mode: false,
        }
    }

@@ -84,6 +85,11 @@ impl NymClient {
        self.on_gateway_connect = Some(on_connect)
    }

+    pub fn set_testnet_mode(&mut self, testnet_mode: bool) {
+        console_log!("Setting testnet mode to {}", testnet_mode);
+        self.testnet_mode = testnet_mode;
+    }
+
    fn self_recipient(&self) -> Recipient {
        Recipient::new(
            *self.identity.public_key(),
@@ -101,8 +107,10 @@ impl NymClient {

    // Right now it's impossible to have async exported functions to take `&self` rather than self
    pub async fn initial_setup(self) -> Self {
+        let testnet_mode = self.testnet_mode;
+
        #[cfg(feature = "coconut")]
-        let bandwidth_controller = Some(BandwidthController::new(
+        let bandwidth_controller = Some(gateway_client::bandwidth::BandwidthController::new(
            vec![self.validator_server.clone()],
            *self.identity.public_key(),
        ));
@@ -126,6 +134,10 @@ impl NymClient {
            bandwidth_controller,
        );

+        if testnet_mode {
+            gateway_client.set_testnet_mode(true)
+        }
+
        gateway_client
            .authenticate_and_start()
            .await
@@ -1,7 +1,7 @@
 [package]
-name = "erc20-bridge-contract"
+name = "bandwidth-claim-contract"
 version = "0.1.0"
-edition = "2018"
+edition = "2021"

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

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

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

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

 # internal
 credentials = { path = "../../credentials" }
@@ -36,12 +38,6 @@ features = ["macros", "rt", "net", "sync", "time"]
 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio-tungstenite]
 version = "0.14"

-[target."cfg(not(target_arch = \"wasm32\"))".dependencies.secp256k1]
-version = "0.20.3"
-
-[target."cfg(not(target_arch = \"wasm32\"))".dependencies.web3]
-version = "0.17.0"
-
 # wasm-only dependencies
 [target."cfg(target_arch = \"wasm32\")".dependencies.wasm-bindgen]
 version = "0.2"
@@ -70,4 +66,6 @@ features = ["js"]
 #url = "2.1"

 [features]
-coconut = ["gateway-requests/coconut", "coconut-interface"]
+coconut = ["gateway-requests/coconut", "coconut-interface"]
+wasm = ["web3/wasm", "web3/http", "web3/signing"]
+default = ["web3/default"]
@@ -203,7 +203,7 @@ impl BandwidthController {
                &self.eth_private_key,
            )
            .await?;
-        if Some(U64::from(0)) == recipt.status {
+        if Some(U64::from(0u64)) == recipt.status {
            Err(GatewayClientError::BurnTokenError(
                web3::Error::InvalidResponse(format!(
                    "Transaction status is 0 (failure): {:?}",
@@ -40,6 +40,7 @@ const DEFAULT_RECONNECTION_BACKOFF: Duration = Duration::from_secs(5);

 pub struct GatewayClient {
    authenticated: bool,
+    testnet_mode: bool,
    bandwidth_remaining: i64,
    gateway_address: String,
    gateway_identity: identity::PublicKey,
@@ -75,6 +76,7 @@ impl GatewayClient {
    ) -> Self {
        GatewayClient {
            authenticated: false,
+            testnet_mode: false,
            bandwidth_remaining: 0,
            gateway_address,
            gateway_identity,
@@ -90,6 +92,10 @@ impl GatewayClient {
        }
    }

+    pub fn set_testnet_mode(&mut self, testnet_mode: bool) {
+        self.testnet_mode = testnet_mode
+    }
+
    // TODO: later convert into proper builder methods
    pub fn with_reconnection_on_failure(&mut self, should_reconnect_on_failure: bool) {
        self.should_reconnect_on_failure = should_reconnect_on_failure
@@ -119,6 +125,7 @@ impl GatewayClient {

        GatewayClient {
            authenticated: false,
+            testnet_mode: false,
            bandwidth_remaining: 0,
            gateway_address,
            gateway_identity,
@@ -513,6 +520,17 @@ impl GatewayClient {
        Ok(())
    }

+    async fn try_claim_testnet_bandwidth(&mut self) -> Result<(), GatewayClientError> {
+        let msg = ClientControlRequest::ClaimFreeTestnetBandwidth.into();
+        self.bandwidth_remaining = match self.send_websocket_message(msg).await? {
+            ServerResponse::Bandwidth { available_total } => Ok(available_total),
+            ServerResponse::Error { message } => Err(GatewayClientError::GatewayError(message)),
+            _ => Err(GatewayClientError::UnexpectedResponse),
+        }?;
+
+        Ok(())
+    }
+
    pub async fn claim_bandwidth(&mut self) -> Result<(), GatewayClientError> {
        if !self.authenticated {
            return Err(GatewayClientError::NotAuthenticated);
@@ -525,6 +543,10 @@ impl GatewayClient {
        }

        warn!("Not enough bandwidth. Trying to get more bandwidth, this might take a while");
+        if self.testnet_mode {
+            info!("The client is running in testnet mode - attempting to claim bandwidth without a credential");
+            return self.try_claim_testnet_bandwidth().await;
+        }

        #[cfg(feature = "coconut")]
        let credential = self
@@ -2,7 +2,7 @@
 name = "mixnet-client"
 version = "0.1.0"
 authors = ["Jedrzej Stuczynski <andrew@nymtech.net>"]
-edition = "2018"
+edition = "2021"

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

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

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

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

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

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

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

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

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

 # required for nymd-client
 # at some point it might be possible to make it wasm-compatible
@@ -27,14 +29,28 @@ network-defaults = { path = "../../network-defaults" }
 async-trait = { version = "0.1.51", optional = true }
 bip39 = { version = "1", features = ["rand"], optional = true }
 config = { path = "../../config", optional = true }
-#cosmrs = { version = "0.3", features = ["rpc", "bip32", "cosmwasm"], optional = true }
-cosmrs = { git = "https://github.com/cosmos/cosmos-rust", rev="e5a1872083abb3d88fa62dda966e7f5408deba58", features = ["rpc", "bip32", "cosmwasm"], optional = true }
+cosmrs = { version = "0.4.1", features = [
+    "rpc",
+    "bip32",
+    "cosmwasm",
+], optional = true }
 prost = { version = "0.9", default-features = false, optional = true }
 flate2 = { version = "1.0.20", optional = true }
 sha2 = { version = "0.9.5", optional = true }
 itertools = { version = "0.10", optional = true }
-cosmwasm-std = { version = "1.0.0-beta2", optional = true }
-ts-rs = {version = "5.1", optional = true}
+cosmwasm-std = { version = "1.0.0-beta3", optional = true }
+ts-rs = { version = "5.1", optional = true }

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

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

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

 #[cfg(feature = "nymd-client")]
+#[must_use]
 pub struct Config {
+    network: network_defaults::all::Network,
    api_url: Url,
    nymd_url: Url,
    mixnet_contract_address: Option<cosmrs::AccountId>,
@@ -30,17 +39,20 @@ pub struct Config {
    mixnode_page_limit: Option<u32>,
    gateway_page_limit: Option<u32>,
    mixnode_delegations_page_limit: Option<u32>,
+    rewarded_set_page_limit: Option<u32>,
 }

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

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

 #[cfg(feature = "nymd-client")]
 pub struct Client<C> {
+    network: network_defaults::all::Network,
    mixnet_contract_address: Option<cosmrs::AccountId>,
    vesting_contract_address: Option<cosmrs::AccountId>,
    mnemonic: Option<bip39::Mnemonic>,
@@ -76,6 +95,7 @@ pub struct Client<C> {
    mixnode_page_limit: Option<u32>,
    gateway_page_limit: Option<u32>,
    mixnode_delegations_page_limit: Option<u32>,
+    rewarded_set_page_limit: Option<u32>,

    // ideally they would have been read-only, but unfortunately rust doesn't have such features
    pub validator_api: validator_api::Client,
@@ -90,6 +110,7 @@ impl Client<SigningNymdClient> {
    ) -> Result<Client<SigningNymdClient>, ValidatorClientError> {
        let validator_api_client = validator_api::Client::new(config.api_url.clone());
        let nymd_client = NymdClient::connect_with_mnemonic(
+            config.network,
            config.nymd_url.as_str(),
            config.mixnet_contract_address.clone(),
            config.vesting_contract_address.clone(),
@@ -98,12 +119,14 @@ impl Client<SigningNymdClient> {
        )?;

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

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

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

+    pub async fn get_cached_rewarded_mixnodes(
+        &self,
+    ) -> Result<Vec<MixNodeBond>, ValidatorClientError> {
+        Ok(self.validator_api.get_rewarded_mixnodes().await?)
+    }
+
+    pub async fn get_cached_active_mixnodes(
+        &self,
+    ) -> Result<Vec<MixNodeBond>, ValidatorClientError> {
+        Ok(self.validator_api.get_active_mixnodes().await?)
+    }
+
    pub async fn get_cached_gateways(&self) -> Result<Vec<GatewayBond>, ValidatorClientError> {
        Ok(self.validator_api.get_gateways().await?)
    }
@@ -197,18 +235,9 @@ impl<C> Client<C> {
        Ok(self.nymd.get_mixnet_contract_version().await?)
    }

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

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

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

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

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

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

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

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

 #[cfg(feature = "nymd-client")]
 pub use client::{Client, Config};
@@ -13,6 +13,7 @@ use cosmrs::proto::cosmos::auth::v1beta1::{
 };
 use cosmrs::proto::cosmos::bank::v1beta1::{
    QueryAllBalancesRequest, QueryAllBalancesResponse, QueryBalanceRequest, QueryBalanceResponse,
+    QueryTotalSupplyRequest, QueryTotalSupplyResponse,
 };
 use cosmrs::proto::cosmos::tx::v1beta1::{
    SimulateRequest, SimulateResponse as ProtoSimulateResponse,
@@ -27,6 +28,7 @@ use cosmrs::tendermint::abci::Code as AbciCode;
 use cosmrs::tendermint::abci::Transaction;
 use cosmrs::tendermint::{abci, block, chain};
 use cosmrs::{tx, AccountId, Coin, Denom, Tx};
+use cosmwasm_std::Coin as CosmWasmCoin;
 use prost::Message;
 use serde::{Deserialize, Serialize};
 use std::convert::{TryFrom, TryInto};
@@ -162,6 +164,43 @@ pub trait CosmWasmClient: rpc::Client {
            .map_err(|_| NymdError::SerializationError("Coins".to_owned()))
    }

+    // this is annoyingly and inconsistently returning `Vec<CosmWasmCoin>` rather than
+    // Vec<Coin>, since cosmrs::Coin can't deal with IBC denoms.
+    // Presumably after https://github.com/cosmos/cosmos-rust/issues/173 is resolved,
+    // the code could be adjusted
+    async fn get_total_supply(&self) -> Result<Vec<CosmWasmCoin>, NymdError> {
+        let path = Some("/cosmos.bank.v1beta1.Query/TotalSupply".parse().unwrap());
+
+        let mut supply = Vec::new();
+        let mut pagination = None;
+
+        loop {
+            let req = QueryTotalSupplyRequest { pagination };
+
+            let mut res = self
+                .make_abci_query::<_, QueryTotalSupplyResponse>(path.clone(), req)
+                .await?;
+
+            supply.append(&mut res.supply);
+            if let Some(pagination_info) = res.pagination {
+                pagination = Some(create_pagination(pagination_info.next_key))
+            } else {
+                break;
+            }
+        }
+
+        supply
+            .into_iter()
+            .map(|coin| {
+                coin.amount.parse().map(|amount| CosmWasmCoin {
+                    denom: coin.denom,
+                    amount,
+                })
+            })
+            .collect::<Result<_, _>>()
+            .map_err(|_| NymdError::SerializationError("Coins".to_owned()))
+    }
+
    async fn get_tx(&self, id: tx::Hash) -> Result<TxResponse, NymdError> {
        Ok(self.tx(id, false).await?)
    }
@@ -160,10 +160,7 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
    {
        let init_msg = cosmwasm::MsgInstantiateContract {
            sender: sender_address.clone(),
-            admin: options
-                .as_mut()
-                .map(|options| options.admin.take())
-                .flatten(),
+            admin: options.as_mut().and_then(|options| options.admin.take()),
            code_id,
            // now this is a weird one. the protobuf files say this field is optional,
            // but if you omit it, the initialisation will fail CheckTx
@@ -636,7 +633,7 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
    }
 }

-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct Client {
    rpc_client: HttpClient,
    signer: DirectSecp256k1HdWallet,
@@ -20,6 +20,7 @@ pub enum Operation {
    BondMixnodeOnBehalf,
    UnbondMixnode,
    UnbondMixnodeOnBehalf,
+    UpdateMixnodeConfig,
    DelegateToMixnode,
    DelegateToMixnodeOnBehalf,
    UndelegateFromMixnode,
@@ -40,6 +41,11 @@ pub enum Operation {
    WithdrawVestedCoins,
    TrackUndelegation,
    CreatePeriodicVestingAccount,
+
+    AdvanceCurrentInterval,
+    WriteRewardedSet,
+    ClearRewardedSet,
+    UpdateMixnetAddress,
 }

 pub(crate) fn calculate_fee(gas_price: &GasPrice, gas_limit: Gas) -> Coin {
@@ -57,6 +63,7 @@ impl fmt::Display for Operation {
            Operation::BondMixnode => f.write_str("BondMixnode"),
            Operation::BondMixnodeOnBehalf => f.write_str("BondMixnodeOnBehalf"),
            Operation::UnbondMixnode => f.write_str("UnbondMixnode"),
+            Operation::UpdateMixnodeConfig => f.write_str("UpdateMixnodeConfig"),
            Operation::UnbondMixnodeOnBehalf => f.write_str("UnbondMixnodeOnBehalf"),
            Operation::BondGateway => f.write_str("BondGateway"),
            Operation::BondGatewayOnBehalf => f.write_str("BondGatewayOnBehalf"),
@@ -76,6 +83,10 @@ impl fmt::Display for Operation {
            Operation::WithdrawVestedCoins => f.write_str("WithdrawVestedCoins"),
            Operation::TrackUndelegation => f.write_str("TrackUndelegation"),
            Operation::CreatePeriodicVestingAccount => f.write_str("CreatePeriodicVestingAccount"),
+            Operation::AdvanceCurrentInterval => f.write_str("AdvanceCurrentInterval"),
+            Operation::WriteRewardedSet => f.write_str("WriteRewardedSet"),
+            Operation::ClearRewardedSet => f.write_str("ClearRewardedSet"),
+            Operation::UpdateMixnetAddress => f.write_str("UpdateMixnetAddress"),
        }
    }
 }
@@ -94,6 +105,7 @@ impl Operation {
            Operation::BondMixnodeOnBehalf => 200_000u64.into(),
            Operation::UnbondMixnode => 175_000u64.into(),
            Operation::UnbondMixnodeOnBehalf => 175_000u64.into(),
+            Operation::UpdateMixnodeConfig => 175_000u64.into(),
            Operation::DelegateToMixnode => 175_000u64.into(),
            Operation::DelegateToMixnodeOnBehalf => 175_000u64.into(),
            Operation::UndelegateFromMixnode => 175_000u64.into(),
@@ -112,6 +124,10 @@ impl Operation {
            Operation::WithdrawVestedCoins => 175_000u64.into(),
            Operation::TrackUndelegation => 175_000u64.into(),
            Operation::CreatePeriodicVestingAccount => 175_000u64.into(),
+            Operation::AdvanceCurrentInterval => 175_000u64.into(),
+            Operation::WriteRewardedSet => 175_000u64.into(),
+            Operation::ClearRewardedSet => 175_000u64.into(),
+            Operation::UpdateMixnetAddress => 80_000u64.into(),
        }
    }

@@ -13,12 +13,12 @@ use cosmrs::rpc::{Error as TendermintRpcError, HttpClientUrl};
 use cosmwasm_std::{Coin, Uint128};
 pub use fee::gas_price::GasPrice;
 use fee::helpers::Operation;
-use mixnet_contract::{
+use mixnet_contract_common::{
    ContractStateParams, Delegation, ExecuteMsg, Gateway, GatewayBond, GatewayOwnershipResponse,
-    IdentityKey, LayerDistribution, MixNode, MixNodeBond, MixOwnershipResponse,
+    IdentityKey, Interval, LayerDistribution, MixNode, MixNodeBond, MixOwnershipResponse,
    MixnetContractVersion, MixnodeRewardingStatusResponse, PagedAllDelegationsResponse,
    PagedDelegatorDelegationsResponse, PagedGatewayResponse, PagedMixDelegationsResponse,
-    PagedMixnodeResponse, QueryMsg, RewardingIntervalResponse,
+    PagedMixnodeResponse, PagedRewardedSetResponse, QueryMsg, RewardedSetUpdateDetails,
 };
 use serde::Serialize;
 use std::convert::TryInto;
@@ -27,9 +27,12 @@ pub use crate::nymd::cosmwasm_client::client::CosmWasmClient;
 pub use crate::nymd::cosmwasm_client::signing_client::SigningCosmWasmClient;
 pub use crate::nymd::fee::Fee;
 use crate::nymd::fee::DEFAULT_SIMULATED_GAS_MULTIPLIER;
+pub use cosmrs::rpc::endpoint::validators::Response as ValidatorResponse;
 pub use cosmrs::rpc::HttpClient as QueryNymdClient;
+pub use cosmrs::rpc::Paging;
 pub use cosmrs::tendermint::block::Height;
 pub use cosmrs::tendermint::hash;
+pub use cosmrs::tendermint::validator::Info as TendermintValidatorInfo;
 pub use cosmrs::tendermint::Time as TendermintTime;
 pub use cosmrs::tx::{self, Gas};
 pub use cosmrs::Coin as CosmosCoin;
@@ -57,16 +60,16 @@ pub struct NymdClient<C> {
 impl NymdClient<QueryNymdClient> {
    pub fn connect<U>(
        endpoint: U,
-        mixnet_contract_address: AccountId,
-        vesting_contract_address: AccountId,
+        mixnet_contract_address: Option<AccountId>,
+        vesting_contract_address: Option<AccountId>,
    ) -> Result<NymdClient<QueryNymdClient>, NymdError>
    where
        U: TryInto<HttpClientUrl, Error = TendermintRpcError>,
    {
        Ok(NymdClient {
            client: QueryNymdClient::new(endpoint)?,
-            mixnet_contract_address: Some(mixnet_contract_address),
-            vesting_contract_address: Some(vesting_contract_address),
+            mixnet_contract_address,
+            vesting_contract_address,
            client_address: None,
            custom_gas_limits: Default::default(),
            simulated_gas_multiplier: DEFAULT_SIMULATED_GAS_MULTIPLIER,
@@ -103,6 +106,7 @@ impl NymdClient<SigningNymdClient> {
    }

    pub fn connect_with_mnemonic<U>(
+        network: config::defaults::all::Network,
        endpoint: U,
        mixnet_contract_address: Option<AccountId>,
        vesting_contract_address: Option<AccountId>,
@@ -112,7 +116,8 @@ impl NymdClient<SigningNymdClient> {
    where
        U: TryInto<HttpClientUrl, Error = TendermintRpcError>,
    {
-        let wallet = DirectSecp256k1HdWallet::from_mnemonic(mnemonic)?;
+        let prefix = network.bech32_prefix();
+        let wallet = DirectSecp256k1HdWallet::from_mnemonic(prefix, mnemonic)?;
        let client_address = wallet
            .try_derive_accounts()?
            .into_iter()
@@ -234,11 +239,33 @@ impl<C> NymdClient<C> {
            .map(|block| block.block_id.hash)
    }

-    pub async fn get_balance(&self, address: &AccountId) -> Result<Option<CosmosCoin>, NymdError>
+    pub async fn get_validators(
+        &self,
+        height: u64,
+        paging: Paging,
+    ) -> Result<ValidatorResponse, NymdError>
    where
        C: CosmWasmClient + Sync,
    {
-        self.client.get_balance(address, self.denom()?).await
+        Ok(self.client.validators(height as u32, paging).await?)
+    }
+
+    pub async fn get_balance(
+        &self,
+        address: &AccountId,
+        denom: Denom,
+    ) -> Result<Option<CosmosCoin>, NymdError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        self.client.get_balance(address, denom).await
+    }
+
+    pub async fn get_total_supply(&self) -> Result<Vec<Coin>, NymdError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        self.client.get_total_supply().await
    }

    pub async fn get_contract_settings(&self) -> Result<ContractStateParams, NymdError>
@@ -261,35 +288,65 @@ impl<C> NymdClient<C> {
            .await
    }

-    pub async fn get_current_rewarding_interval(
-        &self,
-    ) -> Result<RewardingIntervalResponse, NymdError>
-    where
-        C: CosmWasmClient + Sync,
-    {
-        let request = QueryMsg::CurrentRewardingInterval {};
-        self.client
-            .query_contract_smart(self.mixnet_contract_address()?, &request)
-            .await
-    }
-
    pub async fn get_rewarding_status(
        &self,
-        mix_identity: mixnet_contract::IdentityKey,
-        rewarding_interval_nonce: u32,
+        mix_identity: mixnet_contract_common::IdentityKey,
+        interval_id: u32,
    ) -> Result<MixnodeRewardingStatusResponse, NymdError>
    where
        C: CosmWasmClient + Sync,
    {
        let request = QueryMsg::GetRewardingStatus {
            mix_identity,
-            rewarding_interval_nonce,
+            interval_id,
        };
        self.client
            .query_contract_smart(self.mixnet_contract_address()?, &request)
            .await
    }

+    pub async fn query_current_rewarded_set_height(&self) -> Result<u64, NymdError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        let request = QueryMsg::GetCurrentRewardedSetHeight {};
+        self.client
+            .query_contract_smart(self.mixnet_contract_address()?, &request)
+            .await
+    }
+
+    pub async fn query_current_rewarded_set_update_details(
+        &self,
+    ) -> Result<RewardedSetUpdateDetails, NymdError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        let request = QueryMsg::GetRewardedSetUpdateDetails {};
+        self.client
+            .query_contract_smart(self.mixnet_contract_address()?, &request)
+            .await
+    }
+
+    pub async fn get_rewarded_set_identities_paged(
+        &self,
+        start_after: Option<IdentityKey>,
+        page_limit: Option<u32>,
+        height: Option<u64>,
+    ) -> Result<PagedRewardedSetResponse, NymdError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        let request = QueryMsg::GetRewardedSet {
+            height,
+            start_after,
+            limit: page_limit,
+        };
+
+        self.client
+            .query_contract_smart(self.mixnet_contract_address()?, &request)
+            .await
+    }
+
    pub async fn get_layer_distribution(&self) -> Result<LayerDistribution, NymdError>
    where
        C: CosmWasmClient + Sync,
@@ -300,6 +357,16 @@ impl<C> NymdClient<C> {
            .await
    }

+    pub async fn get_current_interval(&self) -> Result<Interval, NymdError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        let request = QueryMsg::GetCurrentInterval {};
+        self.client
+            .query_contract_smart(self.mixnet_contract_address()?, &request)
+            .await
+    }
+
    pub async fn get_reward_pool(&self) -> Result<Uint128, NymdError>
    where
        C: CosmWasmClient + Sync,
@@ -330,11 +397,21 @@ impl<C> NymdClient<C> {
            .await
    }

-    pub async fn get_epoch_reward_percent(&self) -> Result<u8, NymdError>
+    pub async fn get_active_set_work_factor(&self) -> Result<u8, NymdError>
    where
        C: CosmWasmClient + Sync,
    {
-        let request = QueryMsg::GetEpochRewardPercent {};
+        let request = QueryMsg::GetActiveSetWorkFactor {};
+        self.client
+            .query_contract_smart(self.mixnet_contract_address()?, &request)
+            .await
+    }
+
+    pub async fn get_interval_reward_percent(&self) -> Result<u8, NymdError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        let request = QueryMsg::GetIntervalRewardPercent {};
        self.client
            .query_contract_smart(self.mixnet_contract_address()?, &request)
            .await
@@ -759,6 +836,31 @@ impl<C> NymdClient<C> {
            .await
    }

+    /// Update the configuration of a mixnode. Right now, only possible for profit margin.
+    pub async fn update_mixnode_config(
+        &self,
+        profit_margin_percent: u8,
+    ) -> Result<ExecuteResult, NymdError>
+    where
+        C: SigningCosmWasmClient + Sync,
+    {
+        let fee = self.operation_fee(Operation::UpdateMixnodeConfig);
+
+        let req = ExecuteMsg::UpdateMixnodeConfig {
+            profit_margin_percent,
+        };
+        self.client
+            .execute(
+                self.address(),
+                self.mixnet_contract_address()?,
+                &req,
+                fee,
+                "Updating mixnode configuration from rust!",
+                Vec::new(),
+            )
+            .await
+    }
+
    /// Delegates specified amount of stake to particular mixnode.
    pub async fn delegate_to_mixnode(
        &self,
@@ -1062,41 +1164,38 @@ impl<C> NymdClient<C> {
            .await
    }

-    pub async fn begin_mixnode_rewarding(
-        &self,
-        rewarding_interval_nonce: u32,
-    ) -> Result<ExecuteResult, NymdError>
+    pub async fn advance_current_interval(&self) -> Result<ExecuteResult, NymdError>
    where
        C: SigningCosmWasmClient + Sync,
    {
-        let fee = self.operation_fee(Operation::BeginMixnodeRewarding);
+        let fee = self.operation_fee(Operation::AdvanceCurrentInterval);

-        let req = ExecuteMsg::BeginMixnodeRewarding {
-            rewarding_interval_nonce,
-        };
+        let req = ExecuteMsg::AdvanceCurrentInterval {};
        self.client
            .execute(
                self.address(),
                self.mixnet_contract_address()?,
                &req,
                fee,
-                "Beginning mixnode rewarding procedure",
+                "Advancing current interval",
                Vec::new(),
            )
            .await
    }

-    pub async fn finish_mixnode_rewarding(
+    pub async fn write_rewarded_set(
        &self,
-        rewarding_interval_nonce: u32,
+        rewarded_set: Vec<IdentityKey>,
+        expected_active_set_size: u32,
    ) -> Result<ExecuteResult, NymdError>
    where
        C: SigningCosmWasmClient + Sync,
    {
-        let fee = self.operation_fee(Operation::FinishMixnodeRewarding);
+        let fee = self.operation_fee(Operation::WriteRewardedSet);

-        let req = ExecuteMsg::FinishMixnodeRewarding {
-            rewarding_interval_nonce,
+        let req = ExecuteMsg::WriteRewardedSet {
+            rewarded_set,
+            expected_active_set_size,
        };
        self.client
            .execute(
@@ -1104,7 +1203,7 @@ impl<C> NymdClient<C> {
                self.mixnet_contract_address()?,
                &req,
                fee,
-                "Finishing mixnode rewarding procedure",
+                "Writing rewarded set",
                Vec::new(),
            )
            .await
@@ -6,7 +6,8 @@ use crate::nymd::error::NymdError;
 use crate::nymd::NymdClient;
 use async_trait::async_trait;
 use cosmwasm_std::{Coin, Timestamp};
-use vesting_contract::messages::QueryMsg as VestingQueryMsg;
+use vesting_contract::vesting::{Account, PledgeData};
+use vesting_contract_common::messages::QueryMsg as VestingQueryMsg;

 #[async_trait]
 pub trait VestingQueryClient {
@@ -52,9 +53,13 @@ pub trait VestingQueryClient {

    async fn delegated_vesting(
        &self,
-        block_time: Option<Timestamp>,
        vesting_account_address: &str,
+        block_time: Option<Timestamp>,
    ) -> Result<Coin, NymdError>;
+
+    async fn get_account(&self, address: &str) -> Result<Account, NymdError>;
+    async fn get_mixnode_pledge(&self, address: &str) -> Result<Option<PledgeData>, NymdError>;
+    async fn get_gateway_pledge(&self, address: &str) -> Result<Option<PledgeData>, NymdError>;
 }

 #[async_trait]
@@ -162,8 +167,8 @@ impl<C: CosmWasmClient + Sync + Send> VestingQueryClient for NymdClient<C> {

    async fn delegated_vesting(
        &self,
-        block_time: Option<Timestamp>,
        vesting_account_address: &str,
+        block_time: Option<Timestamp>,
    ) -> Result<Coin, NymdError> {
        let request = VestingQueryMsg::GetDelegatedVesting {
            vesting_account_address: vesting_account_address.to_string(),
@@ -173,4 +178,29 @@ impl<C: CosmWasmClient + Sync + Send> VestingQueryClient for NymdClient<C> {
            .query_contract_smart(self.vesting_contract_address()?, &request)
            .await
    }
+
+    async fn get_account(&self, address: &str) -> Result<Account, NymdError> {
+        let request = VestingQueryMsg::GetAccount {
+            address: address.to_string(),
+        };
+        self.client
+            .query_contract_smart(self.vesting_contract_address()?, &request)
+            .await
+    }
+    async fn get_mixnode_pledge(&self, address: &str) -> Result<Option<PledgeData>, NymdError> {
+        let request = VestingQueryMsg::GetMixnode {
+            address: address.to_string(),
+        };
+        self.client
+            .query_contract_smart(self.vesting_contract_address()?, &request)
+            .await
+    }
+    async fn get_gateway_pledge(&self, address: &str) -> Result<Option<PledgeData>, NymdError> {
+        let request = VestingQueryMsg::GetGateway {
+            address: address.to_string(),
+        };
+        self.client
+            .query_contract_smart(self.vesting_contract_address()?, &request)
+            .await
+    }
 }
@@ -8,16 +8,18 @@ use crate::nymd::fee::helpers::Operation;
 use crate::nymd::{cosmwasm_coin_to_cosmos_coin, NymdClient};
 use async_trait::async_trait;
 use cosmwasm_std::Coin;
-use mixnet_contract::{Gateway, IdentityKey, MixNode};
-use vesting_contract::messages::ExecuteMsg as VestingExecuteMsg;
+use mixnet_contract_common::{Gateway, IdentityKey, IdentityKeyRef, MixNode};
+use vesting_contract_common::messages::{ExecuteMsg as VestingExecuteMsg, VestingSpecification};

 #[async_trait]
 pub trait VestingSigningClient {
+    async fn update_mixnet_address(&self, address: &str) -> Result<ExecuteResult, NymdError>;
+
    async fn vesting_bond_gateway(
        &self,
        gateway: Gateway,
-        pledge: Coin,
        owner_signature: &str,
+        pledge: Coin,
    ) -> Result<ExecuteResult, NymdError>;

    async fn vesting_unbond_gateway(&self) -> Result<ExecuteResult, NymdError>;
@@ -31,8 +33,8 @@ pub trait VestingSigningClient {
    async fn vesting_bond_mixnode(
        &self,
        mix_node: MixNode,
-        pledge: Coin,
        owner_signature: &str,
+        pledge: Coin,
    ) -> Result<ExecuteResult, NymdError>;
    async fn vesting_unbond_mixnode(&self) -> Result<ExecuteResult, NymdError>;

@@ -51,21 +53,22 @@ pub trait VestingSigningClient {
        amount: Coin,
    ) -> Result<ExecuteResult, NymdError>;

-    async fn vesting_delegate_to_mixnode(
+    async fn vesting_delegate_to_mixnode<'a>(
        &self,
-        mix_identity: IdentityKey,
-        amount: Coin,
+        mix_identity: IdentityKeyRef<'a>,
+        amount: &Coin,
    ) -> Result<ExecuteResult, NymdError>;

-    async fn vesting_undelegate_from_mixnode(
+    async fn vesting_undelegate_from_mixnode<'a>(
        &self,
-        mix_identity: IdentityKey,
+        mix_identity: IdentityKeyRef<'a>,
    ) -> Result<ExecuteResult, NymdError>;

    async fn create_periodic_vesting_account(
        &self,
-        address: &str,
-        start_time: Option<u64>,
+        owner_address: &str,
+        staking_address: Option<String>,
+        vesting_spec: Option<VestingSpecification>,
        amount: Coin,
    ) -> Result<ExecuteResult, NymdError>;
 }
@@ -75,13 +78,14 @@ impl<C: SigningCosmWasmClient + Sync + Send> VestingSigningClient for NymdClient
    async fn vesting_bond_gateway(
        &self,
        gateway: Gateway,
-        pledge: Coin,
        owner_signature: &str,
+        pledge: Coin,
    ) -> Result<ExecuteResult, NymdError> {
        let fee = self.operation_fee(Operation::BondGateway);
        let req = VestingExecuteMsg::BondGateway {
            gateway,
            owner_signature: owner_signature.to_string(),
+            amount: pledge,
        };
        self.client
            .execute(
@@ -90,7 +94,7 @@ impl<C: SigningCosmWasmClient + Sync + Send> VestingSigningClient for NymdClient
                &req,
                fee,
                "VestingContract::BondGateway",
-                vec![cosmwasm_coin_to_cosmos_coin(pledge)],
+                vec![],
            )
            .await
    }
@@ -135,13 +139,14 @@ impl<C: SigningCosmWasmClient + Sync + Send> VestingSigningClient for NymdClient
    async fn vesting_bond_mixnode(
        &self,
        mix_node: MixNode,
-        pledge: Coin,
        owner_signature: &str,
+        pledge: Coin,
    ) -> Result<ExecuteResult, NymdError> {
        let fee = self.operation_fee(Operation::BondMixnode);
        let req = VestingExecuteMsg::BondMixnode {
            mix_node,
            owner_signature: owner_signature.to_string(),
+            amount: pledge,
        };
        self.client
            .execute(
@@ -150,7 +155,7 @@ impl<C: SigningCosmWasmClient + Sync + Send> VestingSigningClient for NymdClient
                &req,
                fee,
                "VestingContract::BondMixnode",
-                vec![cosmwasm_coin_to_cosmos_coin(pledge)],
+                vec![],
            )
            .await
    }
@@ -230,13 +235,16 @@ impl<C: SigningCosmWasmClient + Sync + Send> VestingSigningClient for NymdClient
            )
            .await
    }
-    async fn vesting_delegate_to_mixnode(
+    async fn vesting_delegate_to_mixnode<'a>(
        &self,
-        mix_identity: IdentityKey,
-        amount: Coin,
+        mix_identity: IdentityKeyRef<'a>,
+        amount: &Coin,
    ) -> Result<ExecuteResult, NymdError> {
        let fee = self.operation_fee(Operation::DelegateToMixnode);
-        let req = VestingExecuteMsg::DelegateToMixnode { mix_identity };
+        let req = VestingExecuteMsg::DelegateToMixnode {
+            mix_identity: mix_identity.into(),
+            amount: amount.clone(),
+        };
        self.client
            .execute(
                self.address(),
@@ -244,16 +252,18 @@ impl<C: SigningCosmWasmClient + Sync + Send> VestingSigningClient for NymdClient
                &req,
                fee,
                "VestingContract::DeledateToMixnode",
-                vec![cosmwasm_coin_to_cosmos_coin(amount)],
+                vec![],
            )
            .await
    }
-    async fn vesting_undelegate_from_mixnode(
+    async fn vesting_undelegate_from_mixnode<'a>(
        &self,
-        mix_identity: IdentityKey,
+        mix_identity: IdentityKeyRef<'a>,
    ) -> Result<ExecuteResult, NymdError> {
        let fee = self.operation_fee(Operation::UndelegateFromMixnode);
-        let req = VestingExecuteMsg::UndelegateFromMixnode { mix_identity };
+        let req = VestingExecuteMsg::UndelegateFromMixnode {
+            mix_identity: mix_identity.into(),
+        };
        self.client
            .execute(
                self.address(),
@@ -267,14 +277,16 @@ impl<C: SigningCosmWasmClient + Sync + Send> VestingSigningClient for NymdClient
    }
    async fn create_periodic_vesting_account(
        &self,
-        address: &str,
-        start_time: Option<u64>,
+        owner_address: &str,
+        staking_address: Option<String>,
+        vesting_spec: Option<VestingSpecification>,
        amount: Coin,
    ) -> Result<ExecuteResult, NymdError> {
        let fee = self.operation_fee(Operation::CreatePeriodicVestingAccount);
        let req = VestingExecuteMsg::CreateAccount {
-            address: address.to_string(),
-            start_time,
+            owner_address: owner_address.to_string(),
+            staking_address,
+            vesting_spec,
        };
        self.client
            .execute(
@@ -287,4 +299,21 @@ impl<C: SigningCosmWasmClient + Sync + Send> VestingSigningClient for NymdClient
            )
            .await
    }
+
+    async fn update_mixnet_address(&self, address: &str) -> Result<ExecuteResult, NymdError> {
+        let fee = self.operation_fee(Operation::UpdateMixnetAddress);
+        let req = VestingExecuteMsg::UpdateMixnetAddress {
+            address: address.to_string(),
+        };
+        self.client
+            .execute(
+                self.address(),
+                self.vesting_contract_address()?,
+                &req,
+                fee,
+                "VestingContract::UpdateMixnetAddress",
+                vec![],
+            )
+            .await
+    }
 }
@@ -10,7 +10,7 @@ use cosmrs::tx::SignDoc;
 use cosmrs::{tx, AccountId};

 /// Derivation information required to derive a keypair and an address from a mnemonic.
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 struct Secp256k1Derivation {
    hd_path: DerivationPath,
    prefix: String,
@@ -40,7 +40,7 @@ impl AccountData {

 type Secp256k1Keypair = (SigningKey, PublicKey);

-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct DirectSecp256k1HdWallet {
    /// Base secret
    secret: bip39::Mnemonic,
@@ -62,13 +62,15 @@ impl DirectSecp256k1HdWallet {
    }

    /// Restores a wallet from the given BIP39 mnemonic using default options.
-    pub fn from_mnemonic(mnemonic: bip39::Mnemonic) -> Result<Self, NymdError> {
-        DirectSecp256k1HdWalletBuilder::new().build(mnemonic)
+    pub fn from_mnemonic(prefix: String, mnemonic: bip39::Mnemonic) -> Result<Self, NymdError> {
+        DirectSecp256k1HdWalletBuilder::new()
+            .with_prefix(prefix)
+            .build(mnemonic)
    }

-    pub fn generate(word_count: usize) -> Result<Self, NymdError> {
+    pub fn generate(prefix: String, word_count: usize) -> Result<Self, NymdError> {
        let mneomonic = bip39::Mnemonic::generate(word_count)?;
-        Self::from_mnemonic(mneomonic)
+        Self::from_mnemonic(prefix, mneomonic)
    }

    fn derive_keypair(&self, hd_path: &DerivationPath) -> Result<Secp256k1Keypair, NymdError> {
@@ -133,6 +135,7 @@ impl DirectSecp256k1HdWallet {
    }
 }

+#[must_use]
 pub struct DirectSecp256k1HdWalletBuilder {
    /// The password to use when deriving a BIP39 seed from a mnemonic.
    bip39_password: String,
@@ -202,18 +205,34 @@ impl DirectSecp256k1HdWalletBuilder {
 #[cfg(test)]
 mod tests {
    use super::*;
+    use network_defaults::{default_network, BECH32_PREFIX};

    #[test]
    fn generating_account_addresses() {
+        let (addr1, addr2, addr3) = match BECH32_PREFIX {
+            "punk" => (
+                "punk1jw6mp7d5xqc7w6xm79lha27glmd0vdt32a3fj2",
+                "punk1h5hgn94nsq4kh99rjj794hr5h5q6yfm22mcqqn",
+                "punk17n9flp6jflljg6fp05dsy07wcprf2uuujse962",
+            ),
+            "nymt" => (
+                "nymt1jw6mp7d5xqc7w6xm79lha27glmd0vdt339me94",
+                "nymt1h5hgn94nsq4kh99rjj794hr5h5q6yfm23rjshv",
+                "nymt17n9flp6jflljg6fp05dsy07wcprf2uuufgn4d4",
+            ),
+            _ => panic!("Test needs to be updated with new bech32 prefix"),
+        };
        // test vectors produced from our js wallet
        let mnemonic_address = vec![
-            ("crush minute paddle tobacco message debate cabin peace bar jacket execute twenty winner view sure mask popular couch penalty fragile demise fresh pizza stove", "nymt1jw6mp7d5xqc7w6xm79lha27glmd0vdt339me94"),
-            ("acquire rebel spot skin gun such erupt pull swear must define ill chief turtle today flower chunk truth battle claw rigid detail gym feel", "nymt1h5hgn94nsq4kh99rjj794hr5h5q6yfm23rjshv"),
-            ("step income throw wheat mobile ship wave drink pool sudden upset jaguar bar globe rifle spice frost bless glimpse size regular carry aspect ball", "nymt17n9flp6jflljg6fp05dsy07wcprf2uuufgn4d4")
+            ("crush minute paddle tobacco message debate cabin peace bar jacket execute twenty winner view sure mask popular couch penalty fragile demise fresh pizza stove", addr1),
+            ("acquire rebel spot skin gun such erupt pull swear must define ill chief turtle today flower chunk truth battle claw rigid detail gym feel", addr2),
+            ("step income throw wheat mobile ship wave drink pool sudden upset jaguar bar globe rifle spice frost bless glimpse size regular carry aspect ball", addr3)
        ];

        for (mnemonic, address) in mnemonic_address.into_iter() {
-            let wallet = DirectSecp256k1HdWallet::from_mnemonic(mnemonic.parse().unwrap()).unwrap();
+            let prefix = default_network().bech32_prefix();
+            let wallet =
+                DirectSecp256k1HdWallet::from_mnemonic(prefix, mnemonic.parse().unwrap()).unwrap();
            assert_eq!(
                wallet.try_derive_accounts().unwrap()[0].address,
                address.parse().unwrap()
@@ -1,16 +1,25 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2021-2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

 use crate::validator_api::error::ValidatorAPIError;
+use crate::validator_api::routes::{CORE_STATUS_COUNT, SINCE_ARG};
 use coconut_interface::{BlindSignRequestBody, BlindedSignatureResponse, VerificationKeyResponse};
-use mixnet_contract::{GatewayBond, MixNodeBond};
+use mixnet_contract_common::{GatewayBond, IdentityKeyRef, MixNodeBond};
 use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
 use url::Url;
+use validator_api_requests::models::{
+    CoreNodeStatusResponse, InclusionProbabilityResponse, MixnodeStatusResponse,
+    RewardEstimationResponse, StakeSaturationResponse,
+};

 pub mod error;
 pub(crate) mod routes;

 type PathSegments<'a> = &'a [&'a str];
+type Params<'a, K, V> = &'a [(K, V)];
+
+const NO_PARAMS: Params<'_, &'_ str, &'_ str> = &[];

 pub struct Client {
    url: Url,
@@ -30,24 +39,33 @@ impl Client {
        self.url = new_url
    }

-    async fn query_validator_api<T>(&self, path: PathSegments<'_>) -> Result<T, ValidatorAPIError>
+    async fn query_validator_api<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 url = create_api_url(&self.url, path);
+        let url = create_api_url(&self.url, path, params);
        Ok(self.reqwest_client.get(url).send().await?.json().await?)
    }

-    async fn post_validator_api<B, T>(
+    async fn post_validator_api<B, T, K, V>(
        &self,
        path: PathSegments<'_>,
+        params: Params<'_, K, V>,
        json_body: &B,
    ) -> Result<T, ValidatorAPIError>
    where
        B: Serialize + ?Sized,
        for<'a> T: Deserialize<'a>,
+        K: AsRef<str>,
+        V: AsRef<str>,
    {
-        let url = create_api_url(&self.url, path);
+        let url = create_api_url(&self.url, path, params);
        Ok(self
            .reqwest_client
            .post(url)
@@ -59,18 +77,176 @@ impl Client {
    }

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

    pub async fn get_gateways(&self) -> Result<Vec<GatewayBond>, ValidatorAPIError> {
-        self.query_validator_api(&[routes::API_VERSION, routes::GATEWAYS])
+        self.query_validator_api(&[routes::API_VERSION, routes::GATEWAYS], NO_PARAMS)
            .await
    }

    pub async fn get_active_mixnodes(&self) -> Result<Vec<MixNodeBond>, ValidatorAPIError> {
-        self.query_validator_api(&[routes::API_VERSION, routes::MIXNODES, routes::ACTIVE])
+        self.query_validator_api(
+            &[routes::API_VERSION, routes::MIXNODES, routes::ACTIVE],
+            NO_PARAMS,
+        )
+        .await
+    }
+
+    pub async fn get_rewarded_mixnodes(&self) -> Result<Vec<MixNodeBond>, ValidatorAPIError> {
+        self.query_validator_api(
+            &[routes::API_VERSION, routes::MIXNODES, routes::REWARDED],
+            NO_PARAMS,
+        )
+        .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> {
+        if let Some(since) = since {
+            self.query_validator_api(
+                &[
+                    routes::API_VERSION,
+                    routes::STATUS_ROUTES,
+                    routes::GATEWAY,
+                    identity,
+                    CORE_STATUS_COUNT,
+                ],
+                &[(SINCE_ARG, since.to_string())],
+            )
            .await
+        } else {
+            self.query_validator_api(
+                &[
+                    routes::API_VERSION,
+                    routes::STATUS_ROUTES,
+                    routes::GATEWAY,
+                    identity,
+                ],
+                NO_PARAMS,
+            )
+            .await
+        }
+    }
+
+    pub async fn get_mixnode_core_status_count(
+        &self,
+        identity: IdentityKeyRef<'_>,
+        since: Option<i64>,
+    ) -> Result<CoreNodeStatusResponse, ValidatorAPIError> {
+        if let Some(since) = since {
+            self.query_validator_api(
+                &[
+                    routes::API_VERSION,
+                    routes::STATUS_ROUTES,
+                    routes::MIXNODE,
+                    identity,
+                    CORE_STATUS_COUNT,
+                ],
+                &[(SINCE_ARG, since.to_string())],
+            )
+            .await
+        } else {
+            self.query_validator_api(
+                &[
+                    routes::API_VERSION,
+                    routes::STATUS_ROUTES,
+                    routes::MIXNODE,
+                    identity,
+                ],
+                NO_PARAMS,
+            )
+            .await
+        }
+    }
+
+    pub async fn get_mixnode_status(
+        &self,
+        identity: IdentityKeyRef<'_>,
+    ) -> Result<MixnodeStatusResponse, ValidatorAPIError> {
+        self.query_validator_api(
+            &[
+                routes::API_VERSION,
+                routes::STATUS_ROUTES,
+                routes::MIXNODE,
+                identity,
+                routes::STATUS,
+            ],
+            NO_PARAMS,
+        )
+        .await
+    }
+
+    pub async fn get_mixnode_reward_estimation(
+        &self,
+        identity: IdentityKeyRef<'_>,
+    ) -> Result<RewardEstimationResponse, ValidatorAPIError> {
+        self.query_validator_api(
+            &[
+                routes::API_VERSION,
+                routes::STATUS_ROUTES,
+                routes::MIXNODE,
+                identity,
+                routes::REWARD_ESTIMATION,
+            ],
+            NO_PARAMS,
+        )
+        .await
+    }
+
+    pub async fn get_mixnode_stake_saturation(
+        &self,
+        identity: IdentityKeyRef<'_>,
+    ) -> Result<StakeSaturationResponse, ValidatorAPIError> {
+        self.query_validator_api(
+            &[
+                routes::API_VERSION,
+                routes::STATUS_ROUTES,
+                routes::MIXNODE,
+                identity,
+                routes::STAKE_SATURATION,
+            ],
+            NO_PARAMS,
+        )
+        .await
+    }
+
+    pub async fn get_mixnode_inclusion_probability(
+        &self,
+        identity: IdentityKeyRef<'_>,
+    ) -> Result<InclusionProbabilityResponse, ValidatorAPIError> {
+        self.query_validator_api(
+            &[
+                routes::API_VERSION,
+                routes::STATUS_ROUTES,
+                routes::MIXNODE,
+                identity,
+                routes::INCLUSION_CHANCE,
+            ],
+            NO_PARAMS,
+        )
+        .await
    }

    pub async fn blind_sign(
@@ -79,6 +255,7 @@ impl Client {
    ) -> Result<BlindedSignatureResponse, ValidatorAPIError> {
        self.post_validator_api(
            &[routes::API_VERSION, routes::COCONUT_BLIND_SIGN],
+            NO_PARAMS,
            request_body,
        )
        .await
@@ -87,13 +264,20 @@ impl Client {
    pub async fn get_coconut_verification_key(
        &self,
    ) -> Result<VerificationKeyResponse, ValidatorAPIError> {
-        self.query_validator_api(&[routes::API_VERSION, routes::COCONUT_VERIFICATION_KEY])
-            .await
+        self.query_validator_api(
+            &[routes::API_VERSION, routes::COCONUT_VERIFICATION_KEY],
+            NO_PARAMS,
+        )
+        .await
    }
 }

 // utility function that should solve the double slash problem in validator API forever.
-fn create_api_url(base: &Url, segments: PathSegments<'_>) -> Url {
+fn create_api_url<K: AsRef<str>, V: AsRef<str>>(
+    base: &Url,
+    segments: PathSegments<'_>,
+    params: Params<'_, K, V>,
+) -> Url {
    let mut url = base.clone();
    let mut path_segments = url
        .path_segments_mut()
@@ -108,6 +292,10 @@ fn create_api_url(base: &Url, segments: PathSegments<'_>) -> Url {
    // and can be dropped
    drop(path_segments);

+    if !params.is_empty() {
+        url.query_pairs_mut().extend_pairs(params);
+    }
+
    url
 }

@@ -122,51 +310,66 @@ mod tests {
        // works with 1 segment
        assert_eq!(
            "http://foomp.com/foo",
-            create_api_url(&base_url, &["foo"]).as_str()
+            create_api_url(&base_url, &["foo"], NO_PARAMS).as_str()
        );

        // works with 2 segments
        assert_eq!(
            "http://foomp.com/foo/bar",
-            create_api_url(&base_url, &["foo", "bar"]).as_str()
+            create_api_url(&base_url, &["foo", "bar"], NO_PARAMS).as_str()
        );

        // works with leading slash
        assert_eq!(
            "http://foomp.com/foo",
-            create_api_url(&base_url, &["/foo"]).as_str()
+            create_api_url(&base_url, &["/foo"], NO_PARAMS).as_str()
        );
        assert_eq!(
            "http://foomp.com/foo/bar",
-            create_api_url(&base_url, &["/foo", "bar"]).as_str()
+            create_api_url(&base_url, &["/foo", "bar"], NO_PARAMS).as_str()
        );
        assert_eq!(
            "http://foomp.com/foo/bar",
-            create_api_url(&base_url, &["foo", "/bar"]).as_str()
+            create_api_url(&base_url, &["foo", "/bar"], NO_PARAMS).as_str()
        );

        // works with trailing slash
        assert_eq!(
            "http://foomp.com/foo",
-            create_api_url(&base_url, &["foo/"]).as_str()
+            create_api_url(&base_url, &["foo/"], NO_PARAMS).as_str()
        );
        assert_eq!(
            "http://foomp.com/foo/bar",
-            create_api_url(&base_url, &["foo/", "bar"]).as_str()
+            create_api_url(&base_url, &["foo/", "bar"], NO_PARAMS).as_str()
        );
        assert_eq!(
            "http://foomp.com/foo/bar",
-            create_api_url(&base_url, &["foo", "bar/"]).as_str()
+            create_api_url(&base_url, &["foo", "bar/"], NO_PARAMS).as_str()
        );

        // works with both leading and trailing slash
        assert_eq!(
            "http://foomp.com/foo",
-            create_api_url(&base_url, &["/foo/"]).as_str()
+            create_api_url(&base_url, &["/foo/"], NO_PARAMS).as_str()
        );
        assert_eq!(
            "http://foomp.com/foo/bar",
-            create_api_url(&base_url, &["/foo/", "/bar/"]).as_str()
+            create_api_url(&base_url, &["/foo/", "/bar/"], NO_PARAMS).as_str()
+        );
+
+        // adds params
+        assert_eq!(
+            "http://foomp.com/foo/bar?foomp=baz",
+            create_api_url(&base_url, &["foo", "bar"], &[("foomp", "baz")]).as_str()
+        );
+        assert_eq!(
+            "http://foomp.com/foo/bar?arg1=val1&arg2=val2",
+            create_api_url(
+                &base_url,
+                &["/foo/", "/bar/"],
+                &[("arg1", "val1"), ("arg2", "val2")]
+            )
+            .as_str()
        );
    }
 }
@@ -8,6 +8,19 @@ pub const MIXNODES: &str = "mixnodes";
 pub const GATEWAYS: &str = "gateways";

 pub const ACTIVE: &str = "active";
+pub const REWARDED: &str = "rewarded";

-pub const COCONUT_BLIND_SIGN: &str = "blind_sign";
-pub const COCONUT_VERIFICATION_KEY: &str = "verification_key";
+pub const COCONUT_BLIND_SIGN: &str = "blind-sign";
+pub const COCONUT_VERIFICATION_KEY: &str = "verification-key";
+
+pub const STATUS_ROUTES: &str = "status";
+pub const MIXNODE: &str = "mixnode";
+pub const GATEWAY: &str = "gateway";
+
+pub const CORE_STATUS_COUNT: &str = "core-status-count";
+pub const SINCE_ARG: &str = "since";
+
+pub const STATUS: &str = "status";
+pub const REWARD_ESTIMATION: &str = "reward-estimation";
+pub const STAKE_SATURATION: &str = "stake-saturation";
+pub const INCLUSION_CHANCE: &str = "inclusion-probability";
@@ -0,0 +1,4 @@
+# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+# yarn lockfile v1
+
+
@@ -1,7 +1,7 @@
 [package]
 name = "coconut-interface"
 version = "0.1.0"
-edition = "2018"
+edition = "2021"
 description = "Crutch library until there is proper SerDe support for coconut structs"

 [dependencies]
@@ -2,7 +2,7 @@
 name = "config"
 version = "0.1.0"
 authors = ["Jedrzej Stuczynski <andrew@nymtech.net>"]
-edition = "2018"
+edition = "2021"

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

@@ -0,0 +1,10 @@
+[package]
+name = "contracts-common"
+version = "0.1.0"
+authors = ["Jędrzej Stuczyński <andrew@nymtech.net>"]
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+cosmwasm-std = "1.0.0-beta3"
@@ -0,0 +1,30 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use cosmwasm_std::Event;
+
+/// Looks up value of particular attribute in the provided event. If it fails to find it,
+/// the function panics.
+///
+/// # Arguments
+///
+/// * `event`: event to search through.
+/// * `key`: key associated with the particular attribute
+pub fn must_find_attribute(event: &Event, key: &str) -> String {
+    may_find_attribute(event, key).unwrap()
+}
+
+/// Looks up value of particular attribute in the provided event. Returns None if it does not exist.
+///
+/// # Arguments
+///
+/// * `event`: event to search through.
+/// * `key`: key associated with the particular attribute
+pub fn may_find_attribute(event: &Event, key: &str) -> Option<String> {
+    for attr in &event.attributes {
+        if attr.key == key {
+            return Some(attr.value.clone());
+        }
+    }
+    None
+}
@@ -0,0 +1,4 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+pub mod events;
@@ -1,23 +1,30 @@
 [package]
-name = "mixnet-contract"
+name = "mixnet-contract-common"
 version = "0.1.0"
 authors = ["Jędrzej Stuczyński <andrew@nymtech.net>"]
-edition = "2018"
+edition = "2021"

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

 [dependencies]
-cosmwasm-std = "1.0.0-beta2"
+cosmwasm-std = "1.0.0-beta3"

 serde = { version = "1.0", features = ["derive"] }
 serde_repr = "0.1"
 schemars = "0.8"
 ts-rs = { version = "5.1", optional = true }
 thiserror = "1.0"
-network-defaults = { path = "../network-defaults" }
+network-defaults = { path = "../../network-defaults" }
 fixed = { version = "1.1", features = ["serde"] }
 az = "1.1"
 log = "0.4.14"
+time = { version = "0.3.6", features = ["parsing", "formatting"] }
+
+contracts-common = { path = "../contracts-common" }
+
+[dev-dependencies]
+time = { version = "0.3.5", features = ["serde", "macros"] }
+

 [features]
 default = []
--- a/Show More
+++ b/Show More