fix(wallet): broken explorer links

refactor(explorer): rename mixnodeidentitykey to mixid
fix(wallet): explorer links
2022-11-17 18:33:29 +01:00 · 2022-11-17 18:33:25 +01:00 · 2022-11-17 18:33:17 +01:00 · 2022-11-17 16:35:14 +00:00 · 2022-11-17 15:33:27 +00:00 · 2022-11-17 15:14:06 +00:00
140 changed files with 1978 additions and 845 deletions
@@ -0,0 +1,56 @@
+name: CI for Network Explorer API
+
+on:
+  workflow_dispatch:
+  release:
+    types: [created]
+    
+env:
+  NETWORK: mainnet    
+
+jobs:
+  publish-nym:
+    strategy:
+      fail-fast: false
+      matrix:
+        platform: [ubuntu-latest]
+
+    runs-on: ${{ matrix.platform }}
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Install Dependencies (Linux)
+        run: sudo apt-get update && sudo apt-get -y install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libudev-dev squashfs-tools
+
+      - name: Check the release tag starts with `nym-explorer-api-`
+        if: startsWith(github.ref, 'refs/tags/nym-explorer-api-') == false && github.event_name != 'workflow_dispatch'
+        uses: actions/github-script@v3
+        with:
+          script: |
+            core.setFailed('Release tag did not start with nym-explorer-api-...')
+
+      - name: Install Rust stable
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+
+      - name: Build all explorer-api
+        uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: --manifest-path explorer-api/Cargo.toml --workspace --release
+
+      - name: Upload Artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: my-artifact
+          path: |
+            target/release/explorer-api
+          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/explorer-api
@@ -25,6 +25,9 @@ jobs:
    steps:
      - uses: actions/checkout@v3

+      - name: Install Dependencies (Linux)
+        run: sudo apt-get update && sudo apt-get -y install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libudev-dev squashfs-tools
+
      - name: Check the release tag starts with `nym-binaries-`
        if: startsWith(github.ref, 'refs/tags/nym-binaries-') == false && github.event_name != 'workflow_dispatch'
        uses: actions/github-script@v3
@@ -2,34 +2,40 @@

 Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

-## Unreleased
+## [v1.1.0](https://github.com/nymtech/nym/tree/v1.1.0) (2022-11-09)

 ### Added

