Added code for gateway migration

* Removed migration artifacts from mixnet and vesting contracts

* Workaround for CI build

* unused imports

.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

CHANGELOG.md

@@ -4,11 +4,18 @@ 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])
+
 ### Changed
 
 - validator-client: made `fee` argument optional for `execute` and `execute_multiple` ([#1541])
 
 [#1541]: https://github.com/nymtech/nym/pull/1541
+[#1558]: https://github.com/nymtech/nym/pull/1558
+[#1577]: https://github.com/nymtech/nym/pull/1577
 
 
 ## [nym-binaries-1.0.2](https://github.com/nymtech/nym/tree/nym-binaries-1.0.2)
@@ -27,6 +34,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 +54,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 +71,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 +101,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"
 ]
 

Makefile

@@ -69,6 +69,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/src/client/real_messages_control/acknowledgement_control/input_message_listener.rs

@@ -133,7 +133,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(

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

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

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/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/mod.rs

@@ -199,9 +199,9 @@ impl NymClient {
             Some(bandwidth_controller),
         );
 
-        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

clients/native/src/commands/init.rs

@@ -46,10 +46,9 @@ 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(any(feature = "eth", 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
@@ -79,7 +78,7 @@ impl From<Init> for OverrideConfig {
             port: init_config.port,
             fastmode: init_config.fastmode,
 
-            #[cfg(all(feature = "eth", not(feature = "coconut")))]
+            #[cfg(any(feature = "eth", feature = "coconut"))]
             enabled_credentials_mode: init_config.enabled_credentials_mode,
 
             #[cfg(all(feature = "eth", not(feature = "coconut")))]

clients/native/src/commands/mod.rs

@@ -78,7 +78,7 @@ pub(crate) struct OverrideConfig {
     port: Option<u16>,
     fastmode: bool,
 
-    #[cfg(all(feature = "eth", not(feature = "coconut")))]
+    #[cfg(any(feature = "eth", feature = "coconut"))]
     enabled_credentials_mode: bool,
 
     #[cfg(all(feature = "eth", not(feature = "coconut")))]
@@ -126,12 +126,15 @@ pub(crate) fn override_config(mut config: Config, args: OverrideConfig) -> Confi
             .get_base_mut()
             .with_eth_private_key(DEFAULT_ETH_PRIVATE_KEY.to_string());
     }
-
-    #[cfg(all(feature = "eth", not(feature = "coconut")))]
+    #[cfg(any(feature = "eth", feature = "coconut"))]
     {
         if args.enabled_credentials_mode {
             config.get_base_mut().with_disabled_credentials(false)
         }
+    }
+
+    #[cfg(all(feature = "eth", not(feature = "coconut")))]
+    {
         if let Some(eth_endpoint) = args.eth_endpoint {
             config.get_base_mut().with_eth_endpoint(eth_endpoint);
         }

clients/native/src/commands/run.rs

@@ -35,10 +35,9 @@ 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(any(feature = "eth", 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
@@ -62,7 +61,7 @@ impl From<Run> for OverrideConfig {
             port: run_config.port,
             fastmode: false,
 
-            #[cfg(all(feature = "eth", not(feature = "coconut")))]
+            #[cfg(any(feature = "eth", feature = "coconut"))]
             enabled_credentials_mode: run_config.enabled_credentials_mode,
 
             #[cfg(all(feature = "eth", not(feature = "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/mod.rs

@@ -198,9 +198,9 @@ impl NymClient {
             Some(bandwidth_controller),
         );
 
-        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

clients/socks5/src/commands/init.rs

@@ -46,10 +46,9 @@ 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(any(feature = "eth", 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
@@ -78,7 +77,7 @@ impl From<Init> for OverrideConfig {
             port: init_config.port,
             fastmode: init_config.fastmode,
 
-            #[cfg(all(feature = "eth", not(feature = "coconut")))]
+            #[cfg(any(feature = "eth", feature = "coconut"))]
             enabled_credentials_mode: init_config.enabled_credentials_mode,
 
             #[cfg(all(feature = "eth", not(feature = "coconut")))]

clients/socks5/src/commands/mod.rs

@@ -78,7 +78,7 @@ pub(crate) struct OverrideConfig {
     port: Option<u16>,
     fastmode: bool,
 
-    #[cfg(all(feature = "eth", not(feature = "coconut")))]
+    #[cfg(any(feature = "eth", feature = "coconut"))]
     enabled_credentials_mode: bool,
 
     #[cfg(all(feature = "eth", not(feature = "coconut")))]
@@ -121,11 +121,14 @@ pub(crate) fn override_config(mut config: Config, args: OverrideConfig) -> Confi
             .with_eth_private_key(DEFAULT_ETH_PRIVATE_KEY.to_string());
     }
 
-    #[cfg(all(feature = "eth", not(feature = "coconut")))]
+    #[cfg(any(feature = "eth", feature = "coconut"))]
     {
         if args.enabled_credentials_mode {
             config.get_base_mut().with_disabled_credentials(false)
         }
+    }
+    #[cfg(all(feature = "eth", not(feature = "coconut")))]
+    {
         if let Some(eth_endpoint) = args.eth_endpoint {
             config.get_base_mut().with_eth_endpoint(eth_endpoint);
         }

clients/socks5/src/commands/run.rs

@@ -39,10 +39,9 @@ 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(any(feature = "eth", 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
@@ -65,7 +64,7 @@ impl From<Run> for OverrideConfig {
             port: run_config.port,
             fastmode: false,
 
-            #[cfg(all(feature = "eth", not(feature = "coconut")))]
+            #[cfg(any(feature = "eth", feature = "coconut"))]
             enabled_credentials_mode: run_config.enabled_credentials_mode,
 
             #[cfg(all(feature = "eth", not(feature = "coconut")))]

clients/socks5/src/socks/mixnet_responses.rs

@@ -54,6 +54,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

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/src/socket_state.rs

@@ -162,12 +162,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/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;
@@ -20,11 +22,11 @@ use mixnet_contract_common::{
     ContractStateParams, Delegation, ExecuteMsg, Gateway, GatewayBond, GatewayBondResponse,
     GatewayOwnershipResponse, IdentityKey, Interval, LayerDistribution, MixNode, MixNodeBond,
     MixOwnershipResponse, MixnetContractVersion, MixnodeBondResponse,
-    MixnodeRewardingStatusResponse, PagedDelegatorDelegationsResponse, PagedGatewayResponse,
-    PagedMixDelegationsResponse, PagedMixnodeResponse, PagedRewardedSetResponse, QueryMsg,
-    RewardedSetUpdateDetails,
+    MixnodeRewardingStatusResponse, PagedAllDelegationsResponse, PagedDelegatorDelegationsResponse,
+    PagedGatewayResponse, 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,
@@ -331,11 +361,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 +398,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 +449,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 +463,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,
@@ -772,6 +838,22 @@ impl<C> NymdClient<C> {
             .await
     }
 
+    pub async fn get_all_delegations_paged(
+        &self,
+        start_after: Option<(IdentityKey, Vec<u8>, u64)>,
+    ) -> Result<PagedAllDelegationsResponse, NymdError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        let request = QueryMsg::GetAllDelegationValuesPaged {
+            start_after,
+            limit: None,
+        };
+        self.client
+            .query_contract_smart(self.mixnet_contract_address(), &request)
+            .await
+    }
+
     /// Checks value of delegation of given client towards particular mixnode.
     pub async fn get_delegation_details(
         &self,

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

@@ -0,0 +1,7 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+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),
+}

common/commands/src/validator/mixnet/operators/gateway/bond_gateway.rs

@@ -0,0 +1,77 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::context::SigningClient;
+use clap::Parser;
+use log::{info, warn};
+use mixnet_contract_common::Coin;
+use network_defaults::{DEFAULT_CLIENT_LISTENING_PORT, DEFAULT_MIX_LISTENING_PORT};
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(long)]
+    pub host: String,
+
+    #[clap(long)]
+    pub signature: String,
+
+    #[clap(long)]
+    pub mix_port: Option<u16>,
+
+    #[clap(long)]
+    pub clients_port: Option<u16>,
+
+    #[clap(long)]
+    pub location: Option<String>,
+
+    #[clap(long)]
+    pub sphinx_key: String,
+
+    #[clap(long)]
+    pub identity_key: String,
+
+    #[clap(long)]
+    pub version: String,
+
+    #[clap(
+        long,
+        help = "bonding amount in current DENOMINATION (so it would be 'unym', rather than 'nym')"
+    )]
+    pub amount: u128,
+
+    #[clap(short, long)]
+    pub force: bool,
+}
+
+pub async fn bond_gateway(args: Args, client: SigningClient) {
+    let denom = client.current_chain_details().mix_denom.base.as_str();
+
+    info!("Starting gateway bonding!");
+
+    // if we're trying to bond less than 1 token
+    if args.amount < 1_000_000 && !args.force {
+        warn!("You're trying to bond only {}{} which is less than 1 full token. Are you sure that's what you want? If so, run with `--force` or `-f` flag", args.amount, denom);
+        return;
+    }
+
+    let gateway = mixnet_contract_common::Gateway {
+        host: args.host,
+        mix_port: args.mix_port.unwrap_or(DEFAULT_MIX_LISTENING_PORT),
+        clients_port: args.clients_port.unwrap_or(DEFAULT_CLIENT_LISTENING_PORT),
+        location: args
+            .location
+            .unwrap_or_else(|| "secret gateway location".to_owned()),
+        sphinx_key: args.sphinx_key,
+        identity_key: args.identity_key,
+        version: args.version,
+    };
+
+    let coin = Coin::new(args.amount, denom);
+
+    let res = client
+        .bond_gateway(gateway, args.signature, coin.into(), None)
+        .await
+        .expect("failed to bond gateway!");
+
+    info!("Bonding result: {:?}", res)
+}

common/commands/src/validator/mixnet/operators/gateway/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 bond_gateway;
+pub mod unbond_gateway;
+pub mod vesting_bond_gateway;
+pub mod vesting_unbond_gateway;
+
+#[derive(Debug, Args)]
+#[clap(args_conflicts_with_subcommands = true, subcommand_required = true)]
+pub struct MixnetOperatorsGateway {
+    #[clap(subcommand)]
+    pub command: MixnetOperatorsGatewayCommands,
+}
+
+#[derive(Debug, Subcommand)]
+pub enum MixnetOperatorsGatewayCommands {
+    /// Bond to a gateway
+    Bond(bond_gateway::Args),
+    /// Unbound from a gateway
+    Unbound(unbond_gateway::Args),
+    /// Bond to a gateway with locked tokens
+    VestingBond(vesting_bond_gateway::Args),
+    /// Unbound from a gateway (when originally using locked tokens)
+    VestingUnbound(vesting_unbond_gateway::Args),
+}

common/commands/src/validator/mixnet/operators/gateway/unbond_gateway.rs

@@ -0,0 +1,20 @@
+// 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 {}
+
+pub async fn unbond_gateway(client: SigningClient) {
+    info!("Starting gateway unbonding!");
+
+    let res = client
+        .unbond_gateway(None)
+        .await
+        .expect("failed to unbond gateway!");
+
+    info!("Unbonding result: {:?}", res)
+}

common/commands/src/validator/mixnet/operators/gateway/vesting_bond_gateway.rs

@@ -0,0 +1,76 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::context::SigningClient;
+use clap::Parser;
+use log::{info, warn};
+use mixnet_contract_common::{Coin, Gateway};
+use network_defaults::{DEFAULT_CLIENT_LISTENING_PORT, DEFAULT_MIX_LISTENING_PORT};
+use validator_client::nymd::VestingSigningClient;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(long)]
+    pub host: String,
+
+    #[clap(long)]
+    pub signature: String,
+
+    #[clap(long)]
+    pub mix_port: Option<u16>,
+
+    #[clap(long)]
+    pub clients_port: Option<u16>,
+
+    #[clap(long)]
+    pub location: Option<String>,
+
+    #[clap(long)]
+    pub sphinx_key: String,
+
+    #[clap(long)]
+    pub identity_key: String,
+
+    #[clap(long)]
+    pub version: String,
+
+    #[clap(
+        long,
+        help = "bonding amount in current DENOMINATION (so it would be 'unym', rather than 'nym')"
+    )]
+    pub amount: u128,
+
+    #[clap(short, long)]
+    pub force: bool,
+}
+
+pub async fn vesting_bond_gateway(client: SigningClient, args: Args, denom: &str) {
+    info!("Starting vesting gateway bonding!");
+
+    // if we're trying to bond less than 1 token
+    if args.amount < 1_000_000 && !args.force {
+        warn!("You're trying to bond only {}{} which is less than 1 full token. Are you sure that's what you want? If so, run with `--force` or `-f` flag", args.amount, denom);
+        return;
+    }
+
+    let gateway = Gateway {
+        host: args.host,
+        mix_port: args.mix_port.unwrap_or(DEFAULT_MIX_LISTENING_PORT),
+        clients_port: args.clients_port.unwrap_or(DEFAULT_CLIENT_LISTENING_PORT),
+        location: args
+            .location
+            .unwrap_or_else(|| "secret gateway location".to_owned()),
+        sphinx_key: args.sphinx_key,
+        identity_key: args.identity_key,
+        version: args.version,
+    };
+
+    let coin = Coin::new(args.amount, denom);
+
+    let res = client
+        .vesting_bond_gateway(gateway, &*args.signature, coin.into(), None)
+        .await
+        .expect("failed to bond gateway!");
+
+    info!("Vesting bonding gateway result: {:?}", res)
+}

common/commands/src/validator/mixnet/operators/gateway/vesting_unbond_gateway.rs

@@ -0,0 +1,20 @@
+// 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 {}
+
+pub async fn vesting_unbond_gateway(client: SigningClient) {
+    info!("Starting vesting gateway unbonding!");
+
+    let res = client
+        .unbond_gateway(None)
+        .await
+        .expect("failed to unbond vesting gateway!");
+
+    info!("Unbonding vesting result: {:?}", res)
+}

common/commands/src/validator/mixnet/operators/mixnode/bond_mixnode.rs

@@ -0,0 +1,85 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::Parser;
+use log::{info, warn};
+
+use mixnet_contract_common::Coin;
+use network_defaults::{
+    DEFAULT_HTTP_API_LISTENING_PORT, DEFAULT_MIX_LISTENING_PORT, DEFAULT_VERLOC_LISTENING_PORT,
+};
+
+use crate::context::SigningClient;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(long)]
+    pub host: String,
+
+    #[clap(long)]
+    pub signature: String,
+
+    #[clap(long)]
+    pub mix_port: Option<u16>,
+
+    #[clap(long)]
+    pub verloc_port: Option<u16>,
+
+    #[clap(long)]
+    pub http_api_port: Option<u16>,
+
+    #[clap(long)]
+    pub sphinx_key: String,
+
+    #[clap(long)]
+    pub identity_key: String,
+
+    #[clap(long)]
+    pub version: String,
+
+    #[clap(long)]
+    pub profit_margin_percent: Option<u8>,
+
+    #[clap(
+        long,
+        help = "bonding amount in current DENOMINATION (so it would be 'unym', rather than 'nym')"
+    )]
+    pub amount: u128,
+
+    #[clap(short, long)]
+    pub force: bool,
+}
+
+pub async fn bond_mixnode(args: Args, client: SigningClient) {
+    let denom = client.current_chain_details().mix_denom.base.as_str();
+
+    info!("Starting mixnode bonding!");
+
+    // if we're trying to bond less than 1 token
+    if args.amount < 1_000_000 && !args.force {
+        warn!("You're trying to bond only {}{} which is less than 1 full token. Are you sure that's what you want? If so, run with `--force` or `-f` flag", args.amount, denom);
+        return;
+    }
+
+    let mixnode = mixnet_contract_common::MixNode {
+        host: args.host,
+        mix_port: args.mix_port.unwrap_or(DEFAULT_MIX_LISTENING_PORT),
+        verloc_port: args.verloc_port.unwrap_or(DEFAULT_VERLOC_LISTENING_PORT),
+        http_api_port: args
+            .http_api_port
+            .unwrap_or(DEFAULT_HTTP_API_LISTENING_PORT),
+        sphinx_key: args.sphinx_key,
+        identity_key: args.identity_key,
+        version: args.version,
+        profit_margin_percent: args.profit_margin_percent.unwrap_or(10),
+    };
+
+    let coin = Coin::new(args.amount, denom);
+
+    let res = client
+        .bond_mixnode(mixnode, args.signature, coin.into(), None)
+        .await
+        .expect("failed to bond mixnode!");
+
+    info!("Bonding result: {:?}", res)
+}

common/commands/src/validator/mixnet/operators/mixnode/keys/decode_mixnode_key.rs

@@ -0,0 +1,17 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::Parser;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(short, long)]
+    pub key: String,
+}
+
+pub fn decode_mixnode_key(args: Args) {
+    let b64_decoded = base64::decode(args.key).expect("failed to decode base64 string");
+    let b58_encoded = bs58::encode(&b64_decoded).into_string();
+
+    println!("{}", b58_encoded)
+}

common/commands/src/validator/mixnet/operators/mixnode/keys/mod.rs

@@ -0,0 +1,19 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::{Args, Subcommand};
+
+pub mod decode_mixnode_key;
+
+#[derive(Debug, Args)]
+#[clap(args_conflicts_with_subcommands = true, subcommand_required = true)]
+pub struct MixnetOperatorsMixnodeKeys {
+    #[clap(subcommand)]
+    pub command: MixnetOperatorsMixnodeKeysCommands,
+}
+
+#[derive(Debug, Subcommand)]
+pub enum MixnetOperatorsMixnodeKeysCommands {
+    /// Decode a mixnode key
+    DecodeMixnodeKey(decode_mixnode_key::Args),
+}

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

@@ -0,0 +1,37 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::{Args, Subcommand};
+
+pub mod bond_mixnode;
+pub mod keys;
+pub mod rewards;
+pub mod settings;
+pub mod unbond_mixnode;
+pub mod vesting_bond_mixnode;
+pub mod vesting_unbond_mixnode;
+
+#[derive(Debug, Args)]
+#[clap(args_conflicts_with_subcommands = true, subcommand_required = true)]
+pub struct MixnetOperatorsMixnode {
+    #[clap(subcommand)]
+    pub command: MixnetOperatorsMixnodeCommands,
+}
+
+#[derive(Debug, Subcommand)]
+pub enum MixnetOperatorsMixnodeCommands {
+    /// Operations for mixnode keys
+    Keys(keys::MixnetOperatorsMixnodeKeys),
+    /// Manage your mixnode operator rewards
+    Rewards(rewards::MixnetOperatorsMixnodeRewards),
+    /// Manage your mixnode settings stored in the directory
+    Settings(settings::MixnetOperatorsMixnodeSettings),
+    /// Bond to a mixnode
+    Bond(bond_mixnode::Args),
+    /// Unbound from a mixnode
+    Unbound(unbond_mixnode::Args),
+    /// Bond to a mixnode with locked tokens
+    BondVesting(vesting_bond_mixnode::Args),
+    /// Unbound from a mixnode (when originally using locked tokens)
+    UnboundVesting(vesting_unbond_mixnode::Args),
+}

common/commands/src/validator/mixnet/operators/mixnode/rewards/claim_operator_reward.rs

@@ -0,0 +1,20 @@
+// 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 {}
+
+pub async fn claim_operator_reward(_args: Args, client: SigningClient) {
+    info!("Claim operator reward");
+
+    let res = client
+        .execute_claim_operator_reward(None)
+        .await
+        .expect("failed to claim operator reward");
+
+    info!("Claiming operator reward: {:?}", res)
+}

common/commands/src/validator/mixnet/operators/mixnode/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_operator_reward;
+pub mod vesting_claim_operator_reward;
+
+#[derive(Debug, Args)]
+#[clap(args_conflicts_with_subcommands = true, subcommand_required = true)]
+pub struct MixnetOperatorsMixnodeRewards {
+    #[clap(subcommand)]
+    pub command: MixnetOperatorsMixnodeRewardsCommands,
+}
+
+#[derive(Debug, Subcommand)]
+pub enum MixnetOperatorsMixnodeRewardsCommands {
+    /// Claim rewards
+    Claim(claim_operator_reward::Args),
+    /// Claim rewards for a mixnode bonded with locked tokens
+    VestingClaim(vesting_claim_operator_reward::Args),
+}

common/commands/src/validator/mixnet/operators/mixnode/rewards/vesting_claim_operator_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 gas: Option<u64>,
+}
+
+pub async fn vesting_claim_operator_reward(client: SigningClient) {
+    info!("Claim vesting operator reward");
+
+    let res = client
+        .execute_vesting_claim_operator_reward(None)
+        .await
+        .expect("failed to claim vesting operator reward");
+
+    info!("Claiming vesting operator reward: {:?}", res)
+}

common/commands/src/validator/mixnet/operators/mixnode/settings/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 update_profit_percent;
+pub mod vesting_update_profit_percent;
+
+#[derive(Debug, Args)]
+#[clap(args_conflicts_with_subcommands = true, subcommand_required = true)]
+pub struct MixnetOperatorsMixnodeSettings {
+    #[clap(subcommand)]
+    pub command: MixnetOperatorsMixnodeSettingsCommands,
+}
+
+#[derive(Debug, Subcommand)]
+pub enum MixnetOperatorsMixnodeSettingsCommands {
+    /// Update profit percentage
+    UpdateProfitPercentage(update_profit_percent::Args),
+    /// Update profit percentage for a mixnode bonded with locked tokens
+    VestingUpdateProfitPercentage(vesting_update_profit_percent::Args),
+}

common/commands/src/validator/mixnet/operators/mixnode/settings/update_profit_percent.rs

@@ -0,0 +1,24 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::context::SigningClient;
+use clap::Parser;
+use log::info;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(long)]
+    pub profit_percent: u8,
+}
+
+pub async fn update_profit_percent(args: Args, client: SigningClient) {
+    info!("Update mix node profit percent - get those rewards!");
+
+    //profit percent between 1-100
+    let res = client
+        .update_mixnode_config(args.profit_percent, None)
+        .await
+        .expect("updating mix-node profit percent");
+
+    info!("profit percentage updated: {:?}", res)
+}

common/commands/src/validator/mixnet/operators/mixnode/settings/vesting_update_profit_percent.rs

@@ -0,0 +1,28 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::context::SigningClient;
+use clap::Parser;
+use log::info;
+use validator_client::nymd::VestingSigningClient;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(long)]
+    pub profit_percent: u8,
+
+    #[clap(long)]
+    pub gas: Option<u64>,
+}
+
+pub async fn vesting_update_profit_percent(client: SigningClient, args: Args) {
+    info!("Update vesting mix node profit percent - get those rewards!");
+
+    //profit percent between 1-100
+    let res = client
+        .vesting_update_mixnode_config(args.profit_percent, None)
+        .await
+        .expect("updating vesting mix-node profit percent");
+
+    info!("profit percentage updated: {:?}", res)
+}

