WIP

NE: 407 filters granularity

.github/workflows/nightly_build.yml

@@ -44,6 +44,12 @@ jobs:
           command: build
           args: --workspace
 
+      - name: Reclaim some disk space (because Windows is being annoying)
+        uses: actions-rs/cargo@v1
+        if: ${{ matrix.os == 'windows-latest' }}
+        with:
+          command: clean
+
       - name: Run all tests
         uses: actions-rs/cargo@v1
         with:
@@ -101,6 +107,12 @@ jobs:
           command: build
           args: --workspace --features=coconut
 
+      - name: Reclaim some disk space (because Windows is being annoying)
+        uses: actions-rs/cargo@v1
+        if: ${{ matrix.os == 'windows-latest' }}
+        with:
+          command: clean
+
       - name: Run all tests with coconut enabled
         uses: actions-rs/cargo@v1
         with:

.github/workflows/nightly_build_on_dispatch.yml

@@ -167,7 +167,7 @@ jobs:
           KEYBASE_NYMBOT_USERNAME: "${{ secrets.KEYBASE_NYMBOT_USERNAME }}"
           KEYBASE_NYMBOT_PAPERKEY: "${{ secrets.KEYBASE_NYMBOT_PAPERKEY }}"
           KEYBASE_NYMBOT_TEAM: "${{ secrets.KEYBASE_NYMTECH_TEAM }}"
-          KEYBASE_NYM_CHANNEL: "test"
+          KEYBASE_NYM_CHANNEL: "${{ secrets.KEYBASE_CHANNEL_DEV_CORE_ID }}"
           IS_SUCCESS: "${{ env.WORKFLOW_CONCLUSION == 'success' }}"
         uses: docker://keybaseio/client:stable-node
         with:

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

@@ -0,0 +1,50 @@
+name: Publish Nym CLI binaries
+
+on:
+  workflow_dispatch:
+  release:
+    types: [created]
+    
+env:
+  NETWORK: mainnet
+
+jobs:
+  publish-nym-cli:
+    strategy:
+      fail-fast: false
+      matrix:
+        platform: [ubuntu-latest, windows-latest, macos-latest]
+
+    runs-on: ${{ matrix.platform }}
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Check the release tag starts with `nym-cli-`
+        if: startsWith(github.ref, 'refs/tags/nym-cli-') == false && github.event_name != 'workflow_dispatch'
+        uses: actions/github-script@v3
+        with:
+          script: |
+            core.setFailed('Release tag did not start with nym-cli-...')
+
+      - name: Install Rust stable
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+
+      - name: Build binary
+        run: make build-nym-cli
+
+      - name: Upload Artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: nym-cli-${{ matrix.platform }}
+          path: |
+            target/release/nym-cli*
+          retention-days: 30
+
+      - name: Upload to release based on tag name
+        uses: softprops/action-gh-release@v1
+        if: github.event_name == 'release'
+        with:
+          files: |
+            target/release/nym-cli

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

@@ -1,5 +1,7 @@
 name: Publish Nym binaries
+
 on:
+  workflow_dispatch:
   release:
     types: [created]
     
@@ -18,7 +20,7 @@ jobs:
       - uses: actions/checkout@v3
 
       - name: Check the release tag starts with `nym-binaries-`
-        if: startsWith(github.ref, 'refs/tags/nym-binaries-') == false
+        if: startsWith(github.ref, 'refs/tags/nym-binaries-') == false && github.event_name != 'workflow_dispatch'
         uses: actions/github-script@v3
         with:
           script: |
@@ -35,8 +37,24 @@ jobs:
           command: build
           args: --workspace --release
 
+      - name: Upload Artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: my-artifact
+          path: |
+            target/release/nym-client
+            target/release/nym-gateway
+            target/release/nym-mixnode
+            target/release/nym-socks5-client
+            target/release/nym-validator-api
+            target/release/nym-network-requester
+            target/release/nym-network-statistics
+            target/release/nym-cli
+          retention-days: 30
+
       - name: Upload to release based on tag name
         uses: softprops/action-gh-release@v1
+        if: github.event_name == 'release'
         with:
           files: |
             target/release/nym-client
@@ -45,4 +63,5 @@ jobs:
             target/release/nym-socks5-client
             target/release/nym-validator-api
             target/release/nym-network-requester
-            target/release/nym-network-statistics
+            target/release/nym-network-statistics
+            target/release/nym-cli

.github/workflows/support-files/notifications/send_message.js

