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

create custom urls for mainnet

.github/CODEOWNERS

@@ -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

.github/workflows/nym-wallet-publish-macos.yml

@@ -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

.github/workflows/nym-wallet-publish-ubuntu.yml

@@ -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

.github/workflows/nym-wallet-publish.yml

@@ -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!

.github/workflows/wasm_client_build.yml

@@ -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

Cargo.toml

@@ -11,13 +11,13 @@ panic = "abort"
 
 [workspace]
 
+resolver = "2"
 members = [
     "clients/client-core",
     "clients/native",
     "clients/native/websocket-requests",
     "clients/socks5",
     "clients/tauri-client/src-tauri",
-    "clients/webassembly",
     "common/client-libs/gateway-client",
     "common/client-libs/mixnet-client",
     "common/client-libs/validator-client",
@@ -26,7 +26,9 @@ members = [
     "common/credentials",
     "common/crypto",
     "common/bandwidth-claim-contract",
-    "common/mixnet-contract",
+    "common/cosmwasm-smart-contracts/contracts-common",
+    "common/cosmwasm-smart-contracts/mixnet-contract",
+    "common/cosmwasm-smart-contracts/vesting-contract",
     "common/mixnode-common",
     "common/network-defaults",
     "common/nonexhaustive-delayqueue",
@@ -52,12 +54,12 @@ members = [
     "mixnode",
     "service-providers/network-requester",
     "validator-api",
+    "validator-api/validator-api-requests",
 ]
 
 default-members = [
     "clients/native",
     "clients/socks5",
-#    "clients/webassembly",
     "gateway",
     "service-providers/network-requester",
     "mixnode",
@@ -65,4 +67,4 @@ default-members = [
     "explorer-api",
 ]
 
-exclude = ["explorer", "contracts", "tokenomics-py"]
+exclude = ["explorer", "contracts", "tokenomics-py", "clients/webassembly"]

Makefile

@@ -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
@@ -29,3 +40,6 @@ 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

README.md

@@ -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
 

clients/client-core/Cargo.toml

@@ -2,7 +2,7 @@
 name = "client-core"
 version = "0.12.0"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
-edition = "2018"
+edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 

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

@@ -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;
         })
     }

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

@@ -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?

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

@@ -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;
         })
     }

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

@@ -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
         })

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

@@ -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();
     }
 }

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

@@ -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)))

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

@@ -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;

clients/native/Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "nym-client"
-version = "0.12.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,7 @@ 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

clients/native/examples/js-examples/websocket/package-lock.json

@@ -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",

clients/native/examples/websocket_binarysend.rs

@@ -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();
 

clients/native/examples/websocket_textsend.rs

@@ -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",

clients/native/src/client/mod.rs

@@ -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,47 +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),
+        );
 
-            if self.config.get_base().get_testnet_mode() {
-                gateway_client.set_testnet_mode(true)
-            }
+        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
-                .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(),
@@ -233,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"
@@ -247,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)
@@ -260,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(
@@ -273,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
@@ -321,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
@@ -335,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
@@ -367,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(

clients/native/src/commands/init.rs

@@ -30,7 +30,13 @@ use topology::{filter::VersionFilterable, gateway};
 use url::Url;
 
 use crate::client::config::Config;
-use crate::commands::{override_config, TESTNET_MODE_ARG_NAME};
+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")
@@ -65,24 +71,29 @@ pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
             .long("fastmode")
             .hidden(true) // this will prevent this flag from being displayed in `--help`
             .help("Mostly debug-related option to increase default traffic rate so that you would not need to modify config post init")
-        )
+        );
+    #[cfg(feature = "eth")]
+    #[cfg(not(feature = "coconut"))]
+        let app = app
         .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")
-        );
-    #[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")
+                .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
 }
@@ -208,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
@@ -226,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();
     }
@@ -239,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());

clients/native/src/commands/mod.rs

@@ -6,6 +6,16 @@ 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;
@@ -22,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()
@@ -46,15 +56,23 @@ 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 matches.is_present(TESTNET_MODE_ARG_NAME) {
+    if !cfg!(feature = "eth") || matches.is_present(TESTNET_MODE_ARG_NAME) {
         config.get_base_mut().with_testnet_mode(true)
     }
 

clients/native/src/commands/run.rs

@@ -3,7 +3,10 @@
 
 use crate::client::config::Config;
 use crate::client::NymClient;
-use crate::commands::{override_config, TESTNET_MODE_ARG_NAME};
+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::*;
@@ -38,21 +41,23 @@ pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
             .long("port")
             .help("Port for the socket (if applicable) to listen on")
             .takes_value(true)
-        )
+        );
+    #[cfg(feature = "eth")]
+    #[cfg(not(feature = "coconut"))]
+        let app = app
         .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")
-        );
-    #[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")
+                .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
@@ -77,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)) {
@@ -88,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;
 }

clients/native/src/commands/upgrade.rs

@@ -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();

clients/native/src/main.rs

@@ -7,7 +7,8 @@ pub mod client;
 pub mod commands;
 pub mod websocket;
 
-fn main() {
+#[tokio::main]
+async fn main() {
     dotenv::dotenv().ok();
     setup_logging();
     println!("{}", banner());
@@ -22,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()),
     }

clients/native/src/websocket/listener.rs

@@ -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 })
     }
 }

clients/native/websocket-requests/Cargo.toml

@@ -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
 

clients/socks5/Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "nym-socks5-client"
-version = "0.12.0"
+version = "0.12.1"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
-edition = "2018"
+edition = "2021"
 rust-version = "1.56"
 
 [lib]
@@ -43,6 +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"] }

clients/socks5/src/client/mod.rs

@@ -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,47 +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),
+        );
 
-            if self.config.get_base().get_testnet_mode() {
-                gateway_client.set_testnet_mode(true)
-            }
+        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
-                .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(),
@@ -221,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"
@@ -235,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)
@@ -248,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(
@@ -267,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
@@ -286,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
@@ -318,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(

clients/socks5/src/commands/init.rs

@@ -28,7 +28,13 @@ use topology::{filter::VersionFilterable, gateway};
 use url::Url;
 
 use crate::client::config::Config;
-use crate::commands::{override_config, TESTNET_MODE_ARG_NAME};
+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")
@@ -65,24 +71,29 @@ pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
             .long("fastmode")
             .hidden(true) // this will prevent this flag from being displayed in `--help`
             .help("Mostly debug-related option to increase default traffic rate so that you would not need to modify config post init")
-        )
+        );
+    #[cfg(feature = "eth")]
+    #[cfg(not(feature = "coconut"))]
+        let app = app
         .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")
-        );
-    #[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")
+                .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
 }
@@ -208,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
@@ -227,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();
     }
@@ -240,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());

clients/socks5/src/commands/mod.rs

@@ -10,6 +10,16 @@ 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(',')
@@ -22,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()
@@ -42,15 +52,23 @@ 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 matches.is_present(TESTNET_MODE_ARG_NAME) {
+    if !cfg!(feature = "eth") || matches.is_present(TESTNET_MODE_ARG_NAME) {
         config.get_base_mut().with_testnet_mode(true)
     }
 

clients/socks5/src/commands/run.rs

@@ -3,7 +3,10 @@
 
 use crate::client::config::Config;
 use crate::client::NymClient;
-use crate::commands::{override_config, TESTNET_MODE_ARG_NAME};
+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::*;
@@ -44,21 +47,23 @@ pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
             .long("port")
             .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(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")
-        );
-    #[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")
+                .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
@@ -83,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)) {
@@ -94,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;
 }

clients/socks5/src/commands/upgrade.rs

@@ -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();

clients/socks5/src/main.rs

@@ -7,7 +7,8 @@ pub mod client;
 mod commands;
 pub mod socks;
 
-fn main() {
+#[tokio::main]
+async fn main() {
     dotenv::dotenv().ok();
     setup_logging();
     println!("{}", banner());
@@ -22,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()),
     }

clients/tauri-client/src-tauri/Cargo.toml

@@ -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

clients/validator/src/index.ts

@@ -180,8 +180,8 @@ export default class ValidatorClient implements INymClient {
     return this.client.getSybilResistancePercent(this.mixnetContract);
   }
 
-  public async getEpochRewardPercent(): Promise<number> {
-    return this.client.getEpochRewardPercent(this.mixnetContract);
+  public async getIntervalRewardPercent(): Promise<number> {
+    return this.client.getIntervalRewardPercent(this.mixnetContract);
   }
 
   public async getAllNymdMixnodes(): Promise<MixNodeBond[]> {
@@ -433,6 +433,14 @@ export default class ValidatorClient implements INymClient {
     return (this.client as ISigningClient).undelegateFromMixNode(this.mixnetContract, mixIdentity, fee, memo);
   }
 
+  public async updateMixnodeConfig(
+    mixIdentity: string,
+    fee: StdFee | 'auto' | number,
+    profitPercentage: number,
+  ): Promise<ExecuteResult> {
+    return (this.client as ISigningClient).updateMixnodeConfig(this.mixnetContract, mixIdentity, profitPercentage, fee);
+  }
+
   public async updateContractStateParams(
     newParams: ContractStateParams,
     fee?: StdFee | 'auto' | number,
@@ -441,4 +449,4 @@ export default class ValidatorClient implements INymClient {
     this.assertSigning();
     return (this.client as ISigningClient).updateContractStateParams(this.mixnetContract, newParams, fee, memo);
   }
-}
+}

clients/validator/src/nymd-querier.ts

@@ -18,7 +18,6 @@ import {
   PagedGatewayResponse,
   PagedMixDelegationsResponse,
   PagedMixnodeResponse,
-  RewardingIntervalResponse,
   RewardingStatus,
 } from './types';
 
@@ -79,12 +78,6 @@ export default class NymdQuerier implements INymdQuery {
     });
   }
 
-  getCurrentRewardingInterval(mixnetContractAddress: string): Promise<RewardingIntervalResponse> {
-    return this.client.queryContractSmart(mixnetContractAddress, {
-      current_rewarding_interval: {},
-    });
-  }
-
   getAllNetworkDelegationsPaged(
     mixnetContractAddress: string,
     limit?: number,
@@ -155,9 +148,9 @@ export default class NymdQuerier implements INymdQuery {
     });
   }
 