common/commands/src/validator/mixnet/operators/mixnode/unbond_mixnode.rs

@@ -0,0 +1,21 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::Parser;
+use log::info;
+
+use crate::context::SigningClient;
+
+#[derive(Debug, Parser)]
+pub struct Args {}
+
+pub async fn unbond_mixnode(_args: Args, client: SigningClient) {
+    info!("Starting mixnode unbonding!");
+
+    let res = client
+        .unbond_mixnode(None)
+        .await
+        .expect("failed to unbond mixnode!");
+
+    info!("Unbonding result: {:?}", res)
+}

common/commands/src/validator/mixnet/operators/mixnode/vesting_bond_mixnode.rs

@@ -0,0 +1,86 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::context::SigningClient;
+use clap::Parser;
+use log::{info, warn};
+use mixnet_contract_common::Coin;
+use mixnet_contract_common::MixNode;
+use network_defaults::{
+    DEFAULT_HTTP_API_LISTENING_PORT, DEFAULT_MIX_LISTENING_PORT, DEFAULT_VERLOC_LISTENING_PORT,
+};
+use validator_client::nymd::VestingSigningClient;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(long)]
+    pub host: String,
+
+    #[clap(long)]
+    pub signature: String,
+
+    #[clap(long)]
+    pub mix_port: Option<u16>,
+
+    #[clap(long)]
+    pub verloc_port: Option<u16>,
+
+    #[clap(long)]
+    pub http_api_port: Option<u16>,
+
+    #[clap(long)]
+    pub sphinx_key: String,
+
+    #[clap(long)]
+    pub identity_key: String,
+
+    #[clap(long)]
+    pub version: String,
+
+    #[clap(long)]
+    pub profit_margin_percent: Option<u8>,
+
+    #[clap(
+        long,
+        help = "bonding amount in current DENOMINATION (so it would be 'unym', rather than 'nym')"
+    )]
+    pub amount: u128,
+
+    #[clap(long)]
+    pub gas: Option<u64>,
+
+    #[clap(short, long)]
+    pub force: bool,
+}
+
+pub async fn vesting_bond_mixnode(client: SigningClient, args: Args, denom: &str) {
+    info!("Starting vesting mixnode bonding!");
+
+    // if we're trying to bond less than 1 token
+    if args.amount < 1_000_000 && !args.force {
+        warn!("You're trying to bond only {}{} which is less than 1 full token. Are you sure that's what you want? If so, run with `--force` or `-f` flag", args.amount, denom);
+        return;
+    }
+
+    let mixnode = MixNode {
+        host: args.host,
+        mix_port: args.mix_port.unwrap_or(DEFAULT_MIX_LISTENING_PORT),
+        verloc_port: args.verloc_port.unwrap_or(DEFAULT_VERLOC_LISTENING_PORT),
+        http_api_port: args
+            .http_api_port
+            .unwrap_or(DEFAULT_HTTP_API_LISTENING_PORT),
+        sphinx_key: args.sphinx_key,
+        identity_key: args.identity_key,
+        version: args.version,
+        profit_margin_percent: args.profit_margin_percent.unwrap_or(10),
+    };
+
+    let coin = Coin::new(args.amount, denom);
+
+    let res = client
+        .vesting_bond_mixnode(mixnode, &*args.signature, coin.into(), None)
+        .await
+        .expect("failed to bond vesting mixnode!");
+
+    info!("Bonding vesting result: {:?}", res)
+}