@@ -89,7 +89,7 @@ async function sendKeybaseMessage(messageBody) {
     });
 
     const channel = {
-      name: 'nymtech_bot',
+      name: context.env.KEYBASE_NYMBOT_TEAM || 'nymtech_bot',
       membersType: 'team',
       topicName: context.keybase.channel,
       topic_type: 'CHAT',

CHANGELOG.md

@@ -4,11 +4,23 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://
 
 ## Unreleased
 
+### Added
+
+- nym-cli: added CLI tool for interacting with the Nyx blockchain and Nym mixnet smart contracts ([#1577])
+- validator-client: added `query_contract_smart` and `query_contract_raw` on `NymdClient` ([#1558])
+- network-requester: added additional Blockstream Green wallet endpoint to `example.allowed.list` ([#1611](https://github.com/nymtech/nym/pull/1611))
+
 ### Changed
 
 - validator-client: made `fee` argument optional for `execute` and `execute_multiple` ([#1541])
+- socks5 client: graceful shutdown should fix error on disconnect in nym-connect ([#1591])
+- wasm-client: fixed build errors on MacOS and changed example JS code to use mainnet ([#1585])
 
 [#1541]: https://github.com/nymtech/nym/pull/1541
+[#1558]: https://github.com/nymtech/nym/pull/1558
+[#1577]: https://github.com/nymtech/nym/pull/1577
+[#1585]: https://github.com/nymtech/nym/pull/1585
+[#1591]: https://github.com/nymtech/nym/pull/1591
 
 
 ## [nym-binaries-1.0.2](https://github.com/nymtech/nym/tree/nym-binaries-1.0.2)
@@ -27,6 +39,7 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://
 - validator-api: add Swagger to document the REST API ([#1249]).
 - validator-api: Added new endpoints for coconut spending flow and communications with coconut & multisig contracts ([#1261])
 - validator-api: add `uptime`, `estimated_operator_apy`, `estimated_delegators_apy` to `/mixnodes/detailed` endpoint ([#1393])
+- validator-api: add node info cache storing simulated active set inclusion probabilities
 - network-statistics: a new mixnet service that aggregates and exposes anonymized data about mixnet services ([#1328])
 - mixnode: Added basic mixnode hardware reporting to the HTTP API ([#1308]).
 - validator-api: endpoint, in coconut mode, for returning the validator-api cosmos address ([#1404]).
@@ -46,7 +59,7 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://
 - validator: fixed local docker-compose setup to work on Apple M1 ([#1329])
 - explorer-api: listen out for SIGTERM and SIGQUIT too, making it play nicely as a system service ([#1482]).
 - network-requester: fix filter for suffix-only domains ([#1487])
-- validator-api: listen out for SIGTERM and SIGQUIT too, making it play nicely as a system service ([#1496]).
+- validator-api: listen out for SIGTERM and SIGQUIT too, making it play nicely as a system service; cleaner shutdown, without panics ([#1496], [#1573]).
 
 ### Changed
 
@@ -63,6 +76,7 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://
 - gateway, network-statistics: include gateway id in the sent statistical data ([#1478])
 - network explorer: tweak how active set probability is shown ([#1503])
 - validator-api: rewarder set update fails without panicking on possible nymd queries ([#1520])
+- network-requester, socks5 client (nym-connect): send and receive respectively a message error to be displayed about filter check failure ([#1576]) 
 
 
 [#1249]: https://github.com/nymtech/nym/pull/1249
@@ -92,6 +106,8 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://
 [#1496]: https://github.com/nymtech/nym/pull/1496
 [#1503]: https://github.com/nymtech/nym/pull/1503
 [#1520]: https://github.com/nymtech/nym/pull/1520
+[#1573]: https://github.com/nymtech/nym/pull/1573
+[#1576]: https://github.com/nymtech/nym/pull/1576
 
 ## [v1.0.1](https://github.com/nymtech/nym/tree/v1.0.1) (2022-05-04)
 

Cargo.toml

@@ -27,6 +27,7 @@ members = [
     "common/client-libs/mixnet-client",
     "common/client-libs/validator-client",
     "common/coconut-interface",
+    "common/commands",
     "common/config",
     "common/cosmwasm-smart-contracts/coconut-bandwidth-contract",
     "common/cosmwasm-smart-contracts/contracts-common",
@@ -69,6 +70,7 @@ members = [
     "service-providers/network-statistics",
     "validator-api",
     "validator-api/validator-api-requests",
+    "tools/nym-cli",
     "tools/ts-rs-cli"
 ]
 
@@ -83,4 +85,4 @@ default-members = [
     "explorer-api",
 ]
 
-exclude = ["explorer", "contracts", "tokenomics-py", "clients/webassembly", "nym-wallet", "nym-connect"]
+exclude = ["explorer", "contracts", "clients/webassembly", "nym-wallet", "nym-connect"]

Makefile

@@ -2,10 +2,10 @@ test: clippy-all cargo-test wasm fmt
 test-all: test cargo-test-expensive
 no-clippy: build cargo-test wasm fmt
 happy: fmt clippy-happy test
-clippy-all: clippy-all-main clippy-all-contracts clippy-all-wallet clippy-all-connect
+clippy-all: clippy-main clippy-coconut clippy-all-contracts clippy-all-wallet clippy-all-connect
 clippy-happy: clippy-happy-main clippy-happy-contracts clippy-happy-wallet clippy-happy-connect
-cargo-test: test-main test-contracts test-wallet test-connect
-cargo-test-expensive: test-main-expensive test-contracts-expensive test-wallet-expensive test-connect-expensive
+cargo-test: test-main test-contracts test-wallet test-connect test-coconut
+cargo-test-expensive: test-main-expensive test-contracts-expensive test-wallet-expensive test-connect-expensive test-coconut-expensive
 build: build-contracts build-wallet build-main build-connect
 fmt: fmt-main fmt-contracts fmt-wallet fmt-connect
 
@@ -21,8 +21,15 @@ clippy-happy-wallet:
 clippy-happy-connect:
 	cargo clippy --manifest-path nym-connect/Cargo.toml
 
-clippy-all-main:
-	cargo clippy --workspace --all-features -- -D warnings
+clippy-main:
+	cargo clippy --workspace -- -D warnings
+
+clippy-coconut:
+	cargo clippy --workspace --features coconut -- -D warnings
+
+clippy-wasm:
+	cargo clippy --workspace --features wasm -- -D warnings
+
 
 clippy-all-contracts:
 	cargo clippy --workspace --manifest-path contracts/Cargo.toml --all-features --target wasm32-unknown-unknown -- -D warnings
@@ -34,10 +41,20 @@ clippy-all-connect:
 	cargo clippy --workspace --manifest-path nym-connect/Cargo.toml --all-features -- -D warnings
 
 test-main:
-	cargo test --all-features --workspace
+	cargo test --workspace
+
+test-coconut:
+	cargo test --workspace --features coconut
+
+test-wasm:
+	cargo test --workspace --features wasm
+
 
 test-main-expensive:
-	cargo test --all-features --workspace -- --ignored
+	cargo test --workspace -- --ignored
+
+test-coconut-expensive:
+	cargo test --workspace --features coconut -- --ignored
 
 test-contracts:
 	cargo test --manifest-path contracts/Cargo.toml --all-features
@@ -69,6 +86,9 @@ build-wallet:
 build-connect:
 	cargo build --manifest-path nym-connect/Cargo.toml --workspace
 
+build-nym-cli:
+	cargo build --release --manifest-path tools/nym-cli/Cargo.toml
+
 fmt-main:
 	cargo fmt --all
 

clients/client-core/Cargo.toml

@@ -14,6 +14,7 @@ log = "0.4"
 rand = { version = "0.7.3", features = ["wasm-bindgen"] }
 serde = { version = "1.0", features = ["derive"] }
 sled = "0.34"
+thiserror = "1.0.34"
 tokio = { version = "1.19.1", features = ["macros"] }
 url = { version ="2.2", features = ["serde"] }
 
@@ -25,8 +26,10 @@ gateway-requests = { path = "../../gateway/gateway-requests" }
 nonexhaustive-delayqueue = { path = "../../common/nonexhaustive-delayqueue" }
 nymsphinx = { path = "../../common/nymsphinx" }
 pemstore = { path = "../../common/pemstore" }
+task = { path = "../../common/task" }
 topology = { path = "../../common/topology" }
 validator-client = { path = "../../common/client-libs/validator-client" }
+tap = "1.0.1"
 
 [dev-dependencies]
 tempfile = "3.1.0"

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

@@ -13,6 +13,7 @@ use nymsphinx::utils::sample_poisson_duration;
 use rand::{rngs::OsRng, CryptoRng, Rng};
 use std::pin::Pin;
 use std::sync::Arc;
+use task::ShutdownListener;
 use tokio::task::JoinHandle;
 use tokio::time;
 
@@ -48,6 +49,9 @@ where
 
     /// Accessor to the common instance of network topology.
     topology_access: TopologyAccessor,
+
+    /// Listen to shutdown signals.
+    shutdown: ShutdownListener,
 }
 
 impl<R> Stream for LoopCoverTrafficStream<R>
@@ -84,6 +88,7 @@ where
 // obviously when we finally make shared rng that is on 'higher' level, this should become
 // generic `R`
 impl LoopCoverTrafficStream<OsRng> {
+    #[allow(clippy::too_many_arguments)]
     pub fn new(
         ack_key: Arc<AckKey>,
         average_ack_delay: time::Duration,
@@ -92,6 +97,7 @@ impl LoopCoverTrafficStream<OsRng> {
         mix_tx: BatchMixMessageSender,
         our_full_destination: Recipient,
         topology_access: TopologyAccessor,
+        shutdown: ShutdownListener,
     ) -> Self {
         let rng = OsRng;
 
@@ -105,6 +111,7 @@ impl LoopCoverTrafficStream<OsRng> {
             our_full_destination,
             rng,
             topology_access,
+            shutdown,
         }
     }
 
@@ -159,9 +166,25 @@ impl LoopCoverTrafficStream<OsRng> {
             self.average_cover_message_sending_delay,
         )));
 
-        while self.next().await.is_some() {
-            self.on_new_message().await;
+        let mut shutdown = self.shutdown.clone();
+        while !shutdown.is_shutdown() {
+            tokio::select! {
+                biased;
+                _ = shutdown.recv() => {
+                    log::trace!("LoopCoverTrafficStream: Received shutdown");
+                }
+                next = self.next() => {
+                    if next.is_some() {
+                        self.on_new_message().await;
+                    } else {
+                        log::trace!("LoopCoverTrafficStream: Stopping since channel closed");
+                        break;
+                    }
+                }
+            }
         }
+        assert!(self.shutdown.is_shutdown_poll());
+        log::debug!("LoopCoverTrafficStream: Exiting");
     }
 
     pub fn start(mut self) -> JoinHandle<()> {

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

@@ -6,6 +6,7 @@ use futures::StreamExt;
 use gateway_client::GatewayClient;
 use log::*;
 use nymsphinx::forwarding::packet::MixPacket;
+use task::ShutdownListener;
 use tokio::task::JoinHandle;
 
 pub type BatchMixMessageSender = mpsc::UnboundedSender<Vec<MixPacket>>;
@@ -18,6 +19,7 @@ pub struct MixTrafficController {
     // later on gateway_client will need to be accessible by other entities
     gateway_client: GatewayClient,
     mix_rx: BatchMixMessageReceiver,
+    shutdown: ShutdownListener,
 
     // TODO: this is temporary work-around.
     // in long run `gateway_client` will be moved away from `MixTrafficController` anyway.
@@ -28,10 +30,12 @@ impl MixTrafficController {
     pub fn new(
         mix_rx: BatchMixMessageReceiver,
         gateway_client: GatewayClient,
+        shutdown: ShutdownListener,
     ) -> MixTrafficController {
         MixTrafficController {
             gateway_client,
             mix_rx,
+            shutdown,
             consecutive_gateway_failure_count: 0,
         }
     }
@@ -66,9 +70,24 @@ impl MixTrafficController {
     }
 
     pub async fn run(&mut self) {
-        while let Some(mix_packets) = self.mix_rx.next().await {
-            self.on_messages(mix_packets).await;
+        while !self.shutdown.is_shutdown() {
+            tokio::select! {
+                mix_packets = self.mix_rx.next() => match mix_packets {
+                    Some(mix_packets) => {
+                        self.on_messages(mix_packets).await;
+                    },
+                    None => {
+                        log::trace!("MixTrafficController: Stopping since channel closed");
+                        break;
+                    }
+                },
+                _ = self.shutdown.recv() => {
+                    log::trace!("MixTrafficController: Received shutdown");
+                }
+            }
         }
+        assert!(self.shutdown.is_shutdown_poll());
+        log::debug!("MixTrafficController: Exiting");
     }
 
     pub fn start(mut self) -> JoinHandle<()> {

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

@@ -1,3 +1,5 @@
+use std::sync::atomic::AtomicBool;
+
 pub mod cover_traffic_stream;
 pub mod inbound_messages;
 pub mod key_manager;
@@ -6,3 +8,10 @@ pub mod real_messages_control;
 pub mod received_buffer;
 pub mod reply_key_storage;
 pub mod topology_control;
+
+// This is *NOT* used to signal shutdown.
+// It's critical that we don't have any tasks finishing early, this is an additional safety check
+// that tasks exiting are doing so because shutdown has been signalled, and no other reason.
+// In particular for tasks that rely on their associated channel being closed to signal shutdown,
+// and don't have access to a shutdown listener channel.
+pub static SHUTDOWN_HAS_BEEN_SIGNALLED: AtomicBool = AtomicBool::new(false);

clients/client-core/src/client/real_messages_control/acknowledgement_control/acknowledgement_listener.rs

@@ -10,6 +10,7 @@ use nymsphinx::{
     chunking::fragment::{FragmentIdentifier, COVER_FRAG_ID},
 };
 use std::sync::Arc;
+use task::ShutdownListener;
 
 /// Module responsible for listening for any data resembling acknowledgements from the network
 /// and firing actions to remove them from the 'Pending' state.
@@ -17,6 +18,7 @@ pub(super) struct AcknowledgementListener {
     ack_key: Arc<AckKey>,
     ack_receiver: AcknowledgementReceiver,
     action_sender: ActionSender,
+    shutdown: ShutdownListener,
 }
 
 impl AcknowledgementListener {
@@ -24,16 +26,18 @@ impl AcknowledgementListener {
         ack_key: Arc<AckKey>,
         ack_receiver: AcknowledgementReceiver,
         action_sender: ActionSender,
+        shutdown: ShutdownListener,
     ) -> Self {
         AcknowledgementListener {
             ack_key,
             ack_receiver,
             action_sender,
+            shutdown,
         }
     }
 
     async fn on_ack(&mut self, ack_content: Vec<u8>) {
-        debug!("Received an ack");
+        trace!("Received an ack");
         let frag_id = match recover_identifier(&self.ack_key, &ack_content)
             .map(FragmentIdentifier::try_from_bytes)
         {
@@ -56,7 +60,7 @@ impl AcknowledgementListener {
             return;
         }
 
-        trace!("Received {} from the mix network", frag_id);
+        debug!("Received {} from the mix network", frag_id);
 
         self.action_sender
             .unbounded_send(Action::new_remove(frag_id))
@@ -65,12 +69,26 @@ impl AcknowledgementListener {
 
     pub(super) async fn run(&mut self) {
         debug!("Started AcknowledgementListener");
-        while let Some(acks) = self.ack_receiver.next().await {
-            // realistically we would only be getting one ack at the time
-            for ack in acks {
-                self.on_ack(ack).await;
+        while !self.shutdown.is_shutdown() {
+            tokio::select! {
+                acks = self.ack_receiver.next() => match acks {
+                    Some(acks) => {
+                        // realistically we would only be getting one ack at the time
+                        for ack in acks {
+                            self.on_ack(ack).await;
+                        }
+                    },
+                    None => {
+                        log::trace!("AcknowledgementListener: Stopping since channel closed");
+                        break;
+                    }
+                },
+                _ = self.shutdown.recv() => {
+                    log::trace!("AcknowledgementListener: Received shutdown");
+                }
             }
         }
-        error!("TODO: error msg. Or maybe panic?")
+        assert!(self.shutdown.is_shutdown_poll());
+        log::debug!("AcknowledgementListener: Exiting");
     }
 }

clients/client-core/src/client/real_messages_control/acknowledgement_control/action_controller.rs

@@ -12,6 +12,7 @@ use nymsphinx::Delay as SphinxDelay;
 use std::collections::HashMap;
 use std::sync::Arc;
 use std::time::Duration;
+use task::ShutdownListener;
 
 pub(crate) type ActionSender = UnboundedSender<Action>;
 
@@ -99,12 +100,16 @@ pub(super) struct ActionController {
 
     /// Channel for notifying `RetransmissionRequestListener` about expired acknowledgements.
     retransmission_sender: RetransmissionRequestSender,
+
+    /// Listen for shutdown notifications
+    shutdown: ShutdownListener,
 }
 
 impl ActionController {
     pub(super) fn new(
         config: Config,
         retransmission_sender: RetransmissionRequestSender,
+        shutdown: ShutdownListener,
     ) -> (Self, ActionSender) {
         let (sender, receiver) = mpsc::unbounded();
         (
@@ -114,6 +119,7 @@ impl ActionController {
                 pending_acks_timers: NonExhaustiveDelayQueue::new(),
                 incoming_actions: receiver,
                 retransmission_sender,
+                shutdown,
             },
             sender,
         )
@@ -122,7 +128,7 @@ impl ActionController {
     fn handle_insert(&mut self, pending_acks: Vec<PendingAcknowledgement>) {
         for pending_ack in pending_acks {
             let frag_id = pending_ack.message_chunk.fragment_identifier();
-            trace!("{} is inserted", frag_id);
+            debug!("{} is inserted", frag_id);
 
             if self
                 .pending_acks_data
@@ -135,7 +141,7 @@ impl ActionController {
     }
 
     fn handle_start_timer(&mut self, frag_id: FragmentIdentifier) {
-        trace!("{} is starting its timer", frag_id);
+        debug!("{} is starting its timer", frag_id);
 
         if let Some((pending_ack_data, queue_key)) = self.pending_acks_data.get_mut(&frag_id) {
             if queue_key.is_some() {
@@ -158,7 +164,7 @@ impl ActionController {
     }
 
     fn handle_remove(&mut self, frag_id: FragmentIdentifier) {
-        trace!("{} is getting removed", frag_id);
+        debug!("{} is getting removed", frag_id);
 
         match self.pending_acks_data.remove(&frag_id) {
             None => {
@@ -189,7 +195,7 @@ impl ActionController {
     // initiated basically as a first step of retransmission. At first data has its delay updated
     // (as new sphinx packet was created with new expected delivery time)
     fn handle_update_delay(&mut self, frag_id: FragmentIdentifier, delay: SphinxDelay) {
-        trace!("{} is updating its delay", frag_id);
+        debug!("{} is updating its delay", frag_id);
         // TODO: is it possible to solve this without either locking or temporarily removing the value?
         if let Some((pending_ack_data, queue_key)) = self.pending_acks_data.remove(&frag_id) {
             // this Action is triggered by `RetransmissionRequestListener` which held the other potential
@@ -215,7 +221,7 @@ impl ActionController {
         // about it. Perhaps just reschedule it at later point?
         let frag_id = expired_ack.into_inner();
 
-        trace!("{} has expired", frag_id);
+        debug!("{} has expired", frag_id);
 
         if let Some((pending_ack_data, queue_key)) = self.pending_acks_data.get_mut(&frag_id) {
             if queue_key.is_none() {
@@ -246,14 +252,30 @@ impl ActionController {
     }
 
     pub(super) async fn run(&mut self) {
-        loop {
-            // at some point there will be a global shutdown signal here as the third option
+        while !self.shutdown.is_shutdown() {
             tokio::select! {
-                // we NEVER expect for ANY sender to get dropped so unwrap here is fine
-                action = self.incoming_actions.next() => self.process_action(action.unwrap()),
-                // pending ack queue Stream CANNOT return a `None` so unwrap here is fine
-                expired_ack = self.pending_acks_timers.next() => self.handle_expired_ack_timer(expired_ack.unwrap())
+                action = self.incoming_actions.next() => match action {
+                    Some(action) => self.process_action(action),
+                    None => {
+                        log::trace!(
+                            "ActionController: Stopping since incoming actions channel closed"
+                        );
+                        break;
+                    }
+                },
+                expired_ack = self.pending_acks_timers.next() => match expired_ack {
+                    Some(expired_ack) => self.handle_expired_ack_timer(expired_ack),
+                    None => {
+                        log::trace!("ActionController: Stopping since ack channel closed");
+                        break;
+                    }
+                },
+                _ = self.shutdown.recv() => {
+                    log::trace!("ActionController: Received shutdown");
+                }
             }
         }
+        assert!(self.shutdown.is_shutdown_poll());
+        log::debug!("ActionController: Exiting");
     }
 }

clients/client-core/src/client/real_messages_control/acknowledgement_control/input_message_listener.rs

@@ -16,6 +16,7 @@ use nymsphinx::preparer::MessagePreparer;
 use nymsphinx::{acknowledgements::AckKey, addressing::clients::Recipient};
 use rand::{CryptoRng, Rng};
 use std::sync::Arc;
+use task::ShutdownListener;
 
 /// Module responsible for dealing with the received messages: splitting them, creating acknowledgements,
 /// putting everything into sphinx packets, etc.
@@ -32,6 +33,7 @@ where
     real_message_sender: BatchRealMessageSender,
     topology_access: TopologyAccessor,
     reply_key_storage: ReplyKeyStorage,
+    shutdown: ShutdownListener,
 }
 
 impl<R> InputMessageListener<R>
@@ -50,6 +52,7 @@ where
         real_message_sender: BatchRealMessageSender,
         topology_access: TopologyAccessor,
         reply_key_storage: ReplyKeyStorage,
+        shutdown: ShutdownListener,
     ) -> Self {
         InputMessageListener {
             ack_key,
@@ -60,6 +63,7 @@ where
             real_message_sender,
             topology_access,
             reply_key_storage,
+            shutdown,
         }
     }
 
@@ -100,6 +104,7 @@ where
         content: Vec<u8>,
         with_reply_surb: bool,
     ) -> Option<Vec<RealMessage>> {
+        log::debug!("handle_fresh_message");
         let topology_permit = self.topology_access.get_read_permit().await;
         let topology = match topology_permit
             .try_get_valid_topology_ref(&self.ack_recipient, Some(&recipient))
@@ -133,7 +138,6 @@ where
             let prepared_fragment = self
                 .message_preparer
                 .prepare_chunk_for_sending(chunk_clone, topology, &self.ack_key, &recipient)
-                .await
                 .unwrap();
 
             real_messages.push(RealMessage::new(
@@ -157,6 +161,7 @@ where
     }
 
     async fn on_input_message(&mut self, msg: InputMessage) {
+        log::debug!("on_input_message");
         let real_messages = match msg {
             InputMessage::Fresh {
                 recipient,
@@ -183,9 +188,23 @@ where
 
     pub(super) async fn run(&mut self) {
         debug!("Started InputMessageListener");
-        while let Some(input_msg) = self.input_receiver.next().await {
-            self.on_input_message(input_msg).await;
+        while !self.shutdown.is_shutdown() {
+            tokio::select! {
+                input_msg = self.input_receiver.next() => match input_msg {
+                    Some(input_msg) => {
+                        self.on_input_message(input_msg).await;
+                    },
+                    None => {
+                        log::trace!("InputMessageListener: Stopping since channel closed");
+                        break;
+                    }
+                },
+                _ = self.shutdown.recv() => {
+                    log::trace!("InputMessageListener: Received shutdown");
+                }
+            }
         }
-        error!("TODO: error msg. Or maybe panic?")
+        assert!(self.shutdown.is_shutdown_poll());
+        log::debug!("InputMessageListener: Exiting");
     }
 }

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

@@ -25,6 +25,7 @@ use std::{
     sync::{Arc, Weak},
     time::Duration,
 };
+use task::ShutdownListener;
 use tokio::task::JoinHandle;
 
 mod acknowledgement_listener;
@@ -152,6 +153,7 @@ impl<R> AcknowledgementController<R>
 where
     R: 'static + CryptoRng + Rng + Clone + Send,
 {
+    #[allow(clippy::too_many_arguments)]
     pub(super) fn new(
         config: Config,
         rng: R,
@@ -160,13 +162,14 @@ where
         ack_recipient: Recipient,
         reply_key_storage: ReplyKeyStorage,
         connectors: AcknowledgementControllerConnectors,
+        shutdown: ShutdownListener,
     ) -> Self {
         let (retransmission_tx, retransmission_rx) = mpsc::unbounded();
 
         let action_config =
             action_controller::Config::new(config.ack_wait_addition, config.ack_wait_multiplier);
         let (action_controller, action_sender) =
-            ActionController::new(action_config, retransmission_tx);
+            ActionController::new(action_config, retransmission_tx, shutdown.clone());
 
         let message_preparer = MessagePreparer::new(
             rng,
@@ -175,11 +178,15 @@ where
             config.average_ack_delay,
         );
 
+        let message_preparer =
+            message_preparer.with_packet_size(nymsphinx::params::PacketSize::ExtendedPacket);
+
         // will listen for any acks coming from the network
         let acknowledgement_listener = AcknowledgementListener::new(
             Arc::clone(&ack_key),
             connectors.ack_receiver,
             action_sender.clone(),
+            shutdown.clone(),
         );
 
         // will listen for any new messages from the client
@@ -192,6 +199,7 @@ where
             connectors.real_message_sender.clone(),
             topology_access.clone(),
             reply_key_storage,
+            shutdown.clone(),
         );
 
         // will listen for any ack timeouts and trigger retransmission
@@ -203,12 +211,13 @@ where
             connectors.real_message_sender,
             retransmission_rx,
             topology_access,
+            shutdown.clone(),
         );
 
         // will listen for events indicating the packet was sent through the network so that
         // the retransmission timer should be started.
         let sent_notification_listener =
-            SentNotificationListener::new(connectors.sent_notifier, action_sender);
+            SentNotificationListener::new(connectors.sent_notifier, action_sender, shutdown);
 
         AcknowledgementController {
             acknowledgement_listener: Some(acknowledgement_listener),
@@ -232,27 +241,27 @@ where
         // graceful shutdowns.
         let ack_listener_fut = tokio::spawn(async move {
             acknowledgement_listener.run().await;
-            error!("The acknowledgement listener has finished execution!");
+            debug!("The acknowledgement listener has finished execution!");
             acknowledgement_listener
         });
         let input_listener_fut = tokio::spawn(async move {
             input_message_listener.run().await;
-            error!("The input listener has finished execution!");
+            debug!("The input listener has finished execution!");
             input_message_listener
         });
         let retransmission_req_fut = tokio::spawn(async move {
             retransmission_request_listener.run().await;
-            error!("The retransmission request listener has finished execution!");
+            debug!("The retransmission request listener has finished execution!");
             retransmission_request_listener
         });
         let sent_notification_fut = tokio::spawn(async move {
             sent_notification_listener.run().await;
-            error!("The sent notification listener has finished execution!");
+            debug!("The sent notification listener has finished execution!");
             sent_notification_listener
         });
         let action_controller_fut = tokio::spawn(async move {
             action_controller.run().await;
-            error!("The controller has finished execution!");
+            debug!("The controller has finished execution!");
             action_controller
         });
 

clients/client-core/src/client/real_messages_control/acknowledgement_control/retransmission_request_listener.rs

@@ -14,6 +14,7 @@ use nymsphinx::preparer::MessagePreparer;
 use nymsphinx::{acknowledgements::AckKey, addressing::clients::Recipient};
 use rand::{CryptoRng, Rng};
 use std::sync::{Arc, Weak};
+use task::ShutdownListener;
 
 // responsible for packet retransmission upon fired timer
 pub(super) struct RetransmissionRequestListener<R>
@@ -27,12 +28,14 @@ where
     real_message_sender: BatchRealMessageSender,
     request_receiver: RetransmissionRequestReceiver,
     topology_access: TopologyAccessor,
+    shutdown: ShutdownListener,
 }
 
 impl<R> RetransmissionRequestListener<R>
 where
     R: CryptoRng + Rng,
 {
+    #[allow(clippy::too_many_arguments)]
     pub(super) fn new(
         ack_key: Arc<AckKey>,
         ack_recipient: Recipient,
@@ -41,6 +44,7 @@ where
         real_message_sender: BatchRealMessageSender,
         request_receiver: RetransmissionRequestReceiver,
         topology_access: TopologyAccessor,
+        shutdown: ShutdownListener,
     ) -> Self {
         RetransmissionRequestListener {
             ack_key,
@@ -50,6 +54,7 @@ where
             real_message_sender,
             request_receiver,
             topology_access,
+            shutdown,
         }
     }
 
@@ -83,7 +88,6 @@ where
         let prepared_fragment = self
             .message_preparer
             .prepare_chunk_for_sending(chunk_clone, topology_ref, &self.ack_key, packet_recipient)
-            .await
             .unwrap();
 
         // if we have the ONLY strong reference to the ack data, it means it was removed from the
@@ -122,9 +126,22 @@ where
 
     pub(super) async fn run(&mut self) {
         debug!("Started RetransmissionRequestListener");
-        while let Some(timed_out_ack) = self.request_receiver.next().await {
-            self.on_retransmission_request(timed_out_ack).await;
+
+        while !self.shutdown.is_shutdown() {
+            tokio::select! {
+                timed_out_ack = self.request_receiver.next() => match timed_out_ack {
+                    Some(timed_out_ack) => self.on_retransmission_request(timed_out_ack).await,
+                    None => {
+                        log::trace!("RetransmissionRequestListener: Stopping since channel closed");
+                        break;
+                    }
+                },
+                _ = self.shutdown.recv() => {
+                    log::trace!("RetransmissionRequestListener: Received shutdown");
+                }
+            }
         }
-        error!("TODO: error msg. Or maybe panic?")
+        assert!(self.shutdown.is_shutdown_poll());
+        log::debug!("RetransmissionRequestListener: Exiting");
     }
 }

clients/client-core/src/client/real_messages_control/acknowledgement_control/sent_notification_listener.rs

@@ -6,6 +6,7 @@ use super::SentPacketNotificationReceiver;
 use futures::StreamExt;
 use log::*;
 use nymsphinx::chunking::fragment::{FragmentIdentifier, COVER_FRAG_ID};
+use task::ShutdownListener;
 
 /// Module responsible for starting up retransmission timers.
 /// It is required because when we send our packet to the `real traffic stream` controlled
@@ -14,16 +15,19 @@ use nymsphinx::chunking::fragment::{FragmentIdentifier, COVER_FRAG_ID};
 pub(super) struct SentNotificationListener {
     sent_notifier: SentPacketNotificationReceiver,
     action_sender: ActionSender,
+    shutdown: ShutdownListener,
 }
 
 impl SentNotificationListener {
     pub(super) fn new(
         sent_notifier: SentPacketNotificationReceiver,
         action_sender: ActionSender,
+        shutdown: ShutdownListener,
     ) -> Self {
         SentNotificationListener {
             sent_notifier,
             action_sender,
+            shutdown,
         }
     }
 
@@ -44,9 +48,23 @@ impl SentNotificationListener {
 
     pub(super) async fn run(&mut self) {
         debug!("Started SentNotificationListener");
-        while let Some(frag_id) = self.sent_notifier.next().await {
-            self.on_sent_message(frag_id).await;
+        while !self.shutdown.is_shutdown() {
+            tokio::select! {
+                frag_id = self.sent_notifier.next() => match frag_id {
+                    Some(frag_id) => {
+                        self.on_sent_message(frag_id).await;
+                    }
+                    None => {
+                        log::trace!("SentNotificationListener: Stopping since channel closed");
+                        break;
+                    }
+                },
+                _ = self.shutdown.recv() => {
+                    log::trace!("SentNotificationListener: Received shutdown");
+                }
+            }
         }
-        error!("TODO: error msg. Or maybe panic?")
+        assert!(self.shutdown.is_shutdown_poll());
+        log::debug!("SentNotificationListener: Exiting");
     }
 }

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

@@ -22,6 +22,7 @@ use nymsphinx::addressing::clients::Recipient;
 use rand::{rngs::OsRng, CryptoRng, Rng};
 use std::sync::Arc;
 use std::time::Duration;
+use task::ShutdownListener;
 use tokio::task::JoinHandle;
 
 mod acknowledgement_control;
@@ -49,9 +50,15 @@ pub struct Config {
 
     /// Average delay an acknowledgement packet is going to get delayed at a single mixnode.
     average_ack_delay_duration: Duration,
+
+    /// Controls whether the main packet stream constantly produces packets according to the predefined
+    /// poisson distribution.
+    disable_main_poisson_packet_distribution: bool,
 }
 
 impl Config {
+    // TODO: change the config into a builder
+    #[allow(clippy::too_many_arguments)]
     pub fn new(
         ack_key: Arc<AckKey>,
         ack_wait_multiplier: f64,
@@ -59,6 +66,7 @@ impl Config {
         average_ack_delay_duration: Duration,
         average_message_sending_delay: Duration,
         average_packet_delay_duration: Duration,
+        disable_main_poisson_packet_distribution: bool,
         self_recipient: Recipient,
     ) -> Self {
         Config {
@@ -69,6 +77,7 @@ impl Config {
             average_message_sending_delay,
             average_packet_delay_duration,
             average_ack_delay_duration,
+            disable_main_poisson_packet_distribution,
         }
     }
 }
@@ -91,6 +100,7 @@ impl RealMessagesController<OsRng> {
         mix_sender: BatchMixMessageSender,
         topology_access: TopologyAccessor,
         reply_key_storage: ReplyKeyStorage,
+        shutdown: ShutdownListener,
     ) -> Self {
         let rng = OsRng;
 
@@ -119,12 +129,14 @@ impl RealMessagesController<OsRng> {
             config.self_recipient,
             reply_key_storage,
             ack_controller_connectors,
+            shutdown.clone(),
         );
 
         let out_queue_config = real_traffic_stream::Config::new(
             config.average_ack_delay_duration,
             config.average_packet_delay_duration,
             config.average_message_sending_delay,
+            config.disable_main_poisson_packet_distribution,
         );
 
         let out_queue_control = OutQueueControl::new(
@@ -136,6 +148,7 @@ impl RealMessagesController<OsRng> {
             rng,
             config.self_recipient,
             topology_access,
+            shutdown,
         );
 
         RealMessagesController {
@@ -153,12 +166,12 @@ impl RealMessagesController<OsRng> {
         // graceful shutdowns.
         let out_queue_control_fut = tokio::spawn(async move {
             out_queue_control.run_out_queue_control().await;
-            error!("The out queue controller has finished execution!");
+            debug!("The out queue controller has finished execution!");
             out_queue_control
         });
         let ack_control_fut = tokio::spawn(async move {
             ack_control.run().await;
-            error!("The acknowledgement controller has finished execution!");
+            debug!("The acknowledgement controller has finished execution!");
             ack_control
         });
 

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

@@ -19,6 +19,7 @@ use std::collections::VecDeque;
 use std::pin::Pin;
 use std::sync::Arc;
 use std::time::Duration;
+use task::ShutdownListener;
 use tokio::time;
 
 /// Configurable parameters of the `OutQueueControl`
@@ -31,6 +32,10 @@ pub(crate) struct Config {
 
     /// Average delay between sending subsequent packets.
     average_message_sending_delay: Duration,
+
+    /// Controls whether the stream constantly produces packets according to the predefined
+    /// poisson distribution.
+    disable_poisson_packet_distribution: bool,
 }
 
 impl Config {
@@ -38,11 +43,13 @@ impl Config {
         average_ack_delay: Duration,
         average_packet_delay: Duration,
         average_message_sending_delay: Duration,
+        disable_poisson_packet_distribution: bool,
     ) -> Self {
         Config {
             average_ack_delay,
             average_packet_delay,
             average_message_sending_delay,
+            disable_poisson_packet_distribution,
         }
     }
 }
@@ -62,7 +69,7 @@ where
 
     /// Internal state, determined by `average_message_sending_delay`,
     /// used to keep track of when a next packet should be sent out.
-    next_delay: Pin<Box<time::Sleep>>,
+    next_delay: Option<Pin<Box<time::Sleep>>>,
 
     /// Channel used for sending prepared sphinx packets to `MixTrafficController` that sends them
     /// out to the network without any further delays.
@@ -83,6 +90,9 @@ where
 
     /// Buffer containing all real messages received. It is first exhausted before more are pulled.
     received_buffer: VecDeque<RealMessage>,
+
+    /// Listens for shutdown signals
+    shutdown: ShutdownListener,
 }
 
 pub(crate) struct RealMessage {
@@ -109,55 +119,6 @@ pub(crate) enum StreamMessage {
     Real(Box<RealMessage>),
 }
 
-impl<R> Stream for OutQueueControl<R>
-where
-    R: CryptoRng + Rng + Unpin,
-{
-    type Item = StreamMessage;
-
-    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        // it is not yet time to return a message
-        if self.next_delay.as_mut().poll(cx).is_pending() {
-            return Poll::Pending;
-        };
-
-        // we know it's time to send a message, so let's prepare delay for the next one
-        // Get the `now` by looking at the current `delay` deadline
-        let avg_delay = self.config.average_message_sending_delay;
-        let now = self.next_delay.deadline();
-        let next_poisson_delay = sample_poisson_duration(&mut self.rng, avg_delay);
-
-        // The next interval value is `next_poisson_delay` after the one that just
-        // yielded.
-        let next = now + next_poisson_delay;
-        self.next_delay.as_mut().reset(next);
-
-        // check if we have anything immediately available
-        if let Some(real_available) = self.received_buffer.pop_front() {
-            return Poll::Ready(Some(StreamMessage::Real(Box::new(real_available))));
-        }
-
-        // decide what kind of message to send
-        match Pin::new(&mut self.real_receiver).poll_next(cx) {
-            // in the case our real message channel stream was closed, we should also indicate we are closed
-            // (and whoever is using the stream should panic)
-            Poll::Ready(None) => Poll::Ready(None),
-
-            // if there are more messages available, return first one and store the rest
-            Poll::Ready(Some(real_messages)) => {
-                self.received_buffer = real_messages.into();
-                // we MUST HAVE received at least ONE message
-                Poll::Ready(Some(StreamMessage::Real(Box::new(
-                    self.received_buffer.pop_front().unwrap(),
-                ))))
-            }
-
-            // otherwise construct a dummy one
-            Poll::Pending => Poll::Ready(Some(StreamMessage::Cover)),
-        }
-    }
-}
-
 impl<R> OutQueueControl<R>
 where
     R: CryptoRng + Rng + Unpin,
@@ -174,18 +135,20 @@ where
         rng: R,
         our_full_destination: Recipient,
         topology_access: TopologyAccessor,
+        shutdown: ShutdownListener,
     ) -> Self {
         OutQueueControl {
             config,
             ack_key,
             sent_notifier,
-            next_delay: Box::pin(time::sleep(Default::default())),
+            next_delay: None,
             mix_tx,
             real_receiver,
             our_full_destination,
             rng,
             topology_access,
             received_buffer: VecDeque::with_capacity(0), // we won't be putting any data into this guy directly
+            shutdown,
         }
     }
 
@@ -239,7 +202,15 @@ where
         // - we run out of memory
         // - the receiver channel is closed
         // in either case there's no recovery and we can only panic
-        self.mix_tx.unbounded_send(vec![next_message]).unwrap();
+        if let Err(err) = self.mix_tx.unbounded_send(vec![next_message]) {
+            if self.shutdown.is_shutdown_poll() {
+                log::info!("Failed to send (shutdown detected)");
+            } else {
+                // We don't try to limp along, panic to avoid continuing in a potentially
+                // inconsistent state
+                panic!("{err}");
+            }
+        }
 
         // JS: Not entirely sure why or how it fixes stuff, but without the yield call,
         // the UnboundedReceiver [of mix_rx] will not get a chance to read anything
@@ -251,19 +222,136 @@ where
 
     // Send messages at certain rate and if no real traffic is available, send cover message.
     async fn run_normal_out_queue(&mut self) {
-        // we should set initial delay only when we actually start the stream
-        self.next_delay = Box::pin(time::sleep(sample_poisson_duration(
-            &mut self.rng,
-            self.config.average_message_sending_delay,
-        )));
-
-        while let Some(next_message) = self.next().await {
-            self.on_message(next_message).await;
+        let mut shutdown = self.shutdown.clone();
+        while !shutdown.is_shutdown() {
+            tokio::select! {
+                biased;
+                _ = shutdown.recv() => {
+                    log::trace!("OutQueueControl: Received shutdown");
+                }
+                next_message = self.next() => match next_message {
+                    Some(next_message) => {
+                        self.on_message(next_message).await;
+                    },
+                    None => {
+                        log::trace!("OutQueueControl: Stopping since channel closed");
+                        break;
+                    }
+                }
+            }
         }
+        assert!(shutdown.is_shutdown_poll());
+        log::debug!("OutQueueControl: Exiting");
     }
 
     pub(crate) async fn run_out_queue_control(&mut self) {
         debug!("Starting out queue controller...");
         self.run_normal_out_queue().await
     }
+
+    fn poll_poisson(&mut self, cx: &mut Context<'_>) -> Poll<Option<StreamMessage>> {
+        if let Some(ref mut next_delay) = &mut self.next_delay {
+            // it is not yet time to return a message
+            if next_delay.as_mut().poll(cx).is_pending() {
+                return Poll::Pending;
+            };
+
+            // we know it's time to send a message, so let's prepare delay for the next one
+            // Get the `now` by looking at the current `delay` deadline
+            let avg_delay = self.config.average_message_sending_delay;
+            let now = next_delay.deadline();
+            let next_poisson_delay = sample_poisson_duration(&mut self.rng, avg_delay);
+
+            // The next interval value is `next_poisson_delay` after the one that just
+            // yielded.
+            let next = now + next_poisson_delay;
+            next_delay.as_mut().reset(next);
+
+            // check if we have anything immediately available
+            if let Some(real_available) = self.received_buffer.pop_front() {
+                return Poll::Ready(Some(StreamMessage::Real(Box::new(real_available))));
+            }
+
+            // decide what kind of message to send
+            match Pin::new(&mut self.real_receiver).poll_next(cx) {
+                // in the case our real message channel stream was closed, we should also indicate we are closed
+                // (and whoever is using the stream should panic)
+                Poll::Ready(None) => Poll::Ready(None),
+
+                // if there are more messages available, return first one and store the rest
+                Poll::Ready(Some(real_messages)) => {
+                    self.received_buffer = real_messages.into();
+                    // we MUST HAVE received at least ONE message
+                    Poll::Ready(Some(StreamMessage::Real(Box::new(
+                        self.received_buffer.pop_front().unwrap(),
+                    ))))
+                }
+
+                // otherwise construct a dummy one
+                Poll::Pending => Poll::Ready(Some(StreamMessage::Cover)),
+            }
+        } else {
+            // we never set an initial delay - let's do it now
+            cx.waker().wake_by_ref();
+
+            self.next_delay = Some(Box::pin(time::sleep(sample_poisson_duration(
+                &mut self.rng,
+                self.config.average_message_sending_delay,
+            ))));
+
+            Poll::Pending
+        }
+    }
+
+    fn poll_immediate(&mut self, cx: &mut Context<'_>) -> Poll<Option<StreamMessage>> {
+        // check if we have anything immediately available
+        if let Some(real_available) = self.received_buffer.pop_front() {
+            // if there are more messages immediately available, notify the runtime
+            // because we should be polled again
+            if !self.received_buffer.is_empty() {
+                cx.waker().wake_by_ref()
+            }
+            return Poll::Ready(Some(StreamMessage::Real(Box::new(real_available))));
+        }
+
+        match Pin::new(&mut self.real_receiver).poll_next(cx) {
+            // in the case our real message channel stream was closed, we should also indicate we are closed
+            // (and whoever is using the stream should panic)
+            Poll::Ready(None) => Poll::Ready(None),
+
+            // if there are more messages available, return first one and store the rest
+            Poll::Ready(Some(real_messages)) => {
+                self.received_buffer = real_messages.into();
+                // we MUST HAVE received at least ONE message
+                Poll::Ready(Some(StreamMessage::Real(Box::new(
+                    self.received_buffer.pop_front().unwrap(),
+                ))))
+            }
+
+            // if there's nothing, then there's nothing
+            Poll::Pending => Poll::Pending,
+        }
+    }
+
+    fn poll_next_message(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<StreamMessage>> {
+        if self.config.disable_poisson_packet_distribution {
+            self.poll_immediate(cx)
+        } else {
+            self.poll_poisson(cx)
+        }
+    }
+}
+
+impl<R> Stream for OutQueueControl<R>
+where
+    R: CryptoRng + Rng + Unpin,
+{
+    type Item = StreamMessage;
+
+    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        self.poll_next_message(cx)
+    }
 }

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

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::client::reply_key_storage::ReplyKeyStorage;
+use crate::client::SHUTDOWN_HAS_BEEN_SIGNALLED;
 use crypto::asymmetric::encryption;
 use crypto::symmetric::stream_cipher;
 use crypto::Digest;
@@ -14,7 +15,9 @@ use nymsphinx::anonymous_replies::{encryption_key::EncryptionKeyDigest, SurbEncr
 use nymsphinx::params::{ReplySurbEncryptionAlgorithm, ReplySurbKeyDigestAlgorithm};
 use nymsphinx::receiver::{MessageReceiver, MessageRecoveryError, ReconstructedMessage};
 use std::collections::HashSet;
+use std::sync::atomic::Ordering;
 use std::sync::Arc;
+use task::ShutdownListener;
 use tokio::task::JoinHandle;
 
 // Buffer Requests to say "hey, send any reconstructed messages to this channel"
@@ -70,6 +73,11 @@ impl ReceivedMessagesBufferInner {
         if self.recently_reconstructed.contains(&fragment.id()) {
             debug!("Received a chunk of already re-assembled message ({:?})! It probably got here because the ack got lost", fragment.id());
             return None;
+        } else {
+            debug!(
+                "Received a chunk of message ({:?}) for the first time",
+                fragment.id()
+            );
         }
 
         // if we returned an error the underlying message is malformed in some way
@@ -201,7 +209,7 @@ impl ReceivedMessagesBuffer {
     }
 
     async fn handle_new_received(&mut self, msgs: Vec<Vec<u8>>) {
-        debug!(
+        trace!(
             "Processing {:?} new message that might get added to the buffer!",
             msgs.len()
         );
@@ -292,16 +300,27 @@ impl RequestReceiver {
 
     fn start(mut self) -> JoinHandle<()> {
         tokio::spawn(async move {
-            while let Some(request) = self.query_receiver.next().await {
-                match request {
-                    ReceivedBufferMessage::ReceiverAnnounce(sender) => {
-                        self.received_buffer.connect_sender(sender).await;
-                    }
-                    ReceivedBufferMessage::ReceiverDisconnect => {
-                        self.received_buffer.disconnect_sender().await
-                    }
-                }
+            loop {
+                tokio::select! {
+                    request = self.query_receiver.next() => {
+                        match request {
+                            Some(ReceivedBufferMessage::ReceiverAnnounce(sender)) => {
+                                self.received_buffer.connect_sender(sender).await;
+                            }
+                            Some(ReceivedBufferMessage::ReceiverDisconnect) => {
+                                self.received_buffer.disconnect_sender().await
+                            }
+                            None => {
+                                log::trace!("RequestReceiver: Stopping since channel closed");
+                                break;
+                            },
+                        }
+                    },
+                };
             }
+
+            assert!(SHUTDOWN_HAS_BEEN_SIGNALLED.load(Ordering::Relaxed));
+            log::debug!("RequestReceiver: Exiting");
         })
     }
 }
@@ -309,23 +328,41 @@ impl RequestReceiver {
 struct FragmentedMessageReceiver {
     received_buffer: ReceivedMessagesBuffer,
     mixnet_packet_receiver: MixnetMessageReceiver,
+    shutdown: ShutdownListener,
 }
 
 impl FragmentedMessageReceiver {
     fn new(
         received_buffer: ReceivedMessagesBuffer,
         mixnet_packet_receiver: MixnetMessageReceiver,
+        shutdown: ShutdownListener,
     ) -> Self {
         FragmentedMessageReceiver {
             received_buffer,
             mixnet_packet_receiver,
+            shutdown,
         }
     }
     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;
+            while !self.shutdown.is_shutdown() {
+                tokio::select! {
+                    new_messages = self.mixnet_packet_receiver.next() => match new_messages {
+                        Some(new_messages) => {
+                            self.received_buffer.handle_new_received(new_messages).await;
+                        }
+                        None => {
+                            log::trace!("FragmentedMessageReceiver: Stopping since channel closed");
+                            break;
+                        }
+                    },
+                    _ = self.shutdown.recv() => {
+                        log::trace!("FragmentedMessageReceiver: Received shutdown");
+                    }
+                }
             }
+            assert!(self.shutdown.is_shutdown_poll());
+            log::debug!("FragmentedMessageReceiver: Exiting");
         })
     }
 }
@@ -341,6 +378,7 @@ impl ReceivedMessagesBufferController {
         query_receiver: ReceivedBufferRequestReceiver,
         mixnet_packet_receiver: MixnetMessageReceiver,
         reply_key_storage: ReplyKeyStorage,
+        shutdown: ShutdownListener,
     ) -> Self {
         let received_buffer =
             ReceivedMessagesBuffer::new(local_encryption_keypair, reply_key_storage);
@@ -349,6 +387,7 @@ impl ReceivedMessagesBufferController {
             fragmented_message_receiver: FragmentedMessageReceiver::new(
                 received_buffer.clone(),
                 mixnet_packet_receiver,
+                shutdown,
             ),
             request_receiver: RequestReceiver::new(received_buffer, query_receiver),
         }

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

@@ -10,6 +10,7 @@ use std::ops::Deref;
 use std::sync::Arc;
 use std::time;
 use std::time::Duration;
+use task::ShutdownListener;
 use tokio::sync::{RwLock, RwLockReadGuard};
 use tokio::task::JoinHandle;
 use topology::{nym_topology_from_bonds, NymTopology};
@@ -303,12 +304,20 @@ impl TopologyRefresher {
         self.topology_accessor.is_routable().await
     }
 
-    pub fn start(mut self) -> JoinHandle<()> {
+    pub fn start(mut self, mut shutdown: ShutdownListener) -> JoinHandle<()> {
         tokio::spawn(async move {
-            loop {
-                tokio::time::sleep(self.refresh_rate).await;
-                self.refresh().await;
+            while !shutdown.is_shutdown() {
+                tokio::select! {
+                    _ = tokio::time::sleep(self.refresh_rate) => {
+                        self.refresh().await;
+                    },
+                    _ = shutdown.recv() => {
+                        log::trace!("TopologyRefresher: Received shutdown");
+                    },
+                }
             }
+            assert!(shutdown.is_shutdown_poll());
+            log::debug!("TopologyRefresher: Exiting");
         })
     }
 }

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

@@ -14,8 +14,10 @@ pub const MISSING_VALUE: &str = "MISSING VALUE";
 
 // 'DEBUG'
 const DEFAULT_ACK_WAIT_MULTIPLIER: f64 = 1.5;
+//const DEFAULT_ACK_WAIT_MULTIPLIER: f64 = 10.0;
 
-const DEFAULT_ACK_WAIT_ADDITION: Duration = Duration::from_millis(1_500);
+//const DEFAULT_ACK_WAIT_ADDITION: Duration = Duration::from_millis(1_500);
+const DEFAULT_ACK_WAIT_ADDITION: Duration = Duration::from_millis(10_000);
 const DEFAULT_LOOP_COVER_STREAM_AVERAGE_DELAY: Duration = Duration::from_millis(200);
 const DEFAULT_MESSAGE_STREAM_AVERAGE_DELAY: Duration = Duration::from_millis(20);
 const DEFAULT_AVERAGE_PACKET_DELAY: Duration = Duration::from_millis(50);
@@ -121,16 +123,6 @@ impl<T: NymConfig> Config<T> {
         self.client.gateway_endpoint.gateway_id = id.into();
     }
 
-    #[cfg(not(feature = "coconut"))]
-    pub fn with_eth_private_key<S: Into<String>>(&mut self, eth_private_key: S) {
-        self.client.eth_private_key = eth_private_key.into();
-    }
-
-    #[cfg(not(feature = "coconut"))]
-    pub fn with_eth_endpoint<S: Into<String>>(&mut self, eth_endpoint: S) {
-        self.client.eth_endpoint = eth_endpoint.into();
-    }
-
     pub fn set_custom_validator_apis(&mut self, validator_api_urls: Vec<Url>) {
         self.client.validator_api_urls = validator_api_urls;
     }
@@ -209,16 +201,6 @@ impl<T: NymConfig> Config<T> {
         self.client.database_path.clone()
     }
 
-    #[cfg(not(feature = "coconut"))]
-    pub fn get_eth_endpoint(&self) -> String {
-        self.client.eth_endpoint.clone()
-    }
-
-    #[cfg(not(feature = "coconut"))]
-    pub fn get_eth_private_key(&self) -> String {
-        self.client.eth_private_key.clone()
-    }
-
     // Debug getters
     pub fn get_average_packet_delay(&self) -> Duration {
         self.debug.average_packet_delay
@@ -256,6 +238,10 @@ impl<T: NymConfig> Config<T> {
         self.debug.topology_resolution_timeout
     }
 
+    pub fn get_disabled_main_poisson_packet_distribution(&self) -> bool {
+        self.debug.disable_main_poisson_packet_distribution
+    }
+
     pub fn get_version(&self) -> &str {
         &self.client.version
     }
@@ -342,14 +328,6 @@ pub struct Client<T> {
     /// Path to the database containing bandwidth credentials of this client.
     database_path: PathBuf,
 
-    /// Ethereum private key.
-    #[cfg(not(feature = "coconut"))]
-    eth_private_key: String,
-
-    /// Address to an Ethereum full node.
-    #[cfg(not(feature = "coconut"))]
-    eth_endpoint: String,
-
     /// nym_home_directory specifies absolute path to the home nym Clients directory.
     /// It is expected to use default value and hence .toml file should not redefine this field.
     nym_root_directory: PathBuf,
@@ -375,10 +353,6 @@ impl<T: NymConfig> Default for Client<T> {
             reply_encryption_key_store_path: Default::default(),
             gateway_endpoint: Default::default(),
             database_path: Default::default(),
-            #[cfg(not(feature = "coconut"))]
-            eth_private_key: "".to_string(),
-            #[cfg(not(feature = "coconut"))]
-            eth_endpoint: "".to_string(),
             nym_root_directory: T::default_root_directory(),
             super_struct: Default::default(),
         }
@@ -477,6 +451,10 @@ pub struct Debug {
     /// did not reach its destination.
     #[serde(with = "humantime_serde")]
     topology_resolution_timeout: Duration,
+
+    /// Controls whether the main packet stream constantly produces packets according to the predefined
+    /// poisson distribution.
+    disable_main_poisson_packet_distribution: bool,
 }
 
 impl Default for Debug {
@@ -491,6 +469,7 @@ impl Default for Debug {
             gateway_response_timeout: DEFAULT_GATEWAY_RESPONSE_TIMEOUT,
             topology_refresh_rate: DEFAULT_TOPOLOGY_REFRESH_RATE,
             topology_resolution_timeout: DEFAULT_TOPOLOGY_RESOLUTION_TIMEOUT,
+            disable_main_poisson_packet_distribution: false,
         }
     }
 }

clients/client-core/src/error.rs

@@ -0,0 +1,27 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crypto::asymmetric::identity::Ed25519RecoveryError;
+use gateway_client::error::GatewayClientError;
+use validator_client::ValidatorClientError;
+
+#[derive(thiserror::Error, Debug)]
+pub enum ClientCoreError {
+    #[error("I/O error: {0}")]
+    IoError(#[from] std::io::Error),
+    #[error("Gateway client error: {0}")]
+    GatewayClientError(#[from] GatewayClientError),
+    #[error("Ed25519 error: {0}")]
+    Ed25519RecoveryError(#[from] Ed25519RecoveryError),
+    #[error("Validator client error: {0}")]
+    ValidatorClientError(#[from] ValidatorClientError),
+
+    #[error("No gateway with id: {0}")]
+    NoGatewayWithId(String),
+    #[error("No gateways on network")]
+    NoGatewaysOnNetwork,
+    #[error("List of validator apis is empty")]
+    ListOfValidatorApisIsEmpty,
+    #[error("Could not load existing gateway configuration: {0}")]
+    CouldNotLoadExistingGatewayConfiguration(std::io::Error),
+}

clients/client-core/src/init.rs

@@ -14,25 +14,27 @@ use nymsphinx::addressing::nodes::NodeIdentity;
 use rand::rngs::OsRng;
 use rand::seq::SliceRandom;
 use rand::thread_rng;
+use tap::TapFallible;
 use topology::{filter::VersionFilterable, gateway};
 use url::Url;
 
 use crate::{
     client::key_manager::KeyManager,
     config::{persistence::key_pathfinder::ClientKeyPathfinder, Config},
+    error::ClientCoreError,
 };
 
 pub async fn query_gateway_details(
     validator_servers: Vec<Url>,
     chosen_gateway_id: Option<&str>,
-) -> gateway::Node {
+) -> Result<gateway::Node, ClientCoreError> {
     let validator_api = validator_servers
         .choose(&mut thread_rng())
-        .expect("The list of validator apis is empty");
+        .ok_or(ClientCoreError::ListOfValidatorApisIsEmpty)?;
     let validator_client = validator_client::ApiClient::new(validator_api.clone());
 
     log::trace!("Fetching list of gateways from: {}", validator_api);
-    let gateways = validator_client.get_cached_gateways().await.unwrap();
+    let gateways = validator_client.get_cached_gateways().await?;
     let valid_gateways = gateways
         .into_iter()
         .filter_map(|gateway| gateway.try_into().ok())
@@ -47,38 +49,40 @@ pub async fn query_gateway_details(
         filtered_gateways
             .iter()
             .find(|gateway| gateway.identity_key.to_base58_string() == gateway_id)
-            .expect(&*format!("no gateway with id {} exists!", gateway_id))
-            .clone()
+            .ok_or_else(|| ClientCoreError::NoGatewayWithId(gateway_id.to_string()))
+            .cloned()
     } else {
         filtered_gateways
             .choose(&mut rand::thread_rng())
-            .expect("there are no gateways on the network!")
-            .clone()
+            .ok_or(ClientCoreError::NoGatewaysOnNetwork)
+            .cloned()
     }
 }
 
 pub async fn register_with_gateway_and_store_keys<T>(
     gateway_details: gateway::Node,
     config: &Config<T>,
-) where
+) -> Result<(), ClientCoreError>
+where
     T: NymConfig,
 {
     let mut rng = OsRng;
     let mut key_manager = KeyManager::new(&mut rng);
 
-    let shared_keys = register_with_gateway(&gateway_details, key_manager.identity_keypair()).await;
+    let shared_keys =
+        register_with_gateway(&gateway_details, key_manager.identity_keypair()).await?;
     key_manager.insert_gateway_shared_key(shared_keys);
 
     let pathfinder = ClientKeyPathfinder::new_from_config(config);
-    key_manager
+    Ok(key_manager
         .store_keys(&pathfinder)
-        .expect("Failed to generated keys");
+        .tap_err(|err| log::error!("Failed to generate keys: {err}"))?)
 }
 
 async fn register_with_gateway(
     gateway: &gateway::Node,
     our_identity: Arc<identity::KeyPair>,
-) -> Arc<SharedKeys> {
+) -> Result<Arc<SharedKeys>, ClientCoreError> {
     let timeout = Duration::from_millis(1500);
     let mut gateway_client = GatewayClient::new_init(
         gateway.clients_address(),
@@ -86,52 +90,59 @@ async fn register_with_gateway(
         gateway.owner.clone(),
         our_identity.clone(),
         timeout,
+        None,
     );
     gateway_client
         .establish_connection()
         .await
-        .expect("failed to establish connection with the gateway!");
-    gateway_client
+        .tap_err(|_| log::warn!("Failed to establish connection with gateway!"))?;
+    let shared_keys = gateway_client
         .perform_initial_authentication()
         .await
-        .expect("failed to register with the gateway!")
+        .tap_err(|_| log::warn!("Failed to register with the gateway!"))?;
+    Ok(shared_keys)
 }
 
-pub fn show_address<T>(config: &Config<T>)
+pub fn show_address<T>(config: &Config<T>) -> Result<(), ClientCoreError>
 where
     T: config::NymConfig,
 {
-    fn load_identity_keys(pathfinder: &ClientKeyPathfinder) -> identity::KeyPair {
+    fn load_identity_keys(
+        pathfinder: &ClientKeyPathfinder,
+    ) -> Result<identity::KeyPair, ClientCoreError> {
         let identity_keypair: identity::KeyPair =
             pemstore::load_keypair(&pemstore::KeyPairPath::new(
                 pathfinder.private_identity_key().to_owned(),
                 pathfinder.public_identity_key().to_owned(),
             ))
-            .expect("Failed to read stored identity key files");
-        identity_keypair
+            .tap_err(|_| log::error!("Failed to read stored identity key files"))?;
+        Ok(identity_keypair)
     }
 
-    fn load_sphinx_keys(pathfinder: &ClientKeyPathfinder) -> encryption::KeyPair {
+    fn load_sphinx_keys(
+        pathfinder: &ClientKeyPathfinder,
+    ) -> Result<encryption::KeyPair, ClientCoreError> {
         let sphinx_keypair: encryption::KeyPair =
             pemstore::load_keypair(&pemstore::KeyPairPath::new(
                 pathfinder.private_encryption_key().to_owned(),
                 pathfinder.public_encryption_key().to_owned(),
             ))
-            .expect("Failed to read stored sphinx key files");
-        sphinx_keypair
+            .tap_err(|_| log::error!("Failed to read stored sphinx key files"))?;
+        Ok(sphinx_keypair)
     }
 
     let pathfinder = ClientKeyPathfinder::new_from_config(config);
-    let identity_keypair = load_identity_keys(&pathfinder);
-    let sphinx_keypair = load_sphinx_keys(&pathfinder);
+    let identity_keypair = load_identity_keys(&pathfinder)?;
+    let sphinx_keypair = load_sphinx_keys(&pathfinder)?;
 
     let client_recipient = Recipient::new(
         *identity_keypair.public_key(),
         *sphinx_keypair.public_key(),
         // TODO: below only works under assumption that gateway address == gateway id
         // (which currently is true)
-        NodeIdentity::from_base58_string(config.get_gateway_id()).unwrap(),
+        NodeIdentity::from_base58_string(config.get_gateway_id())?,
     );
 
     println!("\nThe address of this client is: {}", client_recipient);
+    Ok(())
 }

clients/client-core/src/lib.rs

@@ -1,3 +1,4 @@
 pub mod client;
 pub mod config;
+pub mod error;
 pub mod init;

clients/credential/Cargo.toml

@@ -18,6 +18,7 @@ url = "2.2"
 tokio = { version = "1.19.1", features = ["rt-multi-thread", "net", "signal", "macros"] } # async runtime
 
 coconut-interface = { path = "../../common/coconut-interface" }
+config = { path = "../../common/config" }
 credentials = { path = "../../common/credentials" }
 credential-storage = { path = "../../common/credential-storage" }
 crypto = { path = "../../common/crypto", features = ["rand", "asymmetric", "symmetric", "aes", "hashing"] }

clients/credential/src/client.rs

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::error::Result;
-use crate::{MNEMONIC, NYMD_URL};
 use bip39::Mnemonic;
 use network_defaults::{NymNetworkDetails, VOUCHER_INFO};
 use std::str::FromStr;
@@ -17,9 +16,9 @@ pub(crate) struct Client {
 }
 
 impl Client {
-    pub fn new() -> Self {
-        let nymd_url = Url::from_str(NYMD_URL).unwrap();
-        let mnemonic = Mnemonic::from_str(MNEMONIC).unwrap();
+    pub fn new(nymd_url: &str, mnemonic: &str) -> Self {
+        let nymd_url = Url::from_str(nymd_url).unwrap();
+        let mnemonic = Mnemonic::from_str(mnemonic).unwrap();
         let network_details = NymNetworkDetails::new_from_env();
         let config = nymd::Config::try_from_nym_network_details(&network_details)
             .expect("failed to construct valid validator client config with the provided network");

clients/credential/src/commands.rs

@@ -6,7 +6,6 @@ use clap::{Args, Subcommand};
 use pickledb::PickleDb;
 use rand::rngs::OsRng;
 use std::str::FromStr;
-use url::Url;
 
 use coconut_interface::{Attribute, Base58, BlindSignRequest, Bytable, Parameters};
 use credential_storage::storage::Storage;
@@ -20,7 +19,6 @@ use validator_client::nymd::tx::Hash;
 use crate::client::Client;
 use crate::error::{CredentialClientError, Result};
 use crate::state::{KeyPair, RequestData, State};
-use crate::SIGNER_AUTHORITIES;
 
 #[derive(Subcommand)]
 pub(crate) enum Commands {
@@ -39,6 +37,12 @@ pub(crate) trait Execute {
 
 #[derive(Args, Clone)]
 pub(crate) struct Deposit {
+    /// The nymd URL that should be used
+    #[clap(long)]
+    nymd_url: String,
+    /// A mnemonic for the account that does the deposit
+    #[clap(long)]
+    mnemonic: String,
     /// The amount that needs to be deposited
     #[clap(long)]
     amount: u64,
@@ -51,7 +55,7 @@ impl Execute for Deposit {
         let signing_keypair = KeyPair::from(identity::KeyPair::new(&mut rng));
         let encryption_keypair = KeyPair::from(encryption::KeyPair::new(&mut rng));
 
-        let client = Client::new();
+        let client = Client::new(&self.nymd_url, &self.mnemonic);
         let tx_hash = client
             .deposit(
                 self.amount,
@@ -96,6 +100,10 @@ pub(crate) struct GetCredential {
     /// The hash of a successful deposit transaction
     #[clap(long)]
     tx_hash: String,
+    /// The URLs to the validator-api endpoints the are run as coconut signer authorities, separated
+    /// by comma (,)
+    #[clap(long)]
+    signer_authorities: String,
     /// If we want to get the signature without attaching a blind sign request; it is expected that
     /// there is already a signature stored on the signer
     #[clap(long, parse(from_flag))]
@@ -108,7 +116,8 @@ impl Execute for GetCredential {
         let mut state = db
             .get::<State>(&self.tx_hash)
             .ok_or(CredentialClientError::NoDeposit)?;
-        let urls = SIGNER_AUTHORITIES.map(|addr| Url::from_str(addr).unwrap());
+
+        let urls = config::parse_validators(&self.signer_authorities);
 
         let params = Parameters::new(TOTAL_ATTRIBUTES).unwrap();
         let bandwidth_credential_attributes = if self.__no_request {

clients/credential/src/main.rs

@@ -11,20 +11,24 @@ cfg_if::cfg_if! {
 
         use commands::{Commands, Execute};
         use error::Result;
+        use network_defaults::setup_env;
 
         use clap::Parser;
         use pickledb::{PickleDb, PickleDbDumpPolicy, SerializationMethod};
 
-        pub const MNEMONIC: &str = "jazz fatigue diagram account outer wrist slide cherry mother grid network pause wolf pig round answer mail junior better hair dismiss toward access end";
-        pub const NYMD_URL: &str = "http://127.0.0.1:26657";
-        pub const CONTRACT_ADDRESS: &str = "nymt1nc5tatafv6eyq7llkr2gv50ff9e22mnfp9pc5s";
-        pub const SIGNER_AUTHORITIES: [&str; 1] = [
-            "http://127.0.0.1:8080",
-        ];
-
         #[derive(Parser)]
         #[clap(author = "Nymtech", version, about)]
         struct Cli {
+            /// Path pointing to an env file that configures the client.
+            #[clap(long)]
+            pub(crate) config_env_file: Option<std::path::PathBuf>,
+
+            /// Path where the sqlite credental database will be located.
+            /// It should point to a $HOME/$CLIENT_ID/data/db.sqlite file of
+            /// the client that is supposed to use the credential.
+            #[clap(long)]
+            pub(crate) credential_db_path: std::path::PathBuf,
+
             #[clap(subcommand)]
             command: Commands,
         }
@@ -32,8 +36,9 @@ cfg_if::cfg_if! {
         #[tokio::main]
         async fn main() -> Result<()> {
             let args = Cli::parse();
+            setup_env(args.config_env_file.clone());
 
-            let shared_storage = credential_storage::initialise_storage(std::path::PathBuf::from("/tmp/credential.db")).await;
+            let shared_storage = credential_storage::initialise_storage(args.credential_db_path.clone()).await;
             let mut db = match PickleDb::load(
                 "credential.db",
                 PickleDbDumpPolicy::AutoDump,

clients/native/Cargo.toml

@@ -33,23 +33,23 @@ tokio-tungstenite = "0.14" # websocket
 ## internal
 client-core = { path = "../client-core" }
 coconut-interface = { path = "../../common/coconut-interface", optional = true }
-credentials = { path = "../../common/credentials", optional = true }
-credential-storage = { path = "../../common/credential-storage" }
 config = { path = "../../common/config" }
+credential-storage = { path = "../../common/credential-storage" }
+credentials = { path = "../../common/credentials", optional = true }
 crypto = { path = "../../common/crypto" }
 gateway-client = { path = "../../common/client-libs/gateway-client" }
 gateway-requests = { path = "../../gateway/gateway-requests" }
+network-defaults = { path = "../../common/network-defaults" }
 nymsphinx = { path = "../../common/nymsphinx" }
 pemstore = { path = "../../common/pemstore" }
+task = { path = "../../common/task" }
 topology = { path = "../../common/topology" }
-websocket-requests = { path = "websocket-requests" }
 validator-client = { path = "../../common/client-libs/validator-client", features = ["nymd-client"] }
 version-checker = { path = "../../common/version-checker" }
-network-defaults = { path = "../../common/network-defaults" }
+websocket-requests = { path = "websocket-requests" }
 
 [features]
 coconut = ["coconut-interface", "credentials", "credentials/coconut", "gateway-requests/coconut", "gateway-client/coconut", "client-core/coconut"]
-eth = []
 
 [dev-dependencies]
 serde_json = "1.0" # for the "textsend" example

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

@@ -27,6 +27,58 @@
         "node": ">=10.0.0"
       }
     },
+    "node_modules/@jridgewell/gen-mapping": {
+      "version": "0.3.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.2.tgz",
+      "integrity": "sha512-mh65xKQAzI6iBcFzwv28KVWSmCkdRBWoOh+bYQGW3+6OZvbbN3TqMGo5hqYxQniRcH9F2VZIoJCm4pa3BPDK/A==",
+      "dependencies": {
+        "@jridgewell/set-array": "^1.0.1",
+        "@jridgewell/sourcemap-codec": "^1.4.10",
+        "@jridgewell/trace-mapping": "^0.3.9"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/resolve-uri": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.0.tgz",
+      "integrity": "sha512-F2msla3tad+Mfht5cJq7LSXcdudKTWCVYUgw6pLFOOHSTtZlj6SWNYAp+AhuqLmWdBO2X5hPrLcu8cVP8fy28w==",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/set-array": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/set-array/-/set-array-1.1.2.tgz",
+      "integrity": "sha512-xnkseuNADM0gt2bs+BvhO0p78Mk762YnZdsuzFV018NoG1Sj1SCQvpSqa7XUaTam5vAGasABV9qXASMKnFMwMw==",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/source-map": {
+      "version": "0.3.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/source-map/-/source-map-0.3.2.tgz",
+      "integrity": "sha512-m7O9o2uR8k2ObDysZYzdfhb08VuEml5oWGiosa1VdaPZ/A6QyPkAJuwN0Q1lhULOf6B7MtQmHENS743hWtCrgw==",
+      "dependencies": {
+        "@jridgewell/gen-mapping": "^0.3.0",
+        "@jridgewell/trace-mapping": "^0.3.9"
+      }
+    },
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.4.14",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.14.tgz",
+      "integrity": "sha512-XPSJHWmi394fuUuzDnGz1wiKqWfo1yXecHQMRf2l6hztTO+nPru658AyDngaBe7isIxEkRsPR3FZh+s7iVa4Uw=="
+    },
+    "node_modules/@jridgewell/trace-mapping": {
+      "version": "0.3.15",
+      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.15.tgz",
+      "integrity": "sha512-oWZNOULl+UbhsgB51uuZzglikfIKSUBO/M9W2OfEjn7cmqoAiCgmv9lyACTUacZwBz0ITnJ2NqjU8Tx0DHL88g==",
+      "dependencies": {
+        "@jridgewell/resolve-uri": "^3.0.3",
+        "@jridgewell/sourcemap-codec": "^1.4.10"
+      }
+    },
     "node_modules/@nodelib/fs.scandir": {
       "version": "2.1.5",
       "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
@@ -3529,13 +3581,13 @@
       }
     },
     "node_modules/terser": {
-      "version": "5.12.1",
-      "resolved": "https://registry.npmjs.org/terser/-/terser-5.12.1.tgz",
-      "integrity": "sha512-NXbs+7nisos5E+yXwAD+y7zrcTkMqb0dEJxIGtSKPdCBzopf7ni4odPul2aechpV7EXNvOudYOX2bb5tln1jbQ==",
+      "version": "5.15.0",
+      "resolved": "https://registry.npmjs.org/terser/-/terser-5.15.0.tgz",
+      "integrity": "sha512-L1BJiXVmheAQQy+as0oF3Pwtlo4s3Wi1X2zNZ2NxOB4wx9bdS9Vk67XQENLFdLYGCK/Z2di53mTj/hBafR+dTA==",
       "dependencies": {
+        "@jridgewell/source-map": "^0.3.2",
         "acorn": "^8.5.0",
         "commander": "^2.20.0",
-        "source-map": "~0.7.2",
         "source-map-support": "~0.5.20"
       },
       "bin": {
@@ -3583,14 +3635,6 @@
       "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz",
       "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ=="
     },
-    "node_modules/terser/node_modules/source-map": {
-      "version": "0.7.3",
-      "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.7.3.tgz",
-      "integrity": "sha512-CkCj6giN3S+n9qrYiBTX5gystlENnRW5jZeNLHpe6aue+SrHcG5VYwujhW9s4dY31mEGsxBDrHR6oI69fTXsaQ==",
-      "engines": {
-        "node": ">= 8"
-      }
-    },
     "node_modules/thunky": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/thunky/-/thunky-1.1.0.tgz",
@@ -4330,6 +4374,49 @@
       "integrity": "sha512-dBVuXR082gk3jsFp7Rd/JI4kytwGHecnCoTtXFb7DB6CNHp4rg5k1bhg0nWdLGLnOV71lmDzGQaLMy8iPLY0pw==",
       "dev": true
     },
+    "@jridgewell/gen-mapping": {
+      "version": "0.3.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.2.tgz",
+      "integrity": "sha512-mh65xKQAzI6iBcFzwv28KVWSmCkdRBWoOh+bYQGW3+6OZvbbN3TqMGo5hqYxQniRcH9F2VZIoJCm4pa3BPDK/A==",
+      "requires": {
+        "@jridgewell/set-array": "^1.0.1",
+        "@jridgewell/sourcemap-codec": "^1.4.10",
+        "@jridgewell/trace-mapping": "^0.3.9"
+      }
+    },
+    "@jridgewell/resolve-uri": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.0.tgz",
+      "integrity": "sha512-F2msla3tad+Mfht5cJq7LSXcdudKTWCVYUgw6pLFOOHSTtZlj6SWNYAp+AhuqLmWdBO2X5hPrLcu8cVP8fy28w=="
+    },
+    "@jridgewell/set-array": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/set-array/-/set-array-1.1.2.tgz",
+      "integrity": "sha512-xnkseuNADM0gt2bs+BvhO0p78Mk762YnZdsuzFV018NoG1Sj1SCQvpSqa7XUaTam5vAGasABV9qXASMKnFMwMw=="
+    },
+    "@jridgewell/source-map": {
+      "version": "0.3.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/source-map/-/source-map-0.3.2.tgz",
+      "integrity": "sha512-m7O9o2uR8k2ObDysZYzdfhb08VuEml5oWGiosa1VdaPZ/A6QyPkAJuwN0Q1lhULOf6B7MtQmHENS743hWtCrgw==",
+      "requires": {
+        "@jridgewell/gen-mapping": "^0.3.0",
+        "@jridgewell/trace-mapping": "^0.3.9"
+      }
+    },
+    "@jridgewell/sourcemap-codec": {
+      "version": "1.4.14",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.14.tgz",
+      "integrity": "sha512-XPSJHWmi394fuUuzDnGz1wiKqWfo1yXecHQMRf2l6hztTO+nPru658AyDngaBe7isIxEkRsPR3FZh+s7iVa4Uw=="
+    },
+    "@jridgewell/trace-mapping": {
+      "version": "0.3.15",
+      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.15.tgz",
+      "integrity": "sha512-oWZNOULl+UbhsgB51uuZzglikfIKSUBO/M9W2OfEjn7cmqoAiCgmv9lyACTUacZwBz0ITnJ2NqjU8Tx0DHL88g==",
+      "requires": {
+        "@jridgewell/resolve-uri": "^3.0.3",
+        "@jridgewell/sourcemap-codec": "^1.4.10"
+      }
+    },
     "@nodelib/fs.scandir": {
       "version": "2.1.5",
       "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
@@ -7058,13 +7145,13 @@
       "integrity": "sha512-GNzQvQTOIP6RyTfE2Qxb8ZVlNmw0n88vp1szwWRimP02mnTsx3Wtn5qRdqY9w2XduFNUgvOwhNnQsjwCp+kqaQ=="
     },
     "terser": {
-      "version": "5.12.1",
-      "resolved": "https://registry.npmjs.org/terser/-/terser-5.12.1.tgz",
-      "integrity": "sha512-NXbs+7nisos5E+yXwAD+y7zrcTkMqb0dEJxIGtSKPdCBzopf7ni4odPul2aechpV7EXNvOudYOX2bb5tln1jbQ==",
+      "version": "5.15.0",
+      "resolved": "https://registry.npmjs.org/terser/-/terser-5.15.0.tgz",
+      "integrity": "sha512-L1BJiXVmheAQQy+as0oF3Pwtlo4s3Wi1X2zNZ2NxOB4wx9bdS9Vk67XQENLFdLYGCK/Z2di53mTj/hBafR+dTA==",
       "requires": {
+        "@jridgewell/source-map": "^0.3.2",
         "acorn": "^8.5.0",
         "commander": "^2.20.0",
-        "source-map": "~0.7.2",
         "source-map-support": "~0.5.20"
       },
       "dependencies": {
@@ -7072,11 +7159,6 @@
           "version": "2.20.3",
           "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz",
           "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ=="
-        },
-        "source-map": {
-          "version": "0.7.3",
-          "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.7.3.tgz",
-          "integrity": "sha512-CkCj6giN3S+n9qrYiBTX5gystlENnRW5jZeNLHpe6aue+SrHcG5VYwujhW9s4dY31mEGsxBDrHR6oI69fTXsaQ=="
         }
       }
     },

clients/native/src/client/config/mod.rs

@@ -50,6 +50,10 @@ impl NymConfig for Config {
             .join("clients")
     }
 
+    fn try_default_root_directory() -> Option<PathBuf> {
+        dirs::home_dir().map(|path| path.join(".nym").join("clients"))
+    }
+
     fn root_directory(&self) -> PathBuf {
         self.base.get_nym_root_directory()
     }

clients/native/src/client/config/template.rs

@@ -49,12 +49,6 @@ reply_encryption_key_store_path = '{{ client.reply_encryption_key_store_path }}'
 # Path to the database containing bandwidth credentials
 database_path = '{{ client.database_path }}'
 
-# Ethereum private key.
-eth_private_key = '{{ client.eth_private_key }}'
-
-# Addess to an Ethereum full node.
-eth_endpoint = '{{ client.eth_endpoint }}'
-
 ##### additional client config options #####
 
 # A gateway specific, optional, base58 stringified shared key used for

clients/native/src/client/mod.rs

@@ -32,6 +32,7 @@ use nymsphinx::addressing::clients::Recipient;
 use nymsphinx::addressing::nodes::NodeIdentity;
 use nymsphinx::anonymous_replies::ReplySurb;
 use nymsphinx::receiver::ReconstructedMessage;
+use task::{wait_for_signal, ShutdownListener, ShutdownNotifier};
 
 use crate::client::config::{Config, SocketType};
 use crate::websocket;
@@ -85,6 +86,7 @@ impl NymClient {
         &self,
         topology_accessor: TopologyAccessor,
         mix_tx: BatchMixMessageSender,
+        shutdown: ShutdownListener,
     ) {
         info!("Starting loop cover traffic stream...");
 
@@ -98,6 +100,7 @@ impl NymClient {
             mix_tx,
             self.as_mix_recipient(),
             topology_accessor,
+            shutdown,
         )
         .start();
     }
@@ -109,6 +112,7 @@ impl NymClient {
         ack_receiver: AcknowledgementReceiver,
         input_receiver: InputMessageReceiver,
         mix_sender: BatchMixMessageSender,
+        shutdown: ShutdownListener,
     ) {
         let controller_config = real_messages_control::Config::new(
             self.key_manager.ack_key(),
@@ -117,6 +121,9 @@ impl NymClient {
             self.config.get_base().get_average_ack_delay(),
             self.config.get_base().get_message_sending_average_delay(),
             self.config.get_base().get_average_packet_delay(),
+            self.config
+                .get_base()
+                .get_disabled_main_poisson_packet_distribution(),
             self.as_mix_recipient(),
         );
 
@@ -129,6 +136,7 @@ impl NymClient {
             mix_sender,
             topology_accessor,
             reply_key_storage,
+            shutdown,
         )
         .start();
     }
@@ -140,6 +148,7 @@ impl NymClient {
         query_receiver: ReceivedBufferRequestReceiver,
         mixnet_receiver: MixnetMessageReceiver,
         reply_key_storage: ReplyKeyStorage,
+        shutdown: ShutdownListener,
     ) {
         info!("Starting received messages buffer controller...");
         ReceivedMessagesBufferController::new(
@@ -147,6 +156,7 @@ impl NymClient {
             query_receiver,
             mixnet_receiver,
             reply_key_storage,
+            shutdown,
         )
         .start()
     }
@@ -155,6 +165,7 @@ impl NymClient {
         &mut self,
         mixnet_message_sender: MixnetMessageSender,
         ack_sender: AcknowledgementSender,
+        shutdown: ShutdownListener,
     ) -> GatewayClient {
         let gateway_id = self.config.get_base().get_gateway_id();
         if gateway_id.is_empty() {
@@ -182,8 +193,6 @@ impl NymClient {
         let bandwidth_controller = BandwidthController::new(
             credential_storage::initialise_storage(self.config.get_base().get_database_path())
                 .await,
-            self.config.get_base().get_eth_endpoint(),
-            self.config.get_base().get_eth_private_key(),
         )
         .expect("Could not create bandwidth controller");
 
@@ -197,11 +206,12 @@ impl NymClient {
             ack_sender,
             self.config.get_base().get_gateway_response_timeout(),
             Some(bandwidth_controller),
+            Some(shutdown),
         );
 
-        if self.config.get_base().get_disabled_credentials_mode() {
-            gateway_client.set_disabled_credentials_mode(true)
-        }
+        gateway_client
+            .set_disabled_credentials_mode(self.config.get_base().get_disabled_credentials_mode());
+
         gateway_client
             .authenticate_and_start()
             .await
@@ -212,7 +222,11 @@ impl NymClient {
 
     // future responsible for periodically polling directory server and updating
     // the current global view of topology
-    async fn start_topology_refresher(&mut self, topology_accessor: TopologyAccessor) {
+    async fn start_topology_refresher(
+        &mut self,
+        topology_accessor: TopologyAccessor,
+        shutdown: ShutdownListener,
+    ) {
         let topology_refresher_config = TopologyRefresherConfig::new(
             self.config.get_base().get_validator_api_endpoints(),
             self.config.get_base().get_topology_refresh_rate(),
@@ -234,7 +248,7 @@ impl NymClient {
         }
 
         info!("Starting topology refresher...");
-        topology_refresher.start();
+        topology_refresher.start(shutdown);
     }
 
     // controller for sending sphinx packets to mixnet (either real traffic or cover traffic)
@@ -245,9 +259,10 @@ impl NymClient {
         &mut self,
         mix_rx: BatchMixMessageReceiver,
         gateway_client: GatewayClient,
+        shutdown: ShutdownListener,
     ) {
         info!("Starting mix traffic controller...");
-        MixTrafficController::new(mix_rx, gateway_client).start();
+        MixTrafficController::new(mix_rx, gateway_client, shutdown).start();
     }
 
     fn start_websocket_listener(
@@ -308,20 +323,26 @@ impl NymClient {
 
     /// blocking version of `start` method. Will run forever (or until SIGINT is sent)
     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
-            );
-        }
+        let shutdown = self.start().await;
+        wait_for_signal().await;
 
         println!(
-            "Received SIGINT - the client will terminate now (threads are not yet nicely stopped, if you see stack traces that's alright)."
+            "Received signal - the client will terminate now (threads are not yet nicely stopped, if you see stack traces that's alright)."
         );
+
+        log::info!("Sending shutdown");
+        shutdown.signal_shutdown().ok();
+
+        // Some of these components have shutdown signalling implemented as part of socks5 work,
+        // but since it's not fully implemented (yet) for all the components of the native client,
+        // we don't try to wait and instead just stop immediately.
+        //log::info!("Waiting for tasks to finish... (Press ctrl-c to force)");
+        //shutdown.wait_for_shutdown().await;
+
+        log::info!("Stopping nym-client");
     }
 
-    pub async fn start(&mut self) {
+    pub async fn start(&mut self) -> ShutdownNotifier {
         info!("Starting nym client");
         // channels for inter-component communication
         // TODO: make the channels be internally created by the relevant components
@@ -351,30 +372,43 @@ impl NymClient {
             ReplyKeyStorage::load(self.config.get_base().get_reply_encryption_key_store_path())
                 .expect("Failed to load reply key storage!");
 
+        // Shutdown notifier for signalling tasks to stop
+        let shutdown = ShutdownNotifier::default();
+
         // 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(), shutdown.subscribe())
             .await;
         self.start_received_messages_buffer_controller(
             received_buffer_request_receiver,
             mixnet_messages_receiver,
             reply_key_storage.clone(),
+            shutdown.subscribe(),
         );
 
         let gateway_client = self
-            .start_gateway_client(mixnet_messages_sender, ack_sender)
+            .start_gateway_client(mixnet_messages_sender, ack_sender, shutdown.subscribe())
             .await;
 
-        self.start_mix_traffic_controller(sphinx_message_receiver, gateway_client);
+        self.start_mix_traffic_controller(
+            sphinx_message_receiver,
+            gateway_client,
+            shutdown.subscribe(),
+        );
         self.start_real_traffic_controller(
             shared_topology_accessor.clone(),
             reply_key_storage,
             ack_receiver,
             input_receiver,
             sphinx_message_sender.clone(),
+            shutdown.subscribe(),
         );
 
-        self.start_cover_traffic_stream(shared_topology_accessor, sphinx_message_sender);
+        self.start_cover_traffic_stream(
+            shared_topology_accessor,
+            sphinx_message_sender,
+            shutdown.subscribe(),
+        );
 
         match self.config.get_socket_type() {
             SocketType::WebSocket => {
@@ -399,5 +433,7 @@ impl NymClient {
 
         info!("Client startup finished!");
         info!("The address of this client is: {}", self.as_mix_recipient());
+
+        shutdown
     }
 }

clients/native/src/commands/init.rs

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use clap::Args;
-use client_core::config::GatewayEndpoint;
+use client_core::{config::GatewayEndpoint, error::ClientCoreError};
 use config::NymConfig;
 
 use crate::{
@@ -10,9 +10,6 @@ use crate::{
     commands::{override_config, OverrideConfig},
 };
 
-#[cfg(all(feature = "eth", not(feature = "coconut")))]
-use crate::commands::{DEFAULT_ETH_ENDPOINT, DEFAULT_ETH_PRIVATE_KEY};
-
 #[derive(Args, Clone)]
 pub(crate) struct Init {
     /// Id of the nym-mixnet-client we want to create config for.
@@ -46,29 +43,10 @@ pub(crate) struct Init {
     fastmode: bool,
 
     /// Set this client to work in a enabled credentials mode that would attempt to use gateway
-    /// with bandwidth credential requirement. If this value is set, --eth-endpoint and
-    /// --eth-private_key don't need to be set.
-    #[cfg(all(feature = "eth", not(feature = "coconut")))]
-    #[clap(long, conflicts_with_all = &["eth-endpoint", "eth-private-key"])]
+    /// with bandwidth credential requirement.
+    #[cfg(feature = "coconut")]
+    #[clap(long)]
     enabled_credentials_mode: bool,
-
-    /// 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 --enabled-credentials-mode instead
-    #[cfg(all(feature = "eth", not(feature = "coconut")))]
-    #[clap(
-        long,
-        default_value_if("enabled-credentials-mode", None, Some(DEFAULT_ETH_ENDPOINT))
-    )]
-    eth_endpoint: String,
-
-    /// Ethereum private key used for obtaining bandwidth tokens from ERC20 tokens. If you don't
-    /// want to set this value, use --enabled-credentials-mode instead")
-    #[cfg(all(feature = "eth", not(feature = "coconut")))]
-    #[clap(
-        long,
-        default_value_if("enabled-credentials-mode", None, Some(DEFAULT_ETH_PRIVATE_KEY))
-    )]
-    eth_private_key: String,
 }
 
 impl From<Init> for OverrideConfig {
@@ -79,14 +57,8 @@ impl From<Init> for OverrideConfig {
             port: init_config.port,
             fastmode: init_config.fastmode,
 
-            #[cfg(all(feature = "eth", not(feature = "coconut")))]
+            #[cfg(feature = "coconut")]
             enabled_credentials_mode: init_config.enabled_credentials_mode,
-
-            #[cfg(all(feature = "eth", not(feature = "coconut")))]
-            eth_private_key: Some(init_config.eth_private_key),
-
-            #[cfg(all(feature = "eth", not(feature = "coconut")))]
-            eth_endpoint: Some(init_config.eth_endpoint),
         }
     }
 }
@@ -121,7 +93,12 @@ pub(crate) async fn execute(args: &Init) {
     let override_config_fields = OverrideConfig::from(args.clone());
     config = override_config(config, override_config_fields);
 
-    let gateway = setup_gateway(id, register_gateway, user_chosen_gateway_id, &config).await;
+    let gateway = setup_gateway(id, register_gateway, user_chosen_gateway_id, &config)
+        .await
+        .unwrap_or_else(|err| {
+            eprintln!("Failed to setup gateway\nError: {err}");
+            std::process::exit(1)
+        });
     config.get_base_mut().with_gateway_endpoint(gateway);
 
     let config_save_location = config.get_config_file_save_location();
@@ -139,7 +116,10 @@ pub(crate) async fn execute(args: &Init) {
     );
     println!("Client configuration completed.");
 
-    client_core::init::show_address(config.get_base());
+    client_core::init::show_address(config.get_base()).unwrap_or_else(|err| {
+        eprintln!("Failed to show address\nError: {err}");
+        std::process::exit(1)
+    });
 }
 
 async fn setup_gateway(
@@ -147,7 +127,7 @@ async fn setup_gateway(
     register: bool,
     user_chosen_gateway_id: Option<&str>,
     config: &Config,
-) -> GatewayEndpoint {
+) -> Result<GatewayEndpoint, ClientCoreError> {
     if register {
         // Get the gateway details by querying the validator-api. Either pick one at random or use
         // the chosen one if it's among the available ones.
@@ -156,16 +136,16 @@ async fn setup_gateway(
             config.get_base().get_validator_api_endpoints(),
             user_chosen_gateway_id,
         )
-        .await;
+        .await?;
         log::debug!("Querying gateway gives: {}", gateway);
 
         // Registering with gateway by setting up and writing shared keys to disk
         log::trace!("Registering gateway");
         client_core::init::register_with_gateway_and_store_keys(gateway.clone(), config.get_base())
-            .await;
+            .await?;
         println!("Saved all generated keys");
 
-        gateway.into()
+        Ok(gateway.into())
     } else if user_chosen_gateway_id.is_some() {
         // Just set the config, don't register or create any keys
         // This assumes that the user knows what they are doing, and that the existing keys are
@@ -175,22 +155,22 @@ async fn setup_gateway(
             config.get_base().get_validator_api_endpoints(),
             user_chosen_gateway_id,
         )
-        .await;
+        .await?;
         log::debug!("Querying gateway gives: {}", gateway);
-        gateway.into()
+        Ok(gateway.into())
     } else {
         println!("Not registering gateway, will reuse existing config and keys");
-        match Config::load_from_file(Some(id)) {
-            Ok(existing_config) => existing_config.get_base().get_gateway_endpoint().clone(),
-            Err(err) => {
-                panic!(
-                    "Unable to configure gateway: {err}. \n
-                    Seems like the client was already initialized but it was not possible to read \
-                    the existing configuration file. \n
-                    CAUTION: Consider backing up your gateway keys and try force gateway registration, or \
-                    removing the existing configuration and starting over."
-                )
-            }
-        }
+        let existing_config = Config::load_from_file(Some(id)).map_err(|err| {
+            log::error!(
+                "Unable to configure gateway: {err}. \n
+                Seems like the client was already initialized but it was not possible to read \
+                the existing configuration file. \n
+                CAUTION: Consider backing up your gateway keys and try force gateway registration, or \
+                removing the existing configuration and starting over."
+            );
+            ClientCoreError::CouldNotLoadExistingGatewayConfiguration(err)
+        })?;
+
+        Ok(existing_config.get_base().get_gateway_endpoint().clone())
     }
 }

clients/native/src/commands/mod.rs

@@ -4,13 +4,6 @@
 use crate::client::config::{Config, SocketType};
 use clap::{Parser, Subcommand};
 
-#[cfg(not(feature = "coconut"))]
-pub(crate) const DEFAULT_ETH_ENDPOINT: &str =
-    "https://rinkeby.infura.io/v3/00000000000000000000000000000000";
-#[cfg(not(feature = "coconut"))]
-pub(crate) const DEFAULT_ETH_PRIVATE_KEY: &str =
-    "0000000000000000000000000000000000000000000000000000000000000001";
-
 pub(crate) mod init;
 pub(crate) mod run;
 pub(crate) mod upgrade;
@@ -78,14 +71,8 @@ pub(crate) struct OverrideConfig {
     port: Option<u16>,
     fastmode: bool,
 
-    #[cfg(all(feature = "eth", not(feature = "coconut")))]
+    #[cfg(feature = "coconut")]
     enabled_credentials_mode: bool,
-
-    #[cfg(all(feature = "eth", not(feature = "coconut")))]
-    eth_private_key: Option<String>,
-
-    #[cfg(all(feature = "eth", not(feature = "coconut")))]
-    eth_endpoint: Option<String>,
 }
 
 pub(crate) async fn execute(args: &Cli) {
@@ -117,27 +104,11 @@ pub(crate) fn override_config(mut config: Config, args: OverrideConfig) -> Confi
         config = config.with_port(port);
     }
 
-    #[cfg(all(not(feature = "eth"), not(feature = "coconut")))]
-    {
-        config
-            .get_base_mut()
-            .with_eth_endpoint(DEFAULT_ETH_ENDPOINT.to_string());
-        config
-            .get_base_mut()
-            .with_eth_private_key(DEFAULT_ETH_PRIVATE_KEY.to_string());
-    }
-
-    #[cfg(all(feature = "eth", not(feature = "coconut")))]
+    #[cfg(feature = "coconut")]
     {
         if args.enabled_credentials_mode {
             config.get_base_mut().with_disabled_credentials(false)
         }
-        if let Some(eth_endpoint) = args.eth_endpoint {
-            config.get_base_mut().with_eth_endpoint(eth_endpoint);
-        }
-        if let Some(eth_private_key) = args.eth_private_key {
-            config.get_base_mut().with_eth_private_key(eth_private_key);
-        }
     }
 
     if args.fastmode {

clients/native/src/commands/run.rs

@@ -35,23 +35,10 @@ pub(crate) struct Run {
     port: Option<u16>,
 
     /// Set this client to work in a enabled credentials mode that would attempt to use gateway
-    /// with bandwidth credential requirement. If this value is set, --eth-endpoint and
-    /// --eth-private-key don't need to be set.
-    #[cfg(all(feature = "eth", not(feature = "coconut")))]
-    #[clap(long, conflicts_with_all = &["eth-endpoint", "eth-private-key"])]
+    /// with bandwidth credential requirement.
+    #[cfg(feature = "coconut")]
+    #[clap(long)]
     enabled_credentials_mode: bool,
-
-    /// 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 --enabled-credentials-mode instead
-    #[cfg(all(feature = "eth", not(feature = "coconut")))]
-    #[clap(long)]
-    eth_endpoint: Option<String>,
-
-    /// Ethereum private key used for obtaining bandwidth tokens from ERC20 tokens. If you don't
-    /// want to set this value, use --enabled-credentials-mode instead")
-    #[cfg(all(feature = "eth", not(feature = "coconut")))]
-    #[clap(long)]
-    eth_private_key: Option<String>,
 }
 
 impl From<Run> for OverrideConfig {
@@ -61,15 +48,8 @@ impl From<Run> for OverrideConfig {
             disable_socket: run_config.disable_socket,
             port: run_config.port,
             fastmode: false,
-
-            #[cfg(all(feature = "eth", not(feature = "coconut")))]
+            #[cfg(feature = "coconut")]
             enabled_credentials_mode: run_config.enabled_credentials_mode,
-
-            #[cfg(all(feature = "eth", not(feature = "coconut")))]
-            eth_private_key: run_config.eth_private_key,
-
-            #[cfg(all(feature = "eth", not(feature = "coconut")))]
-            eth_endpoint: run_config.eth_endpoint,
         }
     }
 }

clients/socks5/Cargo.toml

@@ -26,21 +26,22 @@ url = "2.2"
 # internal
 client-core = { path = "../client-core" }
 coconut-interface = { path = "../../common/coconut-interface", optional = true }
-credentials = { path = "../../common/credentials", optional = true }
-credential-storage = { path = "../../common/credential-storage" }
 config = { path = "../../common/config" }
+credential-storage = { path = "../../common/credential-storage" }
+credentials = { path = "../../common/credentials", optional = true }
 crypto = { path = "../../common/crypto" }
 gateway-client = { path = "../../common/client-libs/gateway-client" }
 gateway-requests = { path = "../../gateway/gateway-requests" }
+network-defaults = { path = "../../common/network-defaults" }
 nymsphinx = { path = "../../common/nymsphinx" }
 ordered-buffer = { path = "../../common/socks5/ordered-buffer" }
-socks5-requests = { path = "../../common/socks5/requests" }
-topology = { path = "../../common/topology" }
 pemstore = { path = "../../common/pemstore" }
 proxy-helpers = { path = "../../common/socks5/proxy-helpers" }
+socks5-requests = { path = "../../common/socks5/requests" }
+task = { path = "../../common/task" }
+topology = { path = "../../common/topology" }
 validator-client = { path = "../../common/client-libs/validator-client", features = ["nymd-client"] }
 version-checker = { path = "../../common/version-checker" }
-network-defaults = { path = "../../common/network-defaults" }
 
 [features]
 coconut = ["coconut-interface", "credentials", "gateway-requests/coconut", "gateway-client/coconut", "credentials/coconut", "client-core/coconut"]

clients/socks5/src/client/config/mod.rs

@@ -33,6 +33,10 @@ impl NymConfig for Config {
             .join("socks5-clients")
     }
 
+    fn try_default_root_directory() -> Option<PathBuf> {
+        dirs::home_dir().map(|path| path.join(".nym").join("socks5-clients"))
+    }
+
     fn root_directory(&self) -> PathBuf {
         self.base.get_nym_root_directory()
     }

clients/socks5/src/client/config/template.rs

@@ -49,12 +49,6 @@ reply_encryption_key_store_path = '{{ client.reply_encryption_key_store_path }}'
 # Path to the database containing bandwidth credentials
 database_path = '{{ client.database_path }}'
 
-# Ethereum private key.
-eth_private_key = '{{ client.eth_private_key }}'
-
-# Addess to an Ethereum full node.
-eth_endpoint = '{{ client.eth_endpoint }}'
-
 ##### additional client config options #####
 
 # A gateway specific, optional, base58 stringified shared key used for

clients/socks5/src/client/mod.rs

@@ -1,6 +1,8 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
+use std::sync::atomic::Ordering;
+
 use client_core::client::cover_traffic_stream::LoopCoverTrafficStream;
 use client_core::client::inbound_messages::{
     InputMessage, InputMessageReceiver, InputMessageSender,
@@ -29,6 +31,7 @@ use gateway_client::{
 use log::*;
 use nymsphinx::addressing::clients::Recipient;
 use nymsphinx::addressing::nodes::NodeIdentity;
+use task::{wait_for_signal, ShutdownListener, ShutdownNotifier};
 
 use crate::client::config::Config;
 use crate::socks::{
@@ -84,6 +87,7 @@ impl NymClient {
         &self,
         topology_accessor: TopologyAccessor,
         mix_tx: BatchMixMessageSender,
+        shutdown: ShutdownListener,
     ) {
         info!("Starting loop cover traffic stream...");
 
@@ -97,6 +101,7 @@ impl NymClient {
             mix_tx,
             self.as_mix_recipient(),
             topology_accessor,
+            shutdown,
         )
         .start();
     }
@@ -108,6 +113,7 @@ impl NymClient {
         ack_receiver: AcknowledgementReceiver,
         input_receiver: InputMessageReceiver,
         mix_sender: BatchMixMessageSender,
+        shutdown: ShutdownListener,
     ) {
         let controller_config = client_core::client::real_messages_control::Config::new(
             self.key_manager.ack_key(),
@@ -116,6 +122,9 @@ impl NymClient {
             self.config.get_base().get_average_ack_delay(),
             self.config.get_base().get_message_sending_average_delay(),
             self.config.get_base().get_average_packet_delay(),
+            self.config
+                .get_base()
+                .get_disabled_main_poisson_packet_distribution(),
             self.as_mix_recipient(),
         );
 
@@ -128,6 +137,7 @@ impl NymClient {
             mix_sender,
             topology_accessor,
             reply_key_storage,
+            shutdown,
         )
         .start();
     }
@@ -139,6 +149,7 @@ impl NymClient {
         query_receiver: ReceivedBufferRequestReceiver,
         mixnet_receiver: MixnetMessageReceiver,
         reply_key_storage: ReplyKeyStorage,
+        shutdown: ShutdownListener,
     ) {
         info!("Starting received messages buffer controller...");
         ReceivedMessagesBufferController::new(
@@ -146,6 +157,7 @@ impl NymClient {
             query_receiver,
             mixnet_receiver,
             reply_key_storage,
+            shutdown,
         )
         .start()
     }
@@ -154,6 +166,7 @@ impl NymClient {
         &mut self,
         mixnet_message_sender: MixnetMessageSender,
         ack_sender: AcknowledgementSender,
+        shutdown: ShutdownListener,
     ) -> GatewayClient {
         let gateway_id = self.config.get_base().get_gateway_id();
         if gateway_id.is_empty() {
@@ -181,8 +194,6 @@ impl NymClient {
         let bandwidth_controller = BandwidthController::new(
             credential_storage::initialise_storage(self.config.get_base().get_database_path())
                 .await,
-            self.config.get_base().get_eth_endpoint(),
-            self.config.get_base().get_eth_private_key(),
         )
         .expect("Could not create bandwidth controller");
 
@@ -196,11 +207,12 @@ impl NymClient {
             ack_sender,
             self.config.get_base().get_gateway_response_timeout(),
             Some(bandwidth_controller),
+            Some(shutdown),
         );
 
-        if self.config.get_base().get_disabled_credentials_mode() {
-            gateway_client.set_disabled_credentials_mode(true)
-        }
+        gateway_client
+            .set_disabled_credentials_mode(self.config.get_base().get_disabled_credentials_mode());
+
         gateway_client
             .authenticate_and_start()
             .await
@@ -211,7 +223,11 @@ impl NymClient {
 
     // future responsible for periodically polling directory server and updating
     // the current global view of topology
-    async fn start_topology_refresher(&mut self, topology_accessor: TopologyAccessor) {
+    async fn start_topology_refresher(
+        &mut self,
+        topology_accessor: TopologyAccessor,
+        shutdown: ShutdownListener,
+    ) {
         let topology_refresher_config = TopologyRefresherConfig::new(
             self.config.get_base().get_validator_api_endpoints(),
             self.config.get_base().get_topology_refresh_rate(),
@@ -233,7 +249,7 @@ impl NymClient {
         }
 
         info!("Starting topology refresher...");
-        topology_refresher.start();
+        topology_refresher.start(shutdown);
     }
 
     // controller for sending sphinx packets to mixnet (either real traffic or cover traffic)
@@ -244,15 +260,17 @@ impl NymClient {
         &mut self,
         mix_rx: BatchMixMessageReceiver,
         gateway_client: GatewayClient,
+        shutdown: ShutdownListener,
     ) {
         info!("Starting mix traffic controller...");
-        MixTrafficController::new(mix_rx, gateway_client).start();
+        MixTrafficController::new(mix_rx, gateway_client, shutdown).start();
     }
 
     fn start_socks5_listener(
         &self,
         buffer_requester: ReceivedBufferRequestSender,
         msg_input: InputMessageSender,
+        shutdown: ShutdownListener,
     ) {
         info!("Starting socks5 listener...");
         let auth_methods = vec![AuthenticationMethods::NoAuth as u8];
@@ -264,43 +282,57 @@ impl NymClient {
             authenticator,
             self.config.get_provider_mix_address(),
             self.as_mix_recipient(),
+            shutdown,
         );
         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 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
-            );
-        }
+        let mut shutdown = self.start().await;
+        wait_for_signal().await;
 
-        println!(
-            "Received SIGINT - the client will terminate now (threads are not yet nicely stopped, if you see stack traces that's alright)."
-        );
+        log::info!("Sending shutdown");
+        client_core::client::SHUTDOWN_HAS_BEEN_SIGNALLED.store(true, Ordering::Relaxed);
+        shutdown.signal_shutdown().ok();
+
+        log::info!("Waiting for tasks to finish... (Press ctrl-c to force)");
+        shutdown.wait_for_shutdown().await;
+
+        log::info!("Stopping nym-socks5-client");
     }
 
     // Variant of `run_forever` that listends for remote control messages
     pub async fn run_and_listen(&mut self, mut receiver: Socks5ControlMessageReceiver) {
-        self.start().await;
+        let mut shutdown = self.start().await;
         tokio::select! {
             message = receiver.next() => {
                 log::debug!("Received message: {:?}", message);
                 match message {
                     Some(Socks5ControlMessage::Stop) => {
-                        log::info!("Shutting down");
-                        log::info!("Graceful shutdown of tasks not yet implemented, you might see (harmless) panics until then");
+                        log::info!("Received stop message");
+                    }
+                    None => {
+                        log::info!("Channel closed, stopping");
                     }
-                    None => log::debug!("None"),
                 }
             }
+            _ = tokio::signal::ctrl_c() => {
+                log::info!("Received SIGINT");
+            },
         }
+
+        log::info!("Sending shutdown");
+        client_core::client::SHUTDOWN_HAS_BEEN_SIGNALLED.store(true, Ordering::Relaxed);
+        shutdown.signal_shutdown().ok();
+
+        log::info!("Waiting for tasks to finish... (Press ctrl-c to force)");
+        shutdown.wait_for_shutdown().await;
+
+        log::info!("Stopping nym-socks5-client");
     }
 
-    pub async fn start(&mut self) {
+    pub async fn start(&mut self) -> ShutdownNotifier {
         info!("Starting nym client");
         // channels for inter-component communication
         // TODO: make the channels be internally created by the relevant components
@@ -330,33 +362,52 @@ impl NymClient {
             ReplyKeyStorage::load(self.config.get_base().get_reply_encryption_key_store_path())
                 .expect("Failed to load reply key storage!");
 
+        // Shutdown notifier for signalling tasks to stop
+        let shutdown = ShutdownNotifier::default();
+
         // 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(), shutdown.subscribe())
             .await;
         self.start_received_messages_buffer_controller(
             received_buffer_request_receiver,
             mixnet_messages_receiver,
             reply_key_storage.clone(),
+            shutdown.subscribe(),
         );
 
         let gateway_client = self
-            .start_gateway_client(mixnet_messages_sender, ack_sender)
+            .start_gateway_client(mixnet_messages_sender, ack_sender, shutdown.subscribe())
             .await;
 
-        self.start_mix_traffic_controller(sphinx_message_receiver, gateway_client);
+        self.start_mix_traffic_controller(
+            sphinx_message_receiver,
+            gateway_client,
+            shutdown.subscribe(),
+        );
         self.start_real_traffic_controller(
             shared_topology_accessor.clone(),
             reply_key_storage,
             ack_receiver,
             input_receiver,
             sphinx_message_sender.clone(),
+            shutdown.subscribe(),
         );
 
-        self.start_cover_traffic_stream(shared_topology_accessor, sphinx_message_sender);
-        self.start_socks5_listener(received_buffer_request_sender, input_sender);
+        self.start_cover_traffic_stream(
+            shared_topology_accessor,
+            sphinx_message_sender,
+            shutdown.subscribe(),
+        );
+        self.start_socks5_listener(
+            received_buffer_request_sender,
+            input_sender,
+            shutdown.subscribe(),
+        );
 
         info!("Client startup finished!");
         info!("The address of this client is: {}", self.as_mix_recipient());
+
+        shutdown
     }
 }

clients/socks5/src/commands/init.rs

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use clap::Args;
-use client_core::config::GatewayEndpoint;
+use client_core::{config::GatewayEndpoint, error::ClientCoreError};
 use config::NymConfig;
 
 use crate::{
@@ -10,9 +10,6 @@ use crate::{
     commands::{override_config, OverrideConfig},
 };
 
-#[cfg(all(feature = "eth", not(feature = "coconut")))]
-use crate::commands::{DEFAULT_ETH_ENDPOINT, DEFAULT_ETH_PRIVATE_KEY};
-
 #[derive(Args, Clone)]
 pub(crate) struct Init {
     /// Id of the nym-mixnet-client we want to create config for.
@@ -46,29 +43,10 @@ pub(crate) struct Init {
     fastmode: bool,
 
     /// Set this client to work in a enabled credentials mode that would attempt to use gateway
-    /// with bandwidth credential requirement. If this value is set, --eth-endpoint and
-    /// --eth-private_key don't need to be set.
-    #[cfg(all(feature = "eth", not(feature = "coconut")))]
-    #[clap(long, conflicts_with_all = &["eth-endpoint", "eth-private-key"])]
+    /// with bandwidth credential requirement.
+    #[cfg(feature = "coconut")]
+    #[clap(long)]
     enabled_credentials_mode: bool,
-
-    /// 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 --enabled-credentials-mode instead
-    #[cfg(all(feature = "eth", not(feature = "coconut")))]
-    #[clap(
-        long,
-        default_value_if("enabled-credentials-mode", None, Some(DEFAULT_ETH_ENDPOINT))
-    )]
-    eth_endpoint: String,
-
-    /// Ethereum private key used for obtaining bandwidth tokens from ERC20 tokens. If you don't
-    /// want to set this value, use --enabled-credentials-mode instead")
-    #[cfg(all(feature = "eth", not(feature = "coconut")))]
-    #[clap(
-        long,
-        default_value_if("enabled-credentials-mode", None, Some(DEFAULT_ETH_PRIVATE_KEY))
-    )]
-    eth_private_key: String,
 }
 
 impl From<Init> for OverrideConfig {
@@ -77,15 +55,8 @@ impl From<Init> for OverrideConfig {
             validators: init_config.validators,
             port: init_config.port,
             fastmode: init_config.fastmode,
-
-            #[cfg(all(feature = "eth", not(feature = "coconut")))]
+            #[cfg(feature = "coconut")]
             enabled_credentials_mode: init_config.enabled_credentials_mode,
-
-            #[cfg(all(feature = "eth", not(feature = "coconut")))]
-            eth_private_key: Some(init_config.eth_private_key),
-
-            #[cfg(all(feature = "eth", not(feature = "coconut")))]
-            eth_endpoint: Some(init_config.eth_endpoint),
         }
     }
 }
@@ -121,7 +92,12 @@ pub(crate) async fn execute(args: &Init) {
     let override_config_fields = OverrideConfig::from(args.clone());
     config = override_config(config, override_config_fields);
 
-    let gateway = setup_gateway(id, register_gateway, user_chosen_gateway_id, &config).await;
+    let gateway = setup_gateway(id, register_gateway, user_chosen_gateway_id, &config)
+        .await
+        .unwrap_or_else(|err| {
+            eprintln!("Failed to setup gateway\nError: {err}");
+            std::process::exit(1)
+        });
     config.get_base_mut().with_gateway_endpoint(gateway);
 
     let config_save_location = config.get_config_file_save_location();
@@ -139,7 +115,10 @@ pub(crate) async fn execute(args: &Init) {
     );
     println!("Client configuration completed.");
 
-    client_core::init::show_address(config.get_base());
+    client_core::init::show_address(config.get_base()).unwrap_or_else(|err| {
+        eprintln!("Failed to show address\nError: {err}");
+        std::process::exit(1)
+    });
 }
 
 async fn setup_gateway(
@@ -147,7 +126,7 @@ async fn setup_gateway(
     register: bool,
     user_chosen_gateway_id: Option<&str>,
     config: &Config,
-) -> GatewayEndpoint {
+) -> Result<GatewayEndpoint, ClientCoreError> {
     if register {
         // Get the gateway details by querying the validator-api. Either pick one at random or use
         // the chosen one if it's among the available ones.
@@ -156,16 +135,16 @@ async fn setup_gateway(
             config.get_base().get_validator_api_endpoints(),
             user_chosen_gateway_id,
         )
-        .await;
+        .await?;
         log::debug!("Querying gateway gives: {}", gateway);
 
         // Registering with gateway by setting up and writing shared keys to disk
         log::trace!("Registering gateway");
         client_core::init::register_with_gateway_and_store_keys(gateway.clone(), config.get_base())
-            .await;
+            .await?;
         println!("Saved all generated keys");
 
-        gateway.into()
+        Ok(gateway.into())
     } else if user_chosen_gateway_id.is_some() {
         // Just set the config, don't register or create any keys
         // This assumes that the user knows what they are doing, and that the existing keys are
@@ -175,22 +154,21 @@ async fn setup_gateway(
             config.get_base().get_validator_api_endpoints(),
             user_chosen_gateway_id,
         )
-        .await;
+        .await?;
         log::debug!("Querying gateway gives: {}", gateway);
-        gateway.into()
+        Ok(gateway.into())
     } else {
         println!("Not registering gateway, will reuse existing config and keys");
-        match Config::load_from_file(Some(id)) {
-            Ok(existing_config) => existing_config.get_base().get_gateway_endpoint().clone(),
-            Err(err) => {
-                panic!(
-                    "Unable to configure gateway: {err}. \n
-                    Seems like the client was already initialized but it was not possible to read \
-                    the existing configuration file. \n
-                    CAUTION: Consider backing up your gateway keys and try force gateway registration, or \
-                    removing the existing configuration and starting over."
-                )
-            }
-        }
+        let existing_config = Config::load_from_file(Some(id)).map_err(|err| {
+            log::error!(
+                "Unable to configure gateway: {err}. \n
+                Seems like the client was already initialized but it was not possible to read \
+                the existing configuration file. \n
+                CAUTION: Consider backing up your gateway keys and try force gateway registration, or \
+                removing the existing configuration and starting over."
+            );
+            ClientCoreError::CouldNotLoadExistingGatewayConfiguration(err)
+        })?;
+        Ok(existing_config.get_base().get_gateway_endpoint().clone())
     }
 }

clients/socks5/src/commands/mod.rs

@@ -9,13 +9,6 @@ pub mod init;
 pub(crate) mod run;
 pub(crate) mod upgrade;
 
-#[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 long_version() -> String {
     format!(
         r#"
@@ -78,14 +71,8 @@ pub(crate) struct OverrideConfig {
     port: Option<u16>,
     fastmode: bool,
 
-    #[cfg(all(feature = "eth", not(feature = "coconut")))]
+    #[cfg(feature = "coconut")]
     enabled_credentials_mode: bool,
-
-    #[cfg(all(feature = "eth", not(feature = "coconut")))]
-    eth_private_key: Option<String>,
-
-    #[cfg(all(feature = "eth", not(feature = "coconut")))]
-    eth_endpoint: Option<String>,
 }
 
 pub(crate) async fn execute(args: &Cli) {
@@ -111,27 +98,11 @@ pub(crate) fn override_config(mut config: Config, args: OverrideConfig) -> Confi
         config = config.with_port(port);
     }
 
-    #[cfg(all(not(feature = "eth"), not(feature = "coconut")))]
-    {
-        config
-            .get_base_mut()
-            .with_eth_endpoint(DEFAULT_ETH_ENDPOINT.to_string());
-        config
-            .get_base_mut()
-            .with_eth_private_key(DEFAULT_ETH_PRIVATE_KEY.to_string());
-    }
-
-    #[cfg(all(feature = "eth", not(feature = "coconut")))]
+    #[cfg(feature = "coconut")]
     {
         if args.enabled_credentials_mode {
             config.get_base_mut().with_disabled_credentials(false)
         }
-        if let Some(eth_endpoint) = args.eth_endpoint {
-            config.get_base_mut().with_eth_endpoint(eth_endpoint);
-        }
-        if let Some(eth_private_key) = args.eth_private_key {
-            config.get_base_mut().with_eth_private_key(eth_private_key);
-        }
     }
 
     if args.fastmode {

clients/socks5/src/commands/run.rs

@@ -39,23 +39,10 @@ pub(crate) struct Run {
     port: Option<u16>,
 
     /// Set this client to work in a enabled credentials mode that would attempt to use gateway
-    /// with bandwidth credential requirement. If this value is set, --eth-endpoint and
-    /// --eth-private-key don't need to be set.
-    #[cfg(all(feature = "eth", not(feature = "coconut")))]
-    #[clap(long, conflicts_with_all = &["eth-endpoint", "eth-private-key"])]
+    /// with bandwidth credential requirement.
+    #[cfg(feature = "coconut")]
+    #[clap(long)]
     enabled_credentials_mode: bool,
-
-    /// 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 --enabled-credentials-mode instead
-    #[cfg(all(feature = "eth", not(feature = "coconut")))]
-    #[clap(long)]
-    eth_endpoint: Option<String>,
-
-    /// Ethereum private key used for obtaining bandwidth tokens from ERC20 tokens. If you don't
-    /// want to set this value, use --enabled-credentials-mode instead
-    #[cfg(all(feature = "eth", not(feature = "coconut")))]
-    #[clap(long)]
-    eth_private_key: Option<String>,
 }
 
 impl From<Run> for OverrideConfig {
@@ -65,14 +52,8 @@ impl From<Run> for OverrideConfig {
             port: run_config.port,
             fastmode: false,
 
-            #[cfg(all(feature = "eth", not(feature = "coconut")))]
+            #[cfg(feature = "coconut")]
             enabled_credentials_mode: run_config.enabled_credentials_mode,
-
-            #[cfg(all(feature = "eth", not(feature = "coconut")))]
-            eth_private_key: run_config.eth_private_key,
-
-            #[cfg(all(feature = "eth", not(feature = "coconut")))]
-            eth_endpoint: run_config.eth_endpoint,
         }
     }
 }

clients/socks5/src/main.rs

@@ -52,5 +52,6 @@ fn setup_logging() {
         .filter_module("want", log::LevelFilter::Warn)
         .filter_module("tungstenite", log::LevelFilter::Warn)
         .filter_module("tokio_tungstenite", log::LevelFilter::Warn)
+        .filter_module("sled", log::LevelFilter::Warn)
         .init();
 }

clients/socks5/src/socks/client.rs

@@ -20,6 +20,7 @@ use socks5_requests::{ConnectionId, Message, RemoteAddress, Request};
 use std::io;
 use std::net::SocketAddr;
 use std::pin::Pin;
+use task::ShutdownListener;
 use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt, ReadBuf};
 use tokio::{self, net::TcpStream};
 
@@ -140,6 +141,7 @@ pub(crate) struct SocksClient {
     service_provider: Recipient,
     self_address: Recipient,
     started_proxy: bool,
+    shutdown_listener: ShutdownListener,
 }
 
 impl Drop for SocksClient {
@@ -163,6 +165,7 @@ impl SocksClient {
         service_provider: Recipient,
         controller_sender: ControllerSender,
         self_address: Recipient,
+        shutdown_listener: ShutdownListener,
     ) -> Self {
         let connection_id = Self::generate_random();
         SocksClient {
@@ -176,6 +179,7 @@ impl SocksClient {
             service_provider,
             self_address,
             started_proxy: false,
+            shutdown_listener,
         }
     }
 
@@ -250,6 +254,7 @@ impl SocksClient {
             conn_receiver,
             input_sender,
             connection_id,
+            self.shutdown_listener.clone(),
         )
         .run(move |conn_id, read_data, socket_closed| {
             let provider_request = Request::new_send(conn_id, read_data, socket_closed);

clients/socks5/src/socks/mixnet_responses.rs

@@ -1,16 +1,19 @@
-use client_core::client::received_buffer::ReconstructedMessagesReceiver;
-use client_core::client::received_buffer::{ReceivedBufferMessage, ReceivedBufferRequestSender};
 use futures::channel::mpsc;
 use futures::StreamExt;
 use log::*;
+
+use client_core::client::received_buffer::ReconstructedMessagesReceiver;
+use client_core::client::received_buffer::{ReceivedBufferMessage, ReceivedBufferRequestSender};
 use nymsphinx::receiver::ReconstructedMessage;
 use proxy_helpers::connection_controller::{ControllerCommand, ControllerSender};
 use socks5_requests::Message;
+use task::ShutdownListener;
 
 pub(crate) struct MixnetResponseListener {
     buffer_requester: ReceivedBufferRequestSender,
     mix_response_receiver: ReconstructedMessagesReceiver,
     controller_sender: ControllerSender,
+    shutdown: ShutdownListener,
 }
 
 impl Drop for MixnetResponseListener {
@@ -25,6 +28,7 @@ impl MixnetResponseListener {
     pub(crate) fn new(
         buffer_requester: ReceivedBufferRequestSender,
         controller_sender: ControllerSender,
+        shutdown: ShutdownListener,
     ) -> Self {
         let (mix_response_sender, mix_response_receiver) = mpsc::unbounded();
         buffer_requester
@@ -35,6 +39,7 @@ impl MixnetResponseListener {
             buffer_requester,
             mix_response_receiver,
             controller_sender,
+            shutdown,
         }
     }
 
@@ -54,6 +59,13 @@ impl MixnetResponseListener {
                 return;
             }
             Ok(Message::Response(data)) => data,
+            Ok(Message::NetworkRequesterResponse(r)) => {
+                error!(
+                    "Network requester failed on connection id {} with error: {}",
+                    r.connection_id, r.network_requester_error
+                );
+                return;
+            }
         };
 
         self.controller_sender
@@ -66,11 +78,25 @@ impl MixnetResponseListener {
     }
 
     pub(crate) async fn run(&mut self) {
-        while let Some(received_responses) = self.mix_response_receiver.next().await {
-            for reconstructed_message in received_responses {
-                self.on_message(reconstructed_message).await;
+        while !self.shutdown.is_shutdown() {
+            tokio::select! {
+                received_responses = self.mix_response_receiver.next() => match received_responses {
+                    Some(received_responses) => {
+                        for reconstructed_message in received_responses {
+                            self.on_message(reconstructed_message).await;
+                        }
+                    },
+                    None => {
+                        log::trace!("MixnetResponseListener: Stopping since channel closed");
+                        break;
+                    }
+                },
+                _ = self.shutdown.recv() => {
+                    log::trace!("MixnetResponseListener: Received shutdown");
+                }
             }
         }
-        error!("We should never see this message");
+        assert!(self.shutdown.is_shutdown_poll());
+        log::debug!("MixnetResponseListener: Exiting");
     }
 }

clients/socks5/src/socks/server.rs

@@ -11,6 +11,7 @@ use log::*;
 use nymsphinx::addressing::clients::Recipient;
 use proxy_helpers::connection_controller::Controller;
 use std::net::SocketAddr;
+use task::ShutdownListener;
 use tokio::net::TcpListener;
 
 /// A Socks5 server that listens for connections.
@@ -19,6 +20,7 @@ pub struct SphinxSocksServer {
     listening_address: SocketAddr,
     service_provider: Recipient,
     self_address: Recipient,
+    shutdown: ShutdownListener,
 }
 
 impl SphinxSocksServer {
@@ -28,6 +30,7 @@ impl SphinxSocksServer {
         authenticator: Authenticator,
         service_provider: Recipient,
         self_address: Recipient,
+        shutdown: ShutdownListener,
     ) -> Self {
         // hardcode ip as we (presumably) ONLY want to listen locally. If we change it, we can
         // just modify the config
@@ -38,6 +41,7 @@ impl SphinxSocksServer {
             listening_address: format!("{}:{}", ip, port).parse().unwrap(),
             service_provider,
             self_address,
+            shutdown,
         }
     }
 
@@ -52,62 +56,73 @@ impl SphinxSocksServer {
         info!("Serving Connections...");
 
         // controller for managing all active connections
-        let (mut active_streams_controller, controller_sender) = Controller::new();
+        let (mut active_streams_controller, controller_sender) =
+            Controller::new(self.shutdown.clone());
         tokio::spawn(async move {
             active_streams_controller.run().await;
         });
 
         // listener for mix messages
-        let mut mixnet_response_listener =
-            MixnetResponseListener::new(buffer_requester, controller_sender.clone());
-
+        let mut mixnet_response_listener = MixnetResponseListener::new(
+            buffer_requester,
+            controller_sender.clone(),
+            self.shutdown.clone(),
+        );
         tokio::spawn(async move {
             mixnet_response_listener.run().await;
         });
 
         loop {
-            if let Ok((stream, _remote)) = listener.accept().await {
-                // TODO Optimize this
-                let mut client = SocksClient::new(
-                    stream,
-                    self.authenticator.clone(),
-                    input_sender.clone(),
-                    self.service_provider,
-                    controller_sender.clone(),
-                    self.self_address,
-                );
+            tokio::select! {
+                Ok((stream, _remote)) = listener.accept() => {
+                    // TODO Optimize this
+                    let mut client = SocksClient::new(
+                        stream,
+                        self.authenticator.clone(),
+                        input_sender.clone(),
+                        self.service_provider,
+                        controller_sender.clone(),
+                        self.self_address,
+                        self.shutdown.clone(),
+                    );
 
-                tokio::spawn(async move {
-                    {
-                        match client.run().await {
-                            Ok(_) => {}
-                            Err(error) => {
-                                error!("Error! {}", error);
-                                let error_text = format!("{}", error);
+                    tokio::spawn(async move {
+                        {
+                            match client.run().await {
+                                Ok(_) => {}
+                                Err(error) => {
+                                    error!("Error! {}", error);
+                                    let error_text = format!("{}", error);
 
-                                let response: ResponseCode;
+                                    let response: ResponseCode;
 
-                                if error_text.contains("Host") {
-                                    response = ResponseCode::HostUnreachable;
-                                } else if error_text.contains("Network") {
-                                    response = ResponseCode::NetworkUnreachable;
-                                } else if error_text.contains("ttl") {
-                                    response = ResponseCode::TtlExpired
-                                } else {
-                                    response = ResponseCode::Failure
+                                    if error_text.contains("Host") {
+                                        response = ResponseCode::HostUnreachable;
+                                    } else if error_text.contains("Network") {
+                                        response = ResponseCode::NetworkUnreachable;
+                                    } else if error_text.contains("ttl") {
+                                        response = ResponseCode::TtlExpired
+                                    } else {
+                                        response = ResponseCode::Failure
+                                    }
+
+                                    if client.error(response).await.is_err() {
+                                        warn!("Failed to send error code");
+                                    };
+                                    if client.shutdown().await.is_err() {
+                                        warn!("Failed to shutdown TcpStream");
+                                    };
                                 }
-
-                                if client.error(response).await.is_err() {
-                                    warn!("Failed to send error code");
-                                };
-                                if client.shutdown().await.is_err() {
-                                    warn!("Failed to shutdown TcpStream");
-                                };
-                            }
-                        };
-                        // client gets dropped here
-                    }
-                });
+                            };
+                            // client gets dropped here
+                        }
+                    });
+                },
+                _ = self.shutdown.recv() => {
+                    log::trace!("SphinxSocksServer: Received shutdown");
+                    log::debug!("SphinxSocksServer: Exiting");
+                    return Ok(());
+                }
             }
         }
     }

clients/validator/tests/query/balance.test.ts

@@ -4,8 +4,8 @@ import expect from 'expect';
 describe('Query: balances', () => {
   it('can query for an account balance', async () => {
     const client = await ValidatorClient.connectForQuery(
-      'https://rpc.nyx.nodes.guru/', 'https://validator.nymtech.net/api/', 'n', 'n14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9sjyvg3g', 'n1nc5tatafv6eyq7llkr2gv50ff9e22mnf70qgjlv737ktmt4eswrq73f2nw', 'nym');
+      'https://rpc.nymtech.net/', 'https://validator.nymtech.net/api/', 'n', 'n14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9sjyvg3g', 'n1nc5tatafv6eyq7llkr2gv50ff9e22mnf70qgjlv737ktmt4eswrq73f2nw', 'nym');
     const balance = await client.getBalance('n10yyd98e2tuwu0f7ypz9dy3hhjw7v772q6287gy');
     expect(Number.parseFloat(balance.amount)).toBeGreaterThan(0);
   }).timeout(5000);
-})
+})

clients/webassembly/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "nym-client-wasm"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>", "Jedrzej Stuczynski <andrew@nymtech.net>"]
-version = "1.0.1"
+version = "1.0.0"
 edition = "2021"
 keywords = ["nym", "sphinx", "wasm", "webassembly", "privacy", "client"]
 license = "Apache-2.0"
@@ -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", default-features = false, features = ["wasm"] }
+gateway-client = { path = "../../common/client-libs/gateway-client", default-features = false, features = ["wasm", "coconut"] }
 validator-client = { path = "../../common/client-libs/validator-client", default-features = false }
 wasm-utils = { path = "../../common/wasm-utils" }
 

clients/webassembly/README.md

@@ -11,6 +11,7 @@ This client is part of the [Nym](https://nymtech.net/docs) project. It's written
 ## Security Status 
 
 From a security point of view, this module is not yet complete. Key missing features include, but are not limited to: cover traffic, sending packets with delay according to Poisson distribution. 
+
 They should be implemented soon. You can build your applications, but don't rely on it for strong anonymity yet if your application needs cover traffic.
 
 ## Using it
@@ -37,6 +38,6 @@ To be clear, this is not something that most JS developers need to worry about,
 
 If you're a Nym platform developer who's made changes to the Rust (or JS) files and wants to re-publish the package to NPM, here's how you do it: 
 
-1. `wasm-pack build --scope nymproject` builds the wasm binaries into the `pkg` directory (not in source control)
-2. bump version numbers as necessary for SemVer
-3. `wasm-pack publish --access=public` will publish your changed package to NPM
+1. bump version numbers as necessary for SemVer
+2. `wasm-pack build --scope nymproject` builds the wasm binaries into the `pkg` directory (not in source control)
+3. `cd pkg && npm publish --access=public` will publish your changed package to NPM

clients/webassembly/js-example/index.js

@@ -13,8 +13,8 @@
 // limitations under the License.
 
 import {
-   NymClient,
-   set_panic_hook
+    NymClient,
+    set_panic_hook
 } from "@nymproject/nym-client-wasm"
 
 // current limitation of rust-wasm for async stuff : (
@@ -25,7 +25,7 @@ async function main() {
     set_panic_hook();
 
     // validator server we will use to get topology from
-    const validator = "https://sandbox-validator.nymtech.net/api"; //"http://localhost:8081";
+    const validator = "https://validator.nymtech.net/api"; //"http://localhost:8081";
 
     client = new NymClient(validator);
 

clients/webassembly/js-example/package-lock.json

@@ -36,6 +36,64 @@
         "node": ">=10.0.0"
       }
     },
+    "node_modules/@jridgewell/gen-mapping": {
+      "version": "0.3.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.2.tgz",
+      "integrity": "sha512-mh65xKQAzI6iBcFzwv28KVWSmCkdRBWoOh+bYQGW3+6OZvbbN3TqMGo5hqYxQniRcH9F2VZIoJCm4pa3BPDK/A==",
+      "dev": true,
+      "dependencies": {
+        "@jridgewell/set-array": "^1.0.1",
+        "@jridgewell/sourcemap-codec": "^1.4.10",
+        "@jridgewell/trace-mapping": "^0.3.9"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/resolve-uri": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.0.tgz",
+      "integrity": "sha512-F2msla3tad+Mfht5cJq7LSXcdudKTWCVYUgw6pLFOOHSTtZlj6SWNYAp+AhuqLmWdBO2X5hPrLcu8cVP8fy28w==",
+      "dev": true,
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/set-array": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/set-array/-/set-array-1.1.2.tgz",
+      "integrity": "sha512-xnkseuNADM0gt2bs+BvhO0p78Mk762YnZdsuzFV018NoG1Sj1SCQvpSqa7XUaTam5vAGasABV9qXASMKnFMwMw==",
+      "dev": true,
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/source-map": {
+      "version": "0.3.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/source-map/-/source-map-0.3.2.tgz",
+      "integrity": "sha512-m7O9o2uR8k2ObDysZYzdfhb08VuEml5oWGiosa1VdaPZ/A6QyPkAJuwN0Q1lhULOf6B7MtQmHENS743hWtCrgw==",
+      "dev": true,
+      "dependencies": {
+        "@jridgewell/gen-mapping": "^0.3.0",
+        "@jridgewell/trace-mapping": "^0.3.9"
+      }
+    },
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.4.14",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.14.tgz",
+      "integrity": "sha512-XPSJHWmi394fuUuzDnGz1wiKqWfo1yXecHQMRf2l6hztTO+nPru658AyDngaBe7isIxEkRsPR3FZh+s7iVa4Uw==",
+      "dev": true
+    },
+    "node_modules/@jridgewell/trace-mapping": {
+      "version": "0.3.15",
+      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.15.tgz",
+      "integrity": "sha512-oWZNOULl+UbhsgB51uuZzglikfIKSUBO/M9W2OfEjn7cmqoAiCgmv9lyACTUacZwBz0ITnJ2NqjU8Tx0DHL88g==",
+      "dev": true,
+      "dependencies": {
+        "@jridgewell/resolve-uri": "^3.0.3",
+        "@jridgewell/sourcemap-codec": "^1.4.10"
+      }
+    },
     "node_modules/@nodelib/fs.scandir": {
       "version": "2.1.5",
       "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
@@ -3272,14 +3330,14 @@
       }
     },
     "node_modules/terser": {
-      "version": "5.12.1",
-      "resolved": "https://registry.npmjs.org/terser/-/terser-5.12.1.tgz",
-      "integrity": "sha512-NXbs+7nisos5E+yXwAD+y7zrcTkMqb0dEJxIGtSKPdCBzopf7ni4odPul2aechpV7EXNvOudYOX2bb5tln1jbQ==",
+      "version": "5.15.0",
+      "resolved": "https://registry.npmjs.org/terser/-/terser-5.15.0.tgz",
+      "integrity": "sha512-L1BJiXVmheAQQy+as0oF3Pwtlo4s3Wi1X2zNZ2NxOB4wx9bdS9Vk67XQENLFdLYGCK/Z2di53mTj/hBafR+dTA==",
       "dev": true,
       "dependencies": {
+        "@jridgewell/source-map": "^0.3.2",
         "acorn": "^8.5.0",
         "commander": "^2.20.0",
-        "source-map": "~0.7.2",
         "source-map-support": "~0.5.20"
       },
       "bin": {
@@ -3372,15 +3430,6 @@
         "url": "https://opencollective.com/webpack"
       }
     },
-    "node_modules/terser/node_modules/source-map": {
-      "version": "0.7.3",
-      "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.7.3.tgz",
-      "integrity": "sha512-CkCj6giN3S+n9qrYiBTX5gystlENnRW5jZeNLHpe6aue+SrHcG5VYwujhW9s4dY31mEGsxBDrHR6oI69fTXsaQ==",
-      "dev": true,
-      "engines": {
-        "node": ">= 8"
-      }
-    },
     "node_modules/thunky": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/thunky/-/thunky-1.1.0.tgz",
@@ -3828,6 +3877,55 @@
       "integrity": "sha512-dBVuXR082gk3jsFp7Rd/JI4kytwGHecnCoTtXFb7DB6CNHp4rg5k1bhg0nWdLGLnOV71lmDzGQaLMy8iPLY0pw==",
       "dev": true
     },
+    "@jridgewell/gen-mapping": {
+      "version": "0.3.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.2.tgz",
+      "integrity": "sha512-mh65xKQAzI6iBcFzwv28KVWSmCkdRBWoOh+bYQGW3+6OZvbbN3TqMGo5hqYxQniRcH9F2VZIoJCm4pa3BPDK/A==",
+      "dev": true,
+      "requires": {
+        "@jridgewell/set-array": "^1.0.1",
+        "@jridgewell/sourcemap-codec": "^1.4.10",
+        "@jridgewell/trace-mapping": "^0.3.9"
+      }
+    },
+    "@jridgewell/resolve-uri": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.0.tgz",
+      "integrity": "sha512-F2msla3tad+Mfht5cJq7LSXcdudKTWCVYUgw6pLFOOHSTtZlj6SWNYAp+AhuqLmWdBO2X5hPrLcu8cVP8fy28w==",
+      "dev": true
+    },
+    "@jridgewell/set-array": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/set-array/-/set-array-1.1.2.tgz",
+      "integrity": "sha512-xnkseuNADM0gt2bs+BvhO0p78Mk762YnZdsuzFV018NoG1Sj1SCQvpSqa7XUaTam5vAGasABV9qXASMKnFMwMw==",
+      "dev": true
+    },
+    "@jridgewell/source-map": {
+      "version": "0.3.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/source-map/-/source-map-0.3.2.tgz",
+      "integrity": "sha512-m7O9o2uR8k2ObDysZYzdfhb08VuEml5oWGiosa1VdaPZ/A6QyPkAJuwN0Q1lhULOf6B7MtQmHENS743hWtCrgw==",
+      "dev": true,
+      "requires": {
+        "@jridgewell/gen-mapping": "^0.3.0",
+        "@jridgewell/trace-mapping": "^0.3.9"
+      }
+    },
+    "@jridgewell/sourcemap-codec": {
+      "version": "1.4.14",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.14.tgz",
+      "integrity": "sha512-XPSJHWmi394fuUuzDnGz1wiKqWfo1yXecHQMRf2l6hztTO+nPru658AyDngaBe7isIxEkRsPR3FZh+s7iVa4Uw==",
+      "dev": true
+    },
+    "@jridgewell/trace-mapping": {
+      "version": "0.3.15",
+      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.15.tgz",
+      "integrity": "sha512-oWZNOULl+UbhsgB51uuZzglikfIKSUBO/M9W2OfEjn7cmqoAiCgmv9lyACTUacZwBz0ITnJ2NqjU8Tx0DHL88g==",
+      "dev": true,
+      "requires": {
+        "@jridgewell/resolve-uri": "^3.0.3",
+        "@jridgewell/sourcemap-codec": "^1.4.10"
+      }
+    },
     "@nodelib/fs.scandir": {
       "version": "2.1.5",
       "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
@@ -6334,23 +6432,15 @@
       "dev": true
     },
     "terser": {
-      "version": "5.12.1",
-      "resolved": "https://registry.npmjs.org/terser/-/terser-5.12.1.tgz",
-      "integrity": "sha512-NXbs+7nisos5E+yXwAD+y7zrcTkMqb0dEJxIGtSKPdCBzopf7ni4odPul2aechpV7EXNvOudYOX2bb5tln1jbQ==",
+      "version": "5.15.0",
+      "resolved": "https://registry.npmjs.org/terser/-/terser-5.15.0.tgz",
+      "integrity": "sha512-L1BJiXVmheAQQy+as0oF3Pwtlo4s3Wi1X2zNZ2NxOB4wx9bdS9Vk67XQENLFdLYGCK/Z2di53mTj/hBafR+dTA==",
       "dev": true,
       "requires": {
+        "@jridgewell/source-map": "^0.3.2",
         "acorn": "^8.5.0",
         "commander": "^2.20.0",
-        "source-map": "~0.7.2",
         "source-map-support": "~0.5.20"
-      },
-      "dependencies": {
-        "source-map": {
-          "version": "0.7.3",
-          "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.7.3.tgz",
-          "integrity": "sha512-CkCj6giN3S+n9qrYiBTX5gystlENnRW5jZeNLHpe6aue+SrHcG5VYwujhW9s4dY31mEGsxBDrHR6oI69fTXsaQ==",
-          "dev": true
-        }
       }
     },
     "terser-webpack-plugin": {

clients/webassembly/js-example/webpack.config.js

@@ -9,7 +9,7 @@ module.exports = {
   },
   mode: "development",
   plugins: [
-    new CopyWebpackPlugin({patterns: ['index.html']})
+    new CopyWebpackPlugin({ patterns: ['index.html'] })
   ],
-  experiments: { asyncWebAssembly: true }
+  experiments: { syncWebAssembly: true }
 };

clients/webassembly/src/client/mod.rs

@@ -132,9 +132,7 @@ impl NymClient {
             bandwidth_controller,
         );
 
-        if disabled_credentials_mode {
-            gateway_client.set_disabled_credentials_mode(true)
-        }
+        gateway_client.set_disabled_credentials_mode(disabled_credentials_mode);
 
         gateway_client
             .authenticate_and_start()
@@ -199,7 +197,6 @@ impl NymClient {
             // don't bother with acks etc. for time being
             let prepared_fragment = message_preparer
                 .prepare_chunk_for_sending(message_chunk, topology, &self.ack_key, &recipient)
-                .await
                 .unwrap();
 
             console_warn!("packet is going to have round trip time of {:?}, but we're not going to do anything for acks anyway ", prepared_fragment.total_delay);

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

@@ -10,23 +10,22 @@ edition = "2021"
 # TODO: (for this and other crates), similarly to 'tokio', import only required "futures" modules rather than
 # the entire crate
 futures = "0.3"
-json = "0.12.4"
 log = "0.4"
 thiserror = "1.0"
 url = "2.2"
 rand = { version = "0.7.3", features = ["wasm-bindgen"] }
-secp256k1 = "0.20.3"
-web3 = { version = "0.17.0", default-features = false }
+secp256k1 = { version = "0.20.3", optional = true }
+web3 = { version = "0.17.0", default-features = false, optional = true }
 async-trait = { version = "0.1.51" }
 
 # internal
+coconut-interface = { path = "../../coconut-interface", optional = true }
 credentials = { path = "../../credentials" }
 crypto = { path = "../../crypto" }
 gateway-requests = { path = "../../../gateway/gateway-requests" }
+network-defaults = { path = "../../network-defaults" }
 nymsphinx = { path = "../../nymsphinx" }
 pemstore = { path = "../../pemstore" }
-coconut-interface = { path = "../../coconut-interface", optional = true }
-network-defaults = { path = "../../network-defaults" }
 validator-client = { path = "../validator-client", optional = true }
 
 [dependencies.tungstenite]
@@ -38,12 +37,19 @@ default-features = false
 version = "1.19.1"
 features = ["macros", "rt", "net", "sync", "time"]
 
+[target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio-stream]
+version = "0.1.9"
+features = ["net", "sync", "time"]
+
 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio-tungstenite]
 version = "0.14"
 
 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.credential-storage]
 path = "../../credential-storage"
 
+[target."cfg(not(target_arch = \"wasm32\"))".dependencies.task]
+path = "../../task"
+
 # wasm-only dependencies
 [target."cfg(target_arch = \"wasm32\")".dependencies.wasm-bindgen]
 version = "0.2"
@@ -73,5 +79,5 @@ features = ["js"]
 
 [features]
 coconut = ["gateway-requests/coconut", "coconut-interface", "validator-client", "credentials/coconut"]
-wasm = ["web3/wasm", "web3/http", "web3/signing"]
-default = ["web3/default"]
+wasm = []
+default = ["web3/default", "secp256k1"]

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

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::error::GatewayClientError;
-use std::str::FromStr;
 
 #[cfg(target_arch = "wasm32")]
 use crate::wasm_storage::Storage;
@@ -15,6 +14,8 @@ use crate::wasm_storage::StorageError;
 #[cfg(all(not(target_arch = "wasm32"), feature = "coconut"))]
 use credential_storage::error::StorageError;
 
+#[cfg(feature = "coconut")]
+use std::str::FromStr;
 #[cfg(feature = "coconut")]
 use {
     coconut_interface::Base58,
@@ -23,65 +24,12 @@ use {
     },
 };
 
-#[cfg(not(feature = "coconut"))]
-use {
-    credentials::token::bandwidth::TokenCredential,
-    crypto::asymmetric::identity,
-    network_defaults::{
-        eth_contract::ETH_ERC20_JSON_ABI, eth_contract::ETH_JSON_ABI, BANDWIDTH_VALUE,
-        ETH_BURN_FUNCTION_NAME, ETH_CONTRACT_ADDRESS, ETH_ERC20_APPROVE_FUNCTION_NAME,
-        ETH_ERC20_CONTRACT_ADDRESS, ETH_MIN_BLOCK_DEPTH, TOKENS_TO_BURN, UTOKENS_TO_BURN,
-    },
-    pemstore::traits::PemStorableKeyPair,
-    rand::rngs::OsRng,
-    secp256k1::SecretKey,
-    web3::{
-        contract::{Contract, Options},
-        ethabi::Token,
-        signing::{Key, SecretKeyRef},
-        transports::Http,
-        types::{Address, U256, U64},
-        Web3,
-    },
-};
-
-#[cfg(not(feature = "coconut"))]
-pub fn eth_contract(web3: Web3<Http>) -> Contract<Http> {
-    Contract::from_json(
-        web3.eth(),
-        Address::from(ETH_CONTRACT_ADDRESS),
-        json::parse(ETH_JSON_ABI)
-            .expect("Invalid json abi")
-            .dump()
-            .as_bytes(),
-    )
-    .expect("Invalid json abi")
-}
-
-#[cfg(not(feature = "coconut"))]
-pub fn eth_erc20_contract(web3: Web3<Http>) -> Contract<Http> {
-    Contract::from_json(
-        web3.eth(),
-        Address::from(ETH_ERC20_CONTRACT_ADDRESS),
-        json::parse(ETH_ERC20_JSON_ABI)
-            .expect("Invalid json abi")
-            .dump()
-            .as_bytes(),
-    )
-    .expect("Invalid json abi")
-}
-
 #[derive(Clone)]
 pub struct BandwidthController<St: Storage> {
+    #[allow(dead_code)]
     storage: St,
     #[cfg(feature = "coconut")]
     validator_endpoints: Vec<url::Url>,
-    #[cfg(not(feature = "coconut"))]
-    contract: Contract<Http>,
-    #[cfg(not(feature = "coconut"))]
-    erc20_contract: Contract<Http>,
-    #[cfg(not(feature = "coconut"))]
-    eth_private_key: SecretKey,
 }
 
 impl<St> BandwidthController<St>
@@ -97,60 +45,8 @@ where
     }
 
     #[cfg(not(feature = "coconut"))]
-    pub fn new(
-        storage: St,
-        eth_endpoint: String,
-        eth_private_key: String,
-    ) -> Result<Self, GatewayClientError> {
-        // Fail early, on invalid url
-        let transport =
-            Http::new(&eth_endpoint).map_err(|_| GatewayClientError::InvalidURL(eth_endpoint))?;
-        let web3 = web3::Web3::new(transport);
-        // Fail early, on invalid abi
-        let contract = eth_contract(web3.clone());
-        let erc20_contract = eth_erc20_contract(web3);
-        let eth_private_key = secp256k1::SecretKey::from_str(&eth_private_key)
-            .map_err(|_| GatewayClientError::InvalidEthereumPrivateKey)?;
-
-        Ok(BandwidthController {
-            storage,
-            contract,
-            erc20_contract,
-            eth_private_key,
-        })
-    }
-
-    #[cfg(not(feature = "coconut"))]
-    async fn backup_keypair(&self, keypair: &identity::KeyPair) -> Result<(), GatewayClientError> {
-        self.storage
-            .insert_erc20_credential(
-                keypair.public_key().to_base58_string(),
-                keypair.private_key().to_base58_string(),
-            )
-            .await?;
-
-        Ok(())
-    }
-
-    #[cfg(not(feature = "coconut"))]
-    async fn restore_keypair(&self) -> Result<identity::KeyPair, GatewayClientError> {
-        let data = self.storage.get_next_erc20_credential().await?;
-        let public_key = identity::PublicKey::from_base58_string(data.public_key).unwrap();
-        let private_key = identity::PrivateKey::from_base58_string(data.private_key).unwrap();
-
-        Ok(identity::KeyPair::from_keys(private_key, public_key))
-    }
-
-    #[cfg(not(feature = "coconut"))]
-    async fn mark_keypair_as_spent(
-        &self,
-        keypair: &identity::KeyPair,
-    ) -> Result<(), GatewayClientError> {
-        self.storage
-            .consume_erc20_credential(keypair.public_key().to_base58_string())
-            .await?;
-
-        Ok(())
+    pub fn new(storage: St) -> Result<Self, GatewayClientError> {
+        Ok(BandwidthController { storage })
     }
 
     #[cfg(feature = "coconut")]
@@ -179,206 +75,4 @@ where
             &verification_key,
         )?)
     }
-
-    #[cfg(not(feature = "coconut"))]
-    pub async fn prepare_token_credential(
-        &self,
-        gateway_identity: identity::PublicKey,
-        gateway_owner: String,
-    ) -> Result<TokenCredential, GatewayClientError> {
-        let kp = match self.restore_keypair().await {
-            Ok(kp) => kp,
-            Err(_) => {
-                let mut rng = OsRng;
-                let kp = identity::KeyPair::new(&mut rng);
-                self.backup_keypair(&kp).await?;
-                kp
-            }
-        };
-
-        let verification_key = *kp.public_key();
-        let signed_verification_key = kp.private_key().sign(&verification_key.to_bytes());
-        self.buy_token_credential(verification_key, signed_verification_key, gateway_owner)
-            .await?;
-
-        self.mark_keypair_as_spent(&kp).await?;
-
-        let message: Vec<u8> = verification_key
-            .to_bytes()
-            .iter()
-            .chain(gateway_identity.to_bytes().iter())
-            .copied()
-            .collect();
-        let signature = kp.private_key().sign(&message);
-
-        Ok(TokenCredential::new(
-            verification_key,
-            gateway_identity,
-            BANDWIDTH_VALUE,
-            signature,
-        ))
-    }
-
-    #[cfg(not(feature = "coconut"))]
-    pub async fn buy_token_credential(
-        &self,
-        verification_key: identity::PublicKey,
-        signed_verification_key: identity::Signature,
-        gateway_owner: String,
-    ) -> Result<(), GatewayClientError> {
-        let confirmations = if cfg!(debug_assertions) {
-            1
-        } else {
-            ETH_MIN_BLOCK_DEPTH
-        };
-        // 15 seconds per confirmation block + 10 seconds of network overhead + 20 seconds of wait for kill
-        log::info!(
-            "Waiting for Ethereum transaction. This should take about {} seconds",
-            (confirmations + 1) * 15 + 30
-        );
-        let mut options = Options::default();
-        let estimation = self
-            .erc20_contract
-            .estimate_gas(
-                ETH_ERC20_APPROVE_FUNCTION_NAME,
-                (
-                    Token::Address(Address::from(ETH_CONTRACT_ADDRESS)),
-                    Token::Uint(U256::from(UTOKENS_TO_BURN)),
-                ),
-                SecretKeyRef::from(&self.eth_private_key).address(),
-                options.clone(),
-            )
-            .await?;
-        options.gas = Some(estimation);
-        log::info!("Calling ERC20 approve in 10 seconds with an estimated gas of {}. Kill the process if you want to abort", estimation);
-        #[cfg(not(target_arch = "wasm32"))]
-        tokio::time::sleep(tokio::time::Duration::from_secs(10)).await;
-        #[cfg(target_arch = "wasm32")]
-        if let Err(err) = fluvio_wasm_timer::Delay::new(std::time::Duration::from_secs(10)).await {
-            log::error!(
-                "the timer has gone away while waiting for possible kill! - {}",
-                err
-            );
-        }
-        let recipt = self
-            .erc20_contract
-            .signed_call_with_confirmations(
-                ETH_ERC20_APPROVE_FUNCTION_NAME,
-                (
-                    Token::Address(Address::from(ETH_CONTRACT_ADDRESS)),
-                    Token::Uint(U256::from(UTOKENS_TO_BURN)),
-                ),
-                options,
-                1, // One confirmation is enough, as we'll be consuming the approved token next anyway
-                &self.eth_private_key,
-            )
-            .await?;
-        if Some(U64::from(0u64)) == recipt.status {
-            return Err(GatewayClientError::BurnTokenError(
-                web3::Error::InvalidResponse(format!(
-                    "Approve transaction status is 0 (failure): {:?}",
-                    recipt.logs,
-                )),
-            ));
-        } else {
-            log::info!(
-                "Approved {} tokens for bandwidth use on Ethereum",
-                TOKENS_TO_BURN
-            );
-        }
-
-        let mut options = Options::default();
-        let estimation = self
-            .contract
-            .estimate_gas(
-                ETH_BURN_FUNCTION_NAME,
-                (
-                    Token::Uint(U256::from(UTOKENS_TO_BURN)),
-                    Token::Uint(U256::from(&verification_key.to_bytes())),
-                    Token::Bytes(signed_verification_key.to_bytes().to_vec()),
-                    Token::String(gateway_owner.clone()),
-                ),
-                SecretKeyRef::from(&self.eth_private_key).address(),
-                options.clone(),
-            )
-            .await?;
-        options.gas = Some(estimation);
-        log::info!("Generating bandwidth on ETH contract in 10 seconds with an estimated gas of {}. \
-         Kill the process if you want to abort. Keep in mind that if you abort now, you'll still have \
-         some tokens approved for bandwidth spending from the previous action. \
-         If you don't want that, you'll need to manually decreaseAllowance to revert the approval.", estimation);
-        #[cfg(not(target_arch = "wasm32"))]
-        tokio::time::sleep(tokio::time::Duration::from_secs(10)).await;
-        #[cfg(target_arch = "wasm32")]
-        if let Err(err) = fluvio_wasm_timer::Delay::new(std::time::Duration::from_secs(10)).await {
-            log::error!(
-                "the timer has gone away while waiting for possible kill! - {}",
-                err
-            );
-        }
-        let recipt = self
-            .contract
-            .signed_call_with_confirmations(
-                ETH_BURN_FUNCTION_NAME,
-                (
-                    Token::Uint(U256::from(UTOKENS_TO_BURN)),
-                    Token::Uint(U256::from(&verification_key.to_bytes())),
-                    Token::Bytes(signed_verification_key.to_bytes().to_vec()),
-                    Token::String(gateway_owner),
-                ),
-                options,
-                confirmations,
-                &self.eth_private_key,
-            )
-            .await?;
-        if Some(U64::from(0u64)) == recipt.status {
-            Err(GatewayClientError::BurnTokenError(
-                web3::Error::InvalidResponse(format!(
-                    "Transaction status is 0 (failure): {:?}",
-                    recipt.logs,
-                )),
-            ))
-        } else {
-            log::info!(
-                "Bought bandwidth on Ethereum: {} MB",
-                BANDWIDTH_VALUE / 1024 / 1024
-            );
-            Ok(())
-        }
-    }
-}
-
-#[cfg(not(feature = "coconut"))]
-#[cfg(test)]
-mod tests {
-    use network_defaults::ETH_EVENT_NAME;
-
-    use super::*;
-
-    #[test]
-    fn parse_contract() {
-        let transport =
-            Http::new("https://rinkeby.infura.io/v3/00000000000000000000000000000000").unwrap();
-        let web3 = web3::Web3::new(transport);
-        // test no panic occurs
-        eth_contract(web3);
-    }
-
-    #[test]
-    fn parse_erc20_contract() {
-        let transport =
-            Http::new("https://rinkeby.infura.io/v3/00000000000000000000000000000000").unwrap();
-        let web3 = web3::Web3::new(transport);
-        // test no panic occurs
-        eth_erc20_contract(web3);
-    }
-
-    #[test]
-    fn check_event_name_constant_against_abi() {
-        let transport =
-            Http::new("https://rinkeby.infura.io/v3/00000000000000000000000000000000").unwrap();
-        let web3 = web3::Web3::new(transport);
-        let contract = eth_contract(web3);
-        assert!(contract.abi().event(ETH_EVENT_NAME).is_ok());
-    }
 }

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

@@ -15,8 +15,6 @@ use crate::wasm_storage::PersistentStorage;
 use coconut_interface::Credential;
 #[cfg(not(target_arch = "wasm32"))]
 use credential_storage::PersistentStorage;
-#[cfg(not(feature = "coconut"))]
-use credentials::token::bandwidth::TokenCredential;
 use crypto::asymmetric::identity;
 use futures::{FutureExt, SinkExt, StreamExt};
 use gateway_requests::authentication::encrypted_address::EncryptedAddressBytes;
@@ -30,6 +28,8 @@ use rand::rngs::OsRng;
 use std::convert::TryFrom;
 use std::sync::Arc;
 use std::time::Duration;
+#[cfg(not(target_arch = "wasm32"))]
+use task::ShutdownListener;
 use tungstenite::protocol::Message;
 
 #[cfg(not(target_arch = "wasm32"))]
@@ -65,6 +65,10 @@ pub struct GatewayClient {
     reconnection_attempts: usize,
     /// Delay between each subsequent reconnection attempt.
     reconnection_backoff: Duration,
+
+    #[cfg(not(target_arch = "wasm32"))]
+    /// Listen to shutdown messages.
+    shutdown: Option<ShutdownListener>,
 }
 
 impl GatewayClient {
@@ -80,6 +84,7 @@ impl GatewayClient {
         ack_sender: AcknowledgementSender,
         response_timeout_duration: Duration,
         bandwidth_controller: Option<BandwidthController<PersistentStorage>>,
+        #[cfg(not(target_arch = "wasm32"))] shutdown: Option<ShutdownListener>,
     ) -> Self {
         GatewayClient {
             authenticated: false,
@@ -91,12 +96,19 @@ impl GatewayClient {
             local_identity,
             shared_key,
             connection: SocketState::NotConnected,
-            packet_router: PacketRouter::new(ack_sender, mixnet_message_sender),
+            packet_router: PacketRouter::new(
+                ack_sender,
+                mixnet_message_sender,
+                #[cfg(not(target_arch = "wasm32"))]
+                shutdown.clone(),
+            ),
             response_timeout_duration,
             bandwidth_controller,
             should_reconnect_on_failure: true,
             reconnection_attempts: DEFAULT_RECONNECTION_ATTEMPTS,
             reconnection_backoff: DEFAULT_RECONNECTION_BACKOFF,
+            #[cfg(not(target_arch = "wasm32"))]
+            shutdown,
         }
     }
 
@@ -123,6 +135,7 @@ impl GatewayClient {
         gateway_owner: String,
         local_identity: Arc<identity::KeyPair>,
         response_timeout_duration: Duration,
+        #[cfg(not(target_arch = "wasm32"))] shutdown: Option<ShutdownListener>,
     ) -> Self {
         use futures::channel::mpsc;
 
@@ -130,7 +143,12 @@ impl GatewayClient {
         // perfectly fine here, because it's not meant to be used
         let (ack_tx, _) = mpsc::unbounded();
         let (mix_tx, _) = mpsc::unbounded();
-        let packet_router = PacketRouter::new(ack_tx, mix_tx);
+        let packet_router = PacketRouter::new(
+            ack_tx,
+            mix_tx,
+            #[cfg(not(target_arch = "wasm32"))]
+            shutdown.clone(),
+        );
 
         GatewayClient {
             authenticated: false,
@@ -148,6 +166,8 @@ impl GatewayClient {
             should_reconnect_on_failure: false,
             reconnection_attempts: DEFAULT_RECONNECTION_ATTEMPTS,
             reconnection_backoff: DEFAULT_RECONNECTION_BACKOFF,
+            #[cfg(not(target_arch = "wasm32"))]
+            shutdown,
         }
     }
 
@@ -279,8 +299,33 @@ impl GatewayClient {
         let mut fused_timeout = timeout.fuse();
         let mut fused_stream = conn.fuse();
 
+        // Bit of an ugly workaround for selecting on an `Option` without having access to
+        // `tokio::select`
+        #[cfg(not(target_arch = "wasm32"))]
+        let shutdown = {
+            let m_shutdown = self.shutdown.clone();
+            async {
+                if let Some(mut s) = m_shutdown {
+                    s.recv().await
+                } else {
+                    std::future::pending::<()>().await
+                }
+            }
+            .fuse()
+        };
+        #[cfg(not(target_arch = "wasm32"))]
+        tokio::pin!(shutdown);
+
+        #[cfg(target_arch = "wasm32")]
+        let mut shutdown = std::future::pending::<()>().fuse();
+
         loop {
             futures::select! {
+                _ = shutdown => {
+                    log::trace!("GatewayClient control response: Received shutdown");
+                    log::debug!("GatewayClient control response: Exiting");
+                    break Err(GatewayClientError::ConnectionClosedGatewayShutdown);
+                }
                 _ = &mut fused_timeout => {
                     break Err(GatewayClientError::Timeout);
                 }
@@ -291,14 +336,16 @@ impl GatewayClient {
                     };
                     match ws_msg {
                         Message::Binary(bin_msg) => {
-                            self.packet_router.route_received(vec![bin_msg]);
+                            if let Err(err) = self.packet_router.route_received(vec![bin_msg]) {
+                                log::warn!("Route received failed: {:?}", err);
+                            }
                         }
                         Message::Text(txt_msg) => {
                             break ServerResponse::try_from(txt_msg).map_err(|_| GatewayClientError::MalformedResponse);
                         }
                         _ => (),
                     }
-               }
+                }
             }
         }
     }
@@ -505,30 +552,6 @@ impl GatewayClient {
         Ok(())
     }
 
-    #[cfg(not(feature = "coconut"))]
-    async fn claim_token_bandwidth(
-        &mut self,
-        credential: TokenCredential,
-    ) -> Result<(), GatewayClientError> {
-        let mut rng = OsRng;
-
-        let iv = IV::new_random(&mut rng);
-
-        let msg = ClientControlRequest::new_enc_token_bandwidth_credential(
-            &credential,
-            self.shared_key.as_ref().unwrap(),
-            iv,
-        )
-        .into();
-        self.bandwidth_remaining = match self.send_websocket_message(msg).await? {
-            ServerResponse::Bandwidth { available_total } => Ok(available_total),
-            ServerResponse::Error { message } => Err(GatewayClientError::GatewayError(message)),
-            _ => Err(GatewayClientError::UnexpectedResponse),
-        }?;
-
-        Ok(())
-    }
-
     async fn try_claim_testnet_bandwidth(&mut self) -> Result<(), GatewayClientError> {
         let msg = ClientControlRequest::ClaimFreeTestnetBandwidth.into();
         self.bandwidth_remaining = match self.send_websocket_message(msg).await? {
@@ -567,17 +590,10 @@ impl GatewayClient {
             .prepare_coconut_credential()
             .await?;
         #[cfg(not(feature = "coconut"))]
-        let credential = self
-            .bandwidth_controller
-            .as_ref()
-            .unwrap()
-            .prepare_token_credential(self.gateway_identity, _gateway_owner)
-            .await?;
+        return self.try_claim_testnet_bandwidth().await;
 
         #[cfg(feature = "coconut")]
         return self.claim_coconut_bandwidth(credential).await;
-        #[cfg(not(feature = "coconut"))]
-        return self.claim_token_bandwidth(credential).await;
     }
 
     fn estimate_required_bandwidth(&self, packets: &[MixPacket]) -> i64 {
@@ -723,6 +739,8 @@ impl GatewayClient {
                                 .as_ref()
                                 .expect("no shared key present even though we're authenticated!"),
                         ),
+                        #[cfg(not(target_arch = "wasm32"))]
+                        self.shutdown.clone(),
                     )
                 }
                 _ => unreachable!(),

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

@@ -64,6 +64,9 @@ pub enum GatewayClientError {
     #[error("Connection was abruptly closed")]
     ConnectionAbruptlyClosed,
 
+    #[error("Connection was abruptly closed as gateway was stopped")]
+    ConnectionClosedGatewayShutdown,
+
     #[error("Received response was malformed")]
     MalformedResponse,
 
@@ -93,6 +96,9 @@ pub enum GatewayClientError {
 
     #[error("Timed out")]
     Timeout,
+
+    #[error("Failed to send mixnet message")]
+    MixnetMsgSenderFailedToSend,
 }
 
 impl GatewayClientError {

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

@@ -8,6 +8,10 @@ use futures::channel::mpsc;
 use log::*;
 use nymsphinx::addressing::nodes::MAX_NODE_ADDRESS_UNPADDED_LEN;
 use nymsphinx::params::packet_sizes::PacketSize;
+#[cfg(not(target_arch = "wasm32"))]
+use task::ShutdownListener;
+
+use crate::error::GatewayClientError;
 
 pub type MixnetMessageSender = mpsc::UnboundedSender<Vec<Vec<u8>>>;
 pub type MixnetMessageReceiver = mpsc::UnboundedReceiver<Vec<Vec<u8>>>;
@@ -19,20 +23,28 @@ pub type AcknowledgementReceiver = mpsc::UnboundedReceiver<Vec<Vec<u8>>>;
 pub struct PacketRouter {
     ack_sender: AcknowledgementSender,
     mixnet_message_sender: MixnetMessageSender,
+    #[cfg(not(target_arch = "wasm32"))]
+    shutdown: Option<ShutdownListener>,
 }
 
 impl PacketRouter {
     pub fn new(
         ack_sender: AcknowledgementSender,
         mixnet_message_sender: MixnetMessageSender,
+        #[cfg(not(target_arch = "wasm32"))] shutdown: Option<ShutdownListener>,
     ) -> Self {
         PacketRouter {
             ack_sender,
             mixnet_message_sender,
+            #[cfg(not(target_arch = "wasm32"))]
+            shutdown,
         }
     }
 
-    pub fn route_received(&self, unwrapped_packets: Vec<Vec<u8>>) {
+    pub fn route_received(
+        &mut self,
+        unwrapped_packets: Vec<Vec<u8>>,
+    ) -> Result<(), GatewayClientError> {
         let mut received_messages = Vec::new();
         let mut received_acks = Vec::new();
 
@@ -51,7 +63,7 @@ impl PacketRouter {
             } else if received_packet.len()
                 == PacketSize::ExtendedPacket.plaintext_size() - ack_overhead
             {
-                warn!("received extended packet? Did not expect this...");
+                //warn!("received extended packet? Did not expect this...");
                 received_messages.push(received_packet);
             } else {
                 // this can happen if other clients are not padding their messages
@@ -60,24 +72,29 @@ impl PacketRouter {
             }
         }
 
-        // due to how we are currently using it, those unwraps can't fail, but if we ever
-        // wanted to make `gateway-client` into some more generic library, we would probably need
-        // to catch that error or something.
         if !received_messages.is_empty() {
             trace!("routing 'real'");
-            self.mixnet_message_sender
-                .unbounded_send(received_messages)
-                .unwrap();
+            if let Err(err) = self.mixnet_message_sender.unbounded_send(received_messages) {
+                #[cfg(not(target_arch = "wasm32"))]
+                if let Some(shutdown) = &mut self.shutdown {
+                    if shutdown.is_shutdown_poll() {
+                        // This should ideally not happen, but it's ok
+                        log::warn!("Failed to send mixnet message due to receiver task shutdown");
+                        return Err(GatewayClientError::MixnetMsgSenderFailedToSend);
+                    }
+                }
+                // This should never happen during ordinary operation the way it's currently used.
+                // Abort to be on the safe side
+                panic!("Failed to send mixnet message: {:?}", err);
+            }
         }
 
         if !received_acks.is_empty() {
             trace!("routing acks");
-            match self.ack_sender.unbounded_send(received_acks) {
-                Ok(_) => {}
-                Err(e) => {
-                    error!("failed to send ack: {:?}", e);
-                }
+            if let Err(e) = self.ack_sender.unbounded_send(received_acks) {
+                error!("failed to send ack: {:?}", e);
             };
         }
+        Ok(())
     }
 }

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

@@ -11,6 +11,8 @@ use gateway_requests::registration::handshake::SharedKeys;
 use gateway_requests::BinaryResponse;
 use log::*;
 use std::sync::Arc;
+#[cfg(not(target_arch = "wasm32"))]
+use task::ShutdownListener;
 use tungstenite::Message;
 
 #[cfg(not(target_arch = "wasm32"))]
@@ -44,9 +46,9 @@ pub(crate) struct PartiallyDelegated {
 impl PartiallyDelegated {
     fn route_socket_message(
         ws_msg: Message,
-        packet_router: &PacketRouter,
+        packet_router: &mut PacketRouter,
         shared_key: &SharedKeys,
-    ) {
+    ) -> Result<(), GatewayClientError> {
         match ws_msg {
             Message::Binary(bin_msg) => {
                 // this function decrypts the request and checks the MAC
@@ -60,7 +62,7 @@ impl PartiallyDelegated {
                                 "message received from the gateway was malformed! - {:?}",
                                 err
                             );
-                            return;
+                            return Ok(());
                         }
                     };
 
@@ -74,18 +76,22 @@ impl PartiallyDelegated {
             // This would also require NOT discarding any text responses here.
 
             // TODO: those can return the "send confirmations" - perhaps it should be somehow worked around?
-            Message::Text(text) => trace!(
-                "received a text message - probably a response to some previous query! - {}",
-                text
-            ),
-            _ => (),
-        };
+            Message::Text(text) => {
+                trace!(
+                    "received a text message - probably a response to some previous query! - {}",
+                    text
+                );
+                Ok(())
+            }
+            _ => Ok(()),
+        }
     }
 
     pub(crate) fn split_and_listen_for_mixnet_messages(
         conn: WsConn,
         packet_router: PacketRouter,
         shared_key: Arc<SharedKeys>,
+        #[cfg(not(target_arch = "wasm32"))] shutdown: Option<ShutdownListener>,
     ) -> Self {
         // when called for, it NEEDS TO yield back the stream so that we could merge it and
         // read control request responses.
@@ -97,10 +103,36 @@ impl PartiallyDelegated {
         let mixnet_receiver_future = async move {
             let mut fused_receiver = notify_receiver.fuse();
             let mut fused_stream = (&mut stream).fuse();
+            let mut packet_router = packet_router;
+
+            // Bit of an ugly workaround for selecting on an `Option` without having access to
+            // `tokio::select`
+            #[cfg(not(target_arch = "wasm32"))]
+            let shutdown = {
+                let m_shutdown = shutdown.clone();
+                async {
+                    if let Some(mut s) = m_shutdown {
+                        s.recv().await
+                    } else {
+                        std::future::pending::<()>().await
+                    }
+                }
+                .fuse()
+            };
+            #[cfg(not(target_arch = "wasm32"))]
+            tokio::pin!(shutdown);
+
+            #[cfg(target_arch = "wasm32")]
+            let mut shutdown = std::future::pending::<()>().fuse();
 
             let ret_err = loop {
                 futures::select! {
-                    _ = fused_receiver => {
+                    _ = shutdown => {
+                        log::trace!("GatewayClient listener: Received shutdown");
+                        log::debug!("GatewayClient listener: Exiting");
+                        return;
+                    }
+                    _ = &mut fused_receiver => {
                         break Ok(());
                     }
                     msg = fused_stream.next() => {
@@ -108,7 +140,9 @@ impl PartiallyDelegated {
                             Err(err) => break Err(err),
                             Ok(msg) => msg
                         };
-                        Self::route_socket_message(ws_msg, &packet_router, shared_key.as_ref());
+                        if let Err(err) = Self::route_socket_message(ws_msg, &mut packet_router, shared_key.as_ref()) {
+                            log::warn!("Route socket message failed: {:?}", err);
+                        }
                     }
                 };
             };
@@ -162,12 +196,10 @@ impl PartiallyDelegated {
             .expect("stream sender was somehow dropped without sending anything!");
 
         if let Some(res) = receive_res {
-            if let Err(err) = res {
-                // the receiver got an error. most likely a network one.
-                return Err(err);
-            } else {
-                panic!("This should have NEVER happened - returned a stream before receiving notification")
-            }
+            let _res = res?;
+            panic!(
+                "This should have NEVER happened - returned a stream before receiving notification"
+            )
         }
 
         // this call failing is incredibly unlikely, but not impossible.

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

@@ -26,13 +26,6 @@ pub struct CoconutCredential {
     pub signature: String,
 }
 
-pub struct ERC20Credential {
-    pub id: i64,
-    pub public_key: String,
-    pub private_key: String,
-    pub consumed: bool,
-}
-
 #[async_trait]
 pub trait Storage: Send + Sync {
     async fn insert_coconut_credential(
@@ -47,16 +40,6 @@ pub trait Storage: Send + Sync {
     async fn get_next_coconut_credential(&self) -> Result<CoconutCredential, StorageError>;
 
     async fn remove_coconut_credential(&self, id: i64) -> Result<(), StorageError>;
-
-    async fn insert_erc20_credential(
-        &self,
-        public_key: String,
-        private_key: String,
-    ) -> Result<(), StorageError>;
-
-    async fn get_next_erc20_credential(&self) -> Result<ERC20Credential, StorageError>;
-
-    async fn consume_erc20_credential(&self, public_key: String) -> Result<(), StorageError>;
 }
 
 #[async_trait]
@@ -79,20 +62,4 @@ impl Storage for PersistentStorage {
     async fn remove_coconut_credential(&self, _id: i64) -> Result<(), StorageError> {
         Err(StorageError::WasmNotSupported)
     }
-
-    async fn insert_erc20_credential(
-        &self,
-        _public_key: String,
-        _private_key: String,
-    ) -> Result<(), StorageError> {
-        Err(StorageError::WasmNotSupported)
-    }
-
-    async fn get_next_erc20_credential(&self) -> Result<ERC20Credential, StorageError> {
-        Err(StorageError::WasmNotSupported)
-    }
-
-    async fn consume_erc20_credential(&self, _public_key: String) -> Result<(), StorageError> {
-        Err(StorageError::WasmNotSupported)
-    }
 }

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

@@ -489,7 +489,7 @@ impl TryFrom<ProtoContractCodeHistoryEntry> for ContractCodeHistoryEntry {
     }
 }
 
-#[derive(Copy, Clone, Debug, Default, Eq, PartialEq)]
+#[derive(Copy, Clone, Debug, Default, Eq, PartialEq, Serialize)]
 pub struct GasInfo {
     /// GasWanted is the maximum units of work we allow this tx to perform.
     pub gas_wanted: Gas,
@@ -645,7 +645,7 @@ impl InstantiateOptions {
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Serialize)]
 pub struct InstantiateResult {
     /// The address of the newly instantiated contract
     pub contract_address: AccountId,
@@ -658,7 +658,7 @@ pub struct InstantiateResult {
     pub gas_info: GasInfo,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Serialize)]
 pub struct ChangeAdminResult {
     pub logs: Vec<Log>,
 
@@ -668,7 +668,7 @@ pub struct ChangeAdminResult {
     pub gas_info: GasInfo,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Serialize)]
 pub struct MigrateResult {
     pub logs: Vec<Log>,
 
@@ -678,7 +678,7 @@ pub struct MigrateResult {
     pub gas_info: GasInfo,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Serialize)]
 pub struct ExecuteResult {
     pub logs: Vec<Log>,
 

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

@@ -10,6 +10,8 @@ use crate::nymd::error::NymdError;
 use crate::nymd::fee::DEFAULT_SIMULATED_GAS_MULTIPLIER;
 use crate::nymd::wallet::DirectSecp256k1HdWallet;
 use cosmrs::cosmwasm;
+use cosmrs::rpc::endpoint::block::Response as BlockResponse;
+use cosmrs::rpc::query::Query;
 use cosmrs::rpc::Error as TendermintRpcError;
 use cosmrs::rpc::HttpClientUrl;
 use cosmrs::tx::Msg;
@@ -24,7 +26,7 @@ use mixnet_contract_common::{
     PagedMixDelegationsResponse, PagedMixnodeResponse, PagedRewardedSetResponse, QueryMsg,
     RewardedSetUpdateDetails,
 };
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 use std::convert::TryInto;
 use std::time::SystemTime;
 use vesting_contract_common::ExecuteMsg as VestingExecuteMsg;
@@ -212,6 +214,10 @@ impl<C> NymdClient<C> {
         &self.config
     }
 
+    pub fn current_chain_details(&self) -> &ChainDetails {
+        &self.config.chain_details
+    }
+
     pub fn set_mixnet_contract_address(&mut self, address: AccountId) {
         self.config.mixnet_contract_address = Some(address);
     }
@@ -282,6 +288,30 @@ impl<C> NymdClient<C> {
         self.simulated_gas_multiplier = multiplier;
     }
 
+    pub async fn query_contract_smart<M, T>(
+        &self,
+        contract: &AccountId,
+        query_msg: &M,
+    ) -> Result<T, NymdError>
+    where
+        C: CosmWasmClient + Sync,
+        M: ?Sized + Serialize + Sync,
+        for<'a> T: Deserialize<'a>,
+    {
+        self.client.query_contract_smart(contract, query_msg).await
+    }
+
+    pub async fn query_contract_raw(
+        &self,
+        contract: &AccountId,
+        query_data: Vec<u8>,
+    ) -> Result<Vec<u8>, NymdError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        self.client.query_contract_raw(contract, query_data).await
+    }
+
     pub fn wrap_contract_execute_message<M>(
         &self,
         contract_address: &AccountId,
@@ -308,6 +338,13 @@ impl<C> NymdClient<C> {
         &self.client_address.as_ref().unwrap()[0]
     }
 
+    pub fn signer(&self) -> &DirectSecp256k1HdWallet
+    where
+        C: SigningCosmWasmClient,
+    {
+        self.client.signer()
+    }
+
     pub fn gas_price(&self) -> &GasPrice
     where
         C: SigningCosmWasmClient,
@@ -331,11 +368,26 @@ impl<C> NymdClient<C> {
         address: &AccountId,
     ) -> Result<Option<Account>, NymdError>
     where
-        C: SigningCosmWasmClient + Sync,
+        C: CosmWasmClient + Sync,
     {
         self.client.get_account(address).await
     }
 
+    pub async fn get_account_public_key(
+        &self,
+        address: &AccountId,
+    ) -> Result<Option<cosmrs::crypto::PublicKey>, NymdError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        if let Some(account) = self.client.get_account(address).await? {
+            let base_account = account.try_get_base_account()?;
+            return Ok(base_account.pubkey);
+        }
+
+        Ok(None)
+    }
+
     pub async fn get_current_block_timestamp(&self) -> Result<TendermintTime, NymdError>
     where
         C: CosmWasmClient + Sync,
@@ -353,6 +405,13 @@ impl<C> NymdClient<C> {
         Ok(self.client.get_block(height).await?.block.header.time)
     }
 
+    pub async fn get_block(&self, height: Option<u32>) -> Result<BlockResponse, NymdError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        self.client.get_block(height).await
+    }
+
     pub async fn get_current_block_height(&self) -> Result<Height, NymdError>
     where
         C: CosmWasmClient + Sync,
@@ -397,6 +456,13 @@ impl<C> NymdClient<C> {
         self.client.get_balance(address, denom).await
     }
 
+    pub async fn get_all_balances(&self, address: &AccountId) -> Result<Vec<Coin>, NymdError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        self.client.get_all_balances(address).await
+    }
+
     pub async fn get_tx(&self, id: tx::Hash) -> Result<TxResponse, NymdError>
     where
         C: CosmWasmClient + Sync,
@@ -404,6 +470,13 @@ impl<C> NymdClient<C> {
         self.client.get_tx(id).await
     }
 
+    pub async fn search_tx(&self, query: Query) -> Result<Vec<TxResponse>, NymdError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        self.client.search_tx(query).await
+    }
+
     pub async fn get_total_supply(&self) -> Result<Vec<Coin>, NymdError>
     where
         C: CosmWasmClient + Sync,

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

@@ -7,9 +7,11 @@ use crate::nymd::error::NymdError;
 use crate::nymd::NymdClient;
 use async_trait::async_trait;
 use cosmwasm_std::{Coin as CosmWasmCoin, Timestamp};
+use mixnet_contract_common::IdentityKey;
 use vesting_contract::vesting::Account;
 use vesting_contract_common::{
-    messages::QueryMsg as VestingQueryMsg, OriginalVestingResponse, Period, PledgeData,
+    messages::QueryMsg as VestingQueryMsg, AllDelegationsResponse, DelegationTimesResponse,
+    OriginalVestingResponse, Period, PledgeData, VestingDelegation,
 };
 
 #[async_trait]
@@ -70,6 +72,37 @@ pub trait VestingQueryClient {
         &self,
         vesting_account_address: &str,
     ) -> Result<Period, NymdError>;
+
+    async fn get_delegation_timestamps(
+        &self,
+        address: &str,
+        mix_identity: String,
+    ) -> Result<DelegationTimesResponse, NymdError>;
+
+    async fn get_all_vesting_delegations_paged(
+        &self,
+        start_after: Option<(u32, IdentityKey, u64)>,
+        limit: Option<u32>,
+    ) -> Result<AllDelegationsResponse, NymdError>;
+
+    async fn get_all_vesting_delegations(&self) -> Result<Vec<VestingDelegation>, NymdError> {
+        let mut delegations = Vec::new();
+        let mut start_after = None;
+        loop {
+            let mut paged_response = self
+                .get_all_vesting_delegations_paged(start_after.take(), None)
+                .await?;
+            delegations.append(&mut paged_response.delegations);
+
+            if let Some(start_after_res) = paged_response.start_next_after {
+                start_after = Some(start_after_res)
+            } else {
+                break;
+            }
+        }
+
+        Ok(delegations)
+    }
 }
 
 #[async_trait]
@@ -232,4 +265,29 @@ impl<C: CosmWasmClient + Sync + Send> VestingQueryClient for NymdClient<C> {
             .query_contract_smart(self.vesting_contract_address(), &request)
             .await
     }
+
+    async fn get_delegation_timestamps(
+        &self,
+        address: &str,
+        mix_identity: String,
+    ) -> Result<DelegationTimesResponse, NymdError> {
+        let request = VestingQueryMsg::GetDelegationTimes {
+            address: address.to_string(),
+            mix_identity,
+        };
+        self.client
+            .query_contract_smart(self.vesting_contract_address(), &request)
+            .await
+    }
+
+    async fn get_all_vesting_delegations_paged(
+        &self,
+        start_after: Option<(u32, IdentityKey, u64)>,
+        limit: Option<u32>,
+    ) -> Result<AllDelegationsResponse, NymdError> {
+        let request = VestingQueryMsg::GetAllDelegations { start_after, limit };
+        self.client
+            .query_contract_smart(self.vesting_contract_address(), &request)
+            .await
+    }
 }

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

@@ -4,7 +4,7 @@
 use crate::nymd::error::NymdError;
 use config::defaults;
 use cosmrs::bip32::{DerivationPath, XPrv};
-use cosmrs::crypto::secp256k1::SigningKey;
+use cosmrs::crypto::secp256k1::{Signature, SigningKey};
 use cosmrs::crypto::PublicKey;
 use cosmrs::tx::SignDoc;
 use cosmrs::{tx, AccountId};
@@ -105,6 +105,17 @@ impl DirectSecp256k1HdWallet {
         self.secret.to_string()
     }
 
+    pub fn sign_raw_with_account(
+        &self,
+        signer: &AccountData,
+        message: &[u8],
+    ) -> Result<Signature, NymdError> {
+        signer
+            .private_key
+            .sign(message)
+            .map_err(|_| NymdError::SigningFailure)
+    }
+
     pub fn sign_direct_with_account(
         &self,
         signer: &AccountData,

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

@@ -57,6 +57,7 @@ impl Client {
         V: AsRef<str>,
     {
         let url = create_api_url(&self.url, path, params);
+        log::trace!("url: {:?}", url.as_str());
         Ok(self.reqwest_client.get(url).send().await?.json().await?)
     }
 

common/commands/Cargo.toml

@@ -0,0 +1,32 @@
+[package]
+name = "nym-cli-commands"
+version = "1.0.0"
+authors = ["Nym Technologies SA"]
+edition = "2021"
+
+[dependencies]
+base64 = "0.13.0"
+bip39 = "1.0.1"
+bs58 = "0.4"
+comfy-table = "6.0.0"
+cfg-if = "1.0.0"
+clap = { version = "3.2", features = ["derive"] }
+handlebars = "3.0.1"
+humantime-serde = "1.0"
+k256 = { version = "0.10", features = ["ecdsa", "sha256"] }
+log = "0.4"
+rand = {version = "0.6", features = ["std"] }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1"
+thiserror = "1"
+time = { version = "0.3.6", features = ["parsing", "formatting"] }
+toml = "0.5.6"
+url = "2.2"
+
+cosmrs = { git = "https://github.com/neacsu/cosmos-rust", branch = "neacsu/feegrant_support" }
+cosmwasm-std = { version = "1.0.0" }
+
+validator-client = { path = "../client-libs/validator-client", features = ["nymd-client"] }
+network-defaults = { path = "../network-defaults" }
+mixnet-contract-common = { path = "../cosmwasm-smart-contracts/mixnet-contract" }
+vesting-contract-common = { path = "../cosmwasm-smart-contracts/vesting-contract" }

common/commands/README.md

@@ -0,0 +1,13 @@
+# Common `clap` Command Crate
+
+This crate contains `clap` commands for common operations:
+
+- account creation and queries
+- block queries
+- cosmwasm uploads, instantiate, execution, query, etc
+- mixnet actions and queries
+- sign and verify messages
+- query for transactions
+- create vesting schedules and query for them
+
+For how to use this crate, please see the [Nym CLI](../../tools/nym-cli).

common/commands/src/coconut/mod.rs

@@ -0,0 +1,4 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+// TODO: add coconut commands here

common/commands/src/context/errors.rs

@@ -0,0 +1,18 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum ContextError {
+    #[error("mnemonic was not provided, pass as an argument or an env var called MNEMONIC")]
+    MnemonicNotProvided,
+
+    #[error("failed to parse mnemonic - {0}")]
+    Bip39Error(#[from] bip39::Error),
+
+    // there are lots of error that can occur in the nymd client, so just pass through their display details
+    // TODO: improve this to return known errors
+    #[error("failed to create client - {0}")]
+    NymdError(String),
+}

common/commands/src/context/mod.rs

@@ -0,0 +1,138 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use network_defaults::{
+    setup_env,
+    var_names::{API_VALIDATOR, MIXNET_CONTRACT_ADDRESS, NYMD_VALIDATOR, VESTING_CONTRACT_ADDRESS},
+    NymNetworkDetails,
+};
+use validator_client::nymd::{self, AccountId, NymdClient, QueryNymdClient, SigningNymdClient};
+pub use validator_client::validator_api::Client as ValidatorApiClient;
+
+use crate::context::errors::ContextError;
+
+pub mod errors;
+
+pub type SigningClient = validator_client::nymd::NymdClient<SigningNymdClient>;
+pub type QueryClient = validator_client::nymd::NymdClient<QueryNymdClient>;
+pub type SigningClientWithValidatorAPI = validator_client::Client<SigningNymdClient>;
+pub type QueryClientWithValidatorAPI = validator_client::Client<QueryNymdClient>;
+
+#[derive(Debug)]
+pub struct ClientArgs {
+    pub config_env_file: Option<std::path::PathBuf>,
+    pub nymd_url: Option<String>,
+    pub validator_api_url: Option<String>,
+    pub mnemonic: Option<bip39::Mnemonic>,
+    pub mixnet_contract_address: Option<AccountId>,
+    pub vesting_contract_address: Option<AccountId>,
+}
+
+pub fn get_network_details(args: &ClientArgs) -> Result<NymNetworkDetails, ContextError> {
+    // let the network defaults crate handle setting up the env vars if the file arg is set, otherwise
+    // it will default to what is already in env vars, falling back to mainnet
+    setup_env(args.config_env_file.clone());
+
+    // override the env vars with user supplied arguments, if set
+    if let Some(nymd_url) = args.nymd_url.as_ref() {
+        std::env::set_var(NYMD_VALIDATOR, nymd_url);
+    }
+    if let Some(validator_api_url) = args.validator_api_url.as_ref() {
+        std::env::set_var(API_VALIDATOR, validator_api_url);
+    }
+    if let Some(mixnet_contract_address) = args.mixnet_contract_address.as_ref() {
+        std::env::set_var(MIXNET_CONTRACT_ADDRESS, mixnet_contract_address.to_string());
+    }
+    if let Some(vesting_contract_address) = args.vesting_contract_address.as_ref() {
+        std::env::set_var(
+            VESTING_CONTRACT_ADDRESS,
+            vesting_contract_address.to_string(),
+        );
+    }
+
+    Ok(NymNetworkDetails::new_from_env())
+}
+
+pub fn create_signing_client(
+    args: ClientArgs,
+    network_details: &NymNetworkDetails,
+) -> Result<SigningClient, ContextError> {
+    let client_config = nymd::Config::try_from_nym_network_details(network_details)
+        .expect("failed to construct valid validator client config with the provided network");
+
+    // get mnemonic
+    let mnemonic = match std::env::var("MNEMONIC") {
+        Ok(value) => bip39::Mnemonic::parse(value)?,
+        // env var MNEMONIC is not present, so try to fall back to arg --mnemonic ...
+        Err(_) => match args.mnemonic {
+            Some(value) => value,
+            None => return Err(ContextError::MnemonicNotProvided), // no env var or arg provided
+        },
+    };
+
+    let nymd_url = network_details
+        .endpoints
+        .first()
+        .expect("network details are not defined")
+        .nymd_url
+        .as_str();
+
+    match NymdClient::connect_with_mnemonic(client_config, nymd_url, mnemonic, None) {
+        Ok(client) => Ok(client),
+        Err(e) => Err(ContextError::NymdError(format!("{:?}", e))),
+    }
+}
+
+pub fn create_query_client(
+    network_details: &NymNetworkDetails,
+) -> Result<QueryClient, ContextError> {
+    let client_config = nymd::Config::try_from_nym_network_details(network_details)
+        .expect("failed to construct valid validator client config with the provided network");
+
+    let nymd_url = network_details
+        .endpoints
+        .first()
+        .expect("network details are not defined")
+        .nymd_url
+        .as_str();
+
+    match NymdClient::connect(client_config, nymd_url) {
+        Ok(client) => Ok(client),
+        Err(e) => Err(ContextError::NymdError(format!("{:?}", e))),
+    }
+}
+
+pub fn create_signing_client_with_validator_api(
+    args: ClientArgs,
+    network_details: &NymNetworkDetails,
+) -> Result<SigningClientWithValidatorAPI, ContextError> {
+    let client_config = validator_client::Config::try_from_nym_network_details(network_details)
+        .expect("failed to construct valid validator client config with the provided network");
+
+    // get mnemonic
+    let mnemonic = match std::env::var("MNEMONIC") {
+        Ok(value) => bip39::Mnemonic::parse(value)?,
+        // env var MNEMONIC is not present, so try to fall back to arg --mnemonic ...
+        Err(_) => match args.mnemonic {
+            Some(value) => value,
+            None => return Err(ContextError::MnemonicNotProvided), // no env var or arg provided
+        },
+    };
+
+    match validator_client::client::Client::new_signing(client_config, mnemonic) {
+        Ok(client) => Ok(client),
+        Err(e) => Err(ContextError::NymdError(format!("{:?}", e))),
+    }
+}
+
+pub fn create_query_client_with_validator_api(
+    network_details: &NymNetworkDetails,
+) -> Result<QueryClientWithValidatorAPI, ContextError> {
+    let client_config = validator_client::Config::try_from_nym_network_details(network_details)
+        .expect("failed to construct valid validator client config with the provided network");
+
+    match validator_client::client::Client::new_query(client_config) {
+        Ok(client) => Ok(client),
+        Err(e) => Err(ContextError::NymdError(format!("{:?}", e))),
+    }
+}

common/commands/src/lib.rs

@@ -1,3 +1,7 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
-pub mod tests;
+
+pub mod coconut;
+pub mod context;
+pub mod utils;
+pub mod validator;

common/commands/src/utils.rs

@@ -0,0 +1,44 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use std::error::Error;
+use std::fmt::Display;
+
+use cosmwasm_std::{Coin as CosmWasmCoin, Decimal};
+use log::error;
+use validator_client::nymd::Coin;
+
+pub fn pretty_coin(coin: &Coin) -> String {
+    let amount = Decimal::from_ratio(coin.amount, 1_000_000u128);
+    let denom = if coin.denom.starts_with('u') {
+        &coin.denom[1..]
+    } else {
+        &coin.denom
+    };
+    format!("{} {}", amount, denom)
+}
+
+pub fn pretty_cosmwasm_coin(coin: &CosmWasmCoin) -> String {
+    let amount = Decimal::from_ratio(coin.amount, 1_000_000u128);
+    let denom = if coin.denom.starts_with('u') {
+        &coin.denom[1..]
+    } else {
+        &coin.denom
+    };
+    format!("{} {}", amount, denom)
+}
+
+pub fn show_error<E>(e: E)
+where
+    E: Display,
+{
+    error!("{}", e);
+}
+
+pub fn show_error_passthrough<E>(e: E) -> E
+where
+    E: Error + Display,
+{
+    error!("{}", e);
+    e
+}

common/commands/src/validator/account/balance.rs

@@ -0,0 +1,72 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::Parser;
+use log::{error, info};
+
+use validator_client::nymd::AccountId;
+
+use crate::context::QueryClient;
+use crate::utils::{pretty_coin, show_error};
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(value_parser)]
+    #[clap(help = "The account address to get the balance for")]
+    pub address: Option<AccountId>,
+
+    #[clap(long)]
+    #[clap(help = "Optional currency to show balance for")]
+    pub denom: Option<String>,
+
+    #[clap(long, requires = "denom")]
+    #[clap(help = "Optionally hide the denom")]
+    pub hide_denom: bool,
+
+    #[clap(long)]
+    #[clap(help = "Show as a raw value")]
+    pub raw: bool,
+}
+
+pub async fn query_balance(
+    args: Args,
+    client: &QueryClient,
+    address_from_mnemonic: Option<AccountId>,
+) {
+    if args.address.is_none() && address_from_mnemonic.is_none() {
+        error!("Please specify an account address or a mnemonic to get the balance for");
+        return;
+    }
+
+    let address = args
+        .address
+        .unwrap_or_else(|| address_from_mnemonic.expect("please provide a mnemonic"));
+
+    info!("Getting balance for {}...", address);
+
+    match client.get_all_balances(&address).await {
+        Ok(coins) => {
+            if coins.is_empty() {
+                println!("No balance");
+                return;
+            }
+
+            let denom = args.denom.unwrap_or_else(|| "".to_string());
+
+            for coin in coins {
+                if denom.is_empty() || denom.eq_ignore_ascii_case(&coin.denom) {
+                    if args.raw {
+                        if !args.hide_denom {
+                            println!("{}", coin);
+                        } else {
+                            println!("{}", coin.amount);
+                        }
+                    } else {
+                        println!("{}", pretty_coin(&coin));
+                    }
+                }
+            }
+        }
+        Err(e) => show_error(e),
+    }
+}

common/commands/src/validator/account/create.rs

@@ -0,0 +1,24 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::Parser;
+use validator_client::nymd::wallet::DirectSecp256k1HdWallet;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(long)]
+    // allowed values are 12, 18 or 24
+    pub word_count: Option<usize>,
+}
+
+pub fn create_account(args: Args, prefix: &str) {
+    let word_count = args.word_count.unwrap_or(24);
+    let mnemonic = bip39::Mnemonic::generate(word_count).expect("failed to generate mnemonic!");
+
+    let wallet =
+        DirectSecp256k1HdWallet::from_mnemonic(prefix, mnemonic).expect("failed to build wallet!");
+
+    // Output address and mnemonics into separate lines for easier parsing
+    println!("{}", wallet.mnemonic());
+    println!("{}", wallet.try_derive_accounts().unwrap()[0].address());
+}

common/commands/src/validator/account/mod.rs

@@ -0,0 +1,28 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::{Args, Subcommand};
+
+pub mod balance;
+pub mod create;
+pub mod pubkey;
+pub mod send;
+
+#[derive(Debug, Args)]
+#[clap(args_conflicts_with_subcommands = true, subcommand_required = true)]
+pub struct Account {
+    #[clap(subcommand)]
+    pub command: Option<AccountCommands>,
+}
+
+#[derive(Debug, Subcommand)]
+pub enum AccountCommands {
+    /// Create a new mnemonic - note, this account does not appear on the chain until the account id is used in a transaction
+    Create(crate::validator::account::create::Args),
+    /// Gets the balance of an account
+    Balance(crate::validator::account::balance::Args),
+    /// Gets the public key of an account
+    PubKey(crate::validator::account::pubkey::Args),
+    /// Sends tokens to another account
+    Send(crate::validator::account::send::Args),
+}

common/commands/src/validator/account/pubkey.rs

@@ -0,0 +1,89 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::Parser;
+use log::{error, info};
+
+use validator_client::nymd::wallet::DirectSecp256k1HdWallet;
+use validator_client::nymd::AccountId;
+
+use crate::context::QueryClient;
+use crate::utils::show_error;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(value_parser)]
+    #[clap(
+        help = "Optionally, show the public key for this account address, otherwise generate the account address from the mnemonic"
+    )]
+    pub address: Option<AccountId>,
+
+    #[clap(long)]
+    #[clap(help = "If set, get the public key from the mnemonic, rather than querying for it")]
+    pub from_mnemonic: bool,
+}
+
+pub async fn get_pubkey(
+    args: Args,
+    client: &QueryClient,
+    mnemonic: Option<bip39::Mnemonic>,
+    address_from_mnemonic: Option<AccountId>,
+) {
+    if args.address.is_none() && address_from_mnemonic.is_none() {
+        error!("Please specify an account address or a mnemonic to get the balance for");
+        return;
+    }
+
+    let address = args
+        .address
+        .unwrap_or_else(|| address_from_mnemonic.expect("please provide a mnemonic"));
+
+    if args.from_mnemonic {
+        let prefix = client
+            .current_chain_details()
+            .bech32_account_prefix
+            .as_str();
+        get_pubkey_from_mnemonic(address, prefix, mnemonic.expect("mnemonic not set"));
+        return;
+    }
+
+    get_pubkey_from_chain(address, client).await;
+}
+
+pub fn get_pubkey_from_mnemonic(address: AccountId, prefix: &str, mnemonic: bip39::Mnemonic) {
+    match DirectSecp256k1HdWallet::from_mnemonic(prefix, mnemonic) {
+        Ok(wallet) => match wallet.try_derive_accounts() {
+            Ok(accounts) => match accounts.iter().find(|a| *a.address() == address) {
+                Some(account) => {
+                    println!("{}", account.public_key().to_string());
+                }
+                None => {
+                    error!("Could not derive key that matches {}", address)
+                }
+            },
+            Err(e) => {
+                error!("Failed to derive accounts. {}", e);
+            }
+        },
+        Err(e) => show_error(e),
+    }
+}
+
+pub async fn get_pubkey_from_chain(address: AccountId, client: &QueryClient) {
+    info!("Getting public key for address {} from chain...", address);
+    match client.get_account_details(&address).await {
+        Ok(Some(account)) => {
+            if let Ok(base_account) = account.try_get_base_account() {
+                if let Some(pubkey) = base_account.pubkey {
+                    println!("{}", pubkey.to_string());
+                } else {
+                    println!("No account associated with address {}", address);
+                }
+            }
+        }
+        Ok(None) => {
+            println!("No account associated with address {}", address);
+        }
+        Err(e) => show_error(e),
+    }
+}

common/commands/src/validator/account/send.rs

@@ -0,0 +1,66 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::Parser;
+use log::info;
+use serde_json::json;
+
+use validator_client::nymd::{AccountId, Coin};
+
+use crate::context::SigningClient;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(value_parser, help = "The recipient account address")]
+    pub recipient: AccountId,
+
+    #[clap(
+        value_parser,
+        help = "Amount to transfer in micro denomination (e.g. unym or unyx)"
+    )]
+    pub amount: u128,
+
+    #[clap(long, help = "Override the denomination")]
+    pub denom: Option<String>,
+
+    #[clap(long)]
+    pub memo: Option<String>,
+}
+
+pub async fn send(args: Args, client: &SigningClient) {
+    let memo = args
+        .memo
+        .unwrap_or_else(|| "Sending tokens with nym-cli".to_owned());
+    let denom = args
+        .denom
+        .unwrap_or_else(|| client.current_chain_details().mix_denom.base.clone());
+
+    let coin = Coin {
+        denom,
+        amount: args.amount,
+    };
+
+    info!(
+        "Sending {} {} from {} to {}...",
+        coin.amount,
+        coin.denom,
+        client.address(),
+        args.recipient
+    );
+
+    let res = client
+        .send(&args.recipient, vec![coin], memo, None)
+        .await
+        .expect("failed to send tokens!");
+
+    info!("Sending result: {}", json!(res));
+
+    println!();
+    println!(
+        "Nodesguru: https://nym.explorers.guru/transaction/{}",
+        &res.hash
+    );
+    println!("Mintscan: https://www.mintscan.io/nyx/txs/{}", &res.hash);
+    println!("Transaction result code: {}", &res.tx_result.code.value());
+    println!("Transaction hash: {}", &res.hash);
+}

common/commands/src/validator/block/block_time.rs

@@ -0,0 +1,23 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::Parser;
+
+use crate::context::QueryClient;
+use crate::utils::show_error;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(value_parser)]
+    #[clap(help = "The block height")]
+    pub height: u32,
+}
+
+pub async fn query_for_block_time(args: Args, client: &QueryClient) {
+    match client.get_block_timestamp(Some(args.height)).await {
+        Ok(res) => {
+            println!("{}", res.to_rfc3339())
+        }
+        Err(e) => show_error(e),
+    }
+}

common/commands/src/validator/block/current_height.rs

@@ -0,0 +1,19 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::Parser;
+
+use crate::context::QueryClient;
+use crate::utils::show_error;
+
+#[derive(Debug, Parser)]
+pub struct Args {}
+
+pub async fn query_current_block_height(client: &QueryClient) {
+    match client.get_current_block_height().await {
+        Ok(res) => {
+            println!("Current block height:\n{}", res.value())
+        }
+        Err(e) => show_error(e),
+    }
+}

common/commands/src/validator/block/get.rs

@@ -0,0 +1,24 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::Parser;
+
+use crate::context::QueryClient;
+use crate::utils::show_error;
+use serde_json::json;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(value_parser)]
+    #[clap(help = "The block height")]
+    pub height: u32,
+}
+
+pub async fn query_for_block(args: Args, client: &QueryClient) {
+    match client.get_block(Some(args.height)).await {
+        Ok(res) => {
+            println!("{}", json!(res))
+        }
+        Err(e) => show_error(e),
+    }
+}

common/commands/src/validator/block/mod.rs

@@ -0,0 +1,25 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::{Args, Subcommand};
+
+pub mod block_time;
+pub mod current_height;
+pub mod get;
+
+#[derive(Debug, Args)]
+#[clap(args_conflicts_with_subcommands = true, subcommand_required = true)]
+pub struct Block {
+    #[clap(subcommand)]
+    pub command: Option<BlockCommands>,
+}
+
+#[derive(Debug, Subcommand)]
+pub enum BlockCommands {
+    /// Gets a block's details and prints as JSON
+    Get(crate::validator::block::get::Args),
+    /// Gets the block time at a height
+    Time(crate::validator::block::block_time::Args),
+    /// Gets the current block height
+    CurrentHeight(crate::validator::block::current_height::Args),
+}

common/commands/src/validator/cosmwasm/execute_contract.rs

@@ -0,0 +1,60 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::context::SigningClient;
+use clap::Parser;
+use cosmrs::AccountId;
+use log::{error, info};
+use serde_json::{json, Value};
+use validator_client::nymd::Coin;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(value_parser)]
+    #[clap(help = "The address of contract to execute")]
+    pub contract_address: AccountId,
+
+    #[clap(value_parser)]
+    #[clap(help = "JSON encoded method arguments")]
+    pub json_args: String,
+
+    #[clap(long)]
+    pub memo: Option<String>,
+
+    #[clap(
+        value_parser,
+        requires = "fundsDenom",
+        help = "Amount to supply as funds in micro denomination (e.g. unym or unyx)"
+    )]
+    pub funds: Option<u128>,
+
+    #[clap(long, requires = "funds", help = "Set the denomination for the funds")]
+    pub funds_denom: Option<String>,
+}
+
+pub async fn execute(args: Args, client: SigningClient) {
+    info!("Starting contract method execution!");
+
+    let json_args: Value =
+        serde_json::from_str(&args.json_args).expect("Unable to parse JSON args");
+
+    let memo = args
+        .memo
+        .unwrap_or_else(|| "nym-cli execute contract method".to_owned());
+
+    let funds = match args.funds {
+        Some(funds) => vec![Coin::new(
+            funds,
+            args.funds_denom.expect("denom for funds not set"),
+        )],
+        None => vec![],
+    };
+
+    match client
+        .execute(&args.contract_address, &json_args, None, memo, funds)
+        .await
+    {
+        Ok(res) => info!("SUCCESS ✅\n{}", json!(res)),
+        Err(e) => error!("FAILURE ❌\n{}", e),
+    }
+}

common/commands/src/validator/cosmwasm/init_contract.rs

@@ -0,0 +1,78 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::context::SigningClient;
+use clap::Parser;
+use cosmrs::{AccountId, Coin as CosmosCoin};
+use log::info;
+use network_defaults::NymNetworkDetails;
+use validator_client::nymd::cosmwasm_client::types::{ContractCodeId, InstantiateOptions};
+use validator_client::nymd::Coin;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(value_parser)]
+    pub code_id: ContractCodeId,
+
+    #[clap(long)]
+    pub memo: Option<String>,
+
+    #[clap(long)]
+    pub label: Option<String>,
+
+    #[clap(long)]
+    pub init_message: String,
+
+    #[clap(long)]
+    pub admin: Option<AccountId>,
+
+    #[clap(
+        long,
+        requires = "fundsDenom",
+        help = "Amount to supply as funds in micro denomination (e.g. unym or unyx)"
+    )]
+    pub funds: Option<u128>,
+
+    #[clap(long, requires = "funds", help = "Set the denomination for the funds")]
+    pub funds_denom: Option<String>,
+}
+
+pub async fn init(args: Args, client: SigningClient, network_details: &NymNetworkDetails) {
+    info!("Starting contract instantiation!");
+
+    let memo = args
+        .memo
+        .unwrap_or_else(|| "contract instantiation".to_owned());
+    let label = args
+        .label
+        .unwrap_or_else(|| "Nym mixnet smart contract".to_owned());
+
+    let funds: Vec<CosmosCoin> = match args.funds {
+        Some(funds) => vec![Coin::new(
+            funds,
+            args.funds_denom
+                .unwrap_or_else(|| network_details.chain_details.mix_denom.base.to_string()),
+        )
+        .into()],
+        None => vec![],
+    };
+
+    // by default we make ourselves an admin, let me know if you don't like that behaviour
+    let opts = Some(InstantiateOptions {
+        funds,
+        admin: Some(args.admin.unwrap_or_else(|| client.address().clone())),
+    });
+
+    let msg: serde_json::Value =
+        serde_json::from_str(&args.init_message).expect("failed to parse init message");
+
+    // the EmptyMsg{} argument is equivalent to `--init-message='{}'`
+    let res = client
+        .instantiate(args.code_id, &msg, label, memo, opts, None)
+        .await
+        .expect("failed to instantiate the contract!");
+
+    info!("Init result: {:?}", res);
+
+    println!("{}", res.contract_address)
+}

common/commands/src/validator/cosmwasm/migrate_contract.rs

@@ -0,0 +1,51 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::context::SigningClient;
+use crate::utils::show_error_passthrough;
+use clap::Parser;
+use cosmrs::AccountId;
+use log::info;
+use validator_client::nymd::cosmwasm_client::types::{ContractCodeId, EmptyMsg};
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(value_parser)]
+    pub contract_address: AccountId,
+
+    #[clap(long)]
+    pub code_id: ContractCodeId,
+
+    #[clap(long)]
+    pub memo: Option<String>,
+
+    #[clap(long)]
+    pub init_message: Option<String>,
+}
+
+pub async fn migrate(args: Args, client: SigningClient) {
+    println!("Starting contract migration!");
+
+    let memo = args.memo.unwrap_or_else(|| "contract migration".to_owned());
+    let contract_address = args.contract_address;
+
+    // the EmptyMsg{} argument is equivalent to `--init-message='{}'`
+    let res = if let Some(raw_msg) = args.init_message {
+        let msg: serde_json::Value =
+            serde_json::from_str(&raw_msg).expect("failed to parse init message");
+
+        client
+            .migrate(&contract_address, args.code_id, &msg, memo, None)
+            .await
+            .map_err(show_error_passthrough)
+            .expect("failed to migrate the contract!")
+    } else {
+        client
+            .migrate(&contract_address, args.code_id, &EmptyMsg {}, memo, None)
+            .await
+            .map_err(show_error_passthrough)
+            .expect("failed to migrate the contract!")
+    };
+
+    info!("Migrate result: {:?}", res);
+}

common/commands/src/validator/cosmwasm/mod.rs

@@ -0,0 +1,28 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::{Args, Subcommand};
+
+pub mod execute_contract;
+pub mod init_contract;
+pub mod migrate_contract;
+pub mod upload_contract;
+
+#[derive(Debug, Args)]
+#[clap(args_conflicts_with_subcommands = true, subcommand_required = true)]
+pub struct Cosmwasm {
+    #[clap(subcommand)]
+    pub command: Option<CosmwasmCommands>,
+}
+
+#[derive(Debug, Subcommand)]
+pub enum CosmwasmCommands {
+    /// Upload a smart contract WASM blob
+    Upload(crate::validator::cosmwasm::upload_contract::Args),
+    /// Init a WASM smart contract
+    Init(crate::validator::cosmwasm::init_contract::Args),
+    /// Migrate a WASM smart contract
+    Migrate(crate::validator::cosmwasm::migrate_contract::Args),
+    /// Execute a WASM smart contract method
+    Execute(crate::validator::cosmwasm::execute_contract::Args),
+}

common/commands/src/validator/cosmwasm/upload_contract.rs

@@ -0,0 +1,37 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::context::SigningClient;
+use clap::Parser;
+use log::info;
+use std::io::Read;
+use std::path::PathBuf;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(long)]
+    pub wasm_path: PathBuf,
+
+    #[clap(long)]
+    pub memo: Option<String>,
+}
+
+pub async fn upload(args: Args, client: SigningClient) {
+    info!("Starting contract upload!");
+
+    let mut file = std::fs::File::open(args.wasm_path).expect("failed to open the wasm blob");
+    let mut data = Vec::new();
+
+    file.read_to_end(&mut data).unwrap();
+
+    let memo = args.memo.unwrap_or_else(|| "contract upload".to_owned());
+
+    let res = client
+        .upload(data, memo, None)
+        .await
+        .expect("failed to upload the contract!");
+
+    info!("Upload result: {:?}", res);
+
+    println!("{}", res.code_id)
+}

common/commands/src/validator/mixnet/delegators/delegate_to_mixnode.rs

@@ -0,0 +1,31 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::context::SigningClient;
+use clap::Parser;
+use log::info;
+use mixnet_contract_common::Coin;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(long)]
+    pub identity_key: String,
+
+    #[clap(long)]
+    pub amount: u128,
+}
+
+pub async fn delegate_to_mixnode(args: Args, client: SigningClient) {
+    let denom = client.current_chain_details().mix_denom.base.as_str();
+
+    info!("Starting delegation to mixnode");
+
+    let coin = Coin::new(args.amount, denom);
+
+    let res = client
+        .delegate_to_mixnode(&*args.identity_key, coin.into(), None)
+        .await
+        .expect("failed to delegate to mixnode!");
+
+    info!("delegating to mixnode: {:?}", res);
+}

common/commands/src/validator/mixnet/delegators/mod.rs

@@ -0,0 +1,35 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::{Args, Subcommand};
+
+pub mod rewards;
+
+pub mod delegate_to_mixnode;
+pub mod query_for_delegations;
+pub mod undelegate_from_mixnode;
+pub mod vesting_delegate_to_mixnode;
+pub mod vesting_undelegate_from_mixnode;
+
+#[derive(Debug, Args)]
+#[clap(args_conflicts_with_subcommands = true, subcommand_required = true)]
+pub struct MixnetDelegators {
+    #[clap(subcommand)]
+    pub command: MixnetDelegatorsCommands,
+}
+
+#[derive(Debug, Subcommand)]
+pub enum MixnetDelegatorsCommands {
+    /// Lists current delegations
+    List(query_for_delegations::Args),
+    /// Manage rewards from delegations
+    Rewards(rewards::MixnetDelegatorsReward),
+    /// Delegate to a mixnode
+    Delegate(delegate_to_mixnode::Args),
+    /// Undelegate from a mixnode
+    Undelegate(undelegate_from_mixnode::Args),
+    /// Delegate to a mixnode with locked tokens
+    DelegateVesting(vesting_delegate_to_mixnode::Args),
+    /// Undelegate from a mixnode (when originally using locked tokens)
+    UndelegateVesting(vesting_undelegate_from_mixnode::Args),
+}

common/commands/src/validator/mixnet/delegators/query_for_delegations.rs

@@ -0,0 +1,129 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::Parser;
+use log::info;
+
+use crate::context::SigningClientWithValidatorAPI;
+use crate::utils::{pretty_cosmwasm_coin, show_error_passthrough};
+
+use comfy_table::Table;
+use mixnet_contract_common::mixnode::DelegationEvent;
+use mixnet_contract_common::Delegation;
+
+#[derive(Debug, Parser)]
+pub struct Args {}
+
+pub async fn execute(_args: Args, client: SigningClientWithValidatorAPI) {
+    info!(
+        "Getting delegations for account {}...",
+        client.nymd.address()
+    );
+
+    let delegations = client
+        .get_all_delegator_delegations(client.nymd.address())
+        .await
+        .map_err(show_error_passthrough);
+
+    let mixnet_contract_events = client
+        .nymd
+        .get_pending_delegation_events(client.nymd.address().to_string(), None)
+        .await
+        .map_err(show_error_passthrough);
+
+    let vesting_contract = client.nymd.vesting_contract_address();
+
+    let vesting_contract_events = client
+        .nymd
+        .get_pending_delegation_events(
+            client.nymd.address().to_string(),
+            Some(vesting_contract.to_string()),
+        )
+        .await
+        .map_err(show_error_passthrough);
+
+    if let Ok(res) = delegations {
+        println!();
+        if res.is_empty() {
+            println!("This account has not delegated any tokens to mixnodes");
+        } else {
+            println!("Delegations:");
+            print_delegations(res, &client).await;
+        }
+    }
+    if let Ok(res) = mixnet_contract_events {
+        if !res.is_empty() {
+            println!();
+            println!("Pending delegations (liquid tokens):");
+            print_delegation_events(res, &client).await;
+        }
+    }
+    if let Ok(res) = vesting_contract_events {
+        if !res.is_empty() {
+            println!();
+            println!("Pending delegations (locked tokens):");
+            print_delegation_events(res, &client).await;
+        }
+    }
+}
+
+async fn to_iso_timestamp(block_height: u32, client: &SigningClientWithValidatorAPI) -> String {
+    match client.nymd.get_block_timestamp(Some(block_height)).await {
+        Ok(res) => res.to_rfc3339(),
+        Err(_e) => "-".to_string(),
+    }
+}
+
+async fn print_delegations(delegations: Vec<Delegation>, client: &SigningClientWithValidatorAPI) {
+    let mut table = Table::new();
+
+    table.set_header(vec!["Timestamp", "Identity Key", "Delegation", "Proxy"]);
+
+    for delegation in delegations {
+        table.add_row(vec![
+            to_iso_timestamp(delegation.block_height as u32, client).await,
+            delegation.node_identity.to_string(),
+            pretty_cosmwasm_coin(&delegation.amount),
+            format!("{:?}", delegation.proxy),
+        ]);
+    }
+
+    println!("{table}");
+}
+
+async fn print_delegation_events(
+    events: Vec<DelegationEvent>,
+    client: &SigningClientWithValidatorAPI,
+) {
+    let mut table = Table::new();
+
+    table.set_header(vec![
+        "Timestamp",
+        "Identity Key",
+        "Delegation",
+        "Event Type",
+    ]);
+
+    for event in events {
+        match event {
+            DelegationEvent::Delegate(delegation) => {
+                table.add_row(vec![
+                    to_iso_timestamp(delegation.block_height as u32, client).await,
+                    delegation.node_identity.to_string(),
+                    pretty_cosmwasm_coin(&delegation.amount),
+                    "Delegate".to_string(),
+                ]);
+            }
+            DelegationEvent::Undelegate(undelegate) => {
+                table.add_row(vec![
+                    to_iso_timestamp(undelegate.block_height() as u32, client).await,
+                    undelegate.mix_identity().to_string(),
+                    "-".to_string(),
+                    "Undelegate".to_string(),
+                ]);
+            }
+        }
+    }
+
+    println!("{table}");
+}

common/commands/src/validator/mixnet/delegators/rewards/claim_delegator_reward.rs

@@ -0,0 +1,23 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::context::SigningClient;
+use clap::Parser;
+use log::info;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(long)]
+    pub identity_key: String,
+}
+
+pub async fn claim_delegator_reward(args: Args, client: SigningClient) {
+    info!("Claim delegator reward");
+
+    let res = client
+        .execute_claim_delegator_reward(args.identity_key, None)
+        .await
+        .expect("failed to claim delegator-reward");
+
+    info!("Claiming delegator reward: {:?}", res)
+}

common/commands/src/validator/mixnet/delegators/rewards/mod.rs

@@ -0,0 +1,22 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::{Args, Subcommand};
+
+pub mod claim_delegator_reward;
+pub mod vesting_claim_delegator_reward;
+
+#[derive(Debug, Args)]
+#[clap(args_conflicts_with_subcommands = true, subcommand_required = true)]
+pub struct MixnetDelegatorsReward {
+    #[clap(subcommand)]
+    pub command: MixnetDelegatorsRewardCommands,
+}
+
+#[derive(Debug, Subcommand)]
+pub enum MixnetDelegatorsRewardCommands {
+    /// Claim rewards accumulated during the delegation of unlocked tokens
+    Claim(claim_delegator_reward::Args),
+    /// Claim rewards accumulated during the delegation of locked tokens
+    VestingClaim(vesting_claim_delegator_reward::Args),
+}

common/commands/src/validator/mixnet/delegators/rewards/vesting_claim_delegator_reward.rs

@@ -0,0 +1,23 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::context::SigningClient;
+use clap::Parser;
+use log::info;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(long)]
+    pub identity: String,
+}
+
+pub async fn vesting_claim_delegator_reward(args: Args, client: SigningClient) {
+    info!("Claim vesting delegator reward");
+
+    let res = client
+        .execute_vesting_claim_delegator_reward(args.identity, None)
+        .await
+        .expect("failed to claim vesting delegator-reward");
+
+    info!("Claiming vesting delegator reward: {:?}", res)
+}

common/commands/src/validator/mixnet/delegators/undelegate_from_mixnode.rs

@@ -0,0 +1,23 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::context::SigningClient;
+use clap::Parser;
+use log::info;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(long)]
+    pub identity_key: String,
+}
+
+pub async fn undelegate_from_mixnode(args: Args, client: SigningClient) {
+    info!("removing stake from mix-node");
+
+    let res = client
+        .remove_mixnode_delegation(&*args.identity_key, None)
+        .await
+        .expect("failed to remove stake from mixnode!");
+
+    info!("removing stake from mixnode: {:?}", res)
+}

common/commands/src/validator/mixnet/delegators/vesting_delegate_to_mixnode.rs

@@ -0,0 +1,34 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::Parser;
+use log::info;
+
+use mixnet_contract_common::Coin;
+use validator_client::nymd::VestingSigningClient;
+
+use crate::context::SigningClient;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(long)]
+    pub identity_key: String,
+
+    #[clap(long)]
+    pub amount: u128,
+}
+
+pub async fn vesting_delegate_to_mixnode(args: Args, client: SigningClient) {
+    let denom = client.current_chain_details().mix_denom.base.as_str();
+
+    info!("Starting vesting delegation to mixnode");
+
+    let coin = Coin::new(args.amount, denom);
+
+    let res = client
+        .vesting_delegate_to_mixnode(&*args.identity_key, coin.into(), None)
+        .await
+        .expect("failed to delegate to mixnode!");
+
+    info!("vesting delegating to mixnode: {:?}", res);
+}

common/commands/src/validator/mixnet/delegators/vesting_undelegate_from_mixnode.rs

@@ -0,0 +1,26 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::Parser;
+use log::info;
+
+use validator_client::nymd::VestingSigningClient;
+
+use crate::context::SigningClient;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(long)]
+    pub identity_key: String,
+}
+
+pub async fn vesting_undelegate_from_mixnode(args: Args, client: SigningClient) {
+    info!("removing stake from vesting mix-node");
+
+    let res = client
+        .vesting_undelegate_from_mixnode(&*args.identity_key, None)
+        .await
+        .expect("failed to remove stake from vesting account on mixnode!");
+
+    info!("removing stake from vesting mixnode: {:?}", res)
+}

common/commands/src/validator/mixnet/mod.rs

@@ -0,0 +1,25 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::{Args, Subcommand};
+
+pub mod delegators;
+pub mod operators;
+pub mod query;
+
+#[derive(Debug, Args)]
+#[clap(args_conflicts_with_subcommands = true, subcommand_required = true)]
+pub struct Mixnet {
+    #[clap(subcommand)]
+    pub command: MixnetCommands,
+}
+
+#[derive(Debug, Subcommand)]
+pub enum MixnetCommands {
+    /// Query the mixnet directory
+    Query(query::MixnetQuery),
+    /// Manage your delegations
+    Delegators(delegators::MixnetDelegators),
+    /// Manage a mixnode or gateway you operate
+    Operators(operators::MixnetOperators),
+}