-  getEpochRewardPercent(mixnetContractAddress: string): Promise<number> {
+  getIntervalRewardPercent(mixnetContractAddress: string): Promise<number> {
     return this.client.queryContractSmart(mixnetContractAddress, {
-      get_epoch_reward_percent: {},
+      get_interval_reward_percent: {},
     });
   }
 

clients/validator/src/query-client.ts

@@ -28,7 +28,6 @@ import {
   PagedGatewayResponse,
   PagedMixDelegationsResponse,
   PagedMixnodeResponse,
-  RewardingIntervalResponse,
   RewardingStatus,
 } from './types';
 import ValidatorApiQuerier, { IValidatorApiQuery } from './validator-api-querier';
@@ -63,7 +62,6 @@ export interface INymdQuery {
   ownsMixNode(mixnetContractAddress: string, address: string): Promise<MixOwnershipResponse>;
   ownsGateway(mixnetContractAddress: string, address: string): Promise<GatewayOwnershipResponse>;
   getStateParams(mixnetContractAddress: string): Promise<ContractStateParams>;
-  getCurrentRewardingInterval(mixnetContractAddress: string): Promise<RewardingIntervalResponse>;
 
   getAllNetworkDelegationsPaged(
     mixnetContractAddress: string,
@@ -87,7 +85,7 @@ export interface INymdQuery {
   getLayerDistribution(mixnetContractAddress: string): Promise<LayerDistribution>;
   getRewardPool(mixnetContractAddress: string): Promise<string>;
   getCirculatingSupply(mixnetContractAddress: string): Promise<string>;
-  getEpochRewardPercent(mixnetContractAddress: string): Promise<number>;
+  getIntervalRewardPercent(mixnetContractAddress: string): Promise<number>;
   getSybilResistancePercent(mixnetContractAddress: string): Promise<number>;
   getRewardingStatus(
     mixnetContractAddress: string,
@@ -138,10 +136,6 @@ export default class QueryClient extends CosmWasmClient implements IQueryClient
     return this.nymdQuerier.getStateParams(mixnetContractAddress);
   }
 
-  getCurrentRewardingInterval(mixnetContractAddress: string): Promise<RewardingIntervalResponse> {
-    return this.nymdQuerier.getCurrentRewardingInterval(mixnetContractAddress);
-  }
-
   getAllNetworkDelegationsPaged(
     mixnetContractAddress: string,
     limit?: number,
@@ -184,8 +178,8 @@ export default class QueryClient extends CosmWasmClient implements IQueryClient
     return this.nymdQuerier.getCirculatingSupply(mixnetContractAddress);
   }
 
-  getEpochRewardPercent(mixnetContractAddress: string): Promise<number> {
-    return this.nymdQuerier.getEpochRewardPercent(mixnetContractAddress);
+  getIntervalRewardPercent(mixnetContractAddress: string): Promise<number> {
+    return this.nymdQuerier.getIntervalRewardPercent(mixnetContractAddress);
   }
 
   getSybilResistancePercent(mixnetContractAddress: string): Promise<number> {

clients/validator/src/signing-client.ts

@@ -31,7 +31,6 @@ import {
   PagedGatewayResponse,
   PagedMixDelegationsResponse,
   PagedMixnodeResponse,
-  RewardingIntervalResponse,
   RewardingStatus,
 } from './types';
 import ValidatorApiQuerier from './validator-api-querier';
@@ -178,6 +177,13 @@ export interface ISigningClient extends IQueryClient, ICosmWasmSigning, INymSign
     memo?: string,
   ): Promise<ExecuteResult>;
 
+  updateMixnodeConfig(
+    mixnetContractAddress: string,
+    mixIdentity: string,
+    profitMarginPercent: number,
+    fee: StdFee | 'auto' | number,
+  ): Promise<ExecuteResult>;
+
   updateContractStateParams(
     mixnetContractAddress: string,
     newParams: ContractStateParams,
@@ -250,10 +256,6 @@ export default class SigningClient extends SigningCosmWasmClient implements ISig
     return this.nymdQuerier.getStateParams(mixnetContractAddress);
   }
 
-  getCurrentRewardingInterval(mixnetContractAddress: string): Promise<RewardingIntervalResponse> {
-    return this.nymdQuerier.getCurrentRewardingInterval(mixnetContractAddress);
-  }
-
   getAllNetworkDelegationsPaged(
     mixnetContractAddress: string,
     limit?: number,
@@ -296,8 +298,8 @@ export default class SigningClient extends SigningCosmWasmClient implements ISig
     return this.nymdQuerier.getCirculatingSupply(mixnetContractAddress);
   }
 
-  getEpochRewardPercent(mixnetContractAddress: string): Promise<number> {
-    return this.nymdQuerier.getEpochRewardPercent(mixnetContractAddress);
+  getIntervalRewardPercent(mixnetContractAddress: string): Promise<number> {
+    return this.nymdQuerier.getIntervalRewardPercent(mixnetContractAddress);
   }
 
   getSybilResistancePercent(mixnetContractAddress: string): Promise<number> {
@@ -448,6 +450,20 @@ export default class SigningClient extends SigningCosmWasmClient implements ISig
     );
   }
 
+  updateMixnodeConfig(
+    mixnetContractAddress: string,
+    mixIdentity: string,
+    profitMarginPercent: number,
+    fee: StdFee | 'auto' | number,
+  ): Promise<ExecuteResult> {
+    return this.execute(
+      this.clientAddress,
+      mixnetContractAddress,
+      { update_mixnode_config: { profit_margin_percent: profitMarginPercent, mix_identity: mixIdentity } },
+      fee,
+    );
+  }
+
   updateContractStateParams(
     mixnetContractAddress: string,
     newParams: ContractStateParams,

clients/validator/src/types.ts

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

clients/webassembly/Cargo.toml

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

clients/webassembly/src/client/mod.rs

@@ -3,7 +3,6 @@
 
 use crypto::asymmetric::{encryption, identity};
 use futures::channel::mpsc;
-use gateway_client::bandwidth::BandwidthController;
 use gateway_client::GatewayClient;
 use nymsphinx::acknowledgements::AckKey;
 use nymsphinx::addressing::clients::Recipient;
@@ -111,7 +110,7 @@ impl NymClient {
         let testnet_mode = self.testnet_mode;
 
         #[cfg(feature = "coconut")]
-        let bandwidth_controller = Some(BandwidthController::new(
+        let bandwidth_controller = Some(gateway_client::bandwidth::BandwidthController::new(
             vec![self.validator_server.clone()],
             *self.identity.public_key(),
         ));

common/bandwidth-claim-contract/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "bandwidth-claim-contract"
 version = "0.1.0"
-edition = "2018"
+edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 

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

@@ -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"]

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

@@ -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): {:?}",

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

@@ -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
 

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

@@ -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,

common/client-libs/mixnet-client/src/forwarder.rs

@@ -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::*;

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

@@ -4,4 +4,4 @@
 pub mod client;
 pub mod forwarder;
 
-pub use client::{Client, Config};
+pub use client::{Client, Config, SendWithoutResponse};

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

@@ -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"]

common/client-libs/validator-client/src/client.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,

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

@@ -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};

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

@@ -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?)
     }

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

@@ -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

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

@@ -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(),
         }
     }
 

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

@@ -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,6 +239,17 @@ impl<C> NymdClient<C> {
             .map(|block| block.block_id.hash)
     }
 
+    pub async fn get_validators(
+        &self,
+        height: u64,
+        paging: Paging,
+    ) -> Result<ValidatorResponse, NymdError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        Ok(self.client.validators(height as u32, paging).await?)
+    }
+
     pub async fn get_balance(
         &self,
         address: &AccountId,
@@ -245,14 +261,11 @@ impl<C> NymdClient<C> {
         self.client.get_balance(address, denom).await
     }
 
-    pub async fn get_mixnet_balance(
-        &self,
-        address: &AccountId,
-    ) -> Result<Option<CosmosCoin>, NymdError>
+    pub async fn get_total_supply(&self) -> Result<Vec<Coin>, NymdError>
     where
         C: CosmWasmClient + Sync,
     {
-        self.get_balance(address, self.denom()?).await
+        self.client.get_total_supply().await
     }
 
     pub async fn get_contract_settings(&self) -> Result<ContractStateParams, NymdError>
@@ -275,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,
@@ -314,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,
@@ -344,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
@@ -773,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,
@@ -1076,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(
@@ -1118,7 +1203,7 @@ impl<C> NymdClient<C> {
                 self.mixnet_contract_address()?,
                 &req,
                 fee,
-                "Finishing mixnode rewarding procedure",
+                "Writing rewarded set",
                 Vec::new(),
             )
             .await

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

@@ -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 {
@@ -55,6 +56,10 @@ pub trait VestingQueryClient {
         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]
@@ -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
+    }
 }

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

@@ -8,11 +8,13 @@ use crate::nymd::fee::helpers::Operation;
 use crate::nymd::{cosmwasm_coin_to_cosmos_coin, NymdClient};
 use async_trait::async_trait;
 use cosmwasm_std::Coin;
-use mixnet_contract::{Gateway, IdentityKey, IdentityKeyRef, MixNode};
-use vesting_contract::messages::ExecuteMsg as VestingExecuteMsg;
+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,
@@ -64,8 +66,9 @@ pub trait VestingSigningClient {
 
     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>;
 }
@@ -82,6 +85,7 @@ impl<C: SigningCosmWasmClient + Sync + Send> VestingSigningClient for NymdClient
         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
     }
@@ -142,6 +146,7 @@ impl<C: SigningCosmWasmClient + Sync + Send> VestingSigningClient for NymdClient
         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
     }
@@ -238,6 +243,7 @@ impl<C: SigningCosmWasmClient + Sync + Send> VestingSigningClient for NymdClient
         let fee = self.operation_fee(Operation::DelegateToMixnode);
         let req = VestingExecuteMsg::DelegateToMixnode {
             mix_identity: mix_identity.into(),
+            amount: amount.clone(),
         };
         self.client
             .execute(
@@ -246,7 +252,7 @@ impl<C: SigningCosmWasmClient + Sync + Send> VestingSigningClient for NymdClient
                 &req,
                 fee,
                 "VestingContract::DeledateToMixnode",
-                vec![cosmwasm_coin_to_cosmos_coin(amount.to_owned())],
+                vec![],
             )
             .await
     }
@@ -271,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(
@@ -291,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
+    }
 }

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

@@ -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,7 +205,7 @@ impl DirectSecp256k1HdWalletBuilder {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use network_defaults::BECH32_PREFIX;
+    use network_defaults::{default_network, BECH32_PREFIX};
 
     #[test]
     fn generating_account_addresses() {
@@ -227,7 +230,9 @@ mod tests {
         ];
 
         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()

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

@@ -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()
         );
     }
 }

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

@@ -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";

common/coconut-interface/Cargo.toml

@@ -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]

common/config/Cargo.toml

@@ -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
 

common/cosmwasm-smart-contracts/contracts-common/Cargo.toml

@@ -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"

common/cosmwasm-smart-contracts/contracts-common/src/events.rs

@@ -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
+}

common/cosmwasm-smart-contracts/contracts-common/src/lib.rs

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

common/cosmwasm-smart-contracts/mixnet-contract/Cargo.toml

@@ -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 = []

common/cosmwasm-smart-contracts/mixnet-contract/src/delegation.rs