common/commands/src/validator/mixnet/operators/mixnode/vesting_unbond_mixnode.rs

@@ -0,0 +1,24 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::context::SigningClient;
+use clap::Parser;
+use log::info;
+use validator_client::nymd::VestingSigningClient;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(long)]
+    pub gas: Option<u64>,
+}
+
+pub async fn vesting_unbond_mixnode(client: SigningClient) {
+    info!("Starting vesting mixnode unbonding!");
+
+    let res = client
+        .vesting_unbond_mixnode(None)
+        .await
+        .expect("failed to unbond vesting mixnode!");
+
+    info!("Unbonding vesting result: {:?}", res)
+}

common/commands/src/validator/mixnet/operators/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 gateway;
+pub mod mixnode;
+
+#[derive(Debug, Args)]
+#[clap(args_conflicts_with_subcommands = true, subcommand_required = true)]
+pub struct MixnetOperators {
+    #[clap(subcommand)]
+    pub command: MixnetOperatorsCommands,
+}
+
+#[derive(Debug, Subcommand)]
+pub enum MixnetOperatorsCommands {
+    /// Manage your mixnode
+    Mixnode(mixnode::MixnetOperatorsMixnode),
+    /// Manage your gateway
+    Gateway(gateway::MixnetOperatorsGateway),
+}