- nym-cli: added CLI tool for interacting with the Nyx blockchain and Nym mixnet smart contracts ([#1577])
- validator-client: added `query_contract_smart` and `query_contract_raw` on `NymdClient` ([#1558])
- network-requester: added additional Blockstream Green wallet endpoint to `example.allowed.list` ([#1611](https://github.com/nymtech/nym/pull/1611))
- common/ledger: new library for communicating with a Ledger device ([#1640])
- native-client/socks5-client: `disable_loop_cover_traffic_stream` Debug config option to disable the separate loop cover traffic stream ([#1666])
- native-client/socks5-client: `disable_main_poisson_packet_distribution` Debug config option to make the client ignore poisson distribution in the main packet stream and ONLY send real message (and as fast as they come) ([#1664])
- native-client/socks5-client: `use_extended_packet_size` Debug config option to make the client use 'ExtendedPacketSize' for its traffic (32kB as opposed to 2kB in 1.0.2) ([#1671])
- wasm-client: uses updated wasm-compatible `client-core` so that it's now capable of packet retransmission, cover traffic and poisson delay (among other things!) ([#1673])
- validator-api: add `interval_operating_cost` and `profit_margin_percent` to cmpute reward estimation endpoint
- vesting-contract: optional locked token pledge cap per account ([#1687]), defaults to 100_000 NYM
 - clients: add testing-only support for two more extended packet sizes (8kb and 16kb).
+- common/ledger: new library for communicating with a Ledger device ([#1640])
+- native-client/socks5-client/wasm-client: `disable_loop_cover_traffic_stream` Debug config option to disable the separate loop cover traffic stream ([#1666])
+- native-client/socks5-client/wasm-client: `disable_main_poisson_packet_distribution` Debug config option to make the client ignore poisson distribution in the main packet stream and ONLY send real message (and as fast as they come) ([#1664])
+- native-client/socks5-client/wasm-client: `use_extended_packet_size` Debug config option to make the client use 'ExtendedPacketSize' for its traffic (32kB as opposed to 2kB in 1.0.2) ([#1671])
+- network-requester: added additional Blockstream Green wallet endpoint to `example.allowed.list` ([#1611])
+- validator-api: add `interval_operating_cost` and `profit_margin_percent` to compute reward estimation endpoint
+- validator-client: added `query_contract_smart` and `query_contract_raw` on `NymdClient` ([#1558])
+- wasm-client: uses updated wasm-compatible `client-core` so that it's now capable of packet retransmission, cover traffic and poisson delay (among other things!) ([#1673])

 ### Fixed

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

 ### Changed

- validator-client: made `fee` argument optional for `execute` and `execute_multiple` ([#1541])
- socks5 client: graceful shutdown should fix error on disconnect in nym-connect ([#1591])
- wasm-client: fixed build errors on MacOS and changed example JS code to use mainnet ([#1585])
+- clients: bound the sphinx packet channel and reduce sending rate if gateway can't keep up ([#1703],[#1725])
 - gateway-client: will attempt to read now as many as 8 websocket messages at once, assuming they're already available on the socket ([#1669])
- moved `Percent` struct to to `contracts-common`, change affects explorer-api
+- moved `Percent` struct to `contracts-common`, change affects explorer-api
+- socks5 client: graceful shutdown should fix error on disconnect in nym-connect ([#1591])
+- validator-api: changed error serialization on `inclusion_probability`, `stake-saturation` and `reward-estimation` endpoints to provide more accurate information ([#1681]) 
+- validator-client: made `fee` argument optional for `execute` and `execute_multiple` ([#1541])
+- wasm-client: fixed build errors on MacOS and changed example JS code to use mainnet ([#1585])
+- validator-api: changes to internal SQL schema due to the mixnet contract revamp ([#1472])
+- validator-api: changes to internal data structures due to the mixnet contract revamp ([#1472])
+- validator-api: split epoch-operations into multiple separate transactions ([#1472])

+[#1472]: https://github.com/nymtech/nym/pull/1472
 [#1541]: https://github.com/nymtech/nym/pull/1541
 [#1558]: https://github.com/nymtech/nym/pull/1558
 [#1577]: https://github.com/nymtech/nym/pull/1577
@@ -37,12 +43,18 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://
 [#1591]: https://github.com/nymtech/nym/pull/1591
 [#1640]: https://github.com/nymtech/nym/pull/1640
 [#1645]: https://github.com/nymtech/nym/pull/1645
+[#1611]: https://github.com/nymtech/nym/pull/1611
 [#1664]: https://github.com/nymtech/nym/pull/1664
 [#1666]: https://github.com/nymtech/nym/pull/1645
 [#1669]: https://github.com/nymtech/nym/pull/1669
 [#1671]: https://github.com/nymtech/nym/pull/1671
 [#1673]: https://github.com/nymtech/nym/pull/1673
-[#1687]: https://github.com/nymtech/nym/pull/1687
+[#1681]: https://github.com/nymtech/nym/pull/1681
+[#1702]: https://github.com/nymtech/nym/pull/1702
+[#1703]: https://github.com/nymtech/nym/pull/1703
+[#1721]: https://github.com/nymtech/nym/pull/1721
+[#1724]: https://github.com/nymtech/nym/pull/1724
+[#1725]: https://github.com/nymtech/nym/pull/1725


 ## [nym-binaries-1.0.2](https://github.com/nymtech/nym/tree/nym-binaries-1.0.2)
@@ -578,7 +578,7 @@ dependencies = [

 [[package]]
 name = "client-core"
-version = "1.0.1"
+version = "1.1.0"
 dependencies = [
 "config",
 "crypto",
@@ -1582,7 +1582,7 @@ dependencies = [

 [[package]]
 name = "explorer-api"
-version = "1.0.1"
+version = "1.1.0"
 dependencies = [
 "chrono",
 "clap 3.2.8",
@@ -1592,6 +1592,7 @@ dependencies = [
 "isocountry",
 "itertools",
 "log",
+ "logging",
 "maxminddb",
 "mixnet-contract-common",
 "network-defaults",
@@ -2730,6 +2731,14 @@ dependencies = [
 "cfg-if 1.0.0",
 ]

+[[package]]
+name = "logging"
+version = "0.1.0"
+dependencies = [
+ "log",
+ "pretty_env_logger",
+]
+
 [[package]]
 name = "loom"
 version = "0.5.4"
@@ -3061,7 +3070,7 @@ dependencies = [

 [[package]]
 name = "nym-cli"
-version = "1.0.0"
+version = "1.1.0"
 dependencies = [
 "anyhow",
 "base64",
@@ -3072,6 +3081,7 @@ dependencies = [
 "clap_complete_fig",
 "dotenv",
 "log",
+ "logging",
 "network-defaults",
 "nym-cli-commands",
 "pretty_env_logger",
@@ -3112,7 +3122,7 @@ dependencies = [

 [[package]]
 name = "nym-client"
-version = "1.0.2"
+version = "1.1.0"
 dependencies = [
 "clap 3.2.8",
 "client-core",
@@ -3127,6 +3137,7 @@ dependencies = [
 "gateway-client",
 "gateway-requests",
 "log",
+ "logging",
 "network-defaults",
 "nymsphinx",
 "pemstore",
@@ -3148,7 +3159,7 @@ dependencies = [

 [[package]]
 name = "nym-gateway"
-version = "1.0.2"
+version = "1.1.0"
 dependencies = [
 "anyhow",
 "async-trait",
@@ -3168,6 +3179,7 @@ dependencies = [
 "gateway-requests",
 "humantime-serde",
 "log",
+ "logging",
 "mixnet-client",
 "mixnode-common",
 "network-defaults",
@@ -3194,7 +3206,7 @@ dependencies = [

 [[package]]
 name = "nym-mixnode"
-version = "1.0.2"
+version = "1.1.0"
 dependencies = [
 "anyhow",
 "bs58",
@@ -3210,6 +3222,7 @@ dependencies = [
 "humantime-serde",
 "lazy_static",
 "log",
+ "logging",
 "mixnet-client",
 "mixnode-common",
 "nonexhaustive-delayqueue",
@@ -3235,7 +3248,7 @@ dependencies = [

 [[package]]
 name = "nym-network-requester"
-version = "1.0.2"
+version = "1.1.0"
 dependencies = [
 "async-trait",
 "clap 3.2.8",
@@ -3244,6 +3257,7 @@ dependencies = [
 "futures",
 "ipnetwork 0.20.0",
 "log",
+ "logging",
 "network-defaults",
 "nymsphinx",
 "ordered-buffer",
@@ -3269,6 +3283,7 @@ version = "1.0.2"
 dependencies = [
 "dirs",
 "log",
+ "logging",
 "pretty_env_logger",
 "rocket",
 "serde",
@@ -3280,7 +3295,7 @@ dependencies = [

 [[package]]
 name = "nym-socks5-client"
-version = "1.0.2"
+version = "1.1.0"
 dependencies = [
 "clap 3.2.8",
 "client-core",
@@ -3295,6 +3310,7 @@ dependencies = [
 "gateway-client",
 "gateway-requests",
 "log",
+ "logging",
 "network-defaults",
 "nymsphinx",
 "ordered-buffer",
@@ -3343,7 +3359,7 @@ dependencies = [

 [[package]]
 name = "nym-validator-api"
-version = "1.0.2"
+version = "1.1.0"
 dependencies = [
 "anyhow",
 "async-trait",
@@ -3368,6 +3384,7 @@ dependencies = [
 "humantime-serde",
 "inclusion-probability",
 "log",
+ "logging",
 "mixnet-contract-common",
 "multisig-contract-common",
 "nymcoconut",
@@ -6391,6 +6408,7 @@ dependencies = [
 "coconut-interface",
 "colored",
 "config",
+ "contracts-common",
 "cosmrs",
 "cosmwasm-std",
 "cw3",
@@ -6486,6 +6504,7 @@ dependencies = [
 "schemars",
 "serde",
 "thiserror",
+ "vergen 5.1.17",
 "vesting-contract-common",
 ]

@@ -6495,7 +6514,6 @@ version = "0.1.0"
 dependencies = [
 "contracts-common",
 "cosmwasm-std",
- "log",
 "mixnet-contract-common",
 "schemars",
 "serde",
@@ -41,6 +41,7 @@ members = [
    "common/execute",
    "common/inclusion-probability",
    "common/ledger",
+    "common/logging",
    "common/mixnode-common",
    "common/network-defaults",
    "common/nonexhaustive-delayqueue",
@@ -92,6 +92,9 @@ build-wallet:
 build-connect:
 	cargo build --manifest-path nym-connect/Cargo.toml --workspace

+build-explorer-api:
+	cargo build --manifest-path explorer-api/Cargo.toml --workspace
+
 build-wasm-client:
 	cargo build --manifest-path clients/webassembly/Cargo.toml --workspace --target wasm32-unknown-unknown

@@ -1,6 +1,6 @@
 [package]
 name = "client-core"
-version = "1.0.1"
+version = "1.1.0"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
 edition = "2021"

@@ -16,6 +16,7 @@ use rand::{rngs::OsRng, CryptoRng, Rng};
 use std::pin::Pin;
 use std::sync::Arc;
 use std::time::Duration;
+use tokio::sync::mpsc::error::TrySendError;

 #[cfg(not(target_arch = "wasm32"))]
 use tokio::time;
@@ -171,11 +172,18 @@ impl LoopCoverTrafficStream<OsRng> {
        )
        .expect("Somehow failed to generate a loop cover message with a valid topology");

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

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

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

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

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

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

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

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

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

-            while let Some(mix_packets) = self.mix_rx.next().await {
+            while let Some(mix_packets) = self.mix_rx.recv().await {
                self.on_messages(mix_packets).await;
            }
        })
@@ -27,6 +27,23 @@ use tokio::time;
 #[cfg(target_arch = "wasm32")]
 use wasm_timer;

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

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

+    // To make sure we don't overload the mix_tx channel, we limit the rate we are pushing
+    // messages.
+    sending_rate_controller: SendingDelayController,
+
    /// Channel used for sending prepared sphinx packets to `MixTrafficController` that sends them
    /// out to the network without any further delays.
    mix_tx: BatchMixMessageSender,
@@ -156,6 +272,10 @@ where
            ack_key,
            sent_notifier,
            next_delay: None,
+            sending_rate_controller: SendingDelayController::new(
+                MIN_DELAY_MULTIPLIER,
+                MAX_DELAY_MULTIPLIER,
+            ),
            mix_tx,
            real_receiver,
            our_full_destination,
@@ -212,15 +332,8 @@ where
            }
        };

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

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

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

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

            // The next interval value is `next_poisson_delay` after the one that just
@@ -1,6 +1,6 @@
 [package]
 name = "nym-client"
-version = "1.0.2"
+version = "1.1.0"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>", "Jędrzej Stuczyński <andrew@nymtech.net>"]
 description = "Implementation of the Nym Client"
 edition = "2021"
@@ -38,6 +38,7 @@ completions = { path = "../../common/completions" }
 credential-storage = { path = "../../common/credential-storage" }
 credentials = { path = "../../common/credentials", optional = true }
 crypto = { path = "../../common/crypto" }
+logging = { path = "../../common/logging"}
 gateway-client = { path = "../../common/client-libs/gateway-client" }
 gateway-requests = { path = "../../gateway/gateway-requests" }
 network-defaults = { path = "../../common/network-defaults" }
@@ -6,9 +6,7 @@ use client_core::client::inbound_messages::{
    InputMessage, InputMessageReceiver, InputMessageSender,
 };
 use client_core::client::key_manager::KeyManager;
-use client_core::client::mix_traffic::{
-    BatchMixMessageReceiver, BatchMixMessageSender, MixTrafficController,
-};
+use client_core::client::mix_traffic::{BatchMixMessageSender, MixTrafficController};
 use client_core::client::real_messages_control;
 use client_core::client::real_messages_control::RealMessagesController;
 use client_core::client::received_buffer::{
@@ -264,13 +262,13 @@ impl NymClient {
    // over it. Perhaps GatewayClient needs to be thread-shareable or have some channel for
    // requests?
    fn start_mix_traffic_controller(
-        &mut self,
-        mix_rx: BatchMixMessageReceiver,
        gateway_client: GatewayClient,
        shutdown: ShutdownListener,
-    ) {
+    ) -> BatchMixMessageSender {
        info!("Starting mix traffic controller...");
-        MixTrafficController::new(mix_rx, gateway_client).start_with_shutdown(shutdown);
+        let (mix_traffic_controller, mix_tx) = MixTrafficController::new(gateway_client);
+        mix_traffic_controller.start_with_shutdown(shutdown);
+        mix_tx
    }

    fn start_websocket_listener(
@@ -357,11 +355,6 @@ impl NymClient {
        // rather than creating them here, so say for example the buffer controller would create the request channels
        // and would allow anyone to clone the sender channel

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

-        self.start_mix_traffic_controller(
-            sphinx_message_receiver,
-            gateway_client,
-            shutdown.subscribe(),
-        );
+        // The sphinx_message_sender is the transmitter for any component generating sphinx packets
+        // that are to be sent to the mixnet. They are used by cover traffic stream and real
+        // traffic stream.
+        // The MixTrafficController then sends the actual traffic
+        let sphinx_message_sender =
+            Self::start_mix_traffic_controller(gateway_client, shutdown.subscribe());
+
        self.start_real_traffic_controller(
            shared_topology_accessor.clone(),
            reply_key_storage,
@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0

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

 pub mod client;
@@ -34,25 +35,3 @@ fn banner() -> String {
        crate_version!()
    )
 }
-
-fn setup_logging() {
-    let mut log_builder = pretty_env_logger::formatted_timed_builder();
-    if let Ok(s) = ::std::env::var("RUST_LOG") {
-        log_builder.parse_filters(&s);
-    } else {
-        // default to 'Info'
-        log_builder.filter(None, log::LevelFilter::Info);
-    }
-
-    log_builder
-        .filter_module("hyper", log::LevelFilter::Warn)
-        .filter_module("tokio_reactor", log::LevelFilter::Warn)
-        .filter_module("reqwest", log::LevelFilter::Warn)
-        .filter_module("mio", log::LevelFilter::Warn)
-        .filter_module("want", log::LevelFilter::Warn)
-        .filter_module("tungstenite", log::LevelFilter::Warn)
-        .filter_module("tokio_tungstenite", log::LevelFilter::Warn)
-        .filter_module("handlebars", log::LevelFilter::Warn)
-        .filter_module("sled", log::LevelFilter::Warn)
-        .init();
-}
@@ -1,6 +1,6 @@
 [package]
 name = "nym-socks5-client"
-version = "1.0.2"
+version = "1.1.0"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
 description = "A SOCKS5 localhost proxy that converts incoming messages to Sphinx and sends them to a Nym address"
 edition = "2021"
@@ -31,6 +31,7 @@ completions = { path = "../../common/completions" }
 credential-storage = { path = "../../common/credential-storage" }
 credentials = { path = "../../common/credentials", optional = true }
 crypto = { path = "../../common/crypto" }
+logging = { path = "../../common/logging"}
 gateway-client = { path = "../../common/client-libs/gateway-client" }
 gateway-requests = { path = "../../gateway/gateway-requests" }
 network-defaults = { path = "../../common/network-defaults" }
@@ -13,9 +13,7 @@ use client_core::client::inbound_messages::{
    InputMessage, InputMessageReceiver, InputMessageSender,
 };
 use client_core::client::key_manager::KeyManager;
-use client_core::client::mix_traffic::{
-    BatchMixMessageReceiver, BatchMixMessageSender, MixTrafficController,
-};
+use client_core::client::mix_traffic::{BatchMixMessageSender, MixTrafficController};
 use client_core::client::real_messages_control::RealMessagesController;
 use client_core::client::received_buffer::{
    ReceivedBufferRequestReceiver, ReceivedBufferRequestSender, ReceivedMessagesBufferController,
@@ -264,13 +262,13 @@ impl NymClient {
    // over it. Perhaps GatewayClient needs to be thread-shareable or have some channel for
    // requests?
    fn start_mix_traffic_controller(
-        &mut self,
-        mix_rx: BatchMixMessageReceiver,
        gateway_client: GatewayClient,
        shutdown: ShutdownListener,
-    ) {
+    ) -> BatchMixMessageSender {
        info!("Starting mix traffic controller...");
-        MixTrafficController::new(mix_rx, gateway_client).start_with_shutdown(shutdown);
+        let (mix_traffic_controller, mix_tx) = MixTrafficController::new(gateway_client);
+        mix_traffic_controller.start_with_shutdown(shutdown);
+        mix_tx
    }

    fn start_socks5_listener(
@@ -346,11 +344,6 @@ impl NymClient {
        // rather than creating them here, so say for example the buffer controller would create the request channels
        // and would allow anyone to clone the sender channel

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

-        self.start_mix_traffic_controller(
-            sphinx_message_receiver,
-            gateway_client,
-            shutdown.subscribe(),
-        );
+        // The sphinx_message_sender is the transmitter for any component generating sphinx packets
+        // that are to be sent to the mixnet. They are used by cover traffic stream and real
+        // traffic stream.
+        // The MixTrafficController then sends the actual traffic
+        let sphinx_message_sender =
+            Self::start_mix_traffic_controller(gateway_client, shutdown.subscribe());
+
        self.start_real_traffic_controller(
            shared_topology_accessor.clone(),
            reply_key_storage,
@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0

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

 pub mod client;
@@ -34,23 +35,3 @@ fn banner() -> String {
        crate_version!()
    )
 }
-
-fn setup_logging() {
-    let mut log_builder = pretty_env_logger::formatted_timed_builder();
-    if let Ok(s) = ::std::env::var("RUST_LOG") {
-        log_builder.parse_filters(&s);
-    } else {
-        // default to 'Info'
-        log_builder.filter(None, log::LevelFilter::Info);
-    }
-
-    log_builder
-        .filter_module("hyper", log::LevelFilter::Warn)
-        .filter_module("tokio_reactor", log::LevelFilter::Warn)
-        .filter_module("reqwest", log::LevelFilter::Warn)
-        .filter_module("mio", log::LevelFilter::Warn)
-        .filter_module("want", log::LevelFilter::Warn)
-        .filter_module("tungstenite", log::LevelFilter::Warn)
-        .filter_module("tokio_tungstenite", log::LevelFilter::Warn)
-        .init();
-}
@@ -6,7 +6,7 @@ use client_core::client::{
    cover_traffic_stream::LoopCoverTrafficStream,
    inbound_messages::{InputMessage, InputMessageReceiver, InputMessageSender},
    key_manager::KeyManager,
-    mix_traffic::{BatchMixMessageReceiver, BatchMixMessageSender, MixTrafficController},
+    mix_traffic::{BatchMixMessageSender, MixTrafficController},
    real_messages_control::{self, RealMessagesController},
    received_buffer::{
        ReceivedBufferMessage, ReceivedBufferRequestReceiver, ReceivedBufferRequestSender,
@@ -252,13 +252,11 @@ impl NymClient {
    // TODO: if we want to send control messages to gateway_client, this CAN'T take the ownership
    // over it. Perhaps GatewayClient needs to be thread-shareable or have some channel for
    // requests?
-    fn start_mix_traffic_controller(
-        &mut self,
-        mix_rx: BatchMixMessageReceiver,
-        gateway_client: GatewayClient,
-    ) {
+    fn start_mix_traffic_controller(gateway_client: GatewayClient) -> BatchMixMessageSender {
        console_log!("Starting mix traffic controller...");
-        MixTrafficController::new(mix_rx, gateway_client).start();
+        let (mix_traffic_controller, mix_tx) = MixTrafficController::new(gateway_client);
+        mix_traffic_controller.start();
+        mix_tx
    }

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

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

-        self.start_mix_traffic_controller(sphinx_message_receiver, gateway_client);
+        // The sphinx_message_sender is the transmitter for any component generating sphinx packets
+        // that are to be sent to the mixnet. They are used by cover traffic stream and real
+        // traffic stream.
+        // The MixTrafficController then sends the actual traffic
+        let sphinx_message_sender = Self::start_mix_traffic_controller(gateway_client);
+
        self.start_real_traffic_controller(
            shared_topology_accessor.clone(),
            ack_receiver,
@@ -23,6 +23,7 @@ pub struct Config {
    maximum_reconnection_backoff: Duration,
    initial_connection_timeout: Duration,
    maximum_connection_buffer_size: usize,
+    use_legacy_version: bool,
 }

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

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

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

        let (packet_sender, packet_receiver) = mpsc::unbounded();
@@ -13,6 +13,7 @@ colored = "2.0"
 cw3 = "0.13.1"
 mixnet-contract-common = { path= "../../cosmwasm-smart-contracts/mixnet-contract" }
 vesting-contract-common = { path= "../../cosmwasm-smart-contracts/vesting-contract" }
+contracts-common = { path = "../../cosmwasm-smart-contracts/contracts-common" }
 coconut-bandwidth-contract-common = { path= "../../cosmwasm-smart-contracts/coconut-bandwidth-contract" }
 multisig-contract-common = { path = "../../cosmwasm-smart-contracts/multisig-contract" }
 vesting-contract = { path = "../../../contracts/vesting" }
@@ -6,8 +6,10 @@ pub use crate::nymd::cosmwasm_client::client::CosmWasmClient;
 use crate::nymd::error::NymdError;
 use crate::nymd::NymdClient;
 use async_trait::async_trait;
+use contracts_common::ContractBuildInformation;
 use cosmwasm_std::{Coin as CosmWasmCoin, Timestamp};
 use mixnet_contract_common::MixId;
+use serde::Deserialize;
 use vesting_contract::vesting::Account;
 use vesting_contract_common::{
    messages::QueryMsg as VestingQueryMsg, AllDelegationsResponse, DelegationTimesResponse,
@@ -16,6 +18,15 @@ use vesting_contract_common::{

 #[async_trait]
 pub trait VestingQueryClient {
+    async fn query_vesting_contract<T>(&self, query: VestingQueryMsg) -> Result<T, NymdError>
+    where
+        for<'a> T: Deserialize<'a>;
+
+    async fn get_vesting_contract_version(&self) -> Result<ContractBuildInformation, NymdError> {
+        self.query_vesting_contract(VestingQueryMsg::GetContractVersion {})
+            .await
+    }
+
    async fn locked_coins(
        &self,
        address: &str,
@@ -107,6 +118,15 @@ pub trait VestingQueryClient {

 #[async_trait]
 impl<C: CosmWasmClient + Sync + Send> VestingQueryClient for NymdClient<C> {
+    async fn query_vesting_contract<T>(&self, query: VestingQueryMsg) -> Result<T, NymdError>
+    where
+        for<'a> T: Deserialize<'a>,
+    {
+        self.client
+            .query_contract_smart(self.vesting_contract_address(), &query)
+            .await
+    }
+
    async fn locked_coins(
        &self,
        vesting_account_address: &str,
@@ -1,4 +1,5 @@
 use thiserror::Error;
+use validator_api_requests::models::RequestError;

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

    #[error("Request failed with error message - {0}")]
    GenericRequestFailure(String),
+
+    #[error("The validator API has failed to resolve our request. It returned status code {status} and additional error message: {}", error.message())]
+    ApiRequestFailure { status: u16, error: RequestError },
 }
@@ -5,6 +5,7 @@ use crate::validator_api::error::ValidatorAPIError;
 use crate::validator_api::routes::{CORE_STATUS_COUNT, SINCE_ARG};
 use mixnet_contract_common::mixnode::MixNodeDetails;
 use mixnet_contract_common::{GatewayBond, IdentityKeyRef, MixId};
+use reqwest::Response;
 use serde::{Deserialize, Serialize};
 use url::Url;
 use validator_api_requests::coconut::{
@@ -14,7 +15,7 @@ use validator_api_requests::coconut::{
 use validator_api_requests::models::{
    GatewayCoreStatusResponse, GatewayStatusReportResponse, GatewayUptimeHistoryResponse,
    InclusionProbabilityResponse, MixNodeBondAnnotated, MixnodeCoreStatusResponse,
-    MixnodeStatusReportResponse, MixnodeStatusResponse, MixnodeUptimeHistoryResponse,
+    MixnodeStatusReportResponse, MixnodeStatusResponse, MixnodeUptimeHistoryResponse, RequestError,
    RewardEstimationResponse, StakeSaturationResponse, UptimeResponse,
 };

@@ -48,6 +49,19 @@ impl Client {
        &self.url
    }

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

    async fn post_validator_api<B, T, K, V>(
@@ -303,7 +345,7 @@ impl Client {
        &self,
        mix_id: MixId,
    ) -> Result<RewardEstimationResponse, ValidatorAPIError> {
-        self.query_validator_api(
+        self.query_validator_api_fallible(
            &[
                routes::API_VERSION,
                routes::STATUS_ROUTES,
@@ -320,7 +362,7 @@ impl Client {
        &self,
        mix_id: MixId,
    ) -> Result<StakeSaturationResponse, ValidatorAPIError> {
-        self.query_validator_api(
+        self.query_validator_api_fallible(
            &[
                routes::API_VERSION,
                routes::STATUS_ROUTES,
@@ -337,7 +379,7 @@ impl Client {
        &self,
        mix_id: MixId,
    ) -> Result<InclusionProbabilityResponse, ValidatorAPIError> {
-        self.query_validator_api(
+        self.query_validator_api_fallible(
            &[
                routes::API_VERSION,
                routes::STATUS_ROUTES,
@@ -354,7 +396,7 @@ impl Client {
        &self,
        mix_id: MixId,
    ) -> Result<UptimeResponse, ValidatorAPIError> {
-        self.query_validator_api(
+        self.query_validator_api_fallible(
            &[
                routes::API_VERSION,
                routes::STATUS_ROUTES,
@@ -9,7 +9,6 @@ mixnet-contract-common = { path = "../mixnet-contract" }
 contracts-common = { path = "../contracts-common" }
 serde = { version = "1.0", features = ["derive"] }
 schemars = "0.8"
-log = "0.4"
 ts-rs = {version = "6.1.2", optional = true}

 [features]
@@ -4,7 +4,6 @@ use std::str::FromStr;
 // SPDX-License-Identifier: Apache-2.0
 use contracts_common::Percent;
 use cosmwasm_std::{Addr, Coin, Timestamp, Uint128};
-use log::warn;
 use mixnet_contract_common::MixId;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
@@ -59,30 +58,18 @@ impl FromStr for PledgeCap {
    fn from_str(cap: &str) -> Result<Self, Self::Err> {
        let cap = cap.replace('_', "").replace(',', ".");
        match Percent::from_str(&cap) {
-            Ok(p) => {
-                if p.is_zero() {
-                    warn!("Pledge cap set to 0%, are you sure this is right?")
-                }
-                Ok(PledgeCap::Percent(p))
-            }
-            Err(_) => {
-                match cap.parse::<u128>() {
-                    Ok(i) => {
-                        if i < 100_000_000_000 {
-                            warn!("PledgeCap set to less then 100_000 NYM, are you sure this is right?");
-                        }
-                        Ok(PledgeCap::Absolute(Uint128::from(i)))
-                    }
-                    Err(_e) => Err(format!("Could not parse {} as Percent or Uint128", cap)),
-                }
-            }
+            Ok(p) => Ok(PledgeCap::Percent(p)),
+            Err(_) => match cap.parse::<u128>() {
+                Ok(i) => Ok(PledgeCap::Absolute(Uint128::from(i))),
+                Err(_e) => Err(format!("Could not parse {} as Percent or Uint128", cap)),
+            },
        }
    }
 }

 impl Default for PledgeCap {
    fn default() -> Self {
-        PledgeCap::Absolute(Uint128::from(100_000_000_000u128))
+        PledgeCap::Percent(Percent::from_percentage_value(10).expect("This can never fail!"))
    }
 }

@@ -160,6 +160,7 @@ impl ExecuteMsg {
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub enum QueryMsg {
+    GetContractVersion {},
    LockedCoins {
        vesting_account_address: String,
        block_time: Option<Timestamp>,
@@ -0,0 +1,10 @@
+[package]
+name = "logging"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+log = "0.4.0"
+pretty_env_logger = "0.4.0"
@@ -0,0 +1,25 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+// I'd argue we should start transitioning from `log` to `tracing`
+pub fn setup_logging() {
+    let mut log_builder = pretty_env_logger::formatted_timed_builder();
+    if let Ok(s) = ::std::env::var("RUST_LOG") {
+        log_builder.parse_filters(&s);
+    } else {
+        // default to 'Info'
+        log_builder.filter(None, log::LevelFilter::Info);
+    }
+
+    log_builder
+        .filter_module("hyper", log::LevelFilter::Warn)
+        .filter_module("tokio_reactor", log::LevelFilter::Warn)
+        .filter_module("reqwest", log::LevelFilter::Warn)
+        .filter_module("mio", log::LevelFilter::Warn)
+        .filter_module("want", log::LevelFilter::Warn)
+        .filter_module("tungstenite", log::LevelFilter::Warn)
+        .filter_module("tokio_tungstenite", log::LevelFilter::Warn)
+        .filter_module("handlebars", log::LevelFilter::Warn)
+        .filter_module("sled", log::LevelFilter::Warn)
+        .init();
+}
@@ -10,7 +10,7 @@ pub const MIX_DENOM: DenomDetails = DenomDetails::new("unym", "nym", 6);
 pub const STAKE_DENOM: DenomDetails = DenomDetails::new("unyx", "nyx", 6);

 pub(crate) const MIXNET_CONTRACT_ADDRESS: &str =
-    "n14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9sjyvg3g";
+    "n17srjznxl9dvzdkpwpw24gg668wc73val88a6m5ajg6ankwvz9wtst0cznr";
 pub(crate) const VESTING_CONTRACT_ADDRESS: &str =
    "n1nc5tatafv6eyq7llkr2gv50ff9e22mnf70qgjlv737ktmt4eswrq73f2nw";
 pub(crate) const BANDWIDTH_CLAIM_CONTRACT_ADDRESS: &str =
@@ -6,7 +6,6 @@ use bytes::{Buf, BufMut, BytesMut};
 use nymsphinx_params::packet_modes::InvalidPacketMode;
 use nymsphinx_params::packet_sizes::{InvalidPacketSize, PacketSize};
 use nymsphinx_types::SphinxPacket;
-use std::convert::TryFrom;
 use std::io;
 use tokio_util::codec::{Decoder, Encoder};

@@ -75,7 +74,7 @@ impl Decoder for SphinxCodec {
        if src.is_empty() {
            // can't do anything if we have no bytes, but let's reserve enough for the most
            // conservative case, i.e. receiving an ack packet
-            src.reserve(Header::SIZE + PacketSize::AckPacket.size());
+            src.reserve(Header::LEGACY_SIZE + PacketSize::AckPacket.size());
            return Ok(None);
        }

@@ -87,7 +86,7 @@ impl Decoder for SphinxCodec {
        };

        let sphinx_packet_size = header.packet_size.size();
-        let frame_len = Header::SIZE + sphinx_packet_size;
+        let frame_len = header.size() + sphinx_packet_size;

        if src.len() < frame_len {
            // we don't have enough bytes to read the rest of frame
@@ -96,7 +95,7 @@ impl Decoder for SphinxCodec {
        }

        // advance buffer past the header - at this point we have enough bytes
-        src.advance(Header::SIZE);
+        src.advance(header.size());
        let sphinx_packet_bytes = src.split_to(sphinx_packet_size);
        let sphinx_packet = match SphinxPacket::from_bytes(&sphinx_packet_bytes) {
            Ok(sphinx_packet) => sphinx_packet,
@@ -115,21 +114,27 @@ impl Decoder for SphinxCodec {
        // has appropriate capacity in anticipation of future calls to decode.
        // Failing to do so leads to inefficiency.

-        // if we have at least one more byte available, we can reserve enough bytes for
+        // if we have enough bytes to decode the header of the next packet, we can reserve enough bytes for
        // the entire next frame, if not, we assume the next frame is an ack packet and
        // reserve for that.
+        // we also assume the next packet coming from the same client will use exactly the same versioning
+        // as the current packet
+        let mut allocate_for_next_packet = header.size() + PacketSize::AckPacket.size();
        if !src.is_empty() {
-            let next_packet_len = match PacketSize::try_from(src[0]) {
-                Ok(next_packet_len) => next_packet_len,
+            match Header::decode(src) {
+                Ok(Some(next_header)) => {
+                    allocate_for_next_packet = next_header.size() + next_header.packet_size.size();
+                }
+                Ok(None) => {
+                    // we don't have enough information to know how much to reserve, fallback to the ack case
+                }
+
                // the next frame will be malformed but let's leave handling the error to the next
                // call to 'decode', as presumably, the current sphinx packet is still valid
                Err(_) => return Ok(Some(nymsphinx_packet)),
            };
-            let next_frame_len = next_packet_len.size() + Header::SIZE;
-            src.reserve(next_frame_len - 1);
-        } else {
-            src.reserve(Header::SIZE + PacketSize::AckPacket.size());
        }
+        src.reserve(allocate_for_next_packet);

        Ok(Some(nymsphinx_packet))
    }
@@ -199,6 +204,8 @@ mod packet_encoding {
    #[cfg(test)]
    mod decode_will_allocate_enough_bytes_for_next_call {
        use super::*;
+        use nymsphinx_params::packet_version::PacketVersion;
+        use nymsphinx_params::PacketMode;

        #[test]
        fn for_empty_bytes() {
@@ -207,12 +214,12 @@ mod packet_encoding {
            assert!(SphinxCodec.decode(&mut empty_bytes).unwrap().is_none());
            assert_eq!(
                empty_bytes.capacity(),
-                Header::SIZE + PacketSize::AckPacket.size()
+                Header::LEGACY_SIZE + PacketSize::AckPacket.size()
            );
        }

        #[test]
-        fn for_bytes_with_header() {
+        fn for_bytes_with_legacy_header() {
            // if header gets decoded there should be enough bytes for the entire frame
            let packet_sizes = vec![
                PacketSize::AckPacket,
@@ -223,6 +230,7 @@ mod packet_encoding {
            ];
            for packet_size in packet_sizes {
                let header = Header {
+                    packet_version: PacketVersion::Legacy,
                    packet_size,
                    packet_mode: Default::default(),
                };
@@ -230,12 +238,60 @@ mod packet_encoding {
                header.encode(&mut bytes);
                assert!(SphinxCodec.decode(&mut bytes).unwrap().is_none());

-                assert_eq!(bytes.capacity(), Header::SIZE + packet_size.size())
+                assert_eq!(bytes.capacity(), Header::LEGACY_SIZE + packet_size.size())
            }
        }

        #[test]
-        fn for_full_frame() {
+        fn for_bytes_with_versioned_header() {
+            // if header gets decoded there should be enough bytes for the entire frame
+            let packet_sizes = vec![
+                PacketSize::AckPacket,
+                PacketSize::RegularPacket,
+                PacketSize::ExtendedPacket8,
+                PacketSize::ExtendedPacket16,
+                PacketSize::ExtendedPacket32,
+            ];
+            for packet_size in packet_sizes {
+                let header = Header {
+                    packet_version: PacketVersion::Versioned(123),
+                    packet_size,
+                    packet_mode: Default::default(),
+                };
+                let mut bytes = BytesMut::new();
+                header.encode(&mut bytes);
+                assert!(SphinxCodec.decode(&mut bytes).unwrap().is_none());
+
+                assert_eq!(
+                    bytes.capacity(),
+                    Header::VERSIONED_SIZE + packet_size.size()
+                )
+            }
+        }
+
+        #[test]
+        fn for_full_frame_with_legacy_header() {
+            // if full frame is used exactly, there should be enough space for header + ack packet
+            let packet = FramedSphinxPacket {
+                header: Header {
+                    packet_version: PacketVersion::Legacy,
+                    packet_size: Default::default(),
+                    packet_mode: Default::default(),
+                },
+                packet: make_valid_sphinx_packet(Default::default()),
+            };
+
+            let mut bytes = BytesMut::new();
+            SphinxCodec.encode(packet, &mut bytes).unwrap();
+            assert!(SphinxCodec.decode(&mut bytes).unwrap().is_some());
+            assert_eq!(
+                bytes.capacity(),
+                Header::LEGACY_SIZE + PacketSize::AckPacket.size()
+            );
+        }
+
+        #[test]
+        fn for_full_frame_with_versioned_header() {
            // if full frame is used exactly, there should be enough space for header + ack packet
            let packet = FramedSphinxPacket {
                header: Header::default(),
@@ -247,13 +303,44 @@ mod packet_encoding {
            assert!(SphinxCodec.decode(&mut bytes).unwrap().is_some());
            assert_eq!(
                bytes.capacity(),
-                Header::SIZE + PacketSize::AckPacket.size()
+                Header::VERSIONED_SIZE + PacketSize::AckPacket.size()
            );
        }

        #[test]
-        fn for_full_frame_with_extra_byte() {
-            // if there was at least 1 byte left, there should be enough space for entire next frame
+        fn for_full_frame_with_extra_bytes_with_legacy_header() {
+            // if there was at least 2 byte left, there should be enough space for entire next frame
+            let packet_sizes = vec![
+                PacketSize::AckPacket,
+                PacketSize::RegularPacket,
+                PacketSize::ExtendedPacket8,
+                PacketSize::ExtendedPacket16,
+                PacketSize::ExtendedPacket32,
+            ];
+
+            for packet_size in packet_sizes {
+                let first_packet = FramedSphinxPacket {
+                    header: Header {
+                        packet_version: PacketVersion::Legacy,
+                        packet_size: Default::default(),
+                        packet_mode: Default::default(),
+                    },
+                    packet: make_valid_sphinx_packet(Default::default()),
+                };
+
+                let mut bytes = BytesMut::new();
+                SphinxCodec.encode(first_packet, &mut bytes).unwrap();
+                bytes.put_u8(packet_size as u8);
+                bytes.put_u8(PacketMode::default() as u8);
+                assert!(SphinxCodec.decode(&mut bytes).unwrap().is_some());
+
+                assert!(bytes.capacity() >= Header::LEGACY_SIZE + packet_size.size())
+            }
+        }
+
+        #[test]
+        fn for_full_frame_with_extra_bytes_with_versioned_header() {
+            // if there was at least 3 byte left, there should be enough space for entire next frame
            let packet_sizes = vec![
                PacketSize::AckPacket,
                PacketSize::RegularPacket,
@@ -270,10 +357,12 @@ mod packet_encoding {

                let mut bytes = BytesMut::new();
                SphinxCodec.encode(first_packet, &mut bytes).unwrap();
+                bytes.put_u8(PacketVersion::new_versioned(123).as_u8().unwrap());
                bytes.put_u8(packet_size as u8);
+                bytes.put_u8(PacketMode::default() as u8);
                assert!(SphinxCodec.decode(&mut bytes).unwrap().is_some());

-                assert!(bytes.capacity() >= Header::SIZE + packet_size.size())
+                assert!(bytes.capacity() >= Header::VERSIONED_SIZE + packet_size.size())
            }
        }
    }
@@ -4,6 +4,7 @@
 use crate::codec::SphinxCodecError;
 use bytes::{BufMut, BytesMut};
 use nymsphinx_params::packet_sizes::PacketSize;
+use nymsphinx_params::packet_version::PacketVersion;
 use nymsphinx_params::PacketMode;
 use nymsphinx_types::SphinxPacket;
 use std::convert::TryFrom;
@@ -17,12 +18,14 @@ pub struct FramedSphinxPacket {
 }

 impl FramedSphinxPacket {
-    pub fn new(packet: SphinxPacket, packet_mode: PacketMode) -> Self {
+    pub fn new(packet: SphinxPacket, packet_mode: PacketMode, use_legacy_version: bool) -> Self {
        // If this fails somebody is using the library in a super incorrect way, because they
        // already managed to somehow create a sphinx packet
        let packet_size = PacketSize::get_type(packet.len()).unwrap();
+
        FramedSphinxPacket {
            header: Header {
+                packet_version: PacketVersion::new(use_legacy_version),
                packet_size,
                packet_mode,
            },
@@ -48,6 +51,9 @@ impl FramedSphinxPacket {
 // but would that really be worth it?
 #[derive(Debug, Default, PartialEq, Eq, Copy, Clone)]
 pub struct Header {
+    /// Represents the wire format version used to construct this packet.
+    pub(crate) packet_version: PacketVersion,
+
    /// Represents type and consequently size of the included SphinxPacket.
    pub(crate) packet_size: PacketSize,

@@ -64,11 +70,25 @@ pub struct Header {
 }

 impl Header {
-    pub(crate) const SIZE: usize = 2;
+    pub(crate) const LEGACY_SIZE: usize = 2;
+    pub(crate) const VERSIONED_SIZE: usize = 3;
+
+    pub(crate) fn size(&self) -> usize {
+        if self.packet_version.is_legacy() {
+            Self::LEGACY_SIZE
+        } else {
+            Self::VERSIONED_SIZE
+        }
+    }

    pub(crate) fn encode(&self, dst: &mut BytesMut) {
        // we reserve one byte for `packet_size` and the other for `mode`
-        dst.reserve(Self::SIZE);
+        dst.reserve(Self::LEGACY_SIZE);
+        if let Some(version) = self.packet_version.as_u8() {
+            dst.reserve(Self::VERSIONED_SIZE);
+            dst.put_u8(version)
+        }
+
        dst.put_u8(self.packet_size as u8);
        dst.put_u8(self.packet_mode as u8);
        // reserve bytes for the actual packet
@@ -76,16 +96,30 @@ impl Header {
    }

    pub(crate) fn decode(src: &mut BytesMut) -> Result<Option<Self>, SphinxCodecError> {
-        if src.len() < Self::SIZE {
+        if src.len() < Self::LEGACY_SIZE {
            // can't do anything if we don't have enough bytes - but reserve enough for the next call
-            src.reserve(Self::SIZE);
+            src.reserve(Self::LEGACY_SIZE);
            return Ok(None);
        }

-        Ok(Some(Header {
-            packet_size: PacketSize::try_from(src[0])?,
-            packet_mode: PacketMode::try_from(src[1])?,
-        }))
+        let packet_version = PacketVersion::from(src[0]);
+        if packet_version.is_legacy() {
+            Ok(Some(Header {
+                packet_version,
+                packet_size: PacketSize::try_from(src[0])?,
+                packet_mode: PacketMode::try_from(src[1])?,
+            }))
+        } else if src.len() < Self::VERSIONED_SIZE {
+            // we're missing that 1 byte to read the full header...
+            src.reserve(Self::VERSIONED_SIZE);
+            Ok(None)
+        } else {
+            Ok(Some(Header {
+                packet_version,
+                packet_size: PacketSize::try_from(src[1])?,
+                packet_mode: PacketMode::try_from(src[2])?,
+            }))
+        }
    }
 }

@@ -108,7 +142,16 @@ mod header_encoding {
        // make sure this is still 'unknown' for if we make changes in the future
        assert!(PacketSize::try_from(unknown_packet_size).is_err());

-        let mut bytes = BytesMut::from([unknown_packet_size, PacketMode::default() as u8].as_ref());
+        // unfortunately this will only work for the 'versioned' variant
+        // due to the hack used to get legacy mode compatibility
+        let mut bytes = BytesMut::from(
+            [
+                PacketVersion::new_versioned(123).as_u8().unwrap(),
+                unknown_packet_size,
+                PacketMode::default() as u8,
+            ]
+            .as_ref(),
+        );
        assert!(Header::decode(&mut bytes).is_err())
    }

@@ -127,16 +170,16 @@ mod header_encoding {
        let mut empty_bytes = BytesMut::new();
        let decode_attempt_1 = Header::decode(&mut empty_bytes).unwrap();
        assert!(decode_attempt_1.is_none());
-        assert!(empty_bytes.capacity() > Header::SIZE);
+        assert!(empty_bytes.capacity() > Header::LEGACY_SIZE);

        let mut empty_bytes = BytesMut::with_capacity(1);
        let decode_attempt_2 = Header::decode(&mut empty_bytes).unwrap();
        assert!(decode_attempt_2.is_none());
-        assert!(empty_bytes.capacity() > Header::SIZE);
+        assert!(empty_bytes.capacity() > Header::LEGACY_SIZE);
    }

    #[test]
-    fn header_encoding_reserves_enough_bytes_for_full_sphinx_packet() {
+    fn header_encoding_reserves_enough_bytes_for_full_sphinx_packet_in_legacy_mode() {
        let packet_sizes = vec![
            PacketSize::AckPacket,
            PacketSize::RegularPacket,
@@ -146,6 +189,28 @@ mod header_encoding {
        ];
        for packet_size in packet_sizes {
            let header = Header {
+                packet_version: PacketVersion::Legacy,
+                packet_size,
+                packet_mode: Default::default(),
+            };
+            let mut bytes = BytesMut::new();
+            header.encode(&mut bytes);
+            assert_eq!(bytes.capacity(), bytes.len() + packet_size.size())
+        }
+    }
+
+    #[test]
+    fn header_encoding_reserves_enough_bytes_for_full_sphinx_packet_in_versioned_mode() {
+        let packet_sizes = vec![
+            PacketSize::AckPacket,
+            PacketSize::RegularPacket,
+            PacketSize::ExtendedPacket8,
+            PacketSize::ExtendedPacket16,
+            PacketSize::ExtendedPacket32,
+        ];
+        for packet_size in packet_sizes {
+            let header = Header {
+                packet_version: PacketVersion::Versioned(123),
                packet_size,
                packet_mode: Default::default(),
            };
@@ -13,6 +13,7 @@ pub use packet_sizes::PacketSize;

 pub mod packet_modes;
 pub mod packet_sizes;
+pub mod packet_version;

 // If somebody can provide an argument why it might be reasonable to have more than 255 mix hops,
 // I will change this to [`usize`]
@@ -24,6 +25,17 @@ pub const DEFAULT_NUM_MIX_HOPS: u8 = 3;
 pub const FRAG_ID_LEN: usize = 5;
 pub type SerializedFragmentIdentifier = [u8; FRAG_ID_LEN];

+// wait, wait, but why are we starting with version 7?
+// when packet header gets serialized, the following bytes (in that order) are put onto the wire:
+// - packet_version (starting with v1.1.0)
+// - packet_size indicator
+// - packet_mode
+// it also just so happens that the only valid values for packet_size indicator include values 1-6
+// therefore if we receive byte `7` (or larger than that) we'll know we received a versioned packet,
+// otherwise we should treat it as legacy
+/// Increment it whenever we perform any breaking change in the wire format!
+const CURRENT_PACKET_VERSION_NUMBER: u8 = 7;
+
 // TODO: ask @AP about the choice of below algorithms

 /// Hashing algorithm used during hkdf for ephemeral shared key generation per sphinx packet payload.
@@ -0,0 +1,59 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::{PacketSize, CURRENT_PACKET_VERSION_NUMBER};
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum PacketVersion {
+    // this will allow updated mixnodes to still understand packets from before the update
+    Legacy,
+    Versioned(u8),
+}
+
+impl PacketVersion {
+    pub fn new(use_legacy: bool) -> Self {
+        if use_legacy {
+            Self::new_legacy()
+        } else {
+            Self::new_versioned(CURRENT_PACKET_VERSION_NUMBER)
+        }
+    }
+
+    pub fn new_legacy() -> Self {
+        PacketVersion::Legacy
+    }
+
+    pub fn new_versioned(version: u8) -> Self {
+        PacketVersion::Versioned(version)
+    }
+
+    pub fn is_legacy(&self) -> bool {
+        matches!(self, PacketVersion::Legacy)
+    }
+
+    pub fn as_u8(&self) -> Option<u8> {
+        match self {
+            PacketVersion::Legacy => None,
+            PacketVersion::Versioned(version) => Some(*version),
+        }
+    }
+}
+
+impl From<u8> for PacketVersion {
+    fn from(v: u8) -> Self {
+        match v {
+            n if n == PacketSize::RegularPacket as u8 => PacketVersion::Legacy,
+            n if n == PacketSize::AckPacket as u8 => PacketVersion::Legacy,
+            n if n == PacketSize::ExtendedPacket8 as u8 => PacketVersion::Legacy,
+            n if n == PacketSize::ExtendedPacket16 as u8 => PacketVersion::Legacy,
+            n if n == PacketSize::ExtendedPacket32 as u8 => PacketVersion::Legacy,
+            n => PacketVersion::Versioned(n),
+        }
+    }
+}
+
+impl Default for PacketVersion {
+    fn default() -> Self {
+        PacketVersion::Versioned(CURRENT_PACKET_VERSION_NUMBER)
+    }
+}
@@ -13,6 +13,13 @@ pub struct OrderedMessageBuffer {
    messages: HashMap<u64, OrderedMessage>,
 }

+/// Data returned from `OrderedMessageBuffer` on a successful read of gapless ordered data.
+#[derive(Debug, PartialEq, Eq)]
+pub struct ReadContiguousData {
+    pub data: Vec<u8>,
+    pub last_index: u64,
+}
+
 impl OrderedMessageBuffer {
    pub fn new() -> OrderedMessageBuffer {
        OrderedMessageBuffer {
@@ -42,7 +49,7 @@ impl OrderedMessageBuffer {
    /// a read will return the bytes of messages 0, 1, 2. Subsequent reads will
    /// return `None` until message 3 comes in, at which point 3, 4, and any
    /// further contiguous messages which have arrived will be returned.
-    pub fn read(&mut self) -> Option<Vec<u8>> {
+    pub fn read(&mut self) -> Option<ReadContiguousData> {
        if !self.messages.contains_key(&self.next_index) {
            return None;
        }
@@ -66,7 +73,10 @@ impl OrderedMessageBuffer {
            .collect();

        trace!("Returning {} bytes from ordered message buffer", data.len());
-        Some(data)
+        Some(ReadContiguousData {
+            data,
+            last_index: index,
+        })
    }
 }

@@ -102,11 +112,11 @@ mod test_chunking_and_reassembling {
                };

                buffer.write(first_message);
-                let first_read = buffer.read().unwrap();
+                let first_read = buffer.read().unwrap().data;
                assert_eq!(vec![1, 2, 3, 4], first_read);

                buffer.write(second_message);
-                let second_read = buffer.read().unwrap();
+                let second_read = buffer.read().unwrap().data;
                assert_eq!(vec![5, 6, 7, 8], second_read);

                assert_eq!(None, buffer.read()); // second read on fully ordered result set is empty
@@ -128,7 +138,7 @@ mod test_chunking_and_reassembling {
                buffer.write(first_message);
                buffer.write(second_message);
                let second_read = buffer.read();
-                assert_eq!(vec![1, 2, 3, 4, 5, 6, 7, 8], second_read.unwrap());
+                assert_eq!(vec![1, 2, 3, 4, 5, 6, 7, 8], second_read.unwrap().data);
                assert_eq!(None, buffer.read()); // second read on fully ordered result set is empty
            }

@@ -147,8 +157,8 @@ mod test_chunking_and_reassembling {

                buffer.write(second_message);
                buffer.write(first_message);
-                let read = buffer.read();
-                assert_eq!(vec![1, 2, 3, 4, 5, 6, 7, 8], read.unwrap());
+                let read = buffer.read().unwrap().data;
+                assert_eq!(vec![1, 2, 3, 4, 5, 6, 7, 8], read);
                assert_eq!(None, buffer.read()); // second read on fully ordered result set is empty
            }
        }
@@ -182,7 +192,7 @@ mod test_chunking_and_reassembling {
            #[test]
            fn everything_up_to_the_indexing_gap_is_returned() {
                let mut buffer = setup();
-                let ordered_bytes = buffer.read().unwrap();
+                let ordered_bytes = buffer.read().unwrap().data;
                assert_eq!([0, 0, 0, 0, 1, 1, 1, 1].to_vec(), ordered_bytes);

                // we shouldn't get any more from a second attempt if nothing is added
@@ -208,7 +218,7 @@ mod test_chunking_and_reassembling {
                };
                buffer.write(two_message);

-                let more_ordered_bytes = buffer.read().unwrap();
+                let more_ordered_bytes = buffer.read().unwrap().data;
                assert_eq!([2, 2, 2, 2, 3, 3, 3, 3].to_vec(), more_ordered_bytes);

                // let's add another message
@@ -227,7 +237,10 @@ mod test_chunking_and_reassembling {
                };
                buffer.write(four_message);

-                assert_eq!([4, 4, 4, 4, 5, 5, 5, 5].to_vec(), buffer.read().unwrap());
+                assert_eq!(
+                    [4, 4, 4, 4, 5, 5, 5, 5].to_vec(),
+                    buffer.read().unwrap().data
+                );

                // at this point we should again get back nothing if we try a read
                assert_eq!(None, buffer.read());
@@ -2,7 +2,7 @@ mod buffer;
 mod message;
 mod sender;

-pub use buffer::OrderedMessageBuffer;
+pub use buffer::{OrderedMessageBuffer, ReadContiguousData};
 pub use message::MessageError;
 pub use message::OrderedMessage;
 pub use sender::OrderedMessageSender;
@@ -4,7 +4,7 @@
 use futures::channel::mpsc;
 use futures::StreamExt;
 use log::*;
-use ordered_buffer::{OrderedMessage, OrderedMessageBuffer};
+use ordered_buffer::{OrderedMessage, OrderedMessageBuffer, ReadContiguousData};
 use socks5_requests::ConnectionId;
 use std::collections::{HashMap, HashSet};
 use task::ShutdownListener;
@@ -38,12 +38,13 @@ pub enum ControllerCommand {

 struct ActiveConnection {
    is_closed: bool,
+    closed_at_index: Option<u64>,
    connection_sender: Option<ConnectionSender>,
    ordered_buffer: OrderedMessageBuffer,
 }

 impl ActiveConnection {
-    fn write_to_buf(&mut self, payload: Vec<u8>) {
+    fn write_to_buf(&mut self, payload: Vec<u8>, is_closed: bool) {
        let ordered_message = match OrderedMessage::try_from_bytes(payload) {
            Ok(msg) => msg,
            Err(err) => {
@@ -51,10 +52,13 @@ impl ActiveConnection {
                return;
            }
        };
+        if is_closed {
+            self.closed_at_index = Some(ordered_message.index);
+        }
        self.ordered_buffer.write(ordered_message);
    }

-    fn read_from_buf(&mut self) -> Option<Vec<u8>> {
+    fn read_from_buf(&mut self) -> Option<ReadContiguousData> {
        self.ordered_buffer.read()
    }
 }
@@ -99,6 +103,7 @@ impl Controller {
            is_closed: false,
            connection_sender: Some(connection_sender),
            ordered_buffer: OrderedMessageBuffer::new(),
+            closed_at_index: None,
        };
        if let Some(_active_conn) = self.active_connections.insert(conn_id, active_connection) {
            error!("Received a duplicate 'Connect'!")
@@ -127,21 +132,23 @@ impl Controller {
    fn send_to_connection(&mut self, conn_id: ConnectionId, payload: Vec<u8>, is_closed: bool) {
        if let Some(active_connection) = self.active_connections.get_mut(&conn_id) {
            if !payload.is_empty() {
-                active_connection.write_to_buf(payload);
+                active_connection.write_to_buf(payload, is_closed);
            } else if !is_closed {
                error!("Tried to write an empty message to a not-closing connection. Please let us know if you see this message");
            }
-            // if messages get unordered, make sure we don't lose information about
-            // remote socket getting closed!
-            active_connection.is_closed |= is_closed;

            if let Some(payload) = active_connection.read_from_buf() {
+                if let Some(closed_at_index) = active_connection.closed_at_index {
+                    if payload.last_index > closed_at_index {
+                        active_connection.is_closed = true;
+                    }
+                }
                if let Err(err) = active_connection
                    .connection_sender
                    .as_mut()
                    .unwrap()
                    .unbounded_send(ConnectionMessage {
-                        payload,
+                        payload: payload.data,
                        socket_closed: active_connection.is_closed,
                    })
                {
@@ -62,6 +62,7 @@ pub struct DelegationWithEverything {

    // DEPRECATED, IF POSSIBLE TRY TO DISCONTINUE USE OF IT!
    pub pending_events: Vec<DelegationEvent>,
+    pub mixnode_is_unbonding: Option<bool>,
 }

 #[cfg_attr(feature = "generate-ts", derive(ts_rs::TS))]
@@ -1,14 +1,46 @@
+## [nym-contracts-v1.1.0](https://github.com/nymtech/nym/tree/nym-contracts-v1.1.0) (2022-11-09)
+
+### Changed
+- mixnet-contract: rework of rewarding ([#1472]), which includes, but is not limited to:
+  - internal reward accounting was modified to be similar to the ideas presented in Cosmos' F1 paper, which results in throughput gains and no storage or gas cost bloat over time,
+  - introduced internal queues for pending epoch and interval events that only get resolved once relevant epoch/interval rolls over
+  - the contract no longer stores any historical information regarding past epochs/parameters/stake state for the purposes of rewarding
+  - a lot of queries got renamed to keep naming more consistent,
+  - introduced new utility-based queries such as a query for reward estimation for the current epoch,
+  - mixnodes are now identified by a monotonously increasing `mix_id`
+  - bonding now results in getting fresh `mix_id` and thus if given node decides to unbond and rebond, it will lose all its delegations,
+  - mixnode operators are now allowed to set their operating costs as opposed to having fixed value of 40nym/interval
+  - rewarding parameters are now correctly updated at an **interval** end
+  - rewarding parameters now include a staking supply scale factor attribute (beta in the tokenomics paper)
+  - node performance can now be more granular with internal `Decimal` representation as opposed to an `u8`
+  - node profit margin can now be more granular with internal `Decimal` representation as opposed to an `u8`
+  - mixnode operators are now allowed to change their configuration options, such as port information, without having to unbond
+  - mixnode unbonding is no longer instantaneous, instead it happens once an epoch rolls over
+  - it is now possible to query for operator and node history to see how often (and with what parameters) they rebonded
+  - other minor bugfixes and changes
+  - ...
+  - new exciting bugs to find and squash
+
+- vesting-contract: optional locked token pledge cap per account ([#1687]), defaults to 10%
+- vesting-contract: updated internal delegation storage due to mixnet contract revamp ([#1472])
+
+### Added
+- vesting-contract: added query for obtaining contract build information ([#1726])
+
+[#1472]: https://github.com/nymtech/nym/pull/1472
+[#1687]: https://github.com/nymtech/nym/pull/1687
+[#1726]: https://github.com/nymtech/nym/pull/1726
+
+
 ## [nym-contracts-v1.0.2](https://github.com/nymtech/nym/tree/nym-contracts-v1.0.2) (2022-09-13)

 ### Added

 - vesting-contract: added queries for delegation timestamps and paged query for all vesting delegations in the contract ([#1569])
- all binaries: added shell completion and [Fig](fig.io) spec generation ([#1638])

 ### Changed

 - mixnet-contract: compounding delegator rewards now happens instantaneously as opposed to having to wait for the current epoch to finish ([#1571])
- network-requester: updated CLI to use `clap` macros ([#1638])

 ### Fixed

@@ -18,9 +50,8 @@

 [#1544]: https://github.com/nymtech/nym/pull/1544
 [#1569]: https://github.com/nymtech/nym/pull/1569
-[#1569]: https://github.com/nymtech/nym/pull/1571
+[#1571]: https://github.com/nymtech/nym/pull/1571
 [#1613]: https://github.com/nymtech/nym/pull/1613
-[#1638]: https://github.com/nymtech/nym/pull/1638

 ## [nym-contracts-v1.0.1](https://github.com/nymtech/nym/tree/nym-contracts-v1.0.1) (2022-06-22)

@@ -930,7 +930,7 @@ checksum = "a3e378b66a060d48947b590737b30a1be76706c8dd7b8ba0f2fe3989c68a853f"

 [[package]]
 name = "mixnet-contract"
-version = "1.0.2"
+version = "1.1.0"
 dependencies = [
 "bs58",
 "cosmwasm-schema",
@@ -1615,6 +1615,7 @@ dependencies = [
 "schemars",
 "serde",
 "thiserror",
+ "vergen",
 "vesting-contract-common",
 ]

@@ -1624,7 +1625,6 @@ version = "0.1.0"
 dependencies = [
 "contracts-common",
 "cosmwasm-std",
- "log",
 "mixnet-contract-common",
 "schemars",
 "serde",
@@ -1,6 +1,6 @@
 [package]
 name = "mixnet-contract"
-version = "1.0.2"
+version = "1.1.0"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
 edition = "2021"

@@ -23,4 +23,7 @@ cw-storage-plus = { version = "0.13.4", features = ["iterator"] }

 schemars = "0.8"
 serde = { version = "1.0", default-features = false, features = ["derive"] }
-thiserror = { version = "1.0" }
+thiserror = { version = "1.0" }
+
+[build-dependencies]
+vergen = { version = "5", default-features = false, features = ["build", "git", "rustc"] }
@@ -0,0 +1,8 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use vergen::{vergen, Config};
+
+fn main() {
+    vergen(Config::default()).expect("failed to extract build metadata")
+}
@@ -1,13 +1,14 @@
 use crate::errors::ContractError;
 use crate::queued_migrations::migrate_to_v2_mixnet_contract;
 use crate::storage::{
-    account_from_address, BlockTimestampSecs, ADMIN, DELEGATIONS, MIXNET_CONTRACT_ADDRESS,
-    MIX_DENOM,
+    account_from_address, save_account, BlockTimestampSecs, ADMIN, DELEGATIONS,
+    MIXNET_CONTRACT_ADDRESS, MIX_DENOM,
 };
 use crate::traits::{
    DelegatingAccount, GatewayBondingAccount, MixnodeBondingAccount, VestingAccount,
 };
 use crate::vesting::{populate_vesting_periods, Account};
+use contracts_common::ContractBuildInformation;
 use cosmwasm_std::{
    coin, entry_point, to_binary, BankMsg, Coin, Deps, DepsMut, Env, MessageInfo, Order,
    QueryResponse, Response, StdResult, Timestamp, Uint128,
@@ -157,7 +158,7 @@ pub fn try_update_locked_pledge_cap(
    let mut account = account_from_address(&address, deps.storage, deps.api)?;

    account.pledge_cap = Some(cap);
-    // update_locked_pledge_cap(amount, deps.storage)?;
+    save_account(&account, deps.storage)?;
    Ok(Response::default())
 }

@@ -500,6 +501,7 @@ fn try_create_periodic_vesting_account(
 #[entry_point]
 pub fn query(deps: Deps<'_>, env: Env, msg: QueryMsg) -> Result<QueryResponse, ContractError> {
    let query_res = match msg {
+        QueryMsg::GetContractVersion {} => to_binary(&get_contract_version()),
        QueryMsg::LockedCoins {
            vesting_account_address,
            block_time,
@@ -606,6 +608,21 @@ pub fn try_get_account(address: &str, deps: Deps<'_>) -> Result<Account, Contrac
    account_from_address(address, deps.storage, deps.api)
 }

+/// Gets build information of this contract.
+pub fn get_contract_version() -> ContractBuildInformation {
+    // as per docs
+    // env! macro will expand to the value of the named environment variable at
+    // compile time, yielding an expression of type `&'static str`
+    ContractBuildInformation {
+        build_timestamp: env!("VERGEN_BUILD_TIMESTAMP").to_string(),
+        build_version: env!("VERGEN_BUILD_SEMVER").to_string(),
+        commit_sha: env!("VERGEN_GIT_SHA").to_string(),
+        commit_timestamp: env!("VERGEN_GIT_COMMIT_TIMESTAMP").to_string(),
+        commit_branch: env!("VERGEN_GIT_BRANCH").to_string(),
+        rustc_version: env!("VERGEN_RUSTC_SEMVER").to_string(),
+    }
+}
+
 /// Gets currently locked coins, see [crate::traits::VestingAccount::locked_coins]
 pub fn try_get_locked_coins(
    vesting_account_address: &str,
@@ -105,7 +105,7 @@ impl VestingAccount for Account {
    }

    fn get_end_time(&self) -> Timestamp {
-        self.periods[(self.num_vesting_periods() - 1) as usize].end_time()
+        self.periods[(self.num_vesting_periods() - 1)].end_time()
    }

    fn get_original_vesting(&self) -> OriginalVestingResponse {
@@ -133,7 +133,7 @@ impl VestingAccount for Account {
        let start_time = match period {
            Period::Before => 0,
            Period::After => u64::MAX,
-            Period::In(idx) => self.periods[idx as usize].start_time,
+            Period::In(idx) => self.periods[idx].start_time,
        };

        let coin = self.total_delegations_at_timestamp(storage, start_time)?;
@@ -179,7 +179,7 @@ impl VestingAccount for Account {
        let start_time = match period {
            Period::Before => 0,
            Period::After => u64::MAX,
-            Period::In(idx) => self.periods[idx as usize].start_time,
+            Period::In(idx) => self.periods[idx].start_time,
        };

        let amount = if let Some(bond) = self
@@ -15,7 +15,7 @@ pub struct VestingPeriod {

 impl VestingPeriod {
    pub fn end_time(&self) -> Timestamp {
-        Timestamp::from_seconds(self.start_time + self.period_seconds as u64)
+        Timestamp::from_seconds(self.start_time + self.period_seconds)
    }
 }

@@ -26,7 +26,7 @@ pub fn populate_vesting_periods(
    let mut periods = Vec::with_capacity(vesting_spec.num_periods() as usize);
    for i in 0..vesting_spec.num_periods() {
        let period = VestingPeriod {
-            start_time: start_time + i as u64 * vesting_spec.period_seconds(),
+            start_time: start_time + i * vesting_spec.period_seconds(),
            period_seconds: vesting_spec.period_seconds(),
        };
        periods.push(period);
@@ -1,6 +1,6 @@
 [package]
 name = "explorer-api"
-version = "1.0.1"
+version = "1.1.0"
 edition = "2021"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -29,5 +29,6 @@ dotenv = "0.15.0"
 mixnet-contract-common = { path = "../common/cosmwasm-smart-contracts/mixnet-contract" }
 contracts-common = { path = "../common/cosmwasm-smart-contracts/contracts-common" }
 network-defaults = { path = "../common/network-defaults" }
+logging = { path = "../common/logging"}
 task = { path = "../common/task" }
 validator-client = { path = "../common/client-libs/validator-client", features=["nymd-client"] }
@@ -6,6 +6,7 @@ extern crate rocket_okapi;
 use clap::Parser;
 use dotenv::dotenv;
 use log::info;
+use logging::setup_logging;
 use network_defaults::setup_env;
 use task::ShutdownNotifier;

@@ -115,18 +116,3 @@ async fn wait_for_signal() {
        },
    }
 }
-
-fn setup_logging() {
-    let mut log_builder = pretty_env_logger::formatted_timed_builder();
-    if let Ok(s) = ::std::env::var("RUST_LOG") {
-        log_builder.parse_filters(&s);
-    } else {
-        // default to 'Info'
-        log_builder.filter(None, log::LevelFilter::Info);
-    }
-
-    log_builder
-        .filter_module("tokio_reactor", log::LevelFilter::Warn)
-        .filter_module("reqwest", log::LevelFilter::Warn)
-        .init();
-}
@@ -41,6 +41,8 @@ pub(crate) async fn retrieve_mixnode_econ_stats(

    Some(EconomicDynamicsStats {
        stake_saturation: best_effort_small_dec_to_f64(stake_saturation.saturation) as f32,
+        uncapped_saturation: best_effort_small_dec_to_f64(stake_saturation.uncapped_saturation)
+            as f32,
        active_set_inclusion_probability: inclusion_probability.in_active,
        reserve_set_inclusion_probability: inclusion_probability.in_reserve,
        // drop precision for compatibility sake
@@ -3,6 +3,7 @@

 use crate::cache::Cache;
 use crate::mix_nodes::location::Location;
+use contracts_common::Percent;
 use mixnet_contract_common::Delegation;
 use mixnet_contract_common::{Addr, Coin, Layer, MixId, MixNode};
 use serde::Deserialize;
@@ -33,10 +34,12 @@ pub(crate) struct PrettyDetailedMixNodeBond {
    pub layer: Layer,
    pub mix_node: MixNode,
    pub stake_saturation: f32,
+    pub uncapped_saturation: f32,
    pub avg_uptime: u8,
    pub estimated_operator_apy: f64,
    pub estimated_delegators_apy: f64,
    pub operating_cost: Coin,
+    pub profit_margin_percent: Percent,
 }

 #[derive(Clone, Debug, Deserialize, Serialize, PartialEq, JsonSchema)]
@@ -151,6 +154,7 @@ pub(crate) struct NodeStats {
 #[derive(Clone, Serialize, Deserialize, JsonSchema)]
 pub(crate) struct EconomicDynamicsStats {
    pub(crate) stake_saturation: f32,
+    pub(crate) uncapped_saturation: f32,

    pub(crate) active_set_inclusion_probability: SelectionChance,
    pub(crate) reserve_set_inclusion_probability: SelectionChance,
@@ -126,19 +126,6 @@ impl ThreadsafeMixNodesCache {
        self.mixnodes.read().await.get_mixnode(mix_id)
    }

-    pub(crate) async fn get_mixnode_by_identity(
-        &self,
-        pubkey: &str,
-    ) -> Option<MixNodeBondAnnotated> {
-        let all_nodes = self.get_mixnodes().await?;
-        for (_, node) in all_nodes {
-            if node.mix_node().identity_key == pubkey {
-                return Some(node);
-            }
-        }
-        None
-    }
-
    pub(crate) async fn get_mixnodes(&self) -> Option<HashMap<MixId, MixNodeBondAnnotated>> {
        self.mixnodes.read().await.get_mixnodes()
    }
@@ -164,9 +151,12 @@ impl ThreadsafeMixNodesCache {
            mix_node: node.mixnode_details.bond_information.mix_node.clone(),
            avg_uptime: node.performance.round_to_integer(),
            stake_saturation: best_effort_small_dec_to_f64(node.stake_saturation) as f32,
+            uncapped_saturation: best_effort_small_dec_to_f64(node.uncapped_stake_saturation)
+                as f32,
            estimated_operator_apy: best_effort_small_dec_to_f64(node.estimated_operator_apy),
            estimated_delegators_apy: best_effort_small_dec_to_f64(node.estimated_delegators_apy),
            operating_cost: rewarding_info.cost_params.interval_operating_cost.clone(),
+            profit_margin_percent: rewarding_info.cost_params.profit_margin_percent,
        }
    }

@@ -1,7 +1,7 @@
 // Copyright 2021-2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use mixnet_contract_common::MixNode;
+use mixnet_contract_common::{MixId, MixNode};
 use rocket::serde::json::Json;
 use rocket::{Route, State};
 use rocket_okapi::okapi::openapi3::OpenApi;
@@ -20,41 +20,39 @@ pub fn ping_make_default_routes(settings: &OpenApiSettings) -> (Vec<Route>, Open
    openapi_get_routes_spec![settings: index]
 }

-// TODO: I'm not deprecating this one explicitly since we don't have
-// a decision on whether nodes should be accessed (as in using URL) by id or identity key
 #[openapi(tag = "ping")]
-#[get("/<pubkey>")]
+#[get("/<mix_id>")]
 pub(crate) async fn index(
-    pubkey: &str,
+    mix_id: MixId,
    state: &State<ExplorerApiStateContext>,
 ) -> Option<Json<PingResponse>> {
-    match state.inner.ping.clone().get(pubkey).await {
+    match state.inner.ping.clone().get(mix_id).await {
        Some(cache_value) => {
-            trace!("Returning cached value for {}", pubkey);
+            trace!("Returning cached value for {}", mix_id);
            Some(Json(PingResponse {
                pending: cache_value.pending,
                ports: cache_value.ports,
            }))
        }
        None => {
-            trace!("No cache value for {}", pubkey);
+            trace!("No cache value for {}", mix_id);

-            match state.inner.get_mix_node_by_pubkey(pubkey).await {
+            match state.inner.get_mix_node(mix_id).await {
                Some(node) => {
                    // set status to pending, so that any HTTP requests are pending
-                    state.inner.ping.set_pending(pubkey).await;
+                    state.inner.ping.set_pending(mix_id).await;

                    // do the check
                    let ports = Some(port_check(node.mix_node()).await);
-                    trace!("Tested mix node {}: {:?}", pubkey, ports);
+                    trace!("Tested mix node {}: {:?}", mix_id, ports);
                    let response = PingResponse {
                        ports,
                        pending: false,
                    };

                    // cache for 1 min
-                    trace!("Caching value for {}", pubkey);
-                    state.inner.ping.set(pubkey, response.clone()).await;
+                    trace!("Caching value for {}", mix_id);
+                    state.inner.ping.set(mix_id, response.clone()).await;

                    // return response
                    Some(Json(response))
@@ -2,11 +2,12 @@ use std::collections::HashMap;
 use std::sync::Arc;
 use std::time::{Duration, SystemTime};

+use mixnet_contract_common::MixId;
 use serde::Deserialize;
 use serde::Serialize;
 use tokio::sync::RwLock;

-pub(crate) type PingCache = HashMap<String, PingCacheItem>;
+pub(crate) type PingCache = HashMap<MixId, PingCacheItem>;

 const PING_TTL: Duration = Duration::from_secs(60 * 5); // 5 mins, before port check will be re-tried (only while pending)
 const CACHE_TTL: Duration = Duration::from_secs(60 * 60); // 1 hour, to cache result from port check
@@ -23,11 +24,11 @@ impl ThreadsafePingCache {
        }
    }

-    pub(crate) async fn get(&self, identity_key: &str) -> Option<PingResponse> {
+    pub(crate) async fn get(&self, mix_id: MixId) -> Option<PingResponse> {
        self.inner
            .read()
            .await
-            .get(identity_key)
+            .get(&mix_id)
            .filter(|cache_item| cache_item.valid_until > SystemTime::now())
            .map(|cache_item| {
                if cache_item.pending {
@@ -43,9 +44,9 @@ impl ThreadsafePingCache {
            })
    }

-    pub(crate) async fn set_pending(&self, identity_key: &str) {
+    pub(crate) async fn set_pending(&self, mix_id: MixId) {
        self.inner.write().await.insert(
-            identity_key.to_string(),
+            mix_id,
            PingCacheItem {
                pending: true,
                valid_until: SystemTime::now() + PING_TTL,
@@ -54,9 +55,9 @@ impl ThreadsafePingCache {
        );
    }

-    pub(crate) async fn set(&self, identity_key: &str, item: PingResponse) {
+    pub(crate) async fn set(&self, mix_id: MixId, item: PingResponse) {
        self.inner.write().await.insert(
-            identity_key.to_string(),
+            mix_id,
            PingCacheItem {
                pending: false,
                valid_until: SystemTime::now() + CACHE_TTL,
@@ -3,7 +3,7 @@ use std::path::Path;

 use chrono::{DateTime, Utc};
 use log::info;
-use mixnet_contract_common::{IdentityKeyRef, MixId};
+use mixnet_contract_common::MixId;
 use serde::{Deserialize, Serialize};

 use crate::client::ThreadsafeValidatorClient;
@@ -41,13 +41,6 @@ impl ExplorerApiState {
    pub(crate) async fn get_mix_node(&self, mix_id: MixId) -> Option<MixNodeBondAnnotated> {
        self.mixnodes.get_mixnode(mix_id).await
    }
-
-    pub(crate) async fn get_mix_node_by_pubkey(
-        &self,
-        pubkey: IdentityKeyRef<'_>,
-    ) -> Option<MixNodeBondAnnotated> {
-        self.mixnodes.get_mixnode_by_identity(pubkey).await
-    }
 }

 #[derive(Debug, Serialize, Deserialize)]
@@ -6,14 +6,16 @@ export const EconomicsInfoColumns: ColumnsType[] = [
    title: 'Estimated Total Reward',
    flex: 1,
    headerAlign: 'left',
-    tooltipInfo: 'Estimated reward per epoch for this profit margin if your node is selected in the active set.',
+    tooltipInfo:
+      'Estimated node reward (total for the operator and delegators) in the current epoch. There are roughly 24 epochs in a day.',
  },
  {
    field: 'estimatedOperatorReward',
    title: 'Estimated Operator Reward',
    flex: 1,
    headerAlign: 'left',
-    tooltipInfo: 'Estimated reward per epoch for this profit margin if your node is selected in the active set.',
+    tooltipInfo:
+      "Estimated operator's reward (including PM and Operating Cost) in the current epoch. There are roughly 24 epochs in a day.",
  },
  {
    field: 'selectionChance',
@@ -29,7 +31,7 @@ export const EconomicsInfoColumns: ColumnsType[] = [
    flex: 1,
    headerAlign: 'left',
    tooltipInfo:
-      'Level of stake saturation for this node. Nodes receive more rewards the higher their saturation level, up to 100%. Beyond 100% no additional rewards are granted. The current stake saturation level is: 1 million NYM, computed as S/K where S is  total amount of tokens available to stakeholders and K is the number of nodes in the reward set.',
+      'Level of stake saturation for this node. Nodes receive more rewards the higher their saturation level, up to 100%. Beyond 100% no additional rewards are granted. The current stake saturation level is: 750k NYM, computed as S/K where S is  total amount of tokens available to stakeholders and K is the number of nodes in the reward set.',
  },
  {
    field: 'profitMargin',
@@ -37,7 +39,7 @@ export const EconomicsInfoColumns: ColumnsType[] = [
    flex: 1,
    headerAlign: 'left',
    tooltipInfo:
-      'Percentage of the delegates rewards that the operator takes as fee before rewards are distributed to the delegates.',
+      'Percentage of the delegators rewards that the operator takes as fee before rewards are distributed to the delegators.',
  },
  {
    field: 'operatingCost',
@@ -2,24 +2,10 @@ import { currencyToString, unymToNym } from '../../../utils/currency';
 import { useMixnodeContext } from '../../../context/mixnode';
 import { ApiState, MixNodeEconomicDynamicsStatsResponse } from '../../../typeDefs/explorer-api';
 import { EconomicsInfoRowWithIndex } from './types';
+import { toPercentIntegerString } from '../../../utils';

-const selectionChance = (economicDynamicsStats: ApiState<MixNodeEconomicDynamicsStatsResponse> | undefined) => {
-  const inclusionProbability = economicDynamicsStats?.data?.active_set_inclusion_probability;
-  // TODO: when v2 will be deployed, remove cases: VeryHigh, Moderate and VeryLow
-  switch (inclusionProbability) {
-    case 'VeryLow':
-      return 'Very Low';
-    case 'VeryHigh':
-      return 'Very High';
-    case 'High':
-    case 'Good':
-    case 'Low':
-    case 'Moderate':
-      return inclusionProbability;
-    default:
-      return '-';
-  }
-};
+const selectionChance = (economicDynamicsStats: ApiState<MixNodeEconomicDynamicsStatsResponse> | undefined) =>
+  economicDynamicsStats?.data?.active_set_inclusion_probability || '-';

 export const EconomicsInfoRows = (): EconomicsInfoRowWithIndex => {
  const { economicDynamicsStats, mixNode } = useMixnodeContext();
@@ -28,8 +14,10 @@ export const EconomicsInfoRows = (): EconomicsInfoRowWithIndex => {
    currencyToString((economicDynamicsStats?.data?.estimated_total_node_reward || '').toString()) || '-';
  const estimatedOperatorRewards =
    currencyToString((economicDynamicsStats?.data?.estimated_operator_reward || '').toString()) || '-';
-  const stakeSaturation = economicDynamicsStats?.data?.stake_saturation || '-';
-  const profitMargin = mixNode?.data?.mix_node.profit_margin_percent || '-';
+  const stakeSaturation = economicDynamicsStats?.data?.uncapped_saturation || '-';
+  const profitMargin = mixNode?.data?.profit_margin_percent
+    ? toPercentIntegerString(mixNode?.data?.profit_margin_percent)
+    : '-';
  const avgUptime = economicDynamicsStats?.data?.current_interval_uptime;

  const opCost = mixNode?.data?.operating_cost;
@@ -1,5 +1,6 @@
 /* eslint-disable camelcase */
 import { MixNodeResponse, MixNodeResponseItem, MixnodeStatus } from '../../typeDefs/explorer-api';
+import { toPercentIntegerString } from '../../utils';
 import { unymToNym } from '../../utils/currency';

 export type MixnodeRowType = {
@@ -29,8 +30,8 @@ export function mixNodeResponseItemToMixnodeRowType(item: MixNodeResponseItem):
  const delegations = Number(item.total_delegation.amount) || 0;
  const totalBond = pledge + delegations;
  const selfPercentage = ((pledge * 100) / totalBond).toFixed(2);
-  const profitPercentage = item.mix_node.profit_margin_percent || 0;
-  const stakeSaturation = typeof item.stake_saturation === 'number' ? item.stake_saturation * 100 : 0;
+  const profitPercentage = toPercentIntegerString(item.profit_margin_percent) || 0;
+  const uncappedSaturation = typeof item.uncapped_saturation === 'number' ? item.uncapped_saturation * 100 : 0;

  return {
    mix_id: item.mix_id,
@@ -46,7 +47,7 @@ export function mixNodeResponseItemToMixnodeRowType(item: MixNodeResponseItem):
    layer: item?.layer || '',
    profit_percentage: `${profitPercentage}%`,
    avg_uptime: `${item.avg_uptime}%` || '-',
-    stake_saturation: stakeSaturation,
-    operating_cost: `${unymToNym(item.operating_cost.amount, 6)} NYM`,
+    stake_saturation: uncappedSaturation,
+    operating_cost: `${unymToNym(item.operating_cost?.amount, 6)} NYM`,
  };
 }
@@ -96,15 +96,17 @@ export const MainContextProvider: React.FC = ({ children }) => {
  const filterMixnodes = async (filters: { [key in EnumFilterKey]: number[] }, status?: MixnodeStatus) => {
    setMixnodes((d) => ({ ...d, isLoading: true }));
    const mxns = status ? await Api.fetchMixnodesActiveSetByStatus(status) : await Api.fetchMixnodes();
+
    const filtered = mxns?.filter(
      (m) =>
-        m.mix_node.profit_margin_percent >= filters.profitMargin[0] &&
-        m.mix_node.profit_margin_percent <= filters.profitMargin[1] &&
+        +m.profit_margin_percent >= filters.profitMargin[0] / 100 &&
+        +m.profit_margin_percent <= filters.profitMargin[1] / 100 &&
        m.stake_saturation >= filters.stakeSaturation[0] &&
        m.stake_saturation <= filters.stakeSaturation[1] &&
        m.avg_uptime >= filters.routingScore[0] &&
        m.avg_uptime <= filters.routingScore[1],
    );
+
    setMixnodes({ data: filtered, isLoading: false });
  };

@@ -36,16 +36,16 @@ export const useMixnodeContext = (): React.ContextType<typeof MixnodeContext> =>
  React.useContext<MixnodeState>(MixnodeContext);

 interface MixnodeContextProviderProps {
-  mixNodeIdentityKey: string;
+  mixId: string;
 }

 /**
 * Provides a state context for a mixnode by identity
- * @param mixNodeIdentityKey   The identity key of the mixnode
+ * @param mixId   The mixID of the mixnode
 */
-export const MixnodeContextProvider: React.FC<MixnodeContextProviderProps> = ({ mixNodeIdentityKey, children }) => {
+export const MixnodeContextProvider: React.FC<MixnodeContextProviderProps> = ({ mixId, children }) => {
  const [mixNode, fetchMixnodeById, clearMixnodeById] = useApiState<MixNodeResponseItem | undefined>(
-    mixNodeIdentityKey,
+    mixId,
    Api.fetchMixnodeByID,
    'Failed to fetch mixnode by id',
  );
@@ -53,44 +53,44 @@ export const MixnodeContextProvider: React.FC<MixnodeContextProviderProps> = ({
  const [mixNodeRow, setMixnodeRow] = React.useState<MixnodeRowType | undefined>();

  const [delegations, fetchDelegations, clearDelegations] = useApiState<DelegationsResponse>(
-    mixNodeIdentityKey,
+    mixId,
    Api.fetchDelegationsById,
    'Failed to fetch delegations for mixnode',
  );

  const [uniqDelegations, fetchUniqDelegations, clearUniqDelegations] = useApiState<UniqDelegationsResponse>(
-    mixNodeIdentityKey,
+    mixId,
    Api.fetchUniqDelegationsById,
    'Failed to fetch delegations for mixnode',
  );

  const [status, fetchStatus, clearStatus] = useApiState<StatusResponse>(
-    mixNodeIdentityKey,
+    mixId,
    Api.fetchStatusById,
    'Failed to fetch mixnode status',
  );

  const [stats, fetchStats, clearStats] = useApiState<StatsResponse>(
-    mixNodeIdentityKey,
+    mixId,
    Api.fetchStatsById,
    'Failed to fetch mixnode stats',
  );

  const [description, fetchDescription, clearDescription] = useApiState<MixNodeDescriptionResponse>(
-    mixNodeIdentityKey,
+    mixId,
    Api.fetchMixnodeDescriptionById,
    'Failed to fetch mixnode description',
  );

  const [economicDynamicsStats, fetchEconomicDynamicsStats, clearEconomicDynamicsStats] =
    useApiState<MixNodeEconomicDynamicsStatsResponse>(
-      mixNodeIdentityKey,
+      mixId,
      Api.fetchMixnodeEconomicDynamicsStatsById,
      'Failed to fetch mixnode dynamics stats by id',
    );

  const [uptimeStory, fetchUptimeHistory, clearUptimeHistory] = useApiState<UptimeStoryResponse>(
-    mixNodeIdentityKey,
+    mixId,
    Api.fetchUptimeStoryById,
    'Failed to fetch mixnode uptime history',
  );
@@ -123,7 +123,7 @@ export const MixnodeContextProvider: React.FC<MixnodeContextProviderProps> = ({
        fetchUptimeHistory(),
      ]);
    });
-  }, [mixNodeIdentityKey]);
+  }, [mixId]);

  const state = React.useMemo<MixnodeState>(
    () => ({
@@ -1,6 +1,6 @@
 import * as React from 'react';
 import { Link as RRDLink } from 'react-router-dom';
-import { Box, Button, Card, Grid, Typography, Link as MuiLink } from '@mui/material';
+import { Box, Button, Card, Grid, Link as MuiLink } from '@mui/material';
 import { GridColDef, GridRenderCellParams } from '@mui/x-data-grid';
 import { SelectChangeEvent } from '@mui/material/Select';
 import { useMainContext } from '../../context/main';
@@ -12,6 +12,8 @@ import { Title } from '../../components/Title';
 import { cellStyles, UniversalDataGrid } from '../../components/Universal-DataGrid';
 import { currencyToString } from '../../utils/currency';
 import { Tooltip } from '../../components/Tooltip';
+import { BIG_DIPPER } from '../../api/constants';
+import { splice } from '../../utils';

 export const PageGateways: React.FC = () => {
  const { gateways } = useMainContext();
@@ -69,9 +71,14 @@ export const PageGateways: React.FC = () => {
      headerClassName: 'MuiDataGrid-header-override',
      headerAlign: 'left',
      renderCell: (params: GridRenderCellParams) => (
-        <Typography sx={cellStyles} data-testid="pledge-amount">
+        <MuiLink
+          sx={{ ...cellStyles }}
+          component={RRDLink}
+          to={`/network-components/gateway/${params.row.identityKey}`}
+          data-testid="pledge-amount"
+        >
          {currencyToString(params.value)}
-        </Typography>
+        </MuiLink>
      ),
    },
    {
@@ -81,9 +88,14 @@ export const PageGateways: React.FC = () => {
      headerAlign: 'left',
      headerClassName: 'MuiDataGrid-header-override',
      renderCell: (params: GridRenderCellParams) => (
-        <Typography sx={cellStyles} data-testid="host">
+        <MuiLink
+          sx={{ ...cellStyles }}
+          component={RRDLink}
+          to={`/network-components/gateway/${params.row.identityKey}`}
+          data-testid="host"
+        >
          {params.value}
-        </Typography>
+        </MuiLink>
      ),
    },
    {
@@ -120,9 +132,14 @@ export const PageGateways: React.FC = () => {
      headerAlign: 'left',
      headerClassName: 'MuiDataGrid-header-override',
      renderCell: (params: GridRenderCellParams) => (
-        <Typography sx={cellStyles} data-testid="owner">
-          {params.value}
-        </Typography>
+        <MuiLink
+          sx={{ ...cellStyles }}
+          href={`${BIG_DIPPER}/account/${params.value}`}
+          target="_blank"
+          data-testid="owner"
+        >
+          {splice(7, 29, params.value)}
+        </MuiLink>
      ),
    },
  ];
@@ -35,7 +35,7 @@ const columns: ColumnsType[] = [
  },
  {
    field: 'self_percentage',
-    title: 'Self %',
+    title: 'Bond %',
    headerAlign: 'left',
    width: 99,
  },
@@ -223,7 +223,7 @@ export const PageMixnodeDetail: React.FC = () => {
  }

  return (
-    <MixnodeContextProvider mixNodeIdentityKey={id}>
+    <MixnodeContextProvider mixId={id}>
      <PageMixnodeDetailGuard />
    </MixnodeContextProvider>
  );
@@ -149,7 +149,7 @@ export const PageMixnodes: React.FC = () => {
      renderHeader: () => (
        <CustomColumnHeading
          headingTitle="Stake Saturation"
-          tooltipInfo="Level of stake saturation for this node. Nodes receive more rewards the higher their saturation level, up to 100%. Beyond 100% no additional rewards are granted. The current stake saturation level is: 1 million NYM, computed as S/K where S is  total amount of tokens available to stakeholders and K is the number of nodes in the reward set."
+          tooltipInfo="Level of stake saturation for this node. Nodes receive more rewards the higher their saturation level, up to 100%. Beyond 100% no additional rewards are granted. The current stake saturation level is: 750k NYM, computed as S/K where S is  total amount of tokens available to stakeholders and K is the number of nodes in the reward set."
        />
      ),
      headerClassName: 'MuiDataGrid-header-override',
@@ -192,7 +192,7 @@ export const PageMixnodes: React.FC = () => {
      renderHeader: () => (
        <CustomColumnHeading
          headingTitle="Profit Margin"
-          tooltipInfo="Percentage of the delegates rewards that the operator takes as fee before rewards are distributed to the delegates."
+          tooltipInfo="Percentage of the delegators rewards that the operator takes as fee before rewards are distributed to the delegators."
        />
      ),
      headerClassName: 'MuiDataGrid-header-override',
@@ -210,10 +210,10 @@ export const PageMixnodes: React.FC = () => {
    },
    {
      field: 'operating_cost',
-      headerName: 'Operating cost',
+      headerName: 'Operating Cost',
      renderHeader: () => (
        <CustomColumnHeading
-          headingTitle="Operating cost"
+          headingTitle="Operating Cost"
          tooltipInfo="Monthly operational cost of running this node. This cost is set by the operator and it influences how the rewards are split between the operator and delegators."
        />
      ),
@@ -30,7 +30,6 @@ export interface MixNode {
  sphinx_key: string;
  identity_key: string;
  version: string;
-  profit_margin_percent: number;
  location: string;
 }

@@ -86,7 +85,9 @@ export interface MixNodeResponseItem {
  mix_node: MixNode;
  avg_uptime: number;
  stake_saturation: number;
+  uncapped_saturation: number;
  operating_cost: Amount;
+  profit_margin_percent: string;
 }

 export type MixNodeResponse = MixNodeResponseItem[];
@@ -214,8 +215,9 @@ export type UptimeStoryResponse = {

 export type MixNodeEconomicDynamicsStatsResponse = {
  stake_saturation: number;
+  uncapped_saturation: number;
  // TODO: when v2 will be deployed, remove cases: VeryHigh, Moderate and VeryLow
-  active_set_inclusion_probability: 'High' | 'Good' | 'Low' | 'VeryLow' | 'Moderate' | 'VeryHigh';
+  active_set_inclusion_probability: 'High' | 'Good' | 'Low';
  reserve_set_inclusion_probability: 'High' | 'Good' | 'Low';
  estimated_total_node_reward: number;
  estimated_operator_reward: number;
@@ -45,3 +45,11 @@ export const splice = (start: number, deleteCount: number, address?: string): st
  }
  return '';
 };
+
+/**
+ * Converts a stringified percentage float (0.0-1.0) to a stringified integer (0-100).
+ *
+ * @param value - the percentage to convert
+ * @returns A stringified integer
+ */
+export const toPercentIntegerString = (value: string) => Math.round(Number(value) * 100).toString();
@@ -3,7 +3,7 @@

 [package]
 name = "nym-gateway"
-version = "1.0.2"
+version = "1.1.0"
 authors = [
    "Dave Hrycyszyn <futurechimp@users.noreply.github.com>",
    "Jędrzej Stuczyński <andrew@nymtech.net>",
@@ -56,6 +56,7 @@ credentials = { path = "../common/credentials" }
 config = { path = "../common/config" }
 crypto = { path = "../common/crypto" }
 completions = { path = "../common/completions" }
+logging = { path = "../common/logging"}
 gateway-requests = { path = "gateway-requests" }
 mixnet-client = { path = "../common/client-libs/mixnet-client" }
 mixnode-common = { path = "../common/mixnode-common" }
@@ -289,6 +289,10 @@ impl Config {
        self.debug.maximum_connection_buffer_size
    }

+    pub fn get_use_legacy_sphinx_framing(&self) -> bool {
+        self.debug.use_legacy_framed_packet_version
+    }
+
    pub fn get_message_retrieval_limit(&self) -> i64 {
        self.debug.message_retrieval_limit
    }
@@ -456,6 +460,12 @@ struct Debug {

    /// Number of messages from offline client that can be pulled at once from the storage.
    message_retrieval_limit: i64,
+
+    /// Specifies whether the mixnode should be using the legacy framing for the sphinx packets.
+    // it's set to true by default. The reason for that decision is to preserve compatibility with the
+    // existing nodes whilst everyone else is upgrading and getting the code for handling the new field.
+    // It shall be disabled in the subsequent releases.
+    use_legacy_framed_packet_version: bool,
 }

 impl Default for Debug {
@@ -468,6 +478,8 @@ impl Default for Debug {
            maximum_connection_buffer_size: DEFAULT_MAXIMUM_CONNECTION_BUFFER_SIZE,
            stored_messages_filename_length: DEFAULT_STORED_MESSAGE_FILENAME_LENGTH,
            message_retrieval_limit: DEFAULT_MESSAGE_RETRIEVAL_LIMIT,
+            // TODO: remember to change it in one of future releases!!
+            use_legacy_framed_packet_version: true,
        }
    }
 }
@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0

 use clap::{crate_version, Parser};
+use logging::setup_logging;
 use network_defaults::setup_env;
 use once_cell::sync::OnceCell;

@@ -88,27 +89,6 @@ fn long_version() -> String {
    )
 }

-fn setup_logging() {
-    let mut log_builder = pretty_env_logger::formatted_timed_builder();
-    if let Ok(s) = ::std::env::var("RUST_LOG") {
-        log_builder.parse_filters(&s);
-    } else {
-        // default to 'Info'
-        log_builder.filter(None, log::LevelFilter::Info);
-    }
-
-    log_builder
-        .filter_module("hyper", log::LevelFilter::Warn)
-        .filter_module("tokio_reactor", log::LevelFilter::Warn)
-        .filter_module("reqwest", log::LevelFilter::Warn)
-        .filter_module("mio", log::LevelFilter::Warn)
-        .filter_module("want", log::LevelFilter::Warn)
-        .filter_module("sled", log::LevelFilter::Warn)
-        .filter_module("tungstenite", log::LevelFilter::Warn)
-        .filter_module("tokio_tungstenite", log::LevelFilter::Warn)
-        .init();
-}
-
 #[cfg(test)]
 mod tests {
    use super::*;
@@ -211,6 +211,7 @@ where
            self.config.get_packet_forwarding_maximum_backoff(),
            self.config.get_initial_connection_timeout(),
            self.config.get_maximum_connection_buffer_size(),
+            self.config.get_use_legacy_sphinx_framing(),
        );

        tokio::spawn(async move { packet_forwarder.run().await });
@@ -3,7 +3,7 @@

 [package]
 name = "nym-mixnode"
-version = "1.0.2"
+version = "1.1.0"
 authors = [
    "Dave Hrycyszyn <futurechimp@users.noreply.github.com>",
    "Jędrzej Stuczyński <andrew@nymtech.net>",
@@ -41,6 +41,7 @@ url = { version = "2.2", features = ["serde"] }
 config = { path="../common/config" }
 crypto = { path="../common/crypto" }
 completions = { path="../common/completions" }
+logging = { path="../common/logging" }
 mixnet-client = { path="../common/client-libs/mixnet-client" }
 mixnode-common = { path="../common/mixnode-common" }
 nonexhaustive-delayqueue = { path="../common/nonexhaustive-delayqueue" }
@@ -280,6 +280,10 @@ impl Config {
        self.debug.maximum_connection_buffer_size
    }

+    pub fn get_use_legacy_sphinx_framing(&self) -> bool {
+        self.debug.use_legacy_framed_packet_version
+    }
+
    pub fn get_version(&self) -> &str {
        &self.mixnode.version
    }
@@ -485,6 +489,12 @@ struct Debug {

    /// Maximum number of packets that can be stored waiting to get sent to a particular connection.
    maximum_connection_buffer_size: usize,
+
+    /// Specifies whether the mixnode should be using the legacy framing for the sphinx packets.
+    // it's set to true by default. The reason for that decision is to preserve compatibility with the
+    // existing nodes whilst everyone else is upgrading and getting the code for handling the new field.
+    // It shall be disabled in the subsequent releases.
+    use_legacy_framed_packet_version: bool,
 }

 impl Default for Debug {
@@ -496,6 +506,8 @@ impl Default for Debug {
            packet_forwarding_maximum_backoff: DEFAULT_PACKET_FORWARDING_MAXIMUM_BACKOFF,
            initial_connection_timeout: DEFAULT_INITIAL_CONNECTION_TIMEOUT,
            maximum_connection_buffer_size: DEFAULT_MAXIMUM_CONNECTION_BUFFER_SIZE,
+            // TODO: remember to change it in one of future releases!!
+            use_legacy_framed_packet_version: true,
        }
    }
 }
@@ -7,6 +7,7 @@ extern crate rocket;
 use ::config::defaults::setup_env;
 use clap::{crate_version, Parser};
 use lazy_static::lazy_static;
+use logging::setup_logging;

 mod commands;
 mod config;
@@ -90,24 +91,6 @@ fn long_version() -> String {
    )
 }

-fn setup_logging() {
-    let mut log_builder = pretty_env_logger::formatted_timed_builder();
-    if let Ok(s) = ::std::env::var("RUST_LOG") {
-        log_builder.parse_filters(&s);
-    } else {
-        // default to 'Info'
-        log_builder.filter(None, log::LevelFilter::Info);
-    }
-
-    log_builder
-        .filter_module("hyper", log::LevelFilter::Warn)
-        .filter_module("tokio_reactor", log::LevelFilter::Warn)
-        .filter_module("reqwest", log::LevelFilter::Warn)
-        .filter_module("mio", log::LevelFilter::Warn)
-        .filter_module("want", log::LevelFilter::Warn)
-        .init();
-}
-
 #[cfg(test)]
 mod tests {
    use super::*;
@@ -200,6 +200,7 @@ impl MixNode {
            self.config.get_packet_forwarding_maximum_backoff(),
            self.config.get_initial_connection_timeout(),
            self.config.get_maximum_connection_buffer_size(),
+            self.config.get_use_legacy_sphinx_framing(),
        );

        let mut packet_forwarder = DelayForwarder::new(
@@ -1,3 +1,20 @@
+## [nym-connect-v1.1.0](https://github.com/nymtech/nym/tree/nym-connect-v1.1.0) (2022-11-09)
+
+- nym-connect: rework of rewarding changes the directory data structures that describe the mixnet topology ([#1472])
+- clients: add testing-only support for two more extended packet sizes (8kb and 16kb).
+- native-client/socks5-client: `disable_loop_cover_traffic_stream` Debug config option to disable the separate loop cover traffic stream ([#1666])
+- native-client/socks5-client: `disable_main_poisson_packet_distribution` Debug config option to make the client ignore poisson distribution in the main packet stream and ONLY send real message (and as fast as they come) ([#1664])
+- native-client/socks5-client: `use_extended_packet_size` Debug config option to make the client use 'ExtendedPacketSize' for its traffic (32kB as opposed to 2kB in 1.0.2) ([#1671])
+- network-requester: added additional Blockstream Green wallet endpoint to `example.allowed.list` ([#1611])
+- validator-client: added `query_contract_smart` and `query_contract_raw` on `NymdClient` ([#1558])
+
+[#1472]: https://github.com/nymtech/nym/pull/1472
+[#1558]: https://github.com/nymtech/nym/pull/1558
+[#1611]: https://github.com/nymtech/nym/pull/1611
+[#1664]: https://github.com/nymtech/nym/pull/1664
+[#1666]: https://github.com/nymtech/nym/pull/1666
+[#1671]: https://github.com/nymtech/nym/pull/1671
+
 ## [nym-connect-v1.0.2](https://github.com/nymtech/nym/tree/nym-connect-v1.0.2) (2022-08-18)

 ### Changed
@@ -2870,6 +2870,14 @@ dependencies = [
 "cfg-if",
 ]

+[[package]]
+name = "logging"
+version = "0.1.0"
+dependencies = [
+ "log",
+ "pretty_env_logger",
+]
+
 [[package]]
 name = "loom"
 version = "0.5.6"
@@ -3206,7 +3214,7 @@ dependencies = [

 [[package]]
 name = "nym-connect"
-version = "1.0.2"
+version = "1.1.0"
 dependencies = [
 "bip39",
 "client-core",
@@ -3216,6 +3224,7 @@ dependencies = [
 "fix-path-env",
 "futures",
 "log",
+ "logging",
 "nym-socks5-client",
 "pretty_env_logger",
 "rand 0.8.5",
@@ -3238,7 +3247,7 @@ dependencies = [

 [[package]]
 name = "nym-socks5-client"
-version = "1.0.2"
+version = "1.1.0"
 dependencies = [
 "clap",
 "client-core",
@@ -3251,6 +3260,7 @@ dependencies = [
 "gateway-client",
 "gateway-requests",
 "log",
+ "logging",
 "network-defaults",
 "nymsphinx",
 "ordered-buffer",
@@ -6078,6 +6088,7 @@ dependencies = [
 "coconut-interface",
 "colored",
 "config",
+ "contracts-common",
 "cosmrs",
 "cosmwasm-std",
 "cw3",
@@ -6167,6 +6178,7 @@ dependencies = [
 "schemars",
 "serde",
 "thiserror",
+ "vergen",
 "vesting-contract-common",
 ]

@@ -6176,7 +6188,6 @@ version = "0.1.0"
 dependencies = [
 "contracts-common",
 "cosmwasm-std",
- "log",
 "mixnet-contract-common",
 "schemars",
 "serde",
@@ -1,6 +1,6 @@
 [package]
 name = "nym-connect"
-version = "1.0.2"
+version = "1.1.0"
 description = "nym-connect"
 authors = ["Nym Technologies SA"]
 license = ""
@@ -40,6 +40,7 @@ url = "2.2"

 client-core = { path = "../../clients/client-core" }
 config-common = { path = "../../common/config", package = "config" }
+logging = { path = "../../common/logging"}
 nym-socks5-client = { path = "../../clients/socks5" }
 topology = { path = "../../common/topology" }

@@ -6,6 +6,7 @@
 use std::sync::Arc;

 use config_common::defaults::setup_env;
+use logging::setup_logging;
 use tauri::Menu;
 use tokio::sync::RwLock;

@@ -55,22 +56,3 @@ fn main() {
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
 }
-
-fn setup_logging() {
-    let mut log_builder = pretty_env_logger::formatted_timed_builder();
-    if let Ok(s) = ::std::env::var("RUST_LOG") {
-        log_builder.parse_filters(&s);
-    } else {
-        // default to 'Info'
-        log_builder.filter(None, log::LevelFilter::Info);
-    }
-
-    log_builder
-        .filter_module("handlebars", log::LevelFilter::Warn)
-        .filter_module("mio", log::LevelFilter::Warn)
-        .filter_module("sled", log::LevelFilter::Warn)
-        .filter_module("tokio_tungstenite", log::LevelFilter::Warn)
-        .filter_module("tungstenite", log::LevelFilter::Warn)
-        .filter_module("want", log::LevelFilter::Warn)
-        .init();
-}
@@ -1,7 +1,7 @@
 {
  "package": {
    "productName": "nym-connect",
-    "version": "1.0.2"
+    "version": "1.1.0"
  },
  "build": {
    "distDir": "../dist",
@@ -1,8 +1,21 @@
 # Changelog

-## Unreleased
+## [nym-wallet-v1.1.0](https://github.com/nymtech/nym/releases/tag/nym-wallet-v1.1.0) (2022-11-09)

- Add window for showing logs for when the terminal is not available.
+- wallet: Add window for showing logs for when the terminal is not available.
+- wallet: Rework of rewarding ([#1472])
+- wallet: Highlight delegations on an unbonded node to notify the delegator to undelegate stake
+- wallet: Group delegations on unbonded nodes at the top of the list 
+- wallet: Simplified delegation screen when user has no delegations
+- wallet: Update "create password" howto guide
+- wallet: Allow setting of operatoring cost when node is bonded
+- wallet: Allow update of operatoring cost on bonded node
+- wallet: New bond settings area
+- wallet: Display pending unbonds
+- wallet: Display routing score and average score for gateways
+- wallet: Improve dialogs for account creation
+
+[#1472]: https://github.com/nymtech/nym/pull/1472

 ## [nym-wallet-v1.0.9](https://github.com/nymtech/nym/releases/tag/nym-wallet-v1.0.8) (2022-09-08)

@@ -14,7 +27,6 @@
 - wallet: compound and redeem functionalities for operator rewards
 - wallet: a few minor touch ups and bug fixes 

-
 ## [nym-wallet-v1.0.7](https://github.com/nymtech/nym/tree/nym-wallet-v1.0.7) (2022-07-11)

 - wallet: dark mode
@@ -440,6 +440,9 @@ name = "cc"
 version = "1.0.73"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2fff2a6927b3bb87f9595d67196a70493f627687a71d87a0d692242c33f58c11"
+dependencies = [
+ "jobserver",
+]

 [[package]]
 name = "cesu8"
@@ -1255,6 +1258,26 @@ dependencies = [
 "cfg-if",
 ]

+[[package]]
+name = "enum-iterator"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4eeac5c5edb79e4e39fe8439ef35207780a11f69c52cbe424ce3dfad4cb78de6"
+dependencies = [
+ "enum-iterator-derive",
+]
+
+[[package]]
+name = "enum-iterator-derive"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c134c37760b27a871ba422106eedbb8247da973a09e82558bf26d619c882b159"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "env_logger"
 version = "0.7.1"
@@ -1721,6 +1744,19 @@ dependencies = [
 "winapi",
 ]

+[[package]]
+name = "git2"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2994bee4a3a6a51eb90c218523be382fd7ea09b16380b9312e9dbe955ff7c7d1"
+dependencies = [
+ "bitflags",
+ "libc",
+ "libgit2-sys",
+ "log",
+ "url",
+]
+
 [[package]]
 name = "glib"
 version = "0.15.6"
@@ -2323,6 +2359,15 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8eaf4bc02d17cbdd7ff4c7438cafcdf7fb9a4613313ad11b4f8fefe7d3fa0130"

+[[package]]
+name = "jobserver"
+version = "0.1.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "068b1ee6743e4d11fb9c6a1e6064b3693a1b600e7f5f5988047d98b3dc9fb90b"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "js-sys"
 version = "0.3.56"
@@ -2387,6 +2432,30 @@ version = "0.2.134"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "329c933548736bc49fd575ee68c89e8be4d260064184389a5b77517cddd99ffb"

+[[package]]
+name = "libgit2-sys"
+version = "0.14.0+1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47a00859c70c8a4f7218e6d1cc32875c4b55f6799445b842b0d8ed5e4c3d959b"
+dependencies = [
+ "cc",
+ "libc",
+ "libz-sys",
+ "pkg-config",
+]
+
+[[package]]
+name = "libz-sys"
+version = "1.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9702761c3935f8cc2f101793272e202c72b99da8f4224a19ddcf1279a6450bbf"
+dependencies = [
+ "cc",
+ "libc",
+ "pkg-config",
+ "vcpkg",
+]
+
 [[package]]
 name = "line-wrap"
 version = "0.1.1"
@@ -2415,6 +2484,14 @@ dependencies = [
 "serde",
 ]

+[[package]]
+name = "logging"
+version = "0.1.0"
+dependencies = [
+ "log",
+ "pretty_env_logger",
+]
+
 [[package]]
 name = "loom"
 version = "0.5.4"
@@ -2773,6 +2850,7 @@ dependencies = [
 "bip39",
 "clap",
 "log",
+ "logging",
 "pretty_env_logger",
 "serde_json",
 ]
@@ -2799,7 +2877,7 @@ dependencies = [

 [[package]]
 name = "nym_wallet"
-version = "1.0.9"
+version = "1.1.1"
 dependencies = [
 "aes-gcm",
 "argon2 0.3.4",
@@ -5252,6 +5330,7 @@ dependencies = [
 "coconut-interface",
 "colored 2.0.0",
 "config",
+ "contracts-common",
 "cosmrs",
 "cosmwasm-std",
 "cw3",
@@ -5288,6 +5367,23 @@ version = "0.2.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"

+[[package]]
+name = "vergen"
+version = "5.1.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6cf88d94e969e7956d924ba70741316796177fa0c79a2c9f4ab04998d96e966e"
+dependencies = [
+ "anyhow",
+ "cfg-if",
+ "chrono",
+ "enum-iterator",
+ "getset",
+ "git2",
+ "rustc_version 0.4.0",
+ "rustversion",
+ "thiserror",
+]
+
 [[package]]
 name = "version-compare"
 version = "0.0.11"
@@ -5317,6 +5413,7 @@ dependencies = [
 "schemars",
 "serde",
 "thiserror",
+ "vergen",
 "vesting-contract-common",
 ]

@@ -5326,7 +5423,6 @@ version = "0.1.0"
 dependencies = [
 "contracts-common",
 "cosmwasm-std",
- "log",
 "mixnet-contract-common",
 "schemars",
 "serde",
@@ -15,3 +15,5 @@ clap = { version = "3.2", features = ["derive"] }
 log = "0.4"
 pretty_env_logger = "0.4"
 serde_json = "1.0.0"
+
+logging = { path = "../../common/logging" }
@@ -12,6 +12,7 @@ use aes_gcm::{aead::Aead, Aes256Gcm, Key, NewAead, Nonce};
 use anyhow::{anyhow, Result};
 use argon2::{Algorithm, Argon2, Params, Version};
 use clap::Parser;
+use logging::setup_logging;
 use serde_json::Value;

 // Mostly defaults
@@ -61,18 +62,6 @@ fn main() -> Result<()> {
    decrypt_file(file, &args.password, &parse)
 }

-fn setup_logging() {
-    let mut log_builder = pretty_env_logger::formatted_timed_builder();
-    if let Ok(s) = ::std::env::var("RUST_LOG") {
-        log_builder.parse_filters(&s);
-    } else {
-        // default to 'Info'
-        log_builder.filter(None, log::LevelFilter::Info);
-    }
-
-    log_builder.init();
-}
-
 fn decrypt_file(file: File, passwords: &[String], parse: &ParseMode) -> Result<()> {
    let json_file: Value = serde_json::from_reader(file)?;

@@ -160,9 +160,9 @@ mod qa {
    pub(crate) const STAKE_DENOM: DenomDetails = DenomDetails::new("unyx", "nyx", 6);

    pub(crate) const MIXNET_CONTRACT_ADDRESS: &str =
-        "n1frq2hzkjtatsupc6jtyaz67ytydk9nya437q92qg76ny3y8fcnjsw806vg";
-    pub(crate) const VESTING_CONTRACT_ADDRESS: &str =
        "n14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9sjyvg3g";
+    pub(crate) const VESTING_CONTRACT_ADDRESS: &str =
+        "n1nc5tatafv6eyq7llkr2gv50ff9e22mnf70qgjlv737ktmt4eswrq73f2nw";
    pub(crate) const BANDWIDTH_CLAIM_CONTRACT_ADDRESS: &str =
        "n19lc9u84cz0yz3fww5283nucc9yvr8gsjmgeul0";
    pub(crate) const COCONUT_BANDWIDTH_CONTRACT_ADDRESS: &str =
@@ -177,8 +177,8 @@ mod qa {
    //pub(crate) const STATISTICS_SERVICE_DOMAIN_ADDRESS: &str = "http://0.0.0.0";
    pub(crate) fn validators() -> Vec<ValidatorDetails> {
        vec![ValidatorDetails::new(
-            "https://adv-epoch-qa-validator.qa.nymte.ch/",
-            Some("https://adv-epoch-qa-val-api.qa.nymte.ch/api"),
+            "https://qwerty-validator.qa.nymte.ch/",
+            Some("https://qwerty-validator-api.qa.nymte.ch/api"),
        )]
    }

@@ -1,6 +1,6 @@
 {
  "name": "@nymproject/nym-wallet-app",
-  "version": "1.0.0",
+  "version": "1.1.1",
  "main": "index.js",
  "license": "MIT",
  "scripts": {
@@ -1,6 +1,6 @@
 [package]
 name = "nym_wallet"
-version = "1.0.9"
+version = "1.1.1"
 description = "Nym Native Wallet"
 authors = ["Nym Technologies SA"]
 license = ""
@@ -266,6 +266,13 @@ pub async fn get_all_mix_delegations(
            pending_events.len()
        );

+        let mixnode_is_unbonding = mixnode.as_ref().map(|m| m.is_unbonding());
+        log::trace!(
+            "  >>> mixnode with mix_id: {} is unbonding: {:?}",
+            d.mix_id,
+            mixnode_is_unbonding
+        );
+
        with_everything.push(DelegationWithEverything {
            owner: d.owner,
            mix_id: d.mix_id,
@@ -283,6 +290,7 @@ pub async fn get_all_mix_delegations(
            cost_params,
            unclaimed_rewards: accumulated_rewards,
            pending_events,
+            mixnode_is_unbonding,
        })
    }
    log::trace!("<<< {:?}", with_everything);
@@ -1,7 +1,7 @@
 {
  "package": {
    "productName": "nym-wallet",
-    "version": "1.0.9"
+    "version": "1.1.1"
  },
  "build": {
    "distDir": "../dist",
@@ -34,7 +34,12 @@ export const MultiAccountHowTo = ({ show, handleClose }: { show: boolean; handle
          <Typography>{`${step}`}</Typography>
        </Stack>
      ))}
-      <Link href="todo" target="_blank" text="Open Nym docs for this guide in a browser window" fontWeight={600} />
+      <Link
+        href="https://nymtech.net/docs/stable/wallet/#importing-or-creating-accounts-when-you-have-signed-in-with-mnemonic"
+        target="_blank"
+        text="Open Nym docs for this guide in a browser window"
+        fontWeight={600}
+      />
    </Stack>
  </SimpleModal>
 );
@@ -38,7 +38,12 @@ export const MultiAccountWithPwdHowTo = ({ show, handleClose }: { show: boolean;
          <Typography>{`${step}`}</Typography>
        </Stack>
      ))}
-      <Link href="todo" target="_blank" text="Open Nym docs for this guide in a browser window" fontWeight={600} />
+      <Link
+        href="https://nymtech.net/docs/stable/wallet#importing-or-creating-accounts-when-you-have-signed-in-with-mnemonic-but-a-password-already-exists-on-your-machine"
+        target="_blank"
+        text="Open Nym docs for this guide in a browser window"
+        fontWeight={600}
+      />
    </Stack>
  </SimpleModal>
 );
@@ -122,6 +122,7 @@ const NameAccount = ({ onNext, onBack }: { onNext: (value: string) => void; onBa
            setError(undefined);
          }}
          fullWidth
+          InputLabelProps={{ shrink: true }}
        />
      </DialogContent>
      <DialogActions sx={{ p: 3, pt: 0, gap: 2 }}>
@@ -55,6 +55,7 @@ export const EditAccountModal = () => {
              value={accountName}
              onChange={(e) => setAccountName(e.target.value)}
              autoFocus
+              InputLabelProps={{ shrink: true }}
            />
          </Box>
        </DialogContent>
@@ -1,14 +1,12 @@
-import React, { useEffect } from 'react';
+import React from 'react';
 import { Stack, Typography } from '@mui/material';
 import { Link } from '@nymproject/react/link/Link';
 import { TBondedGateway, urls } from 'src/context';
 import { NymCard } from 'src/components';
 import { Network } from 'src/types';
 import { IdentityKey } from 'src/components/IdentityKey';
-import { getGatewayReport } from 'src/requests';
 import { Cell, Header, NodeTable } from './NodeTable';
 import { BondedGatewayActions, TBondedGatwayActions } from './BondedGatewayAction';
-import { Console } from 'src/utils/console';

 const headers: Header[] = [
  {
@@ -93,7 +91,7 @@ export const BondedGateway = ({
      {network && (
        <Typography sx={{ mt: 2, fontSize: 'small' }}>
          Check more stats of your gateway on the{' '}
-          <Link href={`${urls(network).networkExplorer}/network-components/gateways`} target="_blank">
+          <Link href={`${urls(network).networkExplorer}/network-components/gateway/${identityKey}`} target="_blank">
            explorer
          </Link>
        </Typography>
@@ -1,6 +1,6 @@
 import React from 'react';
 import { useNavigate } from 'react-router-dom';
-import { Box, Button, Stack, Tooltip, Typography } from '@mui/material';
+import { Box, Button, Chip, Stack, Tooltip, Typography } from '@mui/material';
 import { Link } from '@nymproject/react/link/Link';
 import { isMixnode, Network } from 'src/types';
 import { TBondedMixnode, urls } from 'src/context';
@@ -35,13 +35,14 @@ const headers: Header[] = [
  {
    header: 'Operating cost',
    id: 'operator-cost',
-    // tooltipText: 'TODO', // TODO
+    tooltipText:
+      'Monthly operational costs of running your node. The cost also influences how the rewards are split between you and your delegators. ',
  },
  {
    header: 'Operator rewards',
    id: 'operator-rewards',
    tooltipText:
-      'This is your (operator) new rewards including the PM and cost. You can compound your rewards manually every epoch or unbond your node to redeem them.',
+      'This is your (operator) rewards including the PM and cost. Rewards are automatically compounded every epoch. You can redeem your rewards at any time.',
  },
  {
    header: 'No. delegators',
@@ -65,6 +66,7 @@ export const BondedMixnode = ({
  const navigate = useNavigate();
  const {
    name,
+    mixId,
    stake,
    bond,
    stakeSaturation,
@@ -106,7 +108,9 @@ export const BondedMixnode = ({
      id: 'delegators-cell',
    },
    {
-      cell: (
+      cell: mixnode.isUnbonding ? (
+        <Chip label="Pending unbond" sx={{ textTransform: 'initial' }} />
+      ) : (
        <BondedMixnodeActions
          onActionSelect={onActionSelect}
          disabledRedeemAndCompound={(operatorRewards && Number(operatorRewards.amount) === 0) || false}
@@ -142,14 +146,19 @@ export const BondedMixnode = ({
        }
        Action={
          isMixnode(mixnode) && (
-            <Button
-              variant="text"
-              color="secondary"
-              onClick={() => navigate('/bonding/node-settings')}
-              startIcon={<NodeIcon />}
-            >
-              Node Settings
-            </Button>
+            <Tooltip title={mixnode.isUnbonding ? 'You have a pending unbond event. Node settings are disabled.' : ''}>
+              <Box>
+                <Button
+                  variant="text"
+                  color="secondary"
+                  onClick={() => navigate('/bonding/node-settings')}
+                  startIcon={<NodeIcon />}
+                  disabled={mixnode.isUnbonding}
+                >
+                  Node Settings
+                </Button>
+              </Box>
+            </Tooltip>
          )
        }
      >
@@ -157,7 +166,7 @@ export const BondedMixnode = ({
        {network && (
          <Typography sx={{ mt: 2, fontSize: 'small' }}>
            Check more stats of your node on the{' '}
-            <Link href={`${urls(network).networkExplorer}/network-components/mixnodes`} target="_blank">
+            <Link href={`${urls(network).networkExplorer}/network-components/mixnode/${mixId}`} target="_blank">
              explorer
            </Link>
          </Typography>
@@ -47,6 +47,7 @@ const NodeFormData = ({ gatewayData, onNext }: { gatewayData: GatewayData; onNex
        label="Sphinx key"
        error={Boolean(errors.sphinxKey)}
        helperText={errors.sphinxKey?.message}
+        InputLabelProps={{ shrink: true }}
      />
      <TextField
        {...register('ownerSignature')}
@@ -54,6 +55,7 @@ const NodeFormData = ({ gatewayData, onNext }: { gatewayData: GatewayData; onNex
        label="Owner signature"
        error={Boolean(errors.ownerSignature)}
        helperText={errors.ownerSignature?.message}
+        InputLabelProps={{ shrink: true }}
      />
      <TextField
        {...register('location')}
@@ -62,6 +64,7 @@ const NodeFormData = ({ gatewayData, onNext }: { gatewayData: GatewayData; onNex
        error={Boolean(errors.location)}
        helperText={errors.location?.message}
        required
+        InputLabelProps={{ shrink: true }}
        sx={{ flexBasis: '50%' }}
      />
      <Stack direction="row" gap={3}>
@@ -72,6 +75,7 @@ const NodeFormData = ({ gatewayData, onNext }: { gatewayData: GatewayData; onNex
          error={Boolean(errors.host)}
          helperText={errors.host?.message}
          required
+          InputLabelProps={{ shrink: true }}
          sx={{ flexBasis: '50%' }}
        />
        <TextField
@@ -81,6 +85,7 @@ const NodeFormData = ({ gatewayData, onNext }: { gatewayData: GatewayData; onNex
          error={Boolean(errors.version)}
          helperText={errors.version?.message}
          required
+          InputLabelProps={{ shrink: true }}
          sx={{ flexBasis: '50%' }}
        />
      </Stack>
@@ -97,6 +102,7 @@ const NodeFormData = ({ gatewayData, onNext }: { gatewayData: GatewayData; onNex
            error={Boolean(errors.mixPort)}
            helperText={errors.mixPort?.message}
            fullWidth
+            InputLabelProps={{ shrink: true }}
          />
          <TextField
            {...register('clientsPort')}
@@ -105,6 +111,7 @@ const NodeFormData = ({ gatewayData, onNext }: { gatewayData: GatewayData; onNex
            error={Boolean(errors.clientsPort)}
            helperText={errors.clientsPort?.message}
            fullWidth
+            InputLabelProps={{ shrink: true }}
          />
        </Stack>
      )}
@@ -172,7 +179,7 @@ const AmountFormData = ({
        <CurrencyFormField
          required
          fullWidth
-          label="Operator cost"
+          label="Operator Cost"
          autoFocus
          onChanged={(newValue) => setValue('operatorCost', newValue, { shouldValidate: true })}
          validationError={errors.operatorCost?.amount?.message}
@@ -47,6 +47,7 @@ const NodeFormData = ({ mixnodeData, onNext }: { mixnodeData: MixnodeData; onNex
        label="Sphinx key"
        error={Boolean(errors.sphinxKey)}
        helperText={errors.sphinxKey?.message}
+        InputLabelProps={{ shrink: true }}
      />
      <TextField
        {...register('ownerSignature')}
@@ -54,6 +55,7 @@ const NodeFormData = ({ mixnodeData, onNext }: { mixnodeData: MixnodeData; onNex
        label="Owner signature"
        error={Boolean(errors.ownerSignature)}
        helperText={errors.ownerSignature?.message}
+        InputLabelProps={{ shrink: true }}
      />
      <Stack direction="row" gap={3}>
        <TextField
@@ -63,6 +65,7 @@ const NodeFormData = ({ mixnodeData, onNext }: { mixnodeData: MixnodeData; onNex
          error={Boolean(errors.host)}
          helperText={errors.host?.message}
          required
+          InputLabelProps={{ shrink: true }}
          sx={{ flexBasis: '50%' }}
        />
        <TextField
@@ -72,6 +75,7 @@ const NodeFormData = ({ mixnodeData, onNext }: { mixnodeData: MixnodeData; onNex
          error={Boolean(errors.version)}
          helperText={errors.version?.message}
          required
+          InputLabelProps={{ shrink: true }}
          sx={{ flexBasis: '50%' }}
        />
      </Stack>
@@ -88,6 +92,7 @@ const NodeFormData = ({ mixnodeData, onNext }: { mixnodeData: MixnodeData; onNex
            error={Boolean(errors.mixPort)}
            helperText={errors.mixPort?.message}
            fullWidth
+            InputLabelProps={{ shrink: true }}
          />
          <TextField
            {...register('verlocPort')}
@@ -96,6 +101,7 @@ const NodeFormData = ({ mixnodeData, onNext }: { mixnodeData: MixnodeData; onNex
            error={Boolean(errors.verlocPort)}
            helperText={errors.verlocPort?.message}
            fullWidth
+            InputLabelProps={{ shrink: true }}
          />
          <TextField
            {...register('httpApiPort')}
@@ -104,6 +110,7 @@ const NodeFormData = ({ mixnodeData, onNext }: { mixnodeData: MixnodeData; onNex
            error={Boolean(errors.httpApiPort)}
            helperText={errors.httpApiPort?.message}
            fullWidth
+            InputLabelProps={{ shrink: true }}
          />
        </Stack>
      )}
@@ -100,7 +100,13 @@ export const BondMoreModal = ({
        </Box>

        <Box>
-          <TextField fullWidth label="Signature" value={signature} onChange={(e) => setSignature(e.target.value)} />
+          <TextField
+            fullWidth
+            label="Signature"
+            value={signature}
+            onChange={(e) => setSignature(e.target.value)}
+            InputLabelProps={{ shrink: true }}
+          />
          {errorSignature && <FormHelperText sx={{ color: 'error.main' }}>Invalid signature</FormHelperText>}
        </Box>

@@ -114,7 +114,13 @@ export const NodeSettings = ({
          Set profit margin
        </Typography>
        <Box sx={{ mb: 3 }}>
-          <TextField label="Profit margin" value={pm} onChange={(e) => setPm(e.target.value)} fullWidth />
+          <TextField
+            label="Profit margin"
+            value={pm}
+            onChange={(e) => setPm(e.target.value)}
+            fullWidth
+            InputLabelProps={{ shrink: true }}
+          />
          {error && (
            <FormHelperText sx={{ color: 'error.main' }}>
              Profit margin should be a number between 0 and 100
@@ -66,9 +66,9 @@ export const DelegationActions: React.FC<{

 export const DelegationsActionsMenu: React.FC<{
  onActionClick?: (action: DelegationListItemActions) => void;
-  isPending?: DelegationEventKind;
  disableRedeemingRewards?: boolean;
-}> = ({ disableRedeemingRewards, onActionClick, isPending }) => {
+  disableDelegateMore?: boolean | null;
+}> = ({ disableRedeemingRewards, disableDelegateMore, onActionClick }) => {
  const [isOpen, setIsOpen] = useState(false);

  const handleOpenMenu = () => setIsOpen(true);
@@ -79,21 +79,15 @@ export const DelegationsActionsMenu: React.FC<{
    handleOnClose();
  };

-  if (isPending) {
-    return (
-      <Box py={0.5} fontSize="inherit" minWidth={MIN_WIDTH} minHeight={BUTTON_SIZE}>
-        <Tooltip title="There will be a new epoch roughly every hour when your changes will take effect" arrow>
-          <Typography fontSize="inherit" color="text.disabled">
-            Pending {isPending === 'Delegate' ? 'delegation' : 'undelegation'}...
-          </Typography>
-        </Tooltip>
-      </Box>
-    );
-  }
-
  return (
    <ActionsMenu open={isOpen} onOpen={handleOpenMenu} onClose={handleOnClose}>
-      <ActionsMenuItem title="Delegate more" Icon={<Delegate />} onClick={() => handleActionSelect('delegate')} />
+      <ActionsMenuItem
+        title="Delegate more"
+        description={disableDelegateMore ? 'This node is unbonding, action disabled.' : undefined}
+        Icon={<Delegate />}
+        onClick={() => handleActionSelect('delegate')}
+        disabled={Boolean(disableDelegateMore)}
+      />
      <ActionsMenuItem title="Undelegate" Icon={<Undelegate />} onClick={() => handleActionSelect('undelegate')} />
      <ActionsMenuItem
        title="Redeem"
@@ -0,0 +1,104 @@
+import React from 'react';
+import { Chip, IconButton, TableCell, TableRow, Tooltip, Typography } from '@mui/material';
+import { Link } from '@nymproject/react/link/Link';
+import { decimalToPercentage, DelegationWithEverything } from '@nymproject/types';
+import { isDelegation } from 'src/context/delegations';
+import { toPercentIntegerString } from 'src/utils';
+import { format } from 'date-fns';
+import { Undelegate } from 'src/svg-icons';
+import { DelegationListItemActions, DelegationsActionsMenu } from './DelegationActions';
+
+const getStakeSaturation = (item: DelegationWithEverything) =>
+  !item.stake_saturation ? '-' : `${decimalToPercentage(item.stake_saturation)}%`;
+
+const getRewardValue = (item: DelegationWithEverything) => {
+  const { unclaimed_rewards } = item;
+  return !unclaimed_rewards ? '-' : `${unclaimed_rewards.amount} ${unclaimed_rewards.denom}`;
+};
+
+export const DelegationItem = ({
+  item,
+  explorerUrl,
+  nodeIsUnbonded,
+  onItemActionClick,
+}: {
+  item: DelegationWithEverything;
+  explorerUrl: string;
+  nodeIsUnbonded: boolean;
+  onItemActionClick?: (item: DelegationWithEverything, action: DelegationListItemActions) => void;
+}) => {
+  const operatingCost = isDelegation(item) && item.cost_params?.interval_operating_cost;
+
+  return (
+    <Tooltip
+      arrow
+      title={
+        nodeIsUnbonded
+          ? 'This node has unbonded and it does not exist anymore. You need to undelegate from it to get your stake and outstanding rewards (if any) back.'
+          : ''
+      }
+    >
+      <TableRow key={item.node_identity} sx={{ color: !item.node_identity ? 'error.main' : 'inherit' }}>
+        <TableCell sx={{ color: 'inherit', pr: 1 }} padding="normal">
+          {nodeIsUnbonded ? (
+            '-'
+          ) : (
+            <Link
+              target="_blank"
+              href={`${explorerUrl}/network-components/mixnode/${item.mix_id}`}
+              text={`${item.node_identity.slice(0, 6)}...${item.node_identity.slice(-6)}`}
+              color="text.primary"
+              noIcon
+            />
+          )}
+        </TableCell>
+        <TableCell sx={{ color: 'inherit' }}>
+          {isDelegation(item) && (!item.avg_uptime_percent ? '-' : `${item.avg_uptime_percent}%`)}
+        </TableCell>
+        <TableCell sx={{ color: 'inherit' }}>
+          {isDelegation(item) &&
+            (!item.cost_params?.profit_margin_percent
+              ? '-'
+              : `${toPercentIntegerString(item.cost_params.profit_margin_percent)}%`)}
+        </TableCell>
+        <TableCell sx={{ color: 'inherit' }}>
+          <Typography style={{ textTransform: 'uppercase', fontSize: 'inherit' }}>
+            {operatingCost ? `${operatingCost.amount} ${operatingCost.denom}` : '-'}
+          </Typography>
+        </TableCell>
+        <TableCell sx={{ color: 'inherit' }}>{getStakeSaturation(item)}</TableCell>
+        <TableCell sx={{ color: 'inherit' }}>
+          {format(new Date(item.delegated_on_iso_datetime), 'dd/MM/yyyy')}
+        </TableCell>
+        <TableCell sx={{ color: 'inherit' }}>
+          <Typography style={{ textTransform: 'uppercase', fontSize: 'inherit' }}>
+            {isDelegation(item) ? `${item.amount.amount} ${item.amount.denom}` : '-'}
+          </Typography>
+        </TableCell>
+        <TableCell sx={{ textTransform: 'uppercase', color: 'inherit' }}>{getRewardValue(item)}</TableCell>
+        <TableCell align="right" sx={{ color: 'inherit' }}>
+          {!item.pending_events.length && !nodeIsUnbonded && (
+            <DelegationsActionsMenu
+              onActionClick={(action) => (onItemActionClick ? onItemActionClick(item, action) : undefined)}
+              disableRedeemingRewards={!item.unclaimed_rewards || item.unclaimed_rewards.amount === '0'}
+              disableDelegateMore={item.mixnode_is_unbonding}
+            />
+          )}
+          {!item.pending_events.length && nodeIsUnbonded && (
+            <IconButton sx={{ color: (t) => t.palette.nym.nymWallet.text.main }}>
+              <Undelegate onClick={() => (onItemActionClick ? onItemActionClick(item, 'undelegate') : undefined)} />
+            </IconButton>
+          )}
+          {item.pending_events.length > 0 && (
+            <Tooltip
+              title="Your changes will take effect when the new epoch starts. There is a new epoch every hour."
+              arrow
+            >
+              <Chip label="Pending Events" />
+            </Tooltip>
+          )}
+        </TableCell>
+      </TableRow>
+    </Tooltip>
+  );
+};
@@ -13,7 +13,7 @@ const explorerUrl = 'https://sandbox-explorer.nymtech.net/network-components/mix

 export const items: DelegationWithEverything[] = [
  {
-    mix_id: 1234,
+    mix_id: 1,
    node_identity: 'FiojKW7oY9WQmLCiYAsCA21tpowZHS6zcUoyYm319p6Z',
    delegated_on_iso_datetime: new Date(2021, 1, 1).toDateString(),
    unclaimed_rewards: { amount: '0.05', denom: 'nym' },
@@ -33,9 +33,10 @@ export const items: DelegationWithEverything[] = [
    avg_uptime_percent: 0.5,
    uses_vesting_contract_tokens: false,
    pending_events: [],
+    mixnode_is_unbonding: true,
  },
  {
-    mix_id: 5678,
+    mix_id: 2,
    node_identity: 'DT8S942S8AQs2zKHS9SVo1GyHmuca3pfL2uLhLksJ3D8',
    amount: { amount: '100', denom: 'nym' },
    delegated_on_iso_datetime: new Date(2021, 1, 2).toDateString(),
@@ -55,6 +56,237 @@ export const items: DelegationWithEverything[] = [
    avg_uptime_percent: 0.1,
    uses_vesting_contract_tokens: true,
    pending_events: [],
+    mixnode_is_unbonding: true,
+  },
+  {
+    mix_id: 3,
+    node_identity: '',
+    amount: { amount: '100', denom: 'nym' },
+    delegated_on_iso_datetime: new Date(2021, 1, 2).toDateString(),
+    unclaimed_rewards: { amount: '0.05', denom: 'nym' },
+    cost_params: {
+      profit_margin_percent: '0.1122323949234',
+      interval_operating_cost: {
+        amount: '40',
+        denom: 'nym',
+      },
+    },
+    accumulated_by_delegates: { amount: '50', denom: 'nym' },
+    accumulated_by_operator: { amount: '100', denom: 'nym' },
+    owner: '',
+    block_height: BigInt(4000),
+    stake_saturation: '0.5',
+    avg_uptime_percent: 0.1,
+    uses_vesting_contract_tokens: true,
+    pending_events: [],
+    mixnode_is_unbonding: true,
+  },
+  {
+    mix_id: 4,
+    node_identity: 'DT8S942S8AQs2zKHS9SVo1GyHmuca3pfL2uLhLksJ3D8',
+    amount: { amount: '100', denom: 'nym' },
+    delegated_on_iso_datetime: new Date(2021, 1, 2).toDateString(),
+    unclaimed_rewards: { amount: '0.05', denom: 'nym' },
+    cost_params: {
+      profit_margin_percent: '0.1122323949234',
+      interval_operating_cost: {
+        amount: '40',
+        denom: 'nym',
+      },
+    },
+    accumulated_by_delegates: { amount: '50', denom: 'nym' },
+    accumulated_by_operator: { amount: '100', denom: 'nym' },
+    owner: '',
+    block_height: BigInt(4000),
+    stake_saturation: '0.5',
+    avg_uptime_percent: 0.1,
+    uses_vesting_contract_tokens: true,
+    pending_events: [],
+    mixnode_is_unbonding: true,
+  },
+  {
+    mix_id: 5,
+    node_identity: 'DT8S942S8AQs2zKHS9SVo1GyHmuca3pfL2uLhLksJ3D8',
+    amount: { amount: '100', denom: 'nym' },
+    delegated_on_iso_datetime: new Date(2021, 1, 2).toDateString(),
+    unclaimed_rewards: { amount: '0.05', denom: 'nym' },
+    cost_params: {
+      profit_margin_percent: '0.1122323949234',
+      interval_operating_cost: {
+        amount: '40',
+        denom: 'nym',
+      },
+    },
+    accumulated_by_delegates: { amount: '50', denom: 'nym' },
+    accumulated_by_operator: { amount: '100', denom: 'nym' },
+    owner: '',
+    block_height: BigInt(4000),
+    stake_saturation: '0.5',
+    avg_uptime_percent: 0.1,
+    uses_vesting_contract_tokens: true,
+    pending_events: [],
+    mixnode_is_unbonding: true,
+  },
+  {
+    mix_id: 6,
+    node_identity: '',
+    amount: { amount: '100', denom: 'nym' },
+    delegated_on_iso_datetime: new Date(2021, 1, 2).toDateString(),
+    unclaimed_rewards: { amount: '0.05', denom: 'nym' },
+    cost_params: {
+      profit_margin_percent: '0.1122323949234',
+      interval_operating_cost: {
+        amount: '40',
+        denom: 'nym',
+      },
+    },
+    accumulated_by_delegates: { amount: '50', denom: 'nym' },
+    accumulated_by_operator: { amount: '100', denom: 'nym' },
+    owner: '',
+    block_height: BigInt(4000),
+    stake_saturation: '0.5',
+    avg_uptime_percent: 0.1,
+    uses_vesting_contract_tokens: true,
+    pending_events: [],
+    mixnode_is_unbonding: true,
+  },
+  {
+    mix_id: 7,
+    node_identity: 'FiojKW7oY9WQmLCiYAsCA21tpowZHS6zcUoyYm319p6Z',
+    delegated_on_iso_datetime: new Date(2021, 1, 1).toDateString(),
+    unclaimed_rewards: { amount: '0.05', denom: 'nym' },
+    amount: { amount: '10', denom: 'nym' },
+    cost_params: {
+      profit_margin_percent: '0.1122323949234',
+      interval_operating_cost: {
+        amount: '40',
+        denom: 'nym',
+      },
+    },
+    accumulated_by_delegates: { amount: '50', denom: 'nym' },
+    accumulated_by_operator: { amount: '100', denom: 'nym' },
+    owner: '',
+    block_height: BigInt(100),
+    stake_saturation: '0.5',
+    avg_uptime_percent: 0.5,
+    uses_vesting_contract_tokens: false,
+    pending_events: [],
+    mixnode_is_unbonding: true,
+  },
+  {
+    mix_id: 8,
+    node_identity: 'DT8S942S8AQs2zKHS9SVo1GyHmuca3pfL2uLhLksJ3D8',
+    amount: { amount: '100', denom: 'nym' },
+    delegated_on_iso_datetime: new Date(2021, 1, 2).toDateString(),
+    unclaimed_rewards: { amount: '0.05', denom: 'nym' },
+    cost_params: {
+      profit_margin_percent: '0.1122323949234',
+      interval_operating_cost: {
+        amount: '40',
+        denom: 'nym',
+      },
+    },
+    accumulated_by_delegates: { amount: '50', denom: 'nym' },
+    accumulated_by_operator: { amount: '100', denom: 'nym' },
+    owner: '',
+    block_height: BigInt(4000),
+    stake_saturation: '0.5',
+    avg_uptime_percent: 0.1,
+    uses_vesting_contract_tokens: true,
+    pending_events: [],
+    mixnode_is_unbonding: true,
+  },
+  {
+    mix_id: 9,
+    node_identity: '',
+    amount: { amount: '100', denom: 'nym' },
+    delegated_on_iso_datetime: new Date(2021, 1, 2).toDateString(),
+    unclaimed_rewards: { amount: '0.05', denom: 'nym' },
+    cost_params: {
+      profit_margin_percent: '0.1122323949234',
+      interval_operating_cost: {
+        amount: '40',
+        denom: 'nym',
+      },
+    },
+    accumulated_by_delegates: { amount: '50', denom: 'nym' },
+    accumulated_by_operator: { amount: '100', denom: 'nym' },
+    owner: '',
+    block_height: BigInt(4000),
+    stake_saturation: '0.5',
+    avg_uptime_percent: 0.1,
+    uses_vesting_contract_tokens: true,
+    pending_events: [],
+    mixnode_is_unbonding: true,
+  },
+  {
+    mix_id: 10,
+    node_identity: 'DT8S942S8AQs2zKHS9SVo1GyHmuca3pfL2uLhLksJ3D8',
+    amount: { amount: '100', denom: 'nym' },
+    delegated_on_iso_datetime: new Date(2021, 1, 2).toDateString(),
+    unclaimed_rewards: { amount: '0.05', denom: 'nym' },
+    cost_params: {
+      profit_margin_percent: '0.1122323949234',
+      interval_operating_cost: {
+        amount: '40',
+        denom: 'nym',
+      },
+    },
+    accumulated_by_delegates: { amount: '50', denom: 'nym' },
+    accumulated_by_operator: { amount: '100', denom: 'nym' },
+    owner: '',
+    block_height: BigInt(4000),
+    stake_saturation: '0.5',
+    avg_uptime_percent: 0.1,
+    uses_vesting_contract_tokens: true,
+    pending_events: [],
+    mixnode_is_unbonding: true,
+  },
+  {
+    mix_id: 11,
+    node_identity: 'DT8S942S8AQs2zKHS9SVo1GyHmuca3pfL2uLhLksJ3D8',
+    amount: { amount: '100', denom: 'nym' },
+    delegated_on_iso_datetime: new Date(2021, 1, 2).toDateString(),
+    unclaimed_rewards: { amount: '0.05', denom: 'nym' },
+    cost_params: {
+      profit_margin_percent: '0.1122323949234',
+      interval_operating_cost: {
+        amount: '40',
+        denom: 'nym',
+      },
+    },
+    accumulated_by_delegates: { amount: '50', denom: 'nym' },
+    accumulated_by_operator: { amount: '100', denom: 'nym' },
+    owner: '',
+    block_height: BigInt(4000),
+    stake_saturation: '0.5',
+    avg_uptime_percent: 0.1,
+    uses_vesting_contract_tokens: true,
+    pending_events: [],
+    mixnode_is_unbonding: true,
+  },
+  {
+    mix_id: 12,
+    node_identity: '',
+    amount: { amount: '100', denom: 'nym' },
+    delegated_on_iso_datetime: new Date(2021, 1, 2).toDateString(),
+    unclaimed_rewards: { amount: '0.05', denom: 'nym' },
+    cost_params: {
+      profit_margin_percent: '0.1122323949234',
+      interval_operating_cost: {
+        amount: '40',
+        denom: 'nym',
+      },
+    },
+    accumulated_by_delegates: { amount: '50', denom: 'nym' },
+    accumulated_by_operator: { amount: '100', denom: 'nym' },
+    owner: '',
+    block_height: BigInt(4000),
+    stake_saturation: '0.5',
+    avg_uptime_percent: 0.1,
+    uses_vesting_contract_tokens: true,
+    pending_events: [],
+    mixnode_is_unbonding: true,
  },
 ];

@@ -64,4 +296,4 @@ export const Empty = () => <DelegationList items={[]} explorerUrl={explorerUrl}

 export const OneItem = () => <DelegationList items={[items[0]]} explorerUrl={explorerUrl} />;

-export const Loading = () => <DelegationList isLoading explorerUrl={explorerUrl} />;
+export const Loading = () => <DelegationList items={[]} isLoading explorerUrl={explorerUrl} />;
@@ -1,7 +1,6 @@
 import React from 'react';
 import {
  Box,
-  Chip,
  CircularProgress,
  Table,
  TableBody,
@@ -10,17 +9,14 @@ import {
  TableHead,
  TableRow,
  TableSortLabel,
-  Tooltip,
-  Typography,
 } from '@mui/material';
 import { visuallyHidden } from '@mui/utils';
 import ArrowDropDownIcon from '@mui/icons-material/ArrowDropDown';
-import { decimalToPercentage, DelegationWithEverything } from '@nymproject/types';
-import { Link } from '@nymproject/react/link/Link';
-import { format } from 'date-fns';
-import { DelegationListItemActions, DelegationsActionsMenu } from './DelegationActions';
+import { DelegationWithEverything } from '@nymproject/types';
+import { DelegationListItemActions } from './DelegationActions';
 import { DelegationWithEvent, isDelegation, isPendingDelegation, TDelegations } from '../../context/delegations';
-import { toPercentIntegerString } from '../../utils';
+import { DelegationItem } from './DelegationItem';
+import { PendingDelegationItem } from './PendingDelegationItem';

 type Order = 'asc' | 'desc';

@@ -42,44 +38,13 @@ const headCells: HeadCell[] = [
  { id: 'node_identity', label: 'Node ID', sortable: true, align: 'left' },
  { id: 'avg_uptime_percent', label: 'Routing score', sortable: true, align: 'left' },
  { id: 'profit_margin_percent', label: 'Profit margin', sortable: true, align: 'left' },
+  { id: 'operating_cost', label: 'Operating Cost', sortable: true, align: 'left' },
  { id: 'stake_saturation', label: 'Stake saturation', sortable: true, align: 'left' },
  { id: 'delegated_on_iso_datetime', label: 'Delegated on', sortable: true, align: 'left' },
  { id: 'amount', label: 'Delegation', sortable: true, align: 'left' },
  { id: 'unclaimed_rewards', label: 'Reward', sortable: true, align: 'left' },
 ];

-function descendingComparator(a: any, b: any, orderBy: string) {
-  if (b[orderBy] < a[orderBy]) {
-    return -1;
-  }
-  if (b[orderBy] > a[orderBy]) {
-    return 1;
-  }
-  return 0;
-}
-// Sorting function needs fixing
-
-function sortPendingDelegation(a: DelegationWithEvent, b: DelegationWithEvent) {
-  if (isPendingDelegation(a) && isPendingDelegation(b)) return 0;
-  if (isPendingDelegation(b)) return -1;
-  if (isPendingDelegation(a)) return 1;
-  return 2;
-}
-
-function getComparator(order: Order, orderBy: string): (a: DelegationWithEvent, b: DelegationWithEvent) => number {
-  return order === 'desc'
-    ? (a, b) => {
-        const pendingSort = sortPendingDelegation(a, b);
-        if (pendingSort === 2) return descendingComparator(a, b, orderBy);
-        return pendingSort;
-      }
-    : (a, b) => {
-        const pendingSort = -sortPendingDelegation(a, b);
-        if (pendingSort === 2) return -descendingComparator(a, b, orderBy);
-        return pendingSort;
-      };
-}
-
 const EnhancedTableHead: React.FC<EnhancedTableProps> = ({ order, orderBy, onRequestSort }) => {
  const createSortHandler = (property: string) => (event: React.MouseEvent<unknown>) => {
    onRequestSort(event, property);
@@ -117,9 +82,14 @@ const EnhancedTableHead: React.FC<EnhancedTableProps> = ({ order, orderBy, onReq
  );
 };

+const sortByUnbondedMixnodeFirst = (a: DelegationWithEvent) => {
+  if (!a.node_identity) return -1;
+  return 1;
+};
+
 export const DelegationList: React.FC<{
  isLoading?: boolean;
-  items?: TDelegations;
+  items: TDelegations;
  onItemActionClick?: (item: DelegationWithEverything, action: DelegationListItemActions) => void;
  explorerUrl: string;
  // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -133,89 +103,25 @@ export const DelegationList: React.FC<{
    setOrderBy(property);
  };

-  const getStakeSaturation = (item: DelegationWithEvent) => {
-    if (isDelegation(item)) {
-      return !item.stake_saturation ? '-' : `${decimalToPercentage(item.stake_saturation)}%`;
-    }
-    return '';
-  };
-
-  const getRewardValue = (item: DelegationWithEvent) => {
-    if (isPendingDelegation(item)) {
-      return '';
-    }
-    // eslint-disable-next-line @typescript-eslint/naming-convention
-    const { unclaimed_rewards } = item;
-    return !unclaimed_rewards ? '-' : `${unclaimed_rewards.amount} ${unclaimed_rewards.denom}`;
-  };
-
  return (
    <TableContainer>
      <Table sx={{ width: '100%' }}>
        <EnhancedTableHead order={order} orderBy={orderBy} onRequestSort={handleRequestSort} />
        <TableBody>
-          {items?.length ? (
-            items.map((item) => (
-              <TableRow key={item.node_identity}>
-                <TableCell>
-                  <Link
-                    target="_blank"
-                    href={`${explorerUrl}/network-components/mixnode/${item.node_identity}`}
-                    text={`${item.node_identity.slice(0, 6)}...${item.node_identity.slice(-6)}`}
-                    color="text.primary"
-                    noIcon
+          {items.length ? (
+            items.sort(sortByUnbondedMixnodeFirst).map((item) => {
+              if (isPendingDelegation(item)) return <PendingDelegationItem item={item} explorerUrl={explorerUrl} />;
+              if (isDelegation(item))
+                return (
+                  <DelegationItem
+                    item={item}
+                    explorerUrl={explorerUrl}
+                    nodeIsUnbonded={Boolean(!item.node_identity)}
+                    onItemActionClick={onItemActionClick}
                  />
-                </TableCell>
-                <TableCell>
-                  {isDelegation(item) && (!item.avg_uptime_percent ? '-' : `${item.avg_uptime_percent}%`)}
-                </TableCell>
-                <TableCell>
-                  {isDelegation(item) &&
-                    (!item.cost_params?.profit_margin_percent
-                      ? '-'
-                      : `${toPercentIntegerString(item.cost_params.profit_margin_percent)}%`)}
-                </TableCell>
-                <TableCell>{getStakeSaturation(item)}</TableCell>
-                <TableCell>
-                  {isDelegation(item) && format(new Date(item.delegated_on_iso_datetime), 'dd/MM/yyyy')}
-                </TableCell>
-                <TableCell>
-                  <Typography style={{ textTransform: 'uppercase' }}>
-                    {isDelegation(item) && `${item.amount.amount} ${item.amount.denom}`}
-                  </Typography>
-                </TableCell>
-                <TableCell sx={{ textTransform: 'uppercase' }}>{getRewardValue(item)}</TableCell>
-                <TableCell align="right">
-                  {isDelegation(item) && !item.pending_events.length && (
-                    <DelegationsActionsMenu
-                      isPending={undefined}
-                      onActionClick={(action) => (onItemActionClick ? onItemActionClick(item, action) : undefined)}
-                      disableRedeemingRewards={!item.unclaimed_rewards || item.unclaimed_rewards.amount === '0'}
-                    />
-                  )}
-                  {isDelegation(item) && item.pending_events.length > 0 && (
-                    <Tooltip
-                      title="Your changes will take effect when
-the new epoch starts. There is a new
-epoch every hour."
-                      arrow
-                    >
-                      <Chip label="Pending Events" />
-                    </Tooltip>
-                  )}
-                  {isPendingDelegation(item) && (
-                    <Tooltip
-                      title={`Your delegation of ${item.event.amount?.amount} ${item.event.amount?.denom} will take effect 
-                        when the new epoch starts. There is a new
-                        epoch every hour.`}
-                      arrow
-                    >
-                      <Chip label="Pending Events" />
-                    </Tooltip>
-                  )}
-                </TableCell>
-              </TableRow>
-            ))
+                );
+              return null;
+            })
          ) : (
            <TableRow>
              <TableCell colSpan={7}>
@@ -7,7 +7,7 @@ import { DelegationListItemActions } from './DelegationActions';

 export const Delegations: React.FC<{
  isLoading?: boolean;
-  items?: DelegationWithEverything[];
+  items: DelegationWithEverything[];
  explorerUrl: string;
  onDelegationItemActionClick?: (item: DelegationWithEverything, action: DelegationListItemActions) => void;
 }> = ({ isLoading, items, explorerUrl, onDelegationItemActionClick }) => (
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
pierre	e71f6f0f15	fix(wallet): broken explorer links	2022-11-17 18:33:29 +01:00
pierre	b706815802	refactor(explorer): rename mixnodeidentitykey to mixid	2022-11-17 18:33:25 +01:00
pierre	5336b2aa02	fix(wallet): explorer links	2022-11-17 18:33:17 +01:00
fmtabbara	2d2ed2740c	update tauri conf version	2022-11-17 16:35:14 +00:00
fmtabbara	6b914692d6	update version number	2022-11-17 15:33:27 +00:00
fmtabbara	85852086ea	fix undelegating with vesting tokens	2022-11-17 15:14:06 +00:00
Mark Sinclair	b84486c0f4	GitHub Actions: install packages needed for build	2022-11-16 11:56:26 +00:00
Mark Sinclair	8f52f34bc4	GitHub Actions: add workflow to build network explorer api	2022-11-16 11:43:17 +00:00
benedettadavico	b7aa84cd5a	updating mainnet mixnet conract address	2022-11-15 19:54:28 +01:00
Fouad	bfbd509e4b	Update/last minute release updates (#1753 ) * fix vesting update bond settings * style and text updates * show tx fee when updating node settings * allow cost param update with vesting tokens	2022-11-10 16:22:09 +00:00
Jon Häggblad	09b9601c7e	Update client-core to 1.1.0	2022-11-10 09:38:38 +01:00
Mark Sinclair	2a1dd138e0	GH Actions: Install same dependencies as build..yml	2022-11-09 18:21:28 +00:00
Mark Sinclair	9874daa061	Release v1.1.0: bump versions and update CHANGELOGs (#1746 ) * Bump version of nym-cli to 1.1.0 and move CHANGELOG to standalone file * Bump version of nym-connect to v1.1.0 and update CHANGELOG * Bump version of nym-wallet to v1.1.0 and update CHANGELOG * Bump version of explorer-api to v1.1.0 * Bump versions of binaries (native-client, socks5-client, mixnode, gateway, network-requester) to v1.1.0 * Bump version of validator-api to v1.1.0 * Bump version of mixnet contract to v1.1.0 (vesting contract already v1.1.0 from #1472) * Bump Nym Platform version to v1.1.0 and update CHANGELOG * Update CHANGELOG.md * Update CHANGELOG.md * Updated changelog with v2-related changes * Update CHANGELOG.md Co-authored-by: Mark Sinclair <mmsinclair@users.noreply.github.com> Co-authored-by: Fouad <fmtabbara@hotmail.co.uk> Co-authored-by: Pierre Dommerc <dommerc.pierre@gmail.com> Co-authored-by: Jędrzej Stuczyński <jedrzej.stuczynski@gmail.com> Co-authored-by: Jess <31625607+jessgess@users.noreply.github.com>	2022-11-09 15:04:41 +00:00
Fouad	baa61c07d5	Bug fix/ne snag list (#1741 ) * use uncapped saturation * display uncapped saturation update profit margin tooltip update operating cost update rewards tooltip update stake saturation tooltip update reward tooltips update profit margin tooltip * allow full gateway field to be clickable use uncapped saturation on mixnode details page	2022-11-09 12:39:14 +00:00
Jon Häggblad	62e9c8236a	Remove log from vesting-contract (#1745 ) * Remove log from vesting-contract * rustfmt	2022-11-09 11:04:32 +01:00
durch	cf268ffcd5	Actually save updated pledge cap	2022-11-09 10:19:21 +01:00
Drazen Urch	b28ff17c30	Set default pledge cap to 10% (#1739 ) * Set default pledge cap to 10% * fix clippy beta lints	2022-11-07 14:40:52 +01:00
Fouad	a7cd7a58f2	Bugfix/delegations sort by no bonded node (#1737 ) * use sorting function * create hardcoded examples in storybook	2022-11-03 13:44:09 +00:00
Gala	8bbdb94b13	Merge pull request #1733 from nymtech/417-inputs-label Wallet: make input's label always shrink	2022-11-02 16:42:17 +01:00
Pierre Dommerc	e32601ab86	feat(wallet): normalize decimal places in ui (#1731 )	2022-11-02 15:48:49 +01:00
Gala	161138bdff	Merge branch 'release/v1.1.0' into 417-inputs-label	2022-11-02 14:26:03 +01:00
Fouad	0529e84a31	add account how to links (#1732 )	2022-11-02 13:15:48 +00:00
Gala	95f98016de	make label always shrink	2022-11-02 13:49:29 +01:00
Fouad	4967bbb5bd	Feature/delegations without bonded node (#1727 ) * refactor delegations list to include separate delegation and pending delegation item * show tooltip on delegation with unbonded node * feat(wallet): add operating cost in delegations list * add additional state to check for unbonding event * disable actions when pending unbond event * add request and type guard for pending unbond event * add mixnode_is_unbonding to delegation item type Co-authored-by: pierre <dommerc.pierre@gmail.com>	2022-11-02 10:46:45 +00:00
Fouad	2952144d32	add profit margin percent to response (#1729 ) * add profit margin percent to response * use display percentage function * fix profit margin display * fix up filters	2022-11-01 13:02:34 +00:00
Jędrzej Stuczyński	80c21b3ed9	(chore) setting up a common/logging crate (#1730 )	2022-11-01 11:46:47 +00:00
Jędrzej Stuczyński	1f0d5f8ad0	Feature/vesting contract version query (#1726 ) * Introduced vesting contract query for build information * Fixed import paths * Changelog	2022-10-31 17:37:16 +00:00
Jędrzej Stuczyński	49ce56c367	Jedrzej/feature/version field in framed sphinx packets (#1723 ) * introduced PacketVersion into FramedSphinxPacket * Using legacy mode by default in mixnodes and gateways * fixed unit tests	2022-10-31 16:56:37 +00:00
Pierre Dommerc	4ab6f4c3a9	refactor(explorer-api): route ping use mix_id as param (#1728 )	2022-10-31 16:58:30 +01:00
Jędrzej Stuczyński	3727370b9e	Improved error propagation for fallible validator api queries (#1681 ) * Improved error propagation for fallible validator api queries * Updated changelog	2022-10-31 15:28:54 +00:00
Jędrzej Stuczyński	b3272097f9	Jedrzej/bugfix/historical uptimes recording (#1721 ) * Removed commented out type alias * typos * Using the same underlying timer for uptime updater * Updating uptimes at 23:00 UTC each day * Changelog	2022-10-31 12:19:14 +00:00
Jon Häggblad	ebc13c4327	client: make channel to mix traffic controller bounded and add backpressure handling v1.1 (#1725 ) * clients: change mix traffic channel to bounded * clients: dynamically adjust sending delay in steps * rustfmt * wasm-client: update channel * client: introduce SendingDelayController * client-core: downgrade two debug statements to trace * sending delay controller: tweak parameters * wasm-client: add tokio dependency * client-core: rework delay controller * Revert "client-core: downgrade two debug statements to trace" This reverts commit e0a7772fafac7bff0e4a2c50ba25e94b52b794e6. * Remove outdated comment * Remove WIP comments * changelog: add note * out queue controller: simplify with just send * client-core: document constants * client: move creating mix msg channel to mix traffic controller * client-core: downgrade a warning log msg to debug * changelog: update	2022-10-31 12:21:02 +01:00
Jon Häggblad	ec3a6b3e27	socks5: wait to close buffer (v1.1 branch) (#1724 ) * socks5: wait to close buffer This is the fix proposed by @simonwicky in https://github.com/nymtech/nym/issues/1701 * socks5: fix typo in patch * socks5: fix tests * socks5: add type for returned data and index * socks5: make closed_at_index an Option * changelog: add note * changelog: update	2022-10-31 11:56:31 +01:00