@@ -66,7 +66,7 @@ impl Delegation {
 }
 
 impl Display for Delegation {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(
             f,
             "{} delegated towards {} by {} at block {}",

common/cosmwasm-smart-contracts/mixnet-contract/src/events.rs

@@ -0,0 +1,338 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::mixnode::NodeRewardResult;
+use crate::{ContractStateParams, Delegation, IdentityKeyRef, Interval, Layer};
+use cosmwasm_std::{Addr, Coin, Event, Uint128};
+
+pub use contracts_common::events::*;
+
+// event types
+pub const DELEGATION_EVENT_TYPE: &str = "delegation";
+pub const UNDELEGATION_EVENT_TYPE: &str = "undelegation";
+pub const GATEWAY_BONDING_EVENT_TYPE: &str = "gateway_bonding";
+pub const GATEWAY_UNBONDING_EVENT_TYPE: &str = "gateway_unbonding";
+pub const MIXNODE_BONDING_EVENT_TYPE: &str = "mixnode_bonding";
+pub const MIXNODE_UNBONDING_EVENT_TYPE: &str = "mixnode_unbonding";
+pub const SETTINGS_UPDATE_EVENT_TYPE: &str = "settings_update";
+pub const OPERATOR_REWARDING_EVENT_TYPE: &str = "mix_rewarding";
+pub const MIX_DELEGATORS_REWARDING_EVENT_TYPE: &str = "mix_delegators_rewarding";
+pub const CHANGE_REWARDED_SET_EVENT_TYPE: &str = "change_rewarded_set";
+pub const ADVANCE_INTERVAL_EVENT_TYPE: &str = "advance_interval";
+
+// attributes that are used in multiple places
+pub const OWNER_KEY: &str = "owner";
+pub const AMOUNT_KEY: &str = "amount";
+pub const PROXY_KEY: &str = "proxy";
+
+// event-specific attributes
+
+// delegation/undelegation
+pub const DELEGATOR_KEY: &str = "delegator";
+pub const DELEGATION_TARGET_KEY: &str = "delegation_target";
+pub const DELEGATION_HEIGHT_KEY: &str = "delegation_latest_block_height";
+
+// bonding/unbonding
+pub const NODE_IDENTITY_KEY: &str = "identity";
+pub const ASSIGNED_LAYER_KEY: &str = "assigned_layer";
+
+// settings change
+pub const OLD_MINIMUM_MIXNODE_PLEDGE_KEY: &str = "old_minimum_mixnode_pledge";
+pub const OLD_MINIMUM_GATEWAY_PLEDGE_KEY: &str = "old_minimum_gateway_pledge";
+pub const OLD_MIXNODE_REWARDED_SET_SIZE_KEY: &str = "old_mixnode_rewarded_set_size";
+pub const OLD_MIXNODE_ACTIVE_SET_SIZE_KEY: &str = "old_mixnode_active_set_size";
+pub const OLD_ACTIVE_SET_WORK_FACTOR_KEY: &str = "old_active_set_work_factor";
+
+pub const NEW_MINIMUM_MIXNODE_PLEDGE_KEY: &str = "new_minimum_mixnode_pledge";
+pub const NEW_MINIMUM_GATEWAY_PLEDGE_KEY: &str = "new_minimum_gateway_pledge";
+pub const NEW_MIXNODE_REWARDED_SET_SIZE_KEY: &str = "new_mixnode_rewarded_set_size";
+pub const NEW_MIXNODE_ACTIVE_SET_SIZE_KEY: &str = "new_mixnode_active_set_size";
+
+// rewarding
+pub const INTERVAL_ID_KEY: &str = "interval_id";
+pub const TOTAL_MIXNODE_REWARD_KEY: &str = "total_node_reward";
+pub const OPERATOR_REWARD_KEY: &str = "operator_reward";
+pub const LAMBDA_KEY: &str = "lambda";
+pub const SIGMA_KEY: &str = "sigma";
+pub const DISTRIBUTED_DELEGATION_REWARDS_KEY: &str = "distributed_delegation_rewards";
+pub const FURTHER_DELEGATIONS_TO_REWARD_KEY: &str = "further_delegations";
+pub const NO_REWARD_REASON_KEY: &str = "no_reward_reason";
+pub const BOND_NOT_FOUND_VALUE: &str = "bond_not_found";
+pub const BOND_TOO_FRESH_VALUE: &str = "bond_too_fresh";
+pub const ZERO_UPTIME_VALUE: &str = "zero_uptime";
+
+// rewarded set update
+pub const ACTIVE_SET_SIZE_KEY: &str = "active_set_size";
+pub const REWARDED_SET_SIZE_KEY: &str = "rewarded_set_size";
+pub const NODES_IN_REWARDED_SET_KEY: &str = "nodes_in_rewarded_set";
+pub const CURRENT_INTERVAL_ID_KEY: &str = "current_interval";
+
+pub const NEW_CURRENT_INTERVAL_KEY: &str = "new_current_interval";
+
+pub fn new_delegation_event(
+    delegator: &Addr,
+    proxy: &Option<Addr>,
+    amount: &Coin,
+    mix_identity: IdentityKeyRef<'_>,
+) -> Event {
+    let mut event = Event::new(DELEGATION_EVENT_TYPE).add_attribute(DELEGATOR_KEY, delegator);
+
+    if let Some(proxy) = proxy {
+        event = event.add_attribute(PROXY_KEY, proxy)
+    }
+
+    // coin implements Display trait and we use that implementation here
+    event
+        .add_attribute(AMOUNT_KEY, amount.to_string())
+        .add_attribute(DELEGATION_TARGET_KEY, mix_identity)
+}
+
+pub fn new_undelegation_event(
+    delegator: &Addr,
+    proxy: &Option<Addr>,
+    old_delegation: &Delegation,
+    mix_identity: IdentityKeyRef<'_>,
+) -> Event {
+    let mut event = Event::new(UNDELEGATION_EVENT_TYPE).add_attribute(DELEGATOR_KEY, delegator);
+
+    if let Some(proxy) = proxy {
+        event = event.add_attribute(PROXY_KEY, proxy)
+    }
+
+    // coin implements Display trait and we use that implementation here
+    event
+        .add_attribute(AMOUNT_KEY, old_delegation.amount.to_string())
+        .add_attribute(
+            DELEGATION_HEIGHT_KEY,
+            old_delegation.block_height.to_string(),
+        )
+        .add_attribute(DELEGATION_TARGET_KEY, mix_identity)
+}
+
+pub fn new_gateway_bonding_event(
+    owner: &Addr,
+    proxy: &Option<Addr>,
+    amount: &Coin,
+    identity: IdentityKeyRef<'_>,
+) -> Event {
+    let mut event = Event::new(GATEWAY_BONDING_EVENT_TYPE)
+        .add_attribute(OWNER_KEY, owner)
+        .add_attribute(NODE_IDENTITY_KEY, identity);
+
+    if let Some(proxy) = proxy {
+        event = event.add_attribute(PROXY_KEY, proxy)
+    }
+
+    // coin implements Display trait and we use that implementation here
+    event.add_attribute(AMOUNT_KEY, amount.to_string())
+}
+
+pub fn new_gateway_unbonding_event(
+    owner: &Addr,
+    proxy: &Option<Addr>,
+    amount: &Coin,
+    identity: IdentityKeyRef<'_>,
+) -> Event {
+    let mut event = Event::new(GATEWAY_UNBONDING_EVENT_TYPE)
+        .add_attribute(OWNER_KEY, owner)
+        .add_attribute(NODE_IDENTITY_KEY, identity);
+
+    if let Some(proxy) = proxy {
+        event = event.add_attribute(PROXY_KEY, proxy)
+    }
+
+    // coin implements Display trait and we use that implementation here
+    event.add_attribute(AMOUNT_KEY, amount.to_string())
+}
+
+pub fn new_mixnode_bonding_event(
+    owner: &Addr,
+    proxy: &Option<Addr>,
+    amount: &Coin,
+    identity: IdentityKeyRef<'_>,
+    assigned_layer: Layer,
+) -> Event {
+    let mut event = Event::new(MIXNODE_BONDING_EVENT_TYPE)
+        .add_attribute(OWNER_KEY, owner)
+        .add_attribute(NODE_IDENTITY_KEY, identity);
+
+    if let Some(proxy) = proxy {
+        event = event.add_attribute(PROXY_KEY, proxy)
+    }
+
+    // coin implements Display trait and we use that implementation here
+    event
+        .add_attribute(ASSIGNED_LAYER_KEY, assigned_layer)
+        .add_attribute(AMOUNT_KEY, amount.to_string())
+}
+
+pub fn new_mixnode_unbonding_event(
+    owner: &Addr,
+    proxy: &Option<Addr>,
+    amount: &Coin,
+    identity: IdentityKeyRef<'_>,
+) -> Event {
+    let mut event = Event::new(MIXNODE_UNBONDING_EVENT_TYPE)
+        .add_attribute(OWNER_KEY, owner)
+        .add_attribute(NODE_IDENTITY_KEY, identity);
+
+    if let Some(proxy) = proxy {
+        event = event.add_attribute(PROXY_KEY, proxy)
+    }
+
+    // coin implements Display trait and we use that implementation here
+    event.add_attribute(AMOUNT_KEY, amount.to_string())
+}
+
+pub fn new_settings_update_event(
+    old_params: &ContractStateParams,
+    new_params: &ContractStateParams,
+) -> Event {
+    let mut event = Event::new(SETTINGS_UPDATE_EVENT_TYPE);
+
+    if old_params.minimum_mixnode_pledge != new_params.minimum_mixnode_pledge {
+        event = event
+            .add_attribute(
+                OLD_MINIMUM_MIXNODE_PLEDGE_KEY,
+                old_params.minimum_mixnode_pledge,
+            )
+            .add_attribute(
+                NEW_MINIMUM_MIXNODE_PLEDGE_KEY,
+                new_params.minimum_mixnode_pledge,
+            )
+    }
+
+    if old_params.minimum_gateway_pledge != new_params.minimum_gateway_pledge {
+        event = event
+            .add_attribute(
+                OLD_MINIMUM_GATEWAY_PLEDGE_KEY,
+                old_params.minimum_gateway_pledge,
+            )
+            .add_attribute(
+                NEW_MINIMUM_GATEWAY_PLEDGE_KEY,
+                new_params.minimum_gateway_pledge,
+            )
+    }
+
+    if old_params.mixnode_rewarded_set_size != new_params.mixnode_rewarded_set_size {
+        event = event
+            .add_attribute(
+                OLD_MIXNODE_REWARDED_SET_SIZE_KEY,
+                old_params.mixnode_rewarded_set_size.to_string(),
+            )
+            .add_attribute(
+                NEW_MIXNODE_REWARDED_SET_SIZE_KEY,
+                new_params.mixnode_rewarded_set_size.to_string(),
+            )
+    }
+
+    if old_params.mixnode_active_set_size != new_params.mixnode_active_set_size {
+        event = event
+            .add_attribute(
+                OLD_MIXNODE_ACTIVE_SET_SIZE_KEY,
+                old_params.mixnode_active_set_size.to_string(),
+            )
+            .add_attribute(
+                NEW_MIXNODE_ACTIVE_SET_SIZE_KEY,
+                new_params.mixnode_active_set_size.to_string(),
+            )
+    }
+
+    event
+}
+
+pub fn new_not_found_mix_operator_rewarding_event(
+    interval_id: u32,
+    identity: IdentityKeyRef<'_>,
+) -> Event {
+    Event::new(OPERATOR_REWARDING_EVENT_TYPE)
+        .add_attribute(INTERVAL_ID_KEY, interval_id.to_string())
+        .add_attribute(NODE_IDENTITY_KEY, identity)
+        .add_attribute(NO_REWARD_REASON_KEY, BOND_NOT_FOUND_VALUE)
+}
+
+pub fn new_too_fresh_bond_mix_operator_rewarding_event(
+    interval_id: u32,
+    identity: IdentityKeyRef<'_>,
+) -> Event {
+    Event::new(OPERATOR_REWARDING_EVENT_TYPE)
+        .add_attribute(INTERVAL_ID_KEY, interval_id.to_string())
+        .add_attribute(NODE_IDENTITY_KEY, identity)
+        .add_attribute(NO_REWARD_REASON_KEY, BOND_TOO_FRESH_VALUE)
+}
+
+pub fn new_zero_uptime_mix_operator_rewarding_event(
+    interval_id: u32,
+    identity: IdentityKeyRef<'_>,
+) -> Event {
+    Event::new(OPERATOR_REWARDING_EVENT_TYPE)
+        .add_attribute(INTERVAL_ID_KEY, interval_id.to_string())
+        .add_attribute(NODE_IDENTITY_KEY, identity)
+        .add_attribute(NO_REWARD_REASON_KEY, ZERO_UPTIME_VALUE)
+}
+
+pub fn new_mix_operator_rewarding_event(
+    interval_id: u32,
+    identity: IdentityKeyRef<'_>,
+    node_reward_result: NodeRewardResult,
+    operator_reward: Uint128,
+    delegation_rewards_distributed: Uint128,
+    further_delegations: bool,
+) -> Event {
+    Event::new(OPERATOR_REWARDING_EVENT_TYPE)
+        .add_attribute(INTERVAL_ID_KEY, interval_id.to_string())
+        .add_attribute(NODE_IDENTITY_KEY, identity)
+        .add_attribute(
+            TOTAL_MIXNODE_REWARD_KEY,
+            node_reward_result.reward().to_string(),
+        )
+        .add_attribute(LAMBDA_KEY, node_reward_result.lambda().to_string())
+        .add_attribute(SIGMA_KEY, node_reward_result.sigma().to_string())
+        .add_attribute(OPERATOR_REWARD_KEY, operator_reward)
+        .add_attribute(
+            DISTRIBUTED_DELEGATION_REWARDS_KEY,
+            delegation_rewards_distributed,
+        )
+        .add_attribute(
+            FURTHER_DELEGATIONS_TO_REWARD_KEY,
+            further_delegations.to_string(),
+        )
+}
+
+pub fn new_mix_delegators_rewarding_event(
+    interval_id: u32,
+    identity: IdentityKeyRef<'_>,
+    delegation_rewards_distributed: Uint128,
+    further_delegations: bool,
+) -> Event {
+    Event::new(MIX_DELEGATORS_REWARDING_EVENT_TYPE)
+        .add_attribute(INTERVAL_ID_KEY, interval_id.to_string())
+        .add_attribute(NODE_IDENTITY_KEY, identity)
+        .add_attribute(
+            DISTRIBUTED_DELEGATION_REWARDS_KEY,
+            delegation_rewards_distributed,
+        )
+        .add_attribute(
+            FURTHER_DELEGATIONS_TO_REWARD_KEY,
+            further_delegations.to_string(),
+        )
+}
+
+// note that when this event is emitted, we'll know the current block height
+pub fn new_change_rewarded_set_event(
+    active_set_size: u32,
+    rewarded_set_size: u32,
+    nodes_in_rewarded_set: u32,
+    current_interval_id: u32,
+) -> Event {
+    Event::new(CHANGE_REWARDED_SET_EVENT_TYPE)
+        .add_attribute(ACTIVE_SET_SIZE_KEY, active_set_size.to_string())
+        .add_attribute(REWARDED_SET_SIZE_KEY, rewarded_set_size.to_string())
+        .add_attribute(NODES_IN_REWARDED_SET_KEY, nodes_in_rewarded_set.to_string())
+        .add_attribute(CURRENT_INTERVAL_ID_KEY, current_interval_id.to_string())
+}
+
+pub fn new_advance_interval_event(interval: Interval) -> Event {
+    Event::new(ADVANCE_INTERVAL_EVENT_TYPE)
+        .add_attribute(NEW_CURRENT_INTERVAL_KEY, interval.to_string())
+}

common/cosmwasm-smart-contracts/mixnet-contract/src/gateway.rs

@@ -98,7 +98,7 @@ impl PartialOrd for GatewayBond {
 }
 
 impl Display for GatewayBond {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(
             f,
             "amount: {} {}, owner: {}, identity: {}",

common/cosmwasm-smart-contracts/mixnet-contract/src/interval.rs

@@ -0,0 +1,365 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use serde::{Deserialize, Serialize};
+use std::convert::TryInto;
+use std::fmt::{Display, Formatter};
+use std::time::Duration;
+use time::OffsetDateTime;
+
+// internally, since version 0.3.6, time uses deserialize_any for deserialization, which can't be handled
+// by serde wasm. We could just downgrade to 0.3.5 and call it a day, but then it would break
+// when we decided to upgrade it at some point in the future. And then it would have been more problematic
+// to fix it, since the data would have already been stored inside the contract.
+// Hence, an explicit workaround to use string representation of Rfc3339-formatted datetime.
+pub(crate) mod string_rfc3339_offset_date_time {
+    use serde::de::Visitor;
+    use serde::ser::Error;
+    use serde::{Deserializer, Serialize, Serializer};
+    use std::fmt::Formatter;
+    use time::format_description::well_known::Rfc3339;
+    use time::OffsetDateTime;
+
+    struct Rfc3339OffsetDateTimeVisitor;
+
+    impl<'de> Visitor<'de> for Rfc3339OffsetDateTimeVisitor {
+        type Value = OffsetDateTime;
+
+        fn expecting(&self, formatter: &mut Formatter<'_>) -> std::fmt::Result {
+            formatter.write_str("an rfc3339 `OffsetDateTime`")
+        }
+
+        fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+        where
+            E: serde::de::Error,
+        {
+            OffsetDateTime::parse(value, &Rfc3339).map_err(E::custom)
+        }
+    }
+
+    pub(crate) fn deserialize<'de, D>(deserializer: D) -> Result<OffsetDateTime, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(Rfc3339OffsetDateTimeVisitor)
+    }
+
+    pub(crate) fn serialize<S>(datetime: &OffsetDateTime, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        datetime
+            .format(&Rfc3339)
+            .map_err(S::Error::custom)?
+            .serialize(serializer)
+    }
+}
+
+/// Representation of rewarding interval.
+#[derive(Clone, Copy, Debug, Deserialize, PartialEq, PartialOrd, Serialize)]
+pub struct Interval {
+    id: u32,
+    #[serde(with = "string_rfc3339_offset_date_time")]
+    start: OffsetDateTime,
+    length: Duration,
+}
+
+impl Interval {
+    /// Creates new interval instance.
+    pub const fn new(id: u32, start: OffsetDateTime, length: Duration) -> Self {
+        Interval { id, start, length }
+    }
+
+    /// Returns the next interval.
+    #[must_use]
+    pub fn next_interval(&self) -> Self {
+        Interval {
+            id: self.id + 1,
+            start: self.end(),
+            length: self.length,
+        }
+    }
+
+    /// Returns the last interval.
+    pub fn previous_interval(&self) -> Option<Self> {
+        if self.id > 0 {
+            Some(Interval {
+                id: self.id - 1,
+                start: self.start - self.length,
+                length: self.length,
+            })
+        } else {
+            None
+        }
+    }
+
+    /// Determines whether the provided datetime is contained within the interval
+    ///
+    /// # Arguments
+    ///
+    /// * `datetime`: specified datetime
+    pub fn contains(&self, datetime: OffsetDateTime) -> bool {
+        self.start <= datetime && datetime <= self.end()
+    }
+
+    /// Determines whether the provided unix timestamp is contained within the interval
+    ///
+    /// # Arguments
+    ///
+    /// * `timestamp`: specified timestamp
+    pub fn contains_timestamp(&self, timestamp: i64) -> bool {
+        self.start_unix_timestamp() <= timestamp && timestamp <= self.end_unix_timestamp()
+    }
+
+    /// Returns new instance of [Interval] such that the provided datetime would be within
+    /// its duration.
+    ///
+    /// # Arguments
+    ///
+    /// * `now`: current datetime
+    pub fn current(&self, now: OffsetDateTime) -> Option<Self> {
+        let mut candidate = *self;
+
+        if now > self.start {
+            loop {
+                if candidate.contains(now) {
+                    return Some(candidate);
+                }
+                candidate = candidate.next_interval();
+            }
+        } else {
+            loop {
+                if candidate.contains(now) {
+                    return Some(candidate);
+                }
+                candidate = candidate.previous_interval()?;
+            }
+        }
+    }
+
+    /// Returns new instance of [Interval] such that the provided unix timestamp would be within
+    /// its duration.
+    ///
+    /// # Arguments
+    ///
+    /// * `now_unix`: current unix time
+    pub fn current_with_timestamp(&self, now_unix: i64) -> Option<Self> {
+        let mut candidate = *self;
+
+        if now_unix > self.start_unix_timestamp() {
+            loop {
+                if candidate.contains_timestamp(now_unix) {
+                    return Some(candidate);
+                }
+                candidate = candidate.next_interval();
+            }
+        } else {
+            loop {
+                if candidate.contains_timestamp(now_unix) {
+                    return Some(candidate);
+                }
+                candidate = candidate.previous_interval()?;
+            }
+        }
+    }
+
+    /// Checks whether this interval has already finished
+    ///
+    /// # Arguments
+    ///
+    /// * `now`: current datetime
+    pub fn has_elapsed(&self, now: OffsetDateTime) -> bool {
+        self.end() < now
+    }
+
+    /// Returns id of this interval
+    pub const fn id(&self) -> u32 {
+        self.id
+    }
+
+    /// Determines amount of time left until this interval finishes.
+    ///
+    /// # Arguments
+    ///
+    /// * `now`: current datetime
+    pub fn until_end(&self, now: OffsetDateTime) -> Option<Duration> {
+        let remaining = self.end() - now;
+        if remaining.is_negative() {
+            None
+        } else {
+            remaining.try_into().ok()
+        }
+    }
+
+    /// Returns the starting datetime of this interval.
+    pub const fn start(&self) -> OffsetDateTime {
+        self.start
+    }
+
+    /// Returns the length of this interval.
+    pub const fn length(&self) -> Duration {
+        self.length
+    }
+
+    /// Returns the ending datetime of this interval.
+    pub fn end(&self) -> OffsetDateTime {
+        self.start + self.length
+    }
+
+    /// Returns the unix timestamp of the start of this interval.
+    pub const fn start_unix_timestamp(&self) -> i64 {
+        self.start().unix_timestamp()
+    }
+
+    /// Returns the unix timestamp of the end of this interval.
+    pub fn end_unix_timestamp(&self) -> i64 {
+        self.end().unix_timestamp()
+    }
+}
+
+impl Display for Interval {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        let length = self.length().as_secs();
+        let full_hours = length / 3600;
+        let rem = length % 3600;
+        write!(
+            f,
+            "Interval {}: {} - {} ({}h {}s)",
+            self.id,
+            self.start(),
+            self.end(),
+            full_hours,
+            rem
+        )
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn previous_interval() {
+        let interval = Interval {
+            id: 1,
+            start: time::macros::datetime!(2021-08-23 12:00 UTC),
+            length: Duration::from_secs(24 * 60 * 60),
+        };
+        let expected = Interval {
+            id: 0,
+            start: time::macros::datetime!(2021-08-22 12:00 UTC),
+            length: Duration::from_secs(24 * 60 * 60),
+        };
+        assert_eq!(expected, interval.previous_interval().unwrap());
+
+        let genesis_interval = Interval {
+            id: 0,
+            start: time::macros::datetime!(2021-08-23 12:00 UTC),
+            length: Duration::from_secs(24 * 60 * 60),
+        };
+        assert!(genesis_interval.previous_interval().is_none());
+    }
+
+    #[test]
+    fn next_interval() {
+        let interval = Interval {
+            id: 0,
+            start: time::macros::datetime!(2021-08-23 12:00 UTC),
+            length: Duration::from_secs(24 * 60 * 60),
+        };
+        let expected = Interval {
+            id: 1,
+            start: time::macros::datetime!(2021-08-24 12:00 UTC),
+            length: Duration::from_secs(24 * 60 * 60),
+        };
+
+        assert_eq!(expected, interval.next_interval())
+    }
+
+    #[test]
+    fn checking_for_datetime_inclusion() {
+        let interval = Interval {
+            id: 100,
+            start: time::macros::datetime!(2021-08-23 12:00 UTC),
+            length: Duration::from_secs(24 * 60 * 60),
+        };
+
+        // it must contain its own boundaries
+        assert!(interval.contains(interval.start));
+        assert!(interval.contains(interval.end()));
+
+        let in_the_midle = interval.start + Duration::from_secs(interval.length.as_secs() / 2);
+        assert!(interval.contains(in_the_midle));
+
+        assert!(!interval.contains(interval.next_interval().end()));
+        assert!(!interval.contains(interval.previous_interval().unwrap().start()));
+    }
+
+    #[test]
+    fn determining_current_interval() {
+        let first_interval = Interval {
+            id: 100,
+            start: time::macros::datetime!(2021-08-23 12:00 UTC),
+            length: Duration::from_secs(24 * 60 * 60),
+        };
+
+        // interval just before
+        let fake_now = first_interval.start - Duration::from_secs(123);
+        assert_eq!(
+            first_interval.previous_interval(),
+            first_interval.current(fake_now)
+        );
+
+        // this interval (start boundary)
+        assert_eq!(
+            first_interval,
+            first_interval.current(first_interval.start).unwrap()
+        );
+
+        // this interval (in the middle)
+        let fake_now = first_interval.start + Duration::from_secs(123);
+        assert_eq!(first_interval, first_interval.current(fake_now).unwrap());
+
+        // this interval (end boundary)
+        assert_eq!(
+            first_interval,
+            first_interval.current(first_interval.end()).unwrap()
+        );
+
+        // next interval
+        let fake_now = first_interval.end() + Duration::from_secs(123);
+        assert_eq!(
+            first_interval.next_interval(),
+            first_interval.current(fake_now).unwrap()
+        );
+
+        // few intervals in the past
+        let fake_now = first_interval.start()
+            - first_interval.length
+            - first_interval.length
+            - first_interval.length;
+        assert_eq!(
+            first_interval
+                .previous_interval()
+                .unwrap()
+                .previous_interval()
+                .unwrap()
+                .previous_interval()
+                .unwrap(),
+            first_interval.current(fake_now).unwrap()
+        );
+
+        // few intervals in the future
+        let fake_now = first_interval.end()
+            + first_interval.length
+            + first_interval.length
+            + first_interval.length;
+        assert_eq!(
+            first_interval
+                .next_interval()
+                .next_interval()
+                .next_interval(),
+            first_interval.current(fake_now).unwrap()
+        );
+    }
+}

common/cosmwasm-smart-contracts/mixnet-contract/src/lib.rs

@@ -3,7 +3,9 @@
 
 mod delegation;
 pub mod error;
+pub mod events;
 mod gateway;
+mod interval;
 pub mod mixnode;
 mod msg;
 mod types;
@@ -16,6 +18,9 @@ pub use delegation::{
     PagedMixDelegationsResponse,
 };
 pub use gateway::{Gateway, GatewayBond, GatewayOwnershipResponse, PagedGatewayResponse};
-pub use mixnode::{Layer, MixNode, MixNodeBond, MixOwnershipResponse, PagedMixnodeResponse};
+pub use interval::Interval;
+pub use mixnode::{
+    Layer, MixNode, MixNodeBond, MixOwnershipResponse, PagedMixnodeResponse, RewardedSetNodeStatus,
+};
 pub use msg::*;
 pub use types::*;

common/cosmwasm-smart-contracts/mixnet-contract/src/mixnode.rs

@@ -5,7 +5,7 @@ use crate::{IdentityKey, SphinxKey};
 use az::CheckedCast;
 use cosmwasm_std::{coin, Addr, Coin, Uint128};
 use log::error;
-use network_defaults::DEFAULT_OPERATOR_EPOCH_COST;
+use network_defaults::DEFAULT_OPERATOR_INTERVAL_COST;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use serde_repr::{Deserialize_repr, Serialize_repr};
@@ -18,6 +18,19 @@ fixed::const_fixed_from_int! {
     const ONE: U128 = 1;
 }
 
+#[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
+#[derive(Clone, Copy, Debug, Deserialize, PartialEq, PartialOrd, Serialize, JsonSchema)]
+pub enum RewardedSetNodeStatus {
+    Active,
+    Standby,
+}
+
+impl RewardedSetNodeStatus {
+    pub fn is_active(&self) -> bool {
+        matches!(self, RewardedSetNodeStatus::Active)
+    }
+}
+
 #[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
 #[derive(Clone, Debug, Deserialize, PartialEq, PartialOrd, Serialize, JsonSchema)]
 pub struct MixNode {
@@ -53,6 +66,16 @@ pub enum Layer {
     Three = 3,
 }
 
+impl From<Layer> for String {
+    fn from(layer: Layer) -> Self {
+        if layer == Layer::Gateway {
+            "gateway".to_string()
+        } else {
+            (layer as u8).to_string()
+        }
+    }
+}
+
 #[derive(Debug, Clone, JsonSchema, PartialEq, Serialize, Deserialize, Copy)]
 pub struct NodeRewardParams {
     period_reward_pool: Uint128,
@@ -123,7 +146,7 @@ impl NodeRewardParams {
     }
 
     pub fn operator_cost(&self) -> U128 {
-        U128::from_num(self.uptime.u128() / 100u128 * DEFAULT_OPERATOR_EPOCH_COST as u128)
+        U128::from_num(self.uptime.u128() / 100u128 * DEFAULT_OPERATOR_INTERVAL_COST as u128)
     }
 
     pub fn set_reward_blockstamp(&mut self, blockstamp: u64) {
@@ -243,7 +266,7 @@ impl DelegatorRewardParams {
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Copy, Clone)]
 pub struct NodeRewardResult {
     reward: U128,
     lambda: U128,
@@ -315,7 +338,7 @@ impl MixNodeBond {
         &self.mix_node
     }
 
-    pub fn total_stake(&self) -> Option<u128> {
+    pub fn total_bond(&self) -> Option<u128> {
         if self.pledge_amount.denom != self.total_delegation.denom {
             None
         } else {
@@ -327,6 +350,11 @@ impl MixNodeBond {
         self.total_delegation.clone()
     }
 
+    pub fn stake_saturation(&self, circulating_supply: u128, rewarded_set_size: u32) -> U128 {
+        self.total_bond_to_circulating_supply(circulating_supply)
+            * U128::from_num(rewarded_set_size)
+    }
+
     pub fn pledge_to_circulating_supply(&self, circulating_supply: u128) -> U128 {
         U128::from_num(self.pledge_amount().amount.u128()) / U128::from_num(circulating_supply)
     }
@@ -480,7 +508,7 @@ impl PartialOrd for MixNodeBond {
 }
 
 impl Display for MixNodeBond {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(
             f,
             "amount: {} {}, owner: {}, identity: {}",

common/cosmwasm-smart-contracts/mixnet-contract/src/msg.rs

@@ -20,6 +20,9 @@ pub enum ExecuteMsg {
         owner_signature: String,
     },
     UnbondMixnode {},
+    UpdateMixnodeConfig {
+        profit_margin_percent: u8,
+    },
     BondGateway {
         gateway: Gateway,
         owner_signature: String,
@@ -35,28 +38,18 @@ pub enum ExecuteMsg {
         mix_identity: IdentityKey,
     },
 
-    BeginMixnodeRewarding {
-        // nonce of the current rewarding interval
-        rewarding_interval_nonce: u32,
-    },
-
-    FinishMixnodeRewarding {
-        // nonce of the current rewarding interval
-        rewarding_interval_nonce: u32,
-    },
-
     RewardMixnode {
         identity: IdentityKey,
         // percentage value in range 0-100
         params: NodeRewardParams,
 
-        // nonce of the current rewarding interval
-        rewarding_interval_nonce: u32,
+        // id of the current rewarding interval
+        interval_id: u32,
     },
     RewardNextMixDelegators {
         mix_identity: IdentityKey,
-        // nonce of the current rewarding interval
-        rewarding_interval_nonce: u32,
+        // id of the current rewarding interval
+        interval_id: u32,
     },
     DelegateToMixnodeOnBehalf {
         mix_identity: IdentityKey,
@@ -82,6 +75,11 @@ pub enum ExecuteMsg {
     UnbondGatewayOnBehalf {
         owner: String,
     },
+    WriteRewardedSet {
+        rewarded_set: Vec<IdentityKey>,
+        expected_active_set_size: u32,
+    },
+    AdvanceCurrentInterval {},
 }
 
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
@@ -103,7 +101,6 @@ pub enum QueryMsg {
         address: String,
     },
     StateParams {},
-    CurrentRewardingInterval {},
     // gets all [paged] delegations in the entire network
     // TODO: do we even want that?
     GetAllNetworkDelegations {
@@ -134,12 +131,25 @@ pub enum QueryMsg {
     LayerDistribution {},
     GetRewardPool {},
     GetCirculatingSupply {},
-    GetEpochRewardPercent {},
+    GetIntervalRewardPercent {},
     GetSybilResistancePercent {},
+    GetActiveSetWorkFactor {},
     GetRewardingStatus {
         mix_identity: IdentityKey,
-        rewarding_interval_nonce: u32,
+        interval_id: u32,
     },
+    GetRewardedSet {
+        height: Option<u64>,
+        start_after: Option<IdentityKey>,
+        limit: Option<u32>,
+    },
+    GetRewardedSetHeightsForInterval {
+        interval_id: u32,
+    },
+    GetRewardedSetUpdateDetails {},
+    GetCurrentRewardedSetHeight {},
+    GetCurrentInterval {},
+    GetRewardedSetRefreshBlocks {},
 }
 
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]

common/cosmwasm-smart-contracts/mixnet-contract/src/types.rs

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::mixnode::DelegatorRewardParams;
-use crate::Layer;
+use crate::{Layer, RewardedSetNodeStatus};
 use cosmwasm_std::{Addr, Uint128};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
@@ -27,19 +27,12 @@ impl LayerDistribution {
     }
 }
 
-#[derive(Debug, Default, Serialize, Deserialize, Copy, Clone, Eq, PartialEq)]
-pub struct RewardingIntervalResponse {
-    pub current_rewarding_interval_starting_block: u64,
-    pub current_rewarding_interval_nonce: u32,
-    pub rewarding_in_progress: bool,
-}
-
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
 pub struct ContractStateParams {
-    // so currently epoch_length is being unused and validator API performs rewarding
-    // based on its own epoch length config value. I guess that's fine for time being
+    // so currently interval_length is being unused and validator API performs rewarding
+    // based on its own interval length config value. I guess that's fine for time being
     // however, in the future, the contract constant should be controlling it instead.
-    // pub epoch_length: u32, // length of a rewarding epoch/interval, expressed in hours
+    // pub interval_length: u32, // length of a rewarding interval/interval, expressed in hours
     pub minimum_mixnode_pledge: Uint128, // minimum amount a mixnode must pledge to get into the system
     pub minimum_gateway_pledge: Uint128, // minimum amount a gateway must pledge to get into the system
 
@@ -50,7 +43,6 @@ pub struct ContractStateParams {
     // subset of rewarded mixnodes that are actively receiving mix traffic
     // used to handle shorter-term (e.g. hourly) fluctuations of demand
     pub mixnode_active_set_size: u32,
-    pub active_set_work_factor: u8,
 }
 
 impl Display for ContractStateParams {
@@ -75,11 +67,6 @@ impl Display for ContractStateParams {
             f,
             "mixnode active set size: {}",
             self.mixnode_active_set_size
-        )?;
-        write!(
-            f,
-            "mixnode active set work factor: {}",
-            self.active_set_work_factor
         )
     }
 }
@@ -136,3 +123,23 @@ pub struct MixnetContractVersion {
 pub type IdentityKey = String;
 pub type IdentityKeyRef<'a> = &'a str;
 pub type SphinxKey = String;
+
+#[derive(Clone, Debug, Deserialize, PartialEq, Serialize, JsonSchema)]
+pub struct PagedRewardedSetResponse {
+    pub identities: Vec<(IdentityKey, RewardedSetNodeStatus)>,
+    pub start_next_after: Option<IdentityKey>,
+    pub at_height: u64,
+}
+
+#[derive(Clone, Debug, Deserialize, PartialEq, Serialize, JsonSchema)]
+pub struct RewardedSetUpdateDetails {
+    pub refresh_rate_blocks: u64,
+    pub last_refreshed_block: u64,
+    pub current_height: u64,
+}
+
+#[derive(Clone, Debug, Deserialize, PartialEq, Serialize, JsonSchema)]
+pub struct IntervalRewardedSetHeightsResponse {
+    pub interval_id: u32,
+    pub heights: Vec<u64>,
+}

common/cosmwasm-smart-contracts/vesting-contract/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "vesting-contract-common"
+version = "0.1.0"
+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"
+mixnet-contract-common = { path = "../mixnet-contract" }
+serde = { version = "1.0", features = ["derive"] }
+schemars = "0.8"
+cw-storage-plus = "0.11.1"
+config = {path = "../../config"}

common/cosmwasm-smart-contracts/vesting-contract/src/events.rs

@@ -0,0 +1,133 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use cosmwasm_std::{Addr, Coin, Event, Timestamp};
+
+// event types
+pub const WITHDRAW_EVENT_TYPE: &str = "vested_coins_withdraw";
+pub const OWNERSHIP_TRANSFER_EVENT_TYPE: &str = "ownership_transfer";
+pub const STAKING_ADDRESS_UPDATE_EVENT_TYPE: &str = "staking_address_update";
+pub const NEW_PERIODIC_VESTING_ACCOUNT_EVENT_TYPE: &str = "new_periodic_vesting_account";
+
+pub const VESTING_DELEGATION_EVENT_TYPE: &str = "vesting_delegation";
+pub const VESTING_UNDELEGATION_EVENT_TYPE: &str = "vesting_undelegation";
+pub const VESTING_GATEWAY_BONDING_EVENT_TYPE: &str = "vesting_gateway_bonding";
+pub const VESTING_GATEWAY_UNBONDING_EVENT_TYPE: &str = "vesting_gateway_unbonding";
+pub const VESTING_MIXNODE_BONDING_EVENT_TYPE: &str = "vesting_mixnode_bonding";
+pub const VESTING_MIXNODE_UNBONDING_EVENT_TYPE: &str = "vesting_mixnode_unbonding";
+
+pub const TRACK_MIXNODE_UNBOND_EVENT_TYPE: &str = "track_mixnode_unbond";
+pub const TRACK_GATEWAY_UNBOND_EVENT_TYPE: &str = "track_gateway_unbond";
+pub const TRACK_UNDELEGATION_EVENT_TYPE: &str = "track_undelegation";
+
+// attributes that are used in multiple places
+pub const OWNER_KEY: &str = "owner";
+pub const AMOUNT_KEY: &str = "amount";
+
+// event-specific attributes
+
+// withdraw
+pub const REMAINING_SPENDABLE_KEY: &str = "remaining_spendable";
+
+// ownership transfer
+pub const FROM_ACCOUNT_KEY: &str = "from";
+pub const TO_ACCOUNT_KEY: &str = "to";
+pub const NO_VALUE_VALUE: &str = "none";
+
+// new vesting account
+pub const START_TIME_KEY: &str = "start_time";
+pub const STAKING_ADDRESS_KEY: &str = "staking_address";
+
+// OPEN QUESTION: would it make sense to also emit amount of vesting/locked coins here?
+// however, then it would require additional storage reads.
+pub fn new_vested_coins_withdraw_event(
+    address: &Addr,
+    amount: &Coin,
+    remaining_spendable: &Coin,
+) -> Event {
+    Event::new(WITHDRAW_EVENT_TYPE)
+        .add_attribute(OWNER_KEY, address)
+        .add_attribute(AMOUNT_KEY, amount.to_string())
+        .add_attribute(REMAINING_SPENDABLE_KEY, remaining_spendable.to_string())
+}
+
+pub fn new_ownership_transfer_event(from: &Addr, to: &Addr) -> Event {
+    Event::new(OWNERSHIP_TRANSFER_EVENT_TYPE)
+        .add_attribute(FROM_ACCOUNT_KEY, from)
+        .add_attribute(TO_ACCOUNT_KEY, to)
+}
+
+pub fn new_staking_address_update_event(from: &Option<Addr>, to: &Option<Addr>) -> Event {
+    let mut event = Event::new(OWNERSHIP_TRANSFER_EVENT_TYPE);
+
+    if let Some(from) = from {
+        event = event.add_attribute(FROM_ACCOUNT_KEY, from)
+    } else {
+        event = event.add_attribute(FROM_ACCOUNT_KEY, NO_VALUE_VALUE);
+    }
+
+    if let Some(to) = to {
+        event = event.add_attribute(TO_ACCOUNT_KEY, to)
+    } else {
+        event = event.add_attribute(TO_ACCOUNT_KEY, NO_VALUE_VALUE);
+    }
+
+    event
+}
+
+pub fn new_periodic_vesting_account_event(
+    owner_address: &Addr,
+    amount: &Coin,
+    staking_address: &Option<Addr>,
+    start_time: Timestamp,
+) -> Event {
+    let mut event = Event::new(NEW_PERIODIC_VESTING_ACCOUNT_EVENT_TYPE)
+        .add_attribute(OWNER_KEY, owner_address)
+        .add_attribute(AMOUNT_KEY, amount.to_string());
+
+    if let Some(staking_address) = staking_address {
+        event = event.add_attribute(STAKING_ADDRESS_KEY, staking_address);
+    }
+
+    event.add_attribute(START_TIME_KEY, start_time.to_string())
+}
+
+// In most cases the events are rather barebone as there's no point in attaching
+// bunch of data to them as it would be redundant. It is because in most cases when the event is emitted
+// a call to the mixnet contract is made that throws another event with relevant attributes already attached.
+
+pub fn new_vesting_gateway_bonding_event() -> Event {
+    Event::new(VESTING_GATEWAY_BONDING_EVENT_TYPE)
+}
+
+pub fn new_vesting_gateway_unbonding_event() -> Event {
+    Event::new(VESTING_GATEWAY_UNBONDING_EVENT_TYPE)
+}
+
+pub fn new_vesting_mixnode_bonding_event() -> Event {
+    Event::new(VESTING_MIXNODE_BONDING_EVENT_TYPE)
+}
+
+pub fn new_vesting_mixnode_unbonding_event() -> Event {
+    Event::new(VESTING_MIXNODE_UNBONDING_EVENT_TYPE)
+}
+
+pub fn new_vesting_delegation_event() -> Event {
+    Event::new(VESTING_DELEGATION_EVENT_TYPE)
+}
+
+pub fn new_vesting_undelegation_event() -> Event {
+    Event::new(VESTING_UNDELEGATION_EVENT_TYPE)
+}
+
+pub fn new_track_mixnode_unbond_event() -> Event {
+    Event::new(TRACK_MIXNODE_UNBOND_EVENT_TYPE)
+}
+
+pub fn new_track_gateway_unbond_event() -> Event {
+    Event::new(TRACK_GATEWAY_UNBOND_EVENT_TYPE)
+}
+
+pub fn new_track_undelegation_event() -> Event {
+    Event::new(TRACK_UNDELEGATION_EVENT_TYPE)
+}

common/cosmwasm-smart-contracts/vesting-contract/src/lib.rs

@@ -0,0 +1,11 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+use config::defaults::DENOM;
+use cosmwasm_std::Coin;
+
+pub mod events;
+pub mod messages;
+
+pub fn one_unym() -> Coin {
+    Coin::new(1, DENOM)
+}

common/cosmwasm-smart-contracts/vesting-contract/src/messages.rs

@@ -1,25 +1,68 @@
 use cosmwasm_std::{Coin, Timestamp};
-use mixnet_contract::IdentityKey;
-use mixnet_contract::{Gateway, MixNode};
+use mixnet_contract_common::{Gateway, IdentityKey, MixNode};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
 #[serde(rename_all = "snake_case")]
-pub struct InitMsg {}
+pub struct InitMsg {
+    pub mixnet_contract_address: String,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
+#[serde(rename_all = "snake_case")]
+pub struct MigrateMsg {}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema, Default)]
+pub struct VestingSpecification {
+    start_time: Option<u64>,
+    period_seconds: Option<u64>,
+    num_periods: Option<u64>,
+}
+
+impl VestingSpecification {
+    pub fn new(
+        start_time: Option<u64>,
+        period_seconds: Option<u64>,
+        num_periods: Option<u64>,
+    ) -> Self {
+        Self {
+            start_time,
+            period_seconds,
+            num_periods,
+        }
+    }
+
+    pub fn start_time(&self) -> Option<u64> {
+        self.start_time
+    }
+
+    pub fn period_seconds(&self) -> u64 {
+        self.period_seconds.unwrap_or(3 * 30 * 86400)
+    }
+
+    pub fn num_periods(&self) -> u64 {
+        self.num_periods.unwrap_or(8)
+    }
+}
 
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub enum ExecuteMsg {
+    UpdateMixnetAddress {
+        address: String,
+    },
     DelegateToMixnode {
         mix_identity: IdentityKey,
+        amount: Coin,
     },
     UndelegateFromMixnode {
         mix_identity: IdentityKey,
     },
     CreateAccount {
-        address: String,
-        start_time: Option<u64>,
+        owner_address: String,
+        staking_address: Option<String>,
+        vesting_spec: Option<VestingSpecification>,
     },
     WithdrawVestedCoins {
         amount: Coin,
@@ -32,6 +75,7 @@ pub enum ExecuteMsg {
     BondMixnode {
         mix_node: MixNode,
         owner_signature: String,
+        amount: Coin,
     },
     UnbondMixnode {},
     TrackUnbondMixnode {
@@ -41,12 +85,19 @@ pub enum ExecuteMsg {
     BondGateway {
         gateway: Gateway,
         owner_signature: String,
+        amount: Coin,
     },
     UnbondGateway {},
     TrackUnbondGateway {
         owner: String,
         amount: Coin,
     },
+    TransferOwnership {
+        to_address: String,
+    },
+    UpdateStakingAddress {
+        to_address: Option<String>,
+    },
 }
 
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
@@ -85,4 +136,13 @@ pub enum QueryMsg {
         block_time: Option<Timestamp>,
         vesting_account_address: String,
     },
+    GetAccount {
+        address: String,
+    },
+    GetMixnode {
+        address: String,
+    },
+    GetGateway {
+        address: String,
+    },
 }

common/credentials/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "credentials"
 version = "0.1.0"
-edition = "2018"
+edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 

common/credentials/src/coconut/bandwidth.rs

@@ -27,7 +27,7 @@ pub struct BandwidthVoucherAttributes {
     pub binding_number: PrivateAttribute,
     // the value (e.g., bandwidth) encoded in this voucher
     pub voucher_value: PublicAttribute,
-    // a field with public information, e.g., type of voucher, epoch etc.
+    // a field with public information, e.g., type of voucher, interval etc.
     pub voucher_info: PublicAttribute,
 }
 

common/credentials/src/coconut/utils.rs

@@ -28,7 +28,7 @@ use crate::error::Error;
 /// use credentials::obtain_aggregate_verification_key;
 ///
 /// async fn example() -> Result<(), ParseError> {
-///     let validators = vec!["https://testnet-milhon-validator1.nymtech.net/api".parse()?, "https://testnet-milhon-validator2.nymtech.net/api".parse()?];
+///     let validators = vec!["https://sandbox-validator1.nymtech.net/api".parse()?, "https://sandbox-validator2.nymtech.net/api".parse()?];
 ///     let aggregated_key = obtain_aggregate_verification_key(&validators).await;
 ///     // deal with the obtained Result
 ///     Ok(())

common/crypto/Cargo.toml

@@ -2,14 +2,14 @@
 name = "crypto"
 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
 
 [dependencies]
 aes = { version = "0.7.4", features = ["ctr"] }
 bs58 = "0.4.0"
-blake3 = { version = "1.0.0", features = ["traits-preview"] }
+blake3 = { version = "~1.2.0", features = ["traits-preview"] }
 digest = "0.9.0"
 generic-array = "0.14"
 hkdf = "0.11.0"

common/crypto/src/hkdf.rs

@@ -22,7 +22,7 @@ where
 
     let hkdf = Hkdf::<D>::new(salt, ikm);
     let mut okm = vec![0u8; okm_length];
-    hkdf.expand(info.unwrap_or_else(|| &[]), &mut okm)?;
+    hkdf.expand(info.unwrap_or(&[]), &mut okm)?;
 
     Ok(okm)
 }

common/mixnode-common/Cargo.toml

@@ -2,7 +2,7 @@
 name = "mixnode-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
 

common/mixnode-common/src/verloc/mod.rs

@@ -77,6 +77,7 @@ impl Config {
     }
 }
 
+#[must_use]
 pub struct ConfigBuilder(Config);
 
 impl ConfigBuilder {

common/network-defaults/Cargo.toml

@@ -2,12 +2,12 @@
 name = "network-defaults"
 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]
+cfg-if = "1.0.0"
 hex-literal = "0.3.3"
 serde = {version = "1.0", features = ["derive"]}
 url = "2.2"
-time = { version = "0.3", features = ["macros"] }

common/network-defaults/build.rs

@@ -3,7 +3,7 @@
 
 fn main() {
     match option_env!("NETWORK") {
-        Some("milhon") => println!("cargo:rustc-cfg=network=\"milhon\"",),
+        Some("mainnet") => println!("cargo:rustc-cfg=network=\"mainnet\"",),
         None | Some("sandbox") => println!("cargo:rustc-cfg=network=\"sandbox\"",),
         Some("qa") => println!("cargo:rustc-cfg=network=\"qa\""),
         _ => panic!("No such network"),

common/network-defaults/src/all.rs

@@ -0,0 +1,141 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+use crate::{mainnet, qa, sandbox, ValidatorDetails};
+
+#[derive(Copy, Clone, Debug, Deserialize, Eq, Hash, PartialEq, Serialize)]
+pub enum Network {
+    QA,
+    SANDBOX,
+    MAINNET,
+}
+
+impl Network {
+    pub fn bech32_prefix(&self) -> String {
+        match self {
+            Self::QA => String::from(qa::BECH32_PREFIX),
+            Self::SANDBOX => String::from(sandbox::BECH32_PREFIX),
+            Self::MAINNET => String::from(mainnet::BECH32_PREFIX),
+        }
+    }
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct NetworkDetails {
+    bech32_prefix: String,
+    denom: String,
+    mixnet_contract_address: String,
+    vesting_contract_address: String,
+    bandwidth_claim_contract_address: String,
+    rewarding_validator_address: String,
+    validators: Vec<ValidatorDetails>,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct SupportedNetworks {
+    networks: HashMap<Network, NetworkDetails>,
+}
+
+impl SupportedNetworks {
+    pub fn new(support: Vec<Network>) -> Self {
+        let mut networks = HashMap::new();
+
+        for network in support {
+            match network {
+                Network::MAINNET => networks.insert(
+                    Network::MAINNET,
+                    NetworkDetails {
+                        bech32_prefix: String::from(mainnet::BECH32_PREFIX),
+                        denom: String::from(mainnet::DENOM),
+                        mixnet_contract_address: String::from(mainnet::MIXNET_CONTRACT_ADDRESS),
+                        vesting_contract_address: String::from(mainnet::VESTING_CONTRACT_ADDRESS),
+                        bandwidth_claim_contract_address: String::from(
+                            mainnet::BANDWIDTH_CLAIM_CONTRACT_ADDRESS,
+                        ),
+                        rewarding_validator_address: String::from(
+                            mainnet::REWARDING_VALIDATOR_ADDRESS,
+                        ),
+                        validators: mainnet::validators(),
+                    },
+                ),
+
+                Network::SANDBOX => networks.insert(
+                    Network::SANDBOX,
+                    NetworkDetails {
+                        bech32_prefix: String::from(sandbox::BECH32_PREFIX),
+                        denom: String::from(sandbox::DENOM),
+                        mixnet_contract_address: String::from(sandbox::MIXNET_CONTRACT_ADDRESS),
+                        vesting_contract_address: String::from(sandbox::VESTING_CONTRACT_ADDRESS),
+                        bandwidth_claim_contract_address: String::from(
+                            sandbox::BANDWIDTH_CLAIM_CONTRACT_ADDRESS,
+                        ),
+                        rewarding_validator_address: String::from(
+                            sandbox::REWARDING_VALIDATOR_ADDRESS,
+                        ),
+                        validators: sandbox::validators(),
+                    },
+                ),
+                Network::QA => networks.insert(
+                    Network::QA,
+                    NetworkDetails {
+                        bech32_prefix: String::from(qa::BECH32_PREFIX),
+                        denom: String::from(qa::DENOM),
+                        mixnet_contract_address: String::from(qa::MIXNET_CONTRACT_ADDRESS),
+                        vesting_contract_address: String::from(qa::VESTING_CONTRACT_ADDRESS),
+                        bandwidth_claim_contract_address: String::from(
+                            qa::BANDWIDTH_CLAIM_CONTRACT_ADDRESS,
+                        ),
+                        rewarding_validator_address: String::from(qa::REWARDING_VALIDATOR_ADDRESS),
+                        validators: qa::validators(),
+                    },
+                ),
+            };
+        }
+        SupportedNetworks { networks }
+    }
+
+    pub fn bech32_prefix(&self, network: Network) -> Option<&str> {
+        self.networks
+            .get(&network)
+            .map(|network_details| network_details.bech32_prefix.as_str())
+    }
+
+    pub fn denom(&self, network: Network) -> Option<&str> {
+        self.networks
+            .get(&network)
+            .map(|network_details| network_details.denom.as_str())
+    }
+
+    pub fn mixnet_contract_address(&self, network: Network) -> Option<&str> {
+        self.networks
+            .get(&network)
+            .map(|network_details| network_details.mixnet_contract_address.as_str())
+    }
+
+    pub fn vesting_contract_address(&self, network: Network) -> Option<&str> {
+        self.networks
+            .get(&network)
+            .map(|network_details| network_details.vesting_contract_address.as_str())
+    }
+
+    pub fn bandwidth_claim_contract_address(&self, network: Network) -> Option<&str> {
+        self.networks
+            .get(&network)
+            .map(|network_details| network_details.bandwidth_claim_contract_address.as_str())
+    }
+
+    pub fn rewarding_validator_address(&self, network: Network) -> Option<&str> {
+        self.networks
+            .get(&network)
+            .map(|network_details| network_details.rewarding_validator_address.as_str())
+    }
+
+    pub fn validators(&self, network: Network) -> Option<&Vec<ValidatorDetails>> {
+        self.networks
+            .get(&network)
+            .map(|network_details| &network_details.validators)
+    }
+}

common/network-defaults/src/lib.rs

@@ -1,20 +1,65 @@
 // Copyright 2020 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 use serde::{Deserialize, Serialize};
-use std::time::Duration;
-use time::OffsetDateTime;
 use url::Url;
 
+pub mod all;
 pub mod eth_contract;
-#[cfg(network = "milhon")]
-pub mod milhon;
-#[cfg(network = "sandbox")]
+pub mod mainnet;
+pub mod qa;
 pub mod sandbox;
 
-#[cfg(network = "milhon")]
-pub use milhon::*;
-#[cfg(network = "sandbox")]
-pub use sandbox::*;
+cfg_if::cfg_if! {
+    if #[cfg(network = "mainnet")] {
+        pub const BECH32_PREFIX: &str = mainnet::BECH32_PREFIX;
+        pub const DENOM: &str = mainnet::DENOM;
+
+        pub const DEFAULT_MIXNET_CONTRACT_ADDRESS: &str = mainnet::MIXNET_CONTRACT_ADDRESS;
+        pub const DEFAULT_VESTING_CONTRACT_ADDRESS: &str = mainnet::VESTING_CONTRACT_ADDRESS;
+        pub const DEFAULT_BANDWIDTH_CLAIM_CONTRACT_ADDRESS: &str = mainnet::BANDWIDTH_CLAIM_CONTRACT_ADDRESS;
+        pub const DEFAULT_REWARDING_VALIDATOR_ADDRESS: &str = mainnet::REWARDING_VALIDATOR_ADDRESS;
+
+        pub fn default_validators() -> Vec<ValidatorDetails> {
+            mainnet::validators()
+        }
+
+        pub fn default_network() -> all::Network {
+            all::Network::MAINNET
+        }
+    } else if #[cfg(network = "qa")] {
+        pub const BECH32_PREFIX: &str = qa::BECH32_PREFIX;
+        pub const DENOM: &str = qa::DENOM;
+
+        pub const DEFAULT_MIXNET_CONTRACT_ADDRESS: &str = qa::MIXNET_CONTRACT_ADDRESS;
+        pub const DEFAULT_VESTING_CONTRACT_ADDRESS: &str = qa::VESTING_CONTRACT_ADDRESS;
+        pub const DEFAULT_BANDWIDTH_CLAIM_CONTRACT_ADDRESS: &str = qa::BANDWIDTH_CLAIM_CONTRACT_ADDRESS;
+        pub const DEFAULT_REWARDING_VALIDATOR: &str = qa::REWARDING_VALIDATOR_ADDRESS;
+
+        pub fn default_validators() -> Vec<ValidatorDetails> {
+            qa::validators()
+        }
+
+        pub fn default_network() -> all::Network {
+            all::Network::QA
+        }
+    } else if #[cfg(network = "sandbox")] {
+        pub const BECH32_PREFIX: &str = sandbox::BECH32_PREFIX;
+        pub const DENOM: &str = sandbox::DENOM;
+
+        pub const DEFAULT_MIXNET_CONTRACT_ADDRESS: &str = sandbox::MIXNET_CONTRACT_ADDRESS;
+        pub const DEFAULT_VESTING_CONTRACT_ADDRESS: &str = sandbox::VESTING_CONTRACT_ADDRESS;
+        pub const DEFAULT_BANDWIDTH_CLAIM_CONTRACT_ADDRESS: &str = sandbox::BANDWIDTH_CLAIM_CONTRACT_ADDRESS;
+        pub const DEFAULT_REWARDING_VALIDATOR: &str = sandbox::REWARDING_VALIDATOR_ADDRESS;
+
+        pub fn default_validators() -> Vec<ValidatorDetails> {
+            sandbox::validators()
+        }
+
+        pub fn default_network() -> all::Network {
+            all::Network::SANDBOX
+        }
+    }
+}
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct ValidatorDetails {
@@ -47,25 +92,6 @@ impl ValidatorDetails {
     }
 }
 
-#[cfg(network = "milhon")]
-pub fn default_validators() -> Vec<ValidatorDetails> {
-    vec![
-        ValidatorDetails::new(
-            "https://testnet-milhon-validator1.nymtech.net",
-            Some("https://testnet-milhon-validator1.nymtech.net/api"),
-        ),
-        ValidatorDetails::new("https://testnet-milhon-validator2.nymtech.net", None),
-    ]
-}
-
-#[cfg(network = "sandbox")]
-pub fn default_validators() -> Vec<ValidatorDetails> {
-    vec![ValidatorDetails::new(
-        "https://sandbox-validator.nymtech.net",
-        Some("https://sandbox-validator.nymtech.net/api"),
-    )]
-}
-
 pub fn default_nymd_endpoints() -> Vec<Url> {
     default_validators()
         .iter()
@@ -80,6 +106,13 @@ pub fn default_api_endpoints() -> Vec<Url> {
         .collect()
 }
 
+pub const ETH_CONTRACT_ADDRESS: [u8; 20] =
+    hex_literal::hex!("9fEE3e28c17dbB87310A51F13C4fbf4331A6f102");
+// Name of the event triggered by the eth contract. If the event name is changed,
+// this would also need to be changed; It is currently tested against the json abi
+pub const ETH_EVENT_NAME: &str = "Burned";
+pub const ETH_BURN_FUNCTION_NAME: &str = "burnTokenForAccessCode";
+
 // Ethereum constants used for token bridge
 /// How much bandwidth (in bytes) one token can buy
 const BYTES_PER_TOKEN: u64 = 1024 * 1024 * 1024;
@@ -117,10 +150,9 @@ pub const DEFAULT_VALIDATOR_API_PORT: u16 = 8080;
 pub const VALIDATOR_API_VERSION: &str = "v1";
 
 // REWARDING
-pub const DEFAULT_FIRST_EPOCH_START: OffsetDateTime = time::macros::datetime!(2021-08-23 12:00 UTC);
-pub const DEFAULT_EPOCH_LENGTH: Duration = Duration::from_secs(24 * 60 * 60 * 30); // 30 days
-/// We'll be assuming a few more things, profit margin and cost function. Since we don't have relialable package measurement, we'll be using uptime. We'll also set the value of 1 Nym to 1 $, to be able to translate epoch costs to Nyms. We'll also assume a cost of 40$ per epoch(month), converting that to Nym at our 1$ rate translates to 40_000_000 uNyms
-pub const DEFAULT_OPERATOR_EPOCH_COST: u64 = 40_000_000; // 40$/(30 days) at 1 Nym == 1$
+
+/// We'll be assuming a few more things, profit margin and cost function. Since we don't have relialable package measurement, we'll be using uptime. We'll also set the value of 1 Nym to 1 $, to be able to translate interval costs to Nyms. We'll also assume a cost of 40$ per interval(month), converting that to Nym at our 1$ rate translates to 40_000_000 uNyms
+pub const DEFAULT_OPERATOR_INTERVAL_COST: u64 = 40_000_000; // 40$/(30 days) at 1 Nym == 1$
 
 // TODO: is there a way to get this from the chain
 pub const TOTAL_SUPPLY: u128 = 1_000_000_000_000_000;

common/network-defaults/src/mainnet.rs

@@ -0,0 +1,20 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::ValidatorDetails;
+
+pub(crate) const BECH32_PREFIX: &str = "n";
+pub const DENOM: &str = "unym";
+
+pub(crate) const MIXNET_CONTRACT_ADDRESS: &str = "n19lc9u84cz0yz3fww5283nucc9yvr8gsjmgeul0";
+pub(crate) const VESTING_CONTRACT_ADDRESS: &str = "n19lc9u84cz0yz3fww5283nucc9yvr8gsjmgeul0";
+pub(crate) const BANDWIDTH_CLAIM_CONTRACT_ADDRESS: &str =
+    "n19lc9u84cz0yz3fww5283nucc9yvr8gsjmgeul0";
+pub(crate) const REWARDING_VALIDATOR_ADDRESS: &str = "n17zujduc46wvkwvp6f062mm5xhr7jc3fewvqu9e";
+
+pub(crate) fn validators() -> Vec<ValidatorDetails> {
+    vec![ValidatorDetails::new(
+        "https://rpc.nyx.nodes.guru/",
+        Some("https://api.nyx.nodes.guru/"),
+    )]
+}

common/network-defaults/src/milhon.rs

@@ -1,17 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-pub const BECH32_PREFIX: &str = "punk";
-pub const DENOM: &str = "upunk";
-
-pub const DEFAULT_MIXNET_CONTRACT_ADDRESS: &str = "punk10pyejy66429refv3g35g2t7am0was7yalwrzen";
-pub const DEFAULT_VESTING_CONTRACT_ADDRESS: &str = "";
-pub const BANDWIDTH_CLAIM_CONTRACT_ADDRESS: &str = "punk1jld76tqw4wnpfenmay2xkv86nr3j0w426eka82";
-pub const REWARDING_VALIDATOR_ADDRESS: &str = "punk1v9qauwdq5terag6uvfsdytcs2d0sdmfdy7hgk3";
-pub const ETH_CONTRACT_ADDRESS: [u8; 20] =
-    hex_literal::hex!("9fEE3e28c17dbB87310A51F13C4fbf4331A6f102");
-
-// Name of the event triggered by the eth contract. If the event name is changed,
-// this would also need to be changed; It is currently tested against the json abi
-pub const ETH_EVENT_NAME: &str = "Burned";
-pub const ETH_BURN_FUNCTION_NAME: &str = "burnTokenForAccessCode";

common/network-defaults/src/qa.rs

@@ -0,0 +1,20 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::ValidatorDetails;
+
+pub(crate) const BECH32_PREFIX: &str = "nymt";
+pub const DENOM: &str = "unymt";
+
+pub(crate) const MIXNET_CONTRACT_ADDRESS: &str = "nymt14hj2tavq8fpesdwxxcu44rty3hh90vhuysqrsr";
+pub(crate) const VESTING_CONTRACT_ADDRESS: &str = "nymt17p9rzwnnfxcjp32un9ug7yhhzgtkhvl9f8xzkv";
+pub(crate) const BANDWIDTH_CLAIM_CONTRACT_ADDRESS: &str =
+    "nymt17p9rzwnnfxcjp32un9ug7yhhzgtkhvl9f8xzkv";
+pub(crate) const REWARDING_VALIDATOR_ADDRESS: &str = "nymt1dn52nx8wv9wkqmrvj6tcmdzh4es6jt8tr7f6j9";
+
+pub(crate) fn validators() -> Vec<ValidatorDetails> {
+    vec![ValidatorDetails::new(
+        "https://qa-validator.nymtech.net",
+        Some("https://qa-validator.nymtech.net/api"),
+    )]
+}

common/network-defaults/src/sandbox.rs

@@ -1,17 +1,20 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-pub const BECH32_PREFIX: &str = "nymt";
+use crate::ValidatorDetails;
+
+pub(crate) const BECH32_PREFIX: &str = "nymt";
 pub const DENOM: &str = "unymt";
 
-pub const DEFAULT_MIXNET_CONTRACT_ADDRESS: &str = "nymt1ghd753shjuwexxywmgs4xz7x2q732vcnstz02j";
-pub const DEFAULT_VESTING_CONTRACT_ADDRESS: &str = "nymt1nc5tatafv6eyq7llkr2gv50ff9e22mnfp9pc5s";
-pub const BANDWIDTH_CLAIM_CONTRACT_ADDRESS: &str = "nymt17p9rzwnnfxcjp32un9ug7yhhzgtkhvl9f8xzkv";
-pub const REWARDING_VALIDATOR_ADDRESS: &str = "nymt17zujduc46wvkwvp6f062mm5xhr7jc3fewvqu9e";
-pub const ETH_CONTRACT_ADDRESS: [u8; 20] =
-    hex_literal::hex!("9fEE3e28c17dbB87310A51F13C4fbf4331A6f102");
+pub(crate) const MIXNET_CONTRACT_ADDRESS: &str = "nymt1ghd753shjuwexxywmgs4xz7x2q732vcnstz02j";
+pub(crate) const VESTING_CONTRACT_ADDRESS: &str = "nymt1nc5tatafv6eyq7llkr2gv50ff9e22mnfp9pc5s";
+pub(crate) const BANDWIDTH_CLAIM_CONTRACT_ADDRESS: &str =
+    "nymt17p9rzwnnfxcjp32un9ug7yhhzgtkhvl9f8xzkv";
+pub(crate) const REWARDING_VALIDATOR_ADDRESS: &str = "nymt17zujduc46wvkwvp6f062mm5xhr7jc3fewvqu9e";
 
-// Name of the event triggered by the eth contract. If the event name is changed,
-// this would also need to be changed; It is currently tested against the json abi
-pub const ETH_EVENT_NAME: &str = "Burned";
-pub const ETH_BURN_FUNCTION_NAME: &str = "burnTokenForAccessCode";
+pub(crate) fn validators() -> Vec<ValidatorDetails> {
+    vec![ValidatorDetails::new(
+        "https://sandbox-validator.nymtech.net",
+        Some("https://sandbox-validator.nymtech.net/api"),
+    )]
+}

common/nonexhaustive-delayqueue/Cargo.toml

@@ -2,7 +2,7 @@
 name = "nonexhaustive-delayqueue"
 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
 

common/nymcoconut/Cargo.toml

@@ -2,7 +2,7 @@
 name = "nymcoconut"
 version = "0.5.0"
 authors = ["Jedrzej Stuczynski <andrew@nymtech.net>", "Ania Piotrowska <ania@nymtech.net>"]
-edition = "2018"
+edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html