common/commands/src/validator/mixnet/query/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 query_all_gateways;
+pub mod query_all_mixnodes;
+
+#[derive(Debug, Args)]
+#[clap(args_conflicts_with_subcommands = true, subcommand_required = true)]
+pub struct MixnetQuery {
+    #[clap(subcommand)]
+    pub command: MixnetQueryCommands,
+}
+
+#[derive(Debug, Subcommand)]
+pub enum MixnetQueryCommands {
+    /// Query mixnodes
+    Mixnodes(query_all_mixnodes::Args),
+    /// Query gateways
+    Gateways(query_all_gateways::Args),
+}

common/commands/src/validator/mixnet/query/query_all_gateways.rs

@@ -0,0 +1,52 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::Parser;
+use comfy_table::Table;
+
+use crate::context::QueryClientWithValidatorAPI;
+use crate::utils::{pretty_cosmwasm_coin, show_error};
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(value_parser)]
+    #[clap(help = "Optionally, the gateway to display")]
+    pub identity_key: Option<String>,
+}
+
+pub async fn query(args: Args, client: &QueryClientWithValidatorAPI) {
+    match client.validator_api.get_gateways().await {
+        Ok(res) => match args.identity_key {
+            Some(identity_key) => {
+                let node = res.iter().find(|node| {
+                    node.gateway
+                        .identity_key
+                        .to_string()
+                        .eq_ignore_ascii_case(&identity_key)
+                });
+                println!(
+                    "{}",
+                    ::serde_json::to_string_pretty(&node).expect("json formatting error")
+                );
+            }
+            None => {
+                let mut table = Table::new();
+
+                table.set_header(vec!["Identity Key", "Owner", "Host", "Bond", "Version"]);
+                for node in res {
+                    table.add_row(vec![
+                        node.gateway.identity_key.to_string(),
+                        node.owner.to_string(),
+                        node.gateway.host.to_string(),
+                        pretty_cosmwasm_coin(&node.pledge_amount),
+                        node.gateway.version,
+                    ]);
+                }
+
+                println!("The gateways in the directory are:");
+                println!("{table}");
+            }
+        },
+        Err(e) => show_error(e),
+    }
+}

common/commands/src/validator/mixnet/query/query_all_mixnodes.rs

@@ -0,0 +1,60 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::Parser;
+use comfy_table::Table;
+
+use crate::context::QueryClientWithValidatorAPI;
+use crate::utils::{pretty_cosmwasm_coin, show_error};
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(value_parser)]
+    #[clap(help = "Optionally, the mixnode to display")]
+    pub identity_key: Option<String>,
+}
+
+pub async fn query(args: Args, client: &QueryClientWithValidatorAPI) {
+    match client.validator_api.get_mixnodes().await {
+        Ok(res) => match args.identity_key {
+            Some(identity_key) => {
+                let node = res.iter().find(|node| {
+                    node.mix_node
+                        .identity_key
+                        .to_string()
+                        .eq_ignore_ascii_case(&identity_key)
+                });
+                println!(
+                    "{}",
+                    ::serde_json::to_string_pretty(&node).expect("json formatting error")
+                );
+            }
+            None => {
+                let mut table = Table::new();
+
+                table.set_header(vec![
+                    "Identity Key",
+                    "Owner",
+                    "Host",
+                    "Bond",
+                    "Total Delegations",
+                    "Version",
+                ]);
+                for node in res {
+                    table.add_row(vec![
+                        node.mix_node.identity_key.to_string(),
+                        node.owner.to_string(),
+                        node.mix_node.host.to_string(),
+                        pretty_cosmwasm_coin(&node.pledge_amount),
+                        pretty_cosmwasm_coin(&node.total_delegation()),
+                        node.mix_node.version,
+                    ]);
+                }
+
+                println!("The mixnodes in the directory are:");
+                println!("{table}");
+            }
+        },
+        Err(e) => show_error(e),
+    }
+}

common/commands/src/validator/mod.rs

@@ -0,0 +1,10 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+pub mod account;
+pub mod block;
+pub mod cosmwasm;
+pub mod mixnet;
+pub mod signature;
+pub mod transactions;
+pub mod vesting;

common/commands/src/validator/signature/errors.rs

@@ -0,0 +1,13 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum Errors {
+    #[error("signature error - {0}")]
+    SignatureError(#[from] k256::ecdsa::signature::Error),
+
+    #[error("{0}")]
+    CosmrsError(#[from] cosmrs::ErrorReport),
+}

common/commands/src/validator/signature/helpers.rs

@@ -0,0 +1,90 @@
+use std::str::FromStr;
+
+use cosmrs::crypto::secp256k1::{Signature, VerifyingKey};
+use cosmrs::crypto::PublicKey;
+use k256::ecdsa::signature::Verifier;
+
+use crate::validator::signature::errors::Errors;
+
+pub fn secp256k1_verify_with_public_key(
+    public_key_as_bytes: &[u8],
+    signature_as_hex: String,
+    message: String,
+) -> Result<(), k256::ecdsa::signature::Error> {
+    let verifying_key = VerifyingKey::from_sec1_bytes(public_key_as_bytes)?;
+    let signature = Signature::from_str(&signature_as_hex)?;
+    let message_as_bytes = message.into_bytes();
+    verifying_key.verify(&message_as_bytes, &signature)
+}
+
+pub fn secp256k1_verify_with_public_key_json(
+    public_key_as_json: String,
+    signature_as_hex: String,
+    message: String,
+) -> Result<(), Errors> {
+    let public_key = PublicKey::from_json(&public_key_as_json)?;
+    let verifying_key = VerifyingKey::from_sec1_bytes(&public_key.to_bytes())?;
+    let signature = Signature::from_str(&signature_as_hex)?;
+    let message_as_bytes = message.into_bytes();
+    Ok(verifying_key.verify(&message_as_bytes, &signature)?)
+}
+
+#[cfg(test)]
+mod test_secp256k1 {
+    use crate::validator::signature::helpers::{
+        secp256k1_verify_with_public_key, secp256k1_verify_with_public_key_json,
+    };
+    use cosmrs::crypto::PublicKey;
+
+    #[test]
+    fn test_verify_with_json_public_key_with_valid_signature() {
+        let json_public_key = r#"{"@type":"/cosmos.crypto.secp256k1.PubKey","key":"A4FdhUMasPmNhRZjtpKlmjNbq7EEUgPxfdI+E3vSajvc"}"#;
+        let signature_as_hex = "E3AA5AC0DA1B7DEBB7808000F719D8ACB9A0BE10AFA2756A788516268EB246A1257EC1097C5E364EF916145B01641DEDFE955994CB340BDAFA99A65BCA3F6F28".to_string();
+        let message = "test 1234".to_string();
+
+        let public_key = PublicKey::from_json(json_public_key).unwrap();
+        let public_key_bytes = public_key.to_bytes();
+
+        let result = secp256k1_verify_with_public_key(&public_key_bytes, signature_as_hex, message);
+
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn test_verify_with_json_public_key_with_invalid_signature() {
+        let json_public_key = r#"{"@type":"/cosmos.crypto.secp256k1.PubKey","key":"A4FdhUMasPmNhRZjtpKlmjNbq7EEUgPxfdI+E3vSajvc"}"#;
+        let signature_as_hex = "E3AA5AC0DA1B7DEBB7808000F719D8ACB9A0BE10AFA2756A788516268EB246A1257EC1097C5E364EF916145B01641DEDFE955994CB340BDAFA99A65BCA3F6F28".to_string();
+        let message = "abcdef".to_string();
+
+        let public_key = PublicKey::from_json(json_public_key).unwrap();
+        let public_key_bytes = public_key.to_bytes();
+
+        let result = secp256k1_verify_with_public_key(&public_key_bytes, signature_as_hex, message);
+
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_valid_json_public_key_succeeds() {
+        let json_public_key = r#"{"@type":"/cosmos.crypto.secp256k1.PubKey","key":"A4FdhUMasPmNhRZjtpKlmjNbq7EEUgPxfdI+E3vSajvc"}"#.to_string();
+        let signature_as_hex = "E3AA5AC0DA1B7DEBB7808000F719D8ACB9A0BE10AFA2756A788516268EB246A1257EC1097C5E364EF916145B01641DEDFE955994CB340BDAFA99A65BCA3F6F28".to_string();
+        let message = "test 1234".to_string();
+
+        let result =
+            secp256k1_verify_with_public_key_json(json_public_key, signature_as_hex, message);
+
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn test_json_public_key_fails_with_error() {
+        let bad_json_public_key = r#"This is not JSON ☠️"#.to_string();
+        let signature_as_hex = "E3AA5AC0DA1B7DEBB7808000F719D8ACB9A0BE10AFA2756A788516268EB246A1257EC1097C5E364EF916145B01641DEDFE955994CB340BDAFA99A65BCA3F6F28".to_string();
+        let message = "abcdef".to_string();
+
+        let result =
+            secp256k1_verify_with_public_key_json(bad_json_public_key, signature_as_hex, message);
+
+        assert!(result.is_err());
+    }
+}

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

@@ -0,0 +1,24 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::{Args, Subcommand};
+
+pub mod errors;
+pub mod helpers;
+pub mod sign;
+pub mod verify;
+
+#[derive(Debug, Args)]
+#[clap(args_conflicts_with_subcommands = true, subcommand_required = true)]
+pub struct Signature {
+    #[clap(subcommand)]
+    pub command: Option<SignatureCommands>,
+}
+
+#[derive(Debug, Subcommand)]
+pub enum SignatureCommands {
+    /// Sign a message
+    Sign(crate::validator::signature::sign::Args),
+    /// Verify a message
+    Verify(crate::validator::signature::verify::Args),
+}

common/commands/src/validator/signature/sign.rs

@@ -0,0 +1,68 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::utils::show_error;
+use clap::Parser;
+use cosmrs::crypto::PublicKey;
+use log::error;
+use serde::Serialize;
+use serde_json::json;
+use validator_client::nymd::wallet::DirectSecp256k1HdWallet;
+
+#[derive(Debug, Serialize)]
+pub struct SignatureOutputJson {
+    pub account_id: String,
+    pub public_key: PublicKey,
+    pub signature: String,
+}
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(value_parser)]
+    #[clap(help = "The message to sign")]
+    pub message: String,
+}
+
+pub fn sign(args: Args, prefix: &str, mnemonic: Option<bip39::Mnemonic>) {
+    if args.message.trim().is_empty() {
+        error!("Message is empty or contains only whitespace");
+        return;
+    }
+
+    if mnemonic.is_none() {
+        error!(
+            "Please provide the mnemonic as an argument or using the MNEMONIC environment variable"
+        );
+        return;
+    }
+
+    match DirectSecp256k1HdWallet::from_mnemonic(prefix, mnemonic.expect("mnemonic not set")) {
+        Ok(wallet) => match wallet.try_derive_accounts() {
+            Ok(accounts) => match accounts.first() {
+                Some(account) => {
+                    let msg = args.message.into_bytes();
+                    match wallet.sign_raw_with_account(account, &msg) {
+                        Ok(signature) => {
+                            let output = SignatureOutputJson {
+                                account_id: account.address().to_string(),
+                                public_key: account.public_key(),
+                                signature: signature.to_string(),
+                            };
+                            println!("{}", json!(output));
+                        }
+                        Err(e) => {
+                            error!("Failed to sign message. {}", e);
+                        }
+                    }
+                }
+                None => {
+                    error!("Could not derive an account key from the mnemonic",)
+                }
+            },
+            Err(e) => {
+                error!("Failed to derive accounts. {}", e);
+            }
+        },
+        Err(e) => show_error(e),
+    }
+}

common/commands/src/validator/signature/verify.rs

@@ -0,0 +1,89 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use std::str::FromStr;
+
+use clap::Parser;
+use cosmrs::crypto::PublicKey;
+use log::{error, info};
+use serde_json::json;
+
+use validator_client::nymd::AccountId;
+
+use crate::context::QueryClient;
+use crate::validator::signature::helpers::secp256k1_verify_with_public_key;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(value_parser)]
+    #[clap(
+        help = "The public key of the account, or the account id to query for a public key (NOTE: the account must have signed a message stored on the chain for the public key record to exist)"
+    )]
+    pub public_key_or_address: String,
+
+    #[clap(value_parser)]
+    #[clap(help = "The signature to verify as hex")]
+    pub signature_as_hex: String,
+
+    #[clap(value_parser)]
+    #[clap(help = "The message to verify as a string")]
+    pub message: String,
+}
+
+pub async fn verify(args: Args, client: &QueryClient) {
+    if args.public_key_or_address.trim().is_empty() {
+        error!("Please ensure the public key or address is not empty or whitespace");
+        return;
+    }
+
+    let public_key = match AccountId::from_str(&args.public_key_or_address) {
+        Ok(address) => {
+            info!("Found account address instead of public key, so looking up public key for {} from chain", address);
+            match client.get_account_public_key(&address).await.ok() {
+                Some(public_key) => {
+                    if let Some(k) = public_key {
+                        info!("Found public key {}", json!(k));
+                    }
+                    public_key
+                }
+                None => {
+                    error!(
+                        "Address {} does not have a public key recorded on the chain. This is probably because the account has never signed a transaction.",
+                        address
+                    );
+                    None
+                }
+            }
+        }
+        Err(_) => match PublicKey::from_json(&args.public_key_or_address) {
+            Ok(parsed) => Some(parsed),
+            Err(e) => {
+                error!("Public key should be JSON. Unable to parse: {}", e);
+                None
+            }
+        },
+    };
+
+    match public_key {
+        Some(public_key) => {
+            if public_key.type_url() != PublicKey::SECP256K1_TYPE_URL {
+                error!("Sorry, we only support secp256k1 public keys at the moment");
+                return;
+            }
+
+            match secp256k1_verify_with_public_key(
+                &public_key.to_bytes(),
+                args.signature_as_hex,
+                args.message,
+            ) {
+                Ok(()) => println!("SUCCESS ✅ signature verified"),
+                Err(e) => {
+                    error!("FAILURE ❌ Signature verification failed: {}", e);
+                }
+            }
+        }
+        None => {
+            error!("Unable to verify, as unable to get the public key");
+        }
+    }
+}

common/commands/src/validator/transactions/get_transaction.rs

@@ -0,0 +1,28 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::Parser;
+use std::str::FromStr;
+
+use crate::context::QueryClient;
+use crate::utils::show_error;
+use cosmrs::tx::Hash;
+use serde_json::json;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(value_parser)]
+    #[clap(help = "The transaction hash")]
+    pub tx_hash: String,
+}
+
+pub async fn get(args: Args, client: &QueryClient) {
+    let hash = Hash::from_str(&args.tx_hash).expect("could not parse transaction hash");
+
+    match client.get_tx(hash).await {
+        Ok(res) => {
+            println!("{}", json!(res))
+        }
+        Err(e) => show_error(e),
+    }
+}

common/commands/src/validator/transactions/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 get_transaction;
+pub mod query_transactions;
+
+#[derive(Debug, Args)]
+#[clap(args_conflicts_with_subcommands = true, subcommand_required = true)]
+pub struct Transactions {
+    #[clap(subcommand)]
+    pub command: Option<TransactionsCommands>,
+}
+
+#[derive(Debug, Subcommand)]
+pub enum TransactionsCommands {
+    /// Get a transaction by hash or block height
+    Get(crate::validator::transactions::get_transaction::Args),
+    /// Query for transactions
+    Query(crate::validator::transactions::query_transactions::Args),
+}

common/commands/src/validator/transactions/query_transactions.rs

@@ -0,0 +1,30 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use std::str::FromStr;
+
+use clap::Parser;
+use cosmrs::rpc::query::Query;
+use serde_json::json;
+
+use crate::context::QueryClient;
+use crate::utils::show_error;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(value_parser)]
+    #[clap(help = "The query to execute")]
+    pub query: String,
+}
+
+pub async fn query(args: Args, client: &QueryClient) {
+    match Query::from_str(&args.query) {
+        Ok(query) => match client.search_tx(query).await {
+            Ok(res) => {
+                println!("{}", json!(res))
+            }
+            Err(e) => show_error(e),
+        },
+        Err(e) => show_error(e),
+    }
+}

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

@@ -0,0 +1,55 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::Parser;
+use cosmrs::AccountId;
+use log::info;
+
+use validator_client::nymd::{Coin, VestingQueryClient};
+
+use crate::context::SigningClient;
+use crate::utils::show_error;
+use crate::utils::{pretty_coin, pretty_cosmwasm_coin};
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(value_parser)]
+    #[clap(help = "Optionally, the account address to get the balance for")]
+    pub address: Option<AccountId>,
+}
+
+pub async fn balance(args: Args, client: SigningClient) {
+    let account_id = args.address.unwrap_or_else(|| client.address().clone());
+    let vesting_address = account_id.to_string();
+    let denom = client.current_chain_details().mix_denom.base.as_str();
+
+    info!(
+        "Getting vesting schedule information for {}...",
+        &vesting_address
+    );
+
+    let original_vesting = client.original_vesting(&vesting_address).await;
+
+    match original_vesting {
+        Ok(res) => {
+            let spendable_coins = client
+                .spendable_coins(&vesting_address, None)
+                .await
+                .unwrap_or_else(|_| Coin::new(0u128, denom));
+            let liquid_account_balance = client
+                .get_balance(&account_id, denom.to_string())
+                .await
+                .unwrap_or(None)
+                .unwrap_or_else(|| Coin::new(0u128, denom));
+
+            println!(
+                "Account {} has\n{} vested with\n{} available to be withdrawn to the main account (balance {})",
+                &account_id,
+                pretty_cosmwasm_coin(&res.amount),
+                pretty_coin(&spendable_coins),
+                pretty_coin(&liquid_account_balance),
+            );
+        }
+        Err(e) => show_error(e),
+    }
+}

common/commands/src/validator/vesting/create_vesting_schedule.rs

@@ -0,0 +1,83 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use std::str::FromStr;
+
+use clap::Parser;
+use log::info;
+
+use mixnet_contract_common::Coin;
+use network_defaults::NymNetworkDetails;
+use validator_client::nymd::AccountId;
+use validator_client::nymd::VestingSigningClient;
+use validator_client::nymd::{CosmosCoin, Denom};
+use vesting_contract_common::messages::VestingSpecification;
+
+use crate::context::SigningClient;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(long)]
+    pub periods_seconds: Option<u64>,
+
+    #[clap(long)]
+    pub number_of_periods: Option<u64>,
+
+    #[clap(long)]
+    pub start_time: Option<u64>,
+
+    #[clap(long)]
+    pub address: String,
+
+    #[clap(long)]
+    pub amount: u64,
+
+    #[clap(long)]
+    pub staking_address: Option<String>,
+}
+
+pub async fn create(args: Args, client: SigningClient, network_details: &NymNetworkDetails) {
+    info!("Creating vesting schedule!");
+
+    let vesting = VestingSpecification::new(
+        args.start_time,
+        args.periods_seconds,
+        args.number_of_periods,
+    );
+
+    let denom = network_details.chain_details.mix_denom.base.to_string();
+
+    let coin = Coin::new(args.amount.into(), &denom);
+
+    let res = client
+        .create_periodic_vesting_account(
+            &*args.address,
+            args.staking_address,
+            Some(vesting),
+            coin.into(),
+            None,
+        )
+        .await
+        .expect("creating vesting schedule for the user!");
+
+    //send 1 coin
+    let coin_amount: u64 = 1_000_000;
+
+    let coin = CosmosCoin {
+        denom: Denom::from_str(&denom).unwrap(),
+        amount: coin_amount.into(),
+    };
+
+    let send_coin_response = client
+        .send(
+            &AccountId::from_str(&*args.address).unwrap(),
+            vec![coin.into()],
+            "payment made :)",
+            None,
+        )
+        .await
+        .unwrap();
+
+    info!("Vesting result: {:?}", res);
+    info!("Coin send result: {:?}", send_coin_response);
+}

common/commands/src/validator/vesting/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_vesting_schedule;
+pub mod query_vesting_schedule;
+pub mod withdraw_vested;
+
+#[derive(Debug, Args)]
+#[clap(args_conflicts_with_subcommands = true, subcommand_required = true)]
+pub struct VestingSchedule {
+    #[clap(subcommand)]
+    pub command: Option<VestingScheduleCommands>,
+}
+
+#[derive(Debug, Subcommand)]
+pub enum VestingScheduleCommands {
+    /// Creates a vesting schedule
+    Create(crate::validator::vesting::create_vesting_schedule::Args),
+    /// Query for vesting schedule
+    Query(crate::validator::vesting::query_vesting_schedule::Args),
+    /// Get the amount that has vested and is free for withdrawal, delegation or bonding
+    VestedBalance(crate::validator::vesting::balance::Args),
+    /// Withdraw vested tokens (note: the available amount excludes anything delegated or bonded before or after vesting)
+    WithdrawVested(crate::validator::vesting::withdraw_vested::Args),
+}

common/commands/src/validator/vesting/query_vesting_schedule.rs

@@ -0,0 +1,149 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::Parser;
+use cosmrs::AccountId;
+use cosmwasm_std::Coin as CosmWasmCoin;
+use log::info;
+
+use validator_client::nymd::{Coin, VestingQueryClient};
+
+use crate::context::SigningClient;
+use crate::utils::show_error;
+use crate::utils::{pretty_coin, pretty_cosmwasm_coin};
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(value_parser)]
+    #[clap(help = "Optionally, the account address to get the balance for")]
+    pub address: Option<AccountId>,
+}
+
+pub async fn query(args: Args, client: SigningClient) {
+    let account_id = args.address.unwrap_or_else(|| client.address().clone());
+    let vesting_address = account_id.to_string();
+    let denom = client.current_chain_details().mix_denom.base.as_str();
+
+    info!(
+        "Getting vesting schedule information for {}...",
+        &vesting_address
+    );
+
+    let liquid_account_balance = client
+        .get_balance(&account_id, denom.to_string())
+        .await
+        .unwrap_or(None)
+        .unwrap_or_else(|| Coin::new(0u128, denom));
+    let original_vesting = client.original_vesting(&vesting_address).await;
+    let start_time = client.vesting_start_time(&vesting_address).await;
+    let end_time = client.vesting_end_time(&vesting_address).await;
+    let vested_coins = client.vested_coins(&vesting_address, None).await;
+    let spendable_coins = client.spendable_coins(&vesting_address, None).await;
+    let locked_coins = client.locked_coins(&vesting_address, None).await;
+
+    // TODO: get better copy text for what these are
+    let vesting_coins = client.vesting_coins(&vesting_address, None).await;
+    let delegated_vesting = client.delegated_vesting(&vesting_address, None).await;
+    let delegated_free = client.delegated_free(&vesting_address, None).await;
+
+    original_vesting.as_ref().map_or_else(show_error, |res| {
+        println!(
+            "Amount:            {}   ({})",
+            pretty_cosmwasm_coin(&res.amount),
+            res.amount
+        );
+        println!("No of periods:     {}", res.number_of_periods);
+        println!(
+            "Duration each:     {}",
+            time::Duration::seconds(res.period_duration as i64)
+        );
+    });
+
+    start_time.as_ref().map_or_else(show_error, |res| {
+        println!(
+            "Start date:        {}",
+            time::OffsetDateTime::from_unix_timestamp(res.seconds() as i64)
+                .expect("unable to parse vesting start timestamp")
+                .date()
+        );
+    });
+
+    end_time.map_or_else(show_error, |res| {
+        println!(
+            "End date:          {}",
+            time::OffsetDateTime::from_unix_timestamp(res.seconds() as i64)
+                .expect("unable to parse vesting end timestamp")
+                .date()
+        );
+    });
+
+    vested_coins.map_or_else(show_error, |res| {
+        println!("Vested balance:    {}   ({})", pretty_coin(&res), res);
+    });
+
+    if let Ok(res) = original_vesting {
+        if let Ok(start) = start_time {
+            let amount_in_each_period = res.amount.amount.u128() / res.number_of_periods as u128;
+            let coin_in_each_period = CosmWasmCoin::new(amount_in_each_period, denom);
+            println!();
+            println!("Vesting schedule:");
+            for period in 1..(res.number_of_periods as u64 + 1) {
+                let date = time::OffsetDateTime::from_unix_timestamp(
+                    (start.seconds() + period * res.period_duration) as i64,
+                )
+                .expect("unable to parse vesting start timestamp")
+                .date();
+                let amount_in_vested =
+                    period as u128 * res.amount.amount.u128() / res.number_of_periods as u128;
+                let coin_in_vested = CosmWasmCoin::new(amount_in_vested, denom);
+                println!(
+                    "{}.  {}    {}  => {}",
+                    period,
+                    date,
+                    pretty_cosmwasm_coin(&coin_in_each_period),
+                    pretty_cosmwasm_coin(&coin_in_vested),
+                );
+            }
+        }
+    }
+
+    spendable_coins.map_or_else(show_error, |res| {
+        println!();
+        println!("This account has the following vested tokens available either to be withdrawn to the main account, or to be delegated:");
+        println!("Spendable coins:   {}   ({})", pretty_coin(&res), res);
+    });
+
+    locked_coins.map_or_else(show_error, |res| {
+        println!();
+        if res.amount > 0 {
+            println!("This account has delegated more than the current cap, so the following balance is unavailable for bonding or delegation:");
+            println!("Locked balance:    {}   ({})", pretty_coin(&res), res);
+        } else {
+            println!("This account is not capped and can use the spendable balance for bonding or delegations:");
+            println!("Locked balance:    {}   ({})", pretty_coin(&res), res);
+        }
+    });
+
+    println!();
+    println!("The following are shown for information (more help text will follow soon):");
+    vesting_coins.map_or_else(show_error, |res| {
+        println!("Vesting coins:     {}   ({})", pretty_coin(&res), res);
+    });
+    delegated_vesting.map_or_else(show_error, |res| {
+        println!("Delegated vesting: {}   ({})", pretty_coin(&res), res);
+    });
+    delegated_free.map_or_else(show_error, |res| {
+        println!("Delegation free:   {}   ({})", pretty_coin(&res), res);
+    });
+
+    println!();
+    println!(
+        "The main account {} also has a regular balance of:",
+        &account_id
+    );
+    println!(
+        "{}  ({})",
+        pretty_coin(&liquid_account_balance),
+        &liquid_account_balance
+    );
+}

common/commands/src/validator/vesting/withdraw_vested.rs

@@ -0,0 +1,112 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::Parser;
+use log::info;
+
+use validator_client::nymd::{Coin, VestingQueryClient, VestingSigningClient};
+
+use crate::context::SigningClient;
+use crate::utils::show_error;
+use crate::utils::{pretty_coin, pretty_cosmwasm_coin};
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(value_parser)]
+    #[clap(help = "Amount to transfer in micro denomination (e.g. unym or unyx)")]
+    pub amount: u128,
+}
+
+pub async fn execute(args: Args, client: SigningClient) {
+    let account_id = client.address();
+    let vesting_address = account_id.to_string();
+    let denom = client.current_chain_details().mix_denom.base.as_str();
+
+    info!(
+        "Getting vesting schedule information for {}...",
+        &vesting_address
+    );
+
+    let original_vesting = client.original_vesting(&vesting_address).await;
+
+    match original_vesting {
+        Ok(res) => {
+            let spendable_coins = client
+                .spendable_coins(&vesting_address, None)
+                .await
+                .unwrap_or_else(|_| Coin::new(0u128, denom));
+            let liquid_account_balance = client
+                .get_balance(account_id, denom.to_string())
+                .await
+                .unwrap_or(None)
+                .unwrap_or_else(|| Coin::new(0u128, denom));
+
+            println!(
+                "Account {} has\n{} vested with {} available to be withdrawn to the main account (balance {})",
+                &account_id,
+                pretty_cosmwasm_coin(&res.amount),
+                pretty_coin(&spendable_coins),
+                pretty_coin(&liquid_account_balance),
+            );
+            println!();
+
+            // execute withdraw
+
+            let amount = Coin {
+                amount: args.amount,
+                denom: denom.to_string(),
+            };
+
+            info!(
+                "Withdrawing {} ({}) from {}...",
+                pretty_coin(&amount),
+                &amount,
+                &account_id
+            );
+
+            match client.withdraw_vested_coins(amount, None).await {
+                Ok(res) => {
+                    println!();
+                    println!("SUCCESS ✅");
+                    println!(
+                        "Nodesguru: https://nym.explorers.guru/transaction/{}",
+                        &res.transaction_hash
+                    );
+                    println!(
+                        "Mintscan: https://www.mintscan.io/nyx/txs/{}",
+                        &res.transaction_hash
+                    );
+                    println!("Transaction hash: {}", &res.transaction_hash);
+                    println!("Gas used: {}", &res.gas_info.gas_used);
+                    println!();
+                }
+                Err(e) => show_error(e),
+            }
+
+            // query for balances again
+            let res = client
+                .original_vesting(&vesting_address)
+                .await
+                .expect("vesting account does not exist");
+            let spendable_coins = client
+                .spendable_coins(&vesting_address, None)
+                .await
+                .unwrap_or_else(|_| Coin::new(0u128, denom));
+
+            let liquid_account_balance = client
+                .get_balance(account_id, denom.to_string())
+                .await
+                .unwrap_or(None)
+                .unwrap_or_else(|| Coin::new(0u128, denom));
+
+            println!(
+                "After withdrawal, account {} has\n{} vested with {} available to be withdrawn to the main account (balance {})",
+                &account_id,
+                pretty_cosmwasm_coin(&res.amount),
+                pretty_coin(&spendable_coins),
+                pretty_coin(&liquid_account_balance),
+            );
+        }
+        Err(e) => show_error(e),
+    }
+}

common/config/src/lib.rs

@@ -41,6 +41,30 @@ pub trait NymConfig: Default + Serialize + DeserializeOwned {
         Self::default_config_directory(id).join(Self::config_file_name())
     }
 
+    // We provide a second set of functions that tries to not panic.
+
+    fn try_default_root_directory() -> Option<PathBuf>;
+
+    fn try_default_config_directory(id: Option<&str>) -> Option<PathBuf> {
+        if let Some(id) = id {
+            Self::try_default_root_directory().map(|d| d.join(id).join("config"))
+        } else {
+            Self::try_default_root_directory().map(|d| d.join("config"))
+        }
+    }
+
+    fn try_default_data_directory(id: Option<&str>) -> Option<PathBuf> {
+        if let Some(id) = id {
+            Self::try_default_root_directory().map(|d| d.join(id).join("data"))
+        } else {
+            Self::try_default_root_directory().map(|d| d.join("data"))
+        }
+    }
+
+    fn try_default_config_file_path(id: Option<&str>) -> Option<PathBuf> {
+        Self::try_default_config_directory(id).map(|d| d.join(Self::config_file_name()))
+    }
+
     fn root_directory(&self) -> PathBuf;
     fn config_directory(&self) -> PathBuf;
     fn data_directory(&self) -> PathBuf;

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

@@ -166,6 +166,7 @@ pub mod fixed_U128_as_string {
     use super::U128;
     use serde::de::Error;
     use serde::Deserialize;
+    #[allow(unused_imports)]
     use std::str::FromStr;
 
     pub fn serialize<S>(val: &U128, serializer: S) -> Result<S::Ok, S::Error>

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

@@ -2,8 +2,9 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::reward_params::NodeRewardParams;
-use crate::ContractStateParams;
+use crate::{ContractStateParams, Layer, SphinxKey};
 use crate::{Gateway, IdentityKey, MixNode};
+use cosmwasm_std::{Addr, Coin};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
@@ -122,6 +123,10 @@ pub enum ExecuteMsg {
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub enum QueryMsg {
+    GetAllDelegationValuesPaged {
+        start_after: Option<(IdentityKey, Vec<u8>, u64)>,
+        limit: Option<u32>,
+    },
     GetBlacklistedNodes {},
     GetCurrentOperatorCost {},
     GetRewardingValidatorAddress {},
@@ -213,17 +218,147 @@ pub enum QueryMsg {
     },
 }
 
+// all of those `serde rename` are here to reduce the rpc response size to bare minimum
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)]
+#[serde(rename_all = "snake_case")]
+#[serde(rename = "op")]
+pub enum V2MigrationOperation {
+    #[serde(rename = "m1")]
+    MigrateOperator {
+        #[serde(rename = "a1")]
+        node_identity: String,
+    },
+
+    #[serde(rename = "m2")]
+    MigrateDelegator {
+        #[serde(rename = "a1")]
+        address: Addr,
+
+        #[serde(rename = "a2")]
+        node_identity: String,
+
+        #[serde(rename = "a3")]
+        proxy: Option<Addr>,
+
+        #[serde(rename = "a4")]
+        new_mix_id: Option<u32>,
+    },
+
+    #[serde(rename = "m3")]
+    RemoveOperator {
+        #[serde(rename = "a1")]
+        node_identity: String,
+    },
+
+    #[serde(rename = "m4")]
+    RemoveDelegator {
+        #[serde(rename = "a1")]
+        address: Addr,
+
+        #[serde(rename = "a2")]
+        node_identity: String,
+
+        #[serde(rename = "a3")]
+        proxy: Option<Addr>,
+    },
+
+    #[serde(rename = "m5")]
+    MigrateGateway {
+        #[serde(rename = "a1")]
+        node_identity: String,
+    },
+
+    #[serde(rename = "m6")]
+    RemoveGateway {
+        #[serde(rename = "a1")]
+        node_identity: String,
+    },
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
+#[serde(rename_all = "snake_case")]
+pub enum SpecialV2ExecuteMsg {
+    #[serde(rename = "m1")]
+    SaveOperator {
+        #[serde(rename = "a1")]
+        host: String,
+
+        #[serde(rename = "a2")]
+        mix_port: u16,
+
+        #[serde(rename = "a3")]
+        verloc_port: u16,
+
+        #[serde(rename = "a4")]
+        http_api_port: u16,
+
+        #[serde(rename = "a5")]
+        sphinx_key: SphinxKey,
+
+        #[serde(rename = "a6")]
+        identity_key: IdentityKey,
+
+        #[serde(rename = "a7")]
+        version: String,
+
+        #[serde(rename = "a8")]
+        pledge_amount: Coin,
+
+        #[serde(rename = "a9")]
+        owner: Addr,
+
+        #[serde(rename = "a10")]
+        block_height: u64,
+
+        #[serde(rename = "a11")]
+        profit_margin_percent: u8,
+
+        #[serde(rename = "a12")]
+        proxy: Option<Addr>,
+    },
+    #[serde(rename = "m2")]
+    SaveDelegation {
+        #[serde(rename = "a1")]
+        owner: Addr,
+
+        #[serde(rename = "a2")]
+        mix_id: u32,
+
+        #[serde(rename = "a3")]
+        amount: Coin,
+
+        #[serde(rename = "a4")]
+        block_height: u64,
+
+        #[serde(rename = "a5")]
+        proxy: Option<Addr>,
+    },
+    #[serde(rename = "m3")]
+    SaveGateway {
+        #[serde(rename = "a1")]
+        pledge_amount: Coin,
+
+        #[serde(rename = "a2")]
+        owner: Addr,
+
+        #[serde(rename = "a3")]
+        block_height: u64,
+
+        #[serde(rename = "a4")]
+        gateway: Gateway,
+
+        #[serde(rename = "a5")]
+        proxy: Option<Addr>,
+    },
+}
+
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct MigrateMsg {
-    pub mixnet_denom: String,
-    nodes_to_remove: Option<Vec<NodeToRemove>>,
-}
-
-impl MigrateMsg {
-    pub fn nodes_to_remove(&self) -> Vec<NodeToRemove> {
-        self.nodes_to_remove.clone().unwrap_or_default()
-    }
+    pub v2_contract_address: String,
+    pub vesting_contract_address: String,
+    pub operations: Vec<V2MigrationOperation>,
 }
 
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)]

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

@@ -1,10 +1,11 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
-use cosmwasm_std::{Coin, Timestamp};
+use cosmwasm_std::{Addr, Coin, Timestamp, Uint128};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
 pub use messages::{ExecuteMsg, InitMsg, MigrateMsg, QueryMsg};
+use mixnet_contract_common::IdentityKey;
 
 pub mod events;
 pub mod messages;
@@ -73,3 +74,35 @@ impl OriginalVestingResponse {
         }
     }
 }
+
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Clone, JsonSchema)]
+pub struct VestingDelegation {
+    pub account_id: u32,
+    pub mix_identity: IdentityKey,
+    pub block_timestamp: u64,
+    pub amount: Uint128,
+}
+
+impl VestingDelegation {
+    pub fn storage_key(&self) -> (u32, IdentityKey, u64) {
+        (
+            self.account_id,
+            self.mix_identity.clone(),
+            self.block_timestamp,
+        )
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Clone, JsonSchema)]
+pub struct DelegationTimesResponse {
+    pub owner: Addr,
+    pub account_id: u32,
+    pub mix_identity: IdentityKey,
+    pub delegation_timestamps: Vec<u64>,
+}
+
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Clone, JsonSchema)]
+pub struct AllDelegationsResponse {
+    pub delegations: Vec<VestingDelegation>,
+    pub start_next_after: Option<(u32, IdentityKey, u64)>,
+}