merged with fbdf31b879

Feature/split stats service (#1328 )
* Replace client address with service address * Copy over the server parts of the statistics server * Separate API in module * Rename struct * Add insertion endpoint * Remove unused code from network requester * Box big rocket error * Remove the feature-specific code * Construct http req * Clippy + Cargo.lock update * Re-added needed sqlx feature * Wrap http req in ordered msg * Add http headers * Move common api functionality into the separate crate * Make stats server address configurable, especially for testing * Update changelog * Fix clippy * Help command update
2022-06-10 09:56:35 +01:00 · 2022-06-09 16:58:51 +03:00 · 2022-06-09 14:42:15 +01:00 · 2022-06-09 14:35:44 +02:00 · 2022-06-09 11:49:12 +01:00 · 2022-06-08 21:51:00 +02:00
507 changed files with 20611 additions and 8128 deletions
@@ -10,7 +10,7 @@ on:

 jobs:
  build:
-    runs-on: [ self-hosted, custom-linux-exoscale ]
+    runs-on: [ self-hosted, custom-linux ]
    # Enable sccache via environment variable
    env:
      RUSTC_WRAPPER: /home/ubuntu/.cargo/bin/sccache
@@ -4,7 +4,7 @@ on: workflow_dispatch

 jobs:
  build:
-    runs-on: [ self-hosted, custom-linux-exoscale ]
+    runs-on: [ self-hosted, custom-linux ]
    # Enable sccache via environment variable
    env:
      RUSTC_WRAPPER: /home/ubuntu/.cargo/bin/sccache
@@ -10,7 +10,9 @@ on:

 jobs:
  build:
-    runs-on: [ self-hosted, custom-linux-exoscale ]
+    runs-on: [ self-hosted, custom-linux ]
+    env:
+      RUSTC_WRAPPER: /home/ubuntu/.cargo/bin/sccache
    steps:
      - 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 squashfs-tools
@@ -1,34 +1,63 @@
 # Changelog

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

 ### Added

- wallet: require password to switch accounts
+- all: added network compilation target to `--help` (or `--version`) commands ([#1256]).
+- explorer-api: learned how to sum the delegations by owner in a new endpoint.
+- gateway: Added gateway coconut verifications and validator-api communication for double spending protection ([#1261])
+- mixnet-contract: Added ClaimOperatorReward and ClaimDelegatorReward messages ([#1292])
+- mixnet-contract: Replace all naked `-` with `saturating_sub`.
+- validator-api: add `estimated_node_profit` and `estimated_operator_cost` to `reward-estimate` endpoint ([#1284])
+- validator-api: add detailed mixnode bond endpoints, and explorer-api makes use of that data to append stake saturation.
+- validator-api: add Swagger to document the REST API ([#1249]).
+- validator-api: Added new endpoints for coconut spending flow and communications with coconut & multisig contracts ([#1261])
+- vesting-contract: Added ClaimOperatorReward and ClaimDelegatorReward messages ([#1292])
 - wallet: add simple CLI tool for decrypting and recovering the wallet file.
 - wallet: added support for multiple accounts ([#1265])
+- wallet: compound and claim reward endpoints for operators and delegators ([#1302])
+- wallet: require password to switch accounts
 - wallet: the wallet backend learned how to keep track of validator name, either hardcoded or by querying the status endpoint.
- mixnet-contract: Replace all naked `-` with `saturating_sub`.
- validator-api: add Swagger to document the REST API ([#1249]).
- all: added network compilation target to `--help` (or `--version`) commands ([#1256]).
- network-requester: send traffic statistics from all network requesters and receive it in a special network-requester that aggregates the data and exposes it via a rest API ([#1267], [#1278]).
+- network-statistics: a new mixnet service that aggregates and exposes anonymized data about mixnet services ([#1328])

 ### Fixed

- vesting-contract: replaced `checked_sub` with `saturating_sub` to fix the underflow in `get_vesting_tokens` ([#1275])
+- mixnet-contract: `estimated_delegator_reward` calculation ([#1284])
+- mixnet-contract: delegator and operator rewards use lambda and sigma instead of lambda_ticked and sigma_ticked ([#1284])
 - mixnet-contract: removed `expect` in `query_delegator_reward` and queries containing invalid proxy address should now return a more human-readable error ([#1257])
+- mixnet-contract: replaced integer division with fixed for performance calculations ([#1284])
 - mixnet-contract: Under certain circumstances nodes could not be unbonded ([#1255](https://github.com/nymtech/nym/issues/1255)) ([#1258])
 - mixnode, gateway: attempting to determine reconnection backoff to persistently failing mixnode could result in a crash ([#1260])
+- mixnode: the mixnode learned how to shutdown gracefully.
+- vesting-contract: replaced `checked_sub` with `saturating_sub` to fix the underflow in `get_vesting_tokens` ([#1275])
+- native & socks5 clients: fail early when clients try to re-init with a different gateway, which is not supported yet ([#1322])
+
+### Changed
+
+- validator-client: created internal `Coin` type that replaces coins from `cosmrs` and `cosmwasm` for API entrypoints [[#1295]]
+- all: updated all `cosmwasm`-related dependencies to `1.0.0` and `cw-storage-plus` to `0.13.4` [[#1318]]
+- network-requester: allow to voluntarily store and send statistical data about the number of bytes the proxied server serves ([#1328])

-[#1258]: https://github.com/nymtech/nym/pull/1258
 [#1249]: https://github.com/nymtech/nym/pull/1249
 [#1256]: https://github.com/nymtech/nym/pull/1256
 [#1257]: https://github.com/nymtech/nym/pull/1257
+[#1258]: https://github.com/nymtech/nym/pull/1258
 [#1260]: https://github.com/nymtech/nym/pull/1260
+[#1261]: https://github.com/nymtech/nym/pull/1261
 [#1265]: https://github.com/nymtech/nym/pull/1265
 [#1267]: https://github.com/nymtech/nym/pull/1267
 [#1275]: https://github.com/nymtech/nym/pull/1275
 [#1278]: https://github.com/nymtech/nym/pull/1278
+[#1284]: https://github.com/nymtech/nym/pull/1284
+[#1292]: https://github.com/nymtech/nym/pull/1292
+[#1295]: https://github.com/nymtech/nym/pull/1295
+[#1302]: https://github.com/nymtech/nym/pull/1302
+[#1318]: https://github.com/nymtech/nym/pull/1318
+[#1322]: https://github.com/nymtech/nym/pull/1322
+[#1328]: https://github.com/nymtech/nym/pull/1328

 ## [nym-wallet-v1.0.4](https://github.com/nymtech/nym/tree/nym-wallet-v1.0.4) (2022-05-04)

@@ -31,10 +31,12 @@ members = [
    "common/credentials",
    "common/crypto",
    "common/crypto/dkg",
+    "common/execute",
    "common/bandwidth-claim-contract",
    "common/cosmwasm-smart-contracts/coconut-bandwidth-contract",
    "common/cosmwasm-smart-contracts/contracts-common",
    "common/cosmwasm-smart-contracts/mixnet-contract",
+    "common/cosmwasm-smart-contracts/multisig-contract",
    "common/cosmwasm-smart-contracts/vesting-contract",
    "common/mixnode-common",
    "common/network-defaults",
@@ -51,17 +53,22 @@ members = [
    "common/nymsphinx/params",
    "common/nymsphinx/types",
    "common/pemstore",
+    "common/statistics",
    "common/socks5/proxy-helpers",
    "common/socks5/requests",
+    "common/task",
    "common/topology",
+    "common/types",
    "common/wasm-utils",
    "explorer-api",
    "gateway",
    "gateway/gateway-requests",
    "mixnode",
    "service-providers/network-requester",
+    "service-providers/network-statistics",
    "validator-api",
    "validator-api/validator-api-requests",
+    "tools/ts-rs-cli"
 ]

 default-members = [
@@ -74,4 +81,4 @@ default-members = [
    "explorer-api",
 ]

-exclude = ["explorer", "contracts", "tokenomics-py", "clients/webassembly"]
+exclude = ["explorer", "contracts", "tokenomics-py", "clients/webassembly", "nym-wallet"]
@@ -54,3 +54,7 @@ fmt-wallet:

 wasm:
 	RUSTFLAGS='-C link-arg=-s' cargo build --manifest-path contracts/Cargo.toml --release --target wasm32-unknown-unknown
+
+generate-typescript:
+	cd tools/ts-rs-cli && cargo run && cd ../..
+	yarn types:lint:fix
@@ -0,0 +1,7 @@
+<svg viewBox="0 0 200 200" fill="none" xmlns="http://www.w3.org/2000/svg">
+    <path d="M171.7,30.3001 C132.7,-8.7999 69.3001,-8.7999 30.3001,30.3001 C-8.7999,69.4001 -8.7999,132.7 30.3001,171.7 C69.4001,210.8 132.7,210.8 171.7,171.7 C210.8,132.7 210.8,69.3001 171.7,30.3001 Z M163.1,163.1 C128.8,197.4 73.1001,197.4 38.8001,163.1 C4.5001,128.8 4.5001,73.1001 38.8001,38.8001 C73.1001,4.5001 128.8,4.5001 163.1,38.8001 C197.5,73.2001 197.5,128.8 163.1,163.1 Z" id="Shape" fill="#fff"></path>
+    <path d="M163.1,38.9 C128.8,4.60005 73.1002,4.60005 38.8002,38.9 C4.50019,73.2 4.50019,128.9 38.8002,163.2 C73.1002,197.5 128.8,197.5 163.1,163.2 C197.5,128.8 197.5,73.2 163.1,38.9 Z" id="Shape" fill="#000"></path>
+    <g id="T" transform="translate(25, 25) scale(5,5)">
+        <path d="M18.4804688,24 C19.203125,24 19.7182617,23.8608398 20.0258789,23.5825195 C20.3334961,23.3041992 20.4873047,22.9453125 20.4873047,22.5058594 C20.4873047,22.0566406 20.3334961,21.6928711 20.0258789,21.4145508 C19.7182617,21.1362305 19.203125,20.9970703 18.4804688,20.9970703 L18.4804688,20.9970703 L16.4589844,20.9970703 L16.4589844,9.24902344 L19.7548828,9.24902344 L19.7548828,12.0908203 C19.7548828,12.8134766 19.894043,13.3286133 20.1723633,13.6362305 C20.4506836,13.9438477 20.8095703,14.0976562 21.2490234,14.0976562 C21.6982422,14.0976562 22.0620117,13.9438477 22.340332,13.6362305 C22.6186523,13.3286133 22.7578125,12.8134766 22.7578125,12.0908203 L22.7578125,12.0908203 L22.7578125,6.24609375 L7.20117188,6.23144531 L7.20117188,12.0908203 C7.20117188,12.8134766 7.34033203,13.3286133 7.61865234,13.6362305 C7.89697266,13.9438477 8.25585938,14.0976562 8.6953125,14.0976562 C9.14453125,14.0976562 9.50830078,13.9438477 9.78662109,13.6362305 C10.0649414,13.3286133 10.2041016,12.8134766 10.2041016,12.0908203 L10.2041016,12.0908203 L10.2041016,9.24902344 L13.4560547,9.24902344 L13.4560547,20.9970703 L11.4492188,20.9970703 C10.7265625,20.9970703 10.2114258,21.1362305 9.90380859,21.4145508 C9.59619141,21.6928711 9.44238281,22.0517578 9.44238281,22.4912109 C9.44238281,22.9404297 9.59619141,23.3041992 9.90380859,23.5825195 C10.2114258,23.8608398 10.7265625,24 11.4492188,24 L11.4492188,24 L18.4804688,24 Z" id="T" fill="#fff"></path>
+    </g>
+</svg>
@@ -1,4 +1,4 @@
-<svg width="200" height="200" viewBox="0 0 200 200" fill="none" xmlns="http://www.w3.org/2000/svg">
+<svg viewBox="0 0 200 200" fill="none" xmlns="http://www.w3.org/2000/svg">
    <path d="M170.7 29.3001C131.7 -9.7999 68.3001 -9.7999 29.3001 29.3001C-9.7999 68.4001 -9.7999 131.7 29.3001 170.7C68.4001 209.8 131.7 209.8 170.7 170.7C209.8 131.7 209.8 68.3001 170.7 29.3001ZM162.1 162.1C127.8 196.4 72.1001 196.4 37.8001 162.1C3.5001 127.8 3.5001 72.1001 37.8001 37.8001C72.1001 3.5001 127.8 3.5001 162.1 37.8001C196.5 72.2001 196.5 127.8 162.1 162.1Z" fill="white"/>
    <path d="M162.1 37.9C127.8 3.60005 72.1002 3.60005 37.8002 37.9C3.50019 72.2 3.50019 127.9 37.8002 162.2C72.1002 196.5 127.8 196.5 162.1 162.2C196.5 127.8 196.5 72.2 162.1 37.9ZM63.0002 170.7C56.8002 167.4 51.1002 163.2 46.1002 158.4V41.7C51.3002 36.7 57.2002 32.5 63.6002 29.1L137 140.9V29.3C143.2 32.6 148.9 36.8 153.9 41.6V158.3C148.7 163.3 142.8 167.5 136.4 170.9L63.0002 59.1V170.7Z" fill="#070B15"/>
    <path d="M154 158.3V41.7C148.9 36.9 143.2 32.7 137.1 29.4V140.9L63.5 29C57.1 32.4 51.2 36.6 46 41.6V158.3C51.1 163.1 56.8 167.3 62.9 170.6V59.1L136.5 171C142.9 167.6 148.8 163.3 154 158.3Z" fill="white"/>
@@ -0,0 +1,7 @@
+<svg viewBox="0 0 200 200" fill="none" xmlns="http://www.w3.org/2000/svg">
+    <path d="M171.7,30.3001 C132.7,-8.7999 69.3001,-8.7999 30.3001,30.3001 C-8.7999,69.4001 -8.7999,132.7 30.3001,171.7 C69.4001,210.8 132.7,210.8 171.7,171.7 C210.8,132.7 210.8,69.3001 171.7,30.3001 Z M163.1,163.1 C128.8,197.4 73.1001,197.4 38.8001,163.1 C4.5001,128.8 4.5001,73.1001 38.8001,38.8001 C73.1001,4.5001 128.8,4.5001 163.1,38.8001 C197.5,73.2001 197.5,128.8 163.1,163.1 Z" id="Shape" fill="#141521"></path>
+    <path d="M163.1,38.9 C128.8,4.60005 73.1002,4.60005 38.8002,38.9 C4.50019,73.2 4.50019,128.9 38.8002,163.2 C73.1002,197.5 128.8,197.5 163.1,163.2 C197.5,128.8 197.5,73.2 163.1,38.9 Z" id="Shape" fill="#FFFFFF"></path>
+    <g id="T" transform="translate(25, 25) scale(5,5)">
+        <path d="M18.4804688,24 C19.203125,24 19.7182617,23.8608398 20.0258789,23.5825195 C20.3334961,23.3041992 20.4873047,22.9453125 20.4873047,22.5058594 C20.4873047,22.0566406 20.3334961,21.6928711 20.0258789,21.4145508 C19.7182617,21.1362305 19.203125,20.9970703 18.4804688,20.9970703 L18.4804688,20.9970703 L16.4589844,20.9970703 L16.4589844,9.24902344 L19.7548828,9.24902344 L19.7548828,12.0908203 C19.7548828,12.8134766 19.894043,13.3286133 20.1723633,13.6362305 C20.4506836,13.9438477 20.8095703,14.0976562 21.2490234,14.0976562 C21.6982422,14.0976562 22.0620117,13.9438477 22.340332,13.6362305 C22.6186523,13.3286133 22.7578125,12.8134766 22.7578125,12.0908203 L22.7578125,12.0908203 L22.7578125,6.24609375 L7.20117188,6.23144531 L7.20117188,12.0908203 C7.20117188,12.8134766 7.34033203,13.3286133 7.61865234,13.6362305 C7.89697266,13.9438477 8.25585938,14.0976562 8.6953125,14.0976562 C9.14453125,14.0976562 9.50830078,13.9438477 9.78662109,13.6362305 C10.0649414,13.3286133 10.2041016,12.8134766 10.2041016,12.0908203 L10.2041016,12.0908203 L10.2041016,9.24902344 L13.4560547,9.24902344 L13.4560547,20.9970703 L11.4492188,20.9970703 C10.7265625,20.9970703 10.2114258,21.1362305 9.90380859,21.4145508 C9.59619141,21.6928711 9.44238281,22.0517578 9.44238281,22.4912109 C9.44238281,22.9404297 9.59619141,23.3041992 9.90380859,23.5825195 C10.2114258,23.8608398 10.7265625,24 11.4492188,24 L11.4492188,24 L18.4804688,24 Z" id="T" fill="#000" fill-rule="nonzero"></path>
+    </g>
+</svg>
@@ -1,4 +1,4 @@
-<svg width="200" height="200" viewBox="0 0 200 200" fill="none" xmlns="http://www.w3.org/2000/svg">
+<svg viewBox="0 0 200 200" fill="none" xmlns="http://www.w3.org/2000/svg">
    <path d="M170.7 29.3001C131.7 -9.7999 68.3001 -9.7999 29.3001 29.3001C-9.7999 68.4001 -9.7999 131.7 29.3001 170.7C68.4001 209.8 131.7 209.8 170.7 170.7C209.8 131.7 209.8 68.3001 170.7 29.3001ZM162.1 162.1C127.8 196.4 72.1001 196.4 37.8001 162.1C3.5001 127.8 3.5001 72.1001 37.8001 37.8001C72.1001 3.5001 127.8 3.5001 162.1 37.8001C196.5 72.2001 196.5 127.8 162.1 162.1Z" fill="#141521"/>
    <path d="M162.1 37.9C127.8 3.60005 72.1002 3.60005 37.8002 37.9C3.50019 72.2 3.50019 127.9 37.8002 162.2C72.1002 196.5 127.8 196.5 162.1 162.2C196.5 127.8 196.5 72.2 162.1 37.9ZM63.0002 170.7C56.8002 167.4 51.1002 163.2 46.1002 158.4V41.7C51.3002 36.7 57.2002 32.5 63.6002 29.1L137 140.9V29.3C143.2 32.6 148.9 36.8 153.9 41.6V158.3C148.7 163.3 142.8 167.5 136.4 170.9L63.0002 59.1V170.7Z" fill="white"/>
    <path d="M154 158.3V41.7C148.9 36.9 143.2 32.7 137.1 29.4V140.9L63.5 29C57.1 32.4 51.2 36.6 46 41.6V158.3C51.1 163.1 56.8 167.3 62.9 170.6V59.1L136.5 171C142.9 167.6 148.8 163.3 154 158.3Z" fill="#141521"/>
@@ -14,7 +14,7 @@ log = "0.4"
 rand = { version = "0.7.3", features = ["wasm-bindgen"] }
 serde = { version = "1.0", features = ["derive"] }
 sled = "0.34"
-tokio = { version = "1.4", features = ["macros"] }
+tokio = { version = "1.19.1", features = ["macros"] }
 url = { version ="2.2", features = ["serde"] }

 # internal
@@ -6,7 +6,7 @@ use crate::client::real_messages_control::acknowledgement_control::Retransmissio
 use futures::channel::mpsc::{self, UnboundedReceiver, UnboundedSender};
 use futures::StreamExt;
 use log::*;
-use nonexhaustive_delayqueue::{Expired, NonExhaustiveDelayQueue, QueueKey, TimerError};
+use nonexhaustive_delayqueue::{Expired, NonExhaustiveDelayQueue, QueueKey};
 use nymsphinx::chunking::fragment::FragmentIdentifier;
 use nymsphinx::Delay as SphinxDelay;
 use std::collections::HashMap;
@@ -209,16 +209,11 @@ impl ActionController {
    }

    // note: when the entry expires it's automatically removed from pending_acks_timers
-    fn handle_expired_ack_timer(
-        &mut self,
-        expired_ack: Result<Expired<FragmentIdentifier>, TimerError>,
-    ) {
+    fn handle_expired_ack_timer(&mut self, expired_ack: Expired<FragmentIdentifier>) {
        // I'm honestly not sure how to handle it, because getting it means other things in our
        // system are already misbehaving. If we ever see this panic, then I guess we should worry
        // about it. Perhaps just reschedule it at later point?
-        let frag_id = expired_ack
-            .expect("Tokio timer returned an error!")
-            .into_inner();
+        let frag_id = expired_ack.into_inner();

        trace!("{} has expired", frag_id);

@@ -15,9 +15,8 @@ rand = "0.7.3"
 serde = { version = "1.0", features = ["derive"] }
 thiserror = "1.0"
 url = "2.2"
-tokio = { version = "1.4", features = ["rt-multi-thread", "net", "signal", "macros"] } # async runtime
+tokio = { version = "1.19.1", features = ["rt-multi-thread", "net", "signal", "macros"] } # async runtime

-coconut-bandwidth-contract-common = { path = "../../common/cosmwasm-smart-contracts/coconut-bandwidth-contract" }
 coconut-interface = { path = "../../common/coconut-interface" }
 credentials = { path = "../../common/credentials" }
 credential-storage = { path = "../../common/credential-storage" }
@@ -2,66 +2,48 @@
 // SPDX-License-Identifier: Apache-2.0

 use bip39::Mnemonic;
-use coconut_bandwidth_contract_common::deposit::DepositData;
 use std::str::FromStr;
 use url::Url;

 use crate::error::Result;
-use crate::{CONTRACT_ADDRESS, MNEMONIC, NYMD_URL};
+use crate::{MNEMONIC, NYMD_URL};

-use coconut_bandwidth_contract_common::msg::ExecuteMsg;
-use network_defaults::DEFAULT_NETWORK;
-use validator_client::nymd::{
-    AccountId, CosmosCoin, Decimal, Denom, NymdClient, SigningNymdClient,
-};
+use network_defaults::{DEFAULT_NETWORK, MIX_DENOM, VOUCHER_INFO};
+use validator_client::nymd::traits::CoconutBandwidthSigningClient;
+use validator_client::nymd::{Coin, Fee, NymdClient, SigningNymdClient};

 pub(crate) struct Client {
    nymd_client: NymdClient<SigningNymdClient>,
-    denom: Denom,
-    contract_address: AccountId,
 }

 impl Client {
    pub fn new() -> Self {
        let nymd_url = Url::from_str(NYMD_URL).unwrap();
        let mnemonic = Mnemonic::from_str(MNEMONIC).unwrap();
-        let nymd_client = NymdClient::connect_with_mnemonic(
-            DEFAULT_NETWORK,
-            nymd_url.as_ref(),
-            None,
-            None,
-            None,
-            mnemonic,
-            None,
-        )
-        .unwrap();
-        let denom = Denom::from_str(network_defaults::DENOM).unwrap();
-        let contract_address = AccountId::from_str(CONTRACT_ADDRESS).unwrap();
+        let nymd_client =
+            NymdClient::connect_with_mnemonic(DEFAULT_NETWORK, nymd_url.as_ref(), mnemonic, None)
+                .unwrap();

-        Client {
-            nymd_client,
-            denom,
-            contract_address,
-        }
+        Client { nymd_client }
    }

    pub async fn deposit(
        &self,
        amount: u64,
-        info: &str,
        verification_key: String,
        encryption_key: String,
+        fee: Option<Fee>,
    ) -> Result<String> {
-        let req = ExecuteMsg::DepositFunds {
-            data: DepositData::new(info.to_string(), verification_key, encryption_key),
-        };
-        let funds = vec![CosmosCoin {
-            denom: self.denom.clone(),
-            amount: Decimal::from(amount),
-        }];
+        let amount = Coin::new(amount as u128, MIX_DENOM.base.to_string());
        Ok(self
            .nymd_client
-            .execute(&self.contract_address, &req, Default::default(), "", funds)
+            .deposit(
+                amount,
+                String::from(VOUCHER_INFO),
+                verification_key,
+                encryption_key,
+                fee,
+            )
            .await?
            .transaction_hash
            .to_string())
@@ -55,9 +55,9 @@ impl Execute for Deposit {
        let tx_hash = client
            .deposit(
                self.amount,
-                VOUCHER_INFO,
                signing_keypair.public_key.clone(),
                encryption_keypair.public_key.clone(),
+                None,
            )
            .await?;

@@ -27,7 +27,7 @@ pretty_env_logger = "0.4" # for formatting log messages
 rand = { version = "0.7.3", features = ["wasm-bindgen"] } # rng-related traits + some rng implementation to use
 serde = { version = "1.0.104", features = ["derive"] } # for config serialization/deserialization
 sled = "0.34" # for storage of replySURB decryption keys
-tokio = { version = "1.4", features = ["rt-multi-thread", "net", "signal"] } # async runtime
+tokio = { version = "1.19.1", features = ["rt-multi-thread", "net", "signal"] } # async runtime
 tokio-tungstenite = "0.14" # websocket

 ## internal
@@ -119,6 +119,7 @@ async fn gateway_details(
        .expect("The list of validator apis is empty");
    let validator_client = validator_client::ApiClient::new(validator_api.clone());

+    log::trace!("Fetching list of gateways from: {}", validator_api);
    let gateways = validator_client.get_cached_gateways().await.unwrap();
    let valid_gateways = gateways
        .into_iter()
@@ -186,6 +187,9 @@ pub async fn execute(matches: ArgMatches<'static>) {
    let id = matches.value_of("id").unwrap(); // required for now

    let already_init = if Config::default_config_file_path(Some(id)).exists() {
+        if matches.is_present("gateway") {
+            panic!("At the moment, gateway information can't be overwritten. If you want to point to a different gateway, client {}'s directory will need to be manually removed", id);
+        }
        println!("Client \"{}\" was already initialised before! Config information will be overwritten (but keys will be kept)!", id);
        true
    } else {
@@ -210,12 +214,14 @@ pub async fn execute(matches: ArgMatches<'static>) {
        let mut key_manager = KeyManager::new(&mut rng);

        let chosen_gateway_id = matches.value_of("gateway");
+        log::trace!("Chosen gateway: {:?}", chosen_gateway_id);

        let gateway_details = gateway_details(
            config.get_base().get_validator_api_endpoints(),
            chosen_gateway_id,
        )
        .await;
+        log::trace!("Used gateway: {}", gateway_details);
        let shared_keys =
            register_with_gateway(&gateway_details, key_manager.identity_keypair()).await;

@@ -238,8 +244,14 @@ pub async fn execute(matches: ArgMatches<'static>) {
        .save_to_file(None)
        .expect("Failed to save the config file");
    println!("Saved configuration file to {:?}", config_save_location);
-    println!("Using gateway: {}", config.get_base().get_gateway_id(),);
-    println!("Client configuration completed.\n\n\n");
+    println!("Using gateway: {}", config.get_base().get_gateway_id());
+    log::debug!("Gateway id: {}", config.get_base().get_gateway_id());
+    log::debug!("Gateway owner: {}", config.get_base().get_gateway_owner());
+    log::debug!(
+        "Gateway listener: {}",
+        config.get_base().get_gateway_listener()
+    );
+    println!("Client configuration completed.");

    show_address(&config);
 }
@@ -39,15 +39,11 @@ pub(crate) fn override_config(mut config: Config, matches: &ArgMatches<'_>) -> C
            .set_custom_validator_apis(parse_validators(raw_validators));
    }

-    if let Some(gateway_id) = matches.value_of("gateway") {
-        config.get_base_mut().with_gateway_id(gateway_id);
-    }
-
    if matches.is_present("disable-socket") {
        config = config.with_socket(SocketType::None);
    }

-    if let Some(port) = matches.value_of("port").map(|port| port.parse::<u16>()) {
+    if let Some(port) = matches.value_of("port").map(str::parse) {
        if let Err(err) = port {
            // if port was overridden, it must be parsable
            panic!("Invalid port value provided - {:?}", err);
@@ -70,7 +70,9 @@ pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
 fn version_check(cfg: &Config) -> bool {
    let binary_version = env!("CARGO_PKG_VERSION");
    let config_version = cfg.get_base().get_version();
-    if binary_version != config_version {
+    if binary_version == config_version {
+        true
+    } else {
        warn!("The mixnode binary has different version than what is specified in config file! {} and {}", binary_version, config_version);
        if is_minor_version_compatible(binary_version, config_version) {
            info!("but they are still semver compatible. However, consider running the `upgrade` command");
@@ -79,8 +81,6 @@ fn version_check(cfg: &Config) -> bool {
            error!("and they are semver incompatible! - please run the `upgrade` command before attempting `run` again");
            false
        }
-    } else {
-        true
    }
 }

@@ -131,22 +131,22 @@ fn minor_0_12_upgrade(
    config
 }

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

-        if config_version == package_version {
+        if &config_version == package_version {
            println!("You're using the most recent version!");
            return;
        }

        config = match config_version.major {
            0 => match config_version.minor {
-                9 | 10 => outdated_upgrade(&config_version, &package_version),
-                11 => minor_0_12_upgrade(config, matches, &config_version, &package_version),
-                _ => unsupported_upgrade(&config_version, &package_version),
+                9 | 10 => outdated_upgrade(&config_version, package_version),
+                11 => minor_0_12_upgrade(config, matches, &config_version, package_version),
+                _ => unsupported_upgrade(&config_version, package_version),
            },
-            _ => unsupported_upgrade(&config_version, &package_version),
+            _ => unsupported_upgrade(&config_version, package_version),
        }
    }
 }
@@ -167,5 +167,5 @@ pub fn execute(matches: &ArgMatches<'_>) {
    }

    // here be upgrade path to 0.9.X and beyond based on version number from config
-    do_upgrade(existing_config, matches, package_version)
+    do_upgrade(existing_config, matches, &package_version)
 }
@@ -108,5 +108,7 @@ fn setup_logging() {
        .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();
 }
@@ -20,7 +20,7 @@ pretty_env_logger = "0.4"
 rand = { version = "0.7.3", features = ["wasm-bindgen"] }
 serde = { version = "1.0", features = ["derive"] } # for config serialization/deserialization
 snafu = "0.6"
-tokio = { version = "1.4", features = ["rt-multi-thread", "net", "signal"] }
+tokio = { version = "1.19.1", features = ["rt-multi-thread", "net", "signal"] }
 url = "2.2"

 # internal
@@ -187,6 +187,9 @@ pub async fn execute(matches: ArgMatches<'static>) {
    let provider_address = matches.value_of("provider").unwrap();

    let already_init = if Config::default_config_file_path(Some(id)).exists() {
+        if matches.is_present("gateway") {
+            panic!("At the moment, gateway information can't be overwritten. If you want to point to a different gateway, client {}'s directory will need to be manually removed", id);
+        }
        println!("Socks5 client \"{}\" was already initialised before! Config information will be overwritten (but keys will be kept)!", id);
        true
    } else {
@@ -39,10 +39,6 @@ pub(crate) fn override_config(mut config: Config, matches: &ArgMatches<'_>) -> C
            .set_custom_validator_apis(parse_validators(raw_validators));
    }

-    if let Some(gateway_id) = matches.value_of("gateway") {
-        config.get_base_mut().with_gateway_id(gateway_id);
-    }
-
    if let Some(port) = matches.value_of("port").map(|port| port.parse::<u16>()) {
        if let Err(err) = port {
            // if port was overridden, it must be parsable
@@ -35,7 +35,7 @@ default-features = false

 # non-wasm-only dependencies
 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio]
-version = "1.4"
+version = "1.19.1"
 features = ["macros", "rt", "net", "sync", "time"]

 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio-tungstenite]
@@ -101,7 +101,7 @@ impl GatewayClient {
    }

    pub fn set_disabled_credentials_mode(&mut self, disabled_credentials_mode: bool) {
-        self.disabled_credentials_mode = disabled_credentials_mode
+        self.disabled_credentials_mode = disabled_credentials_mode;
    }

    // TODO: later convert into proper builder methods
@@ -496,7 +496,6 @@ impl GatewayClient {
            self.shared_key.as_ref().unwrap(),
            iv,
        )
-        .ok_or(GatewayClientError::SerializeCredential)?
        .into();
        self.bandwidth_remaining = match self.send_websocket_message(msg).await? {
            ServerResponse::Bandwidth { available_total } => Ok(available_total),
@@ -9,8 +9,8 @@ edition = "2021"
 [dependencies]
 futures = "0.3"
 log = "0.4.8"
-tokio = { version = "1.4", features = ["time", "net", "rt"] }
-tokio-util = { version = "0.6", features = ["codec"] }
+tokio = { version = "1.19.1", features = ["time", "net", "rt"] }
+tokio-util = { version = "0.7.3", features = ["codec"] }

 # internal
 nymsphinx = {path = "../../nymsphinx" }
@@ -10,8 +10,11 @@ rust-version = "1.56"
 [dependencies]
 base64 = "0.13"
 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" }
+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" }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
@@ -19,7 +22,7 @@ reqwest = { version = "0.11", features = ["json"] }
 thiserror = "1"
 log = "0.4"
 url = { version = "2.2", features = ["serde"] }
-tokio = { version = "1.10", features = ["sync", "time"] }
+tokio = { version = "1.19.1", features = ["sync", "time"] }
 futures = "0.3"

 coconut-interface = { path = "../../coconut-interface" }
@@ -32,14 +35,14 @@ validator-api-requests = { path = "../../../validator-api/validator-api-requests
 async-trait = { version = "0.1.51", optional = true }
 bip39 = { version = "1", features = ["rand"], optional = true }
 config = { path = "../../config", optional = true }
-cosmrs = { git = "https://github.com/nymtech/cosmos-rust", branch = "bugfix/account-id-length-validation", features = ["rpc", "bip32", "cosmwasm"], optional = true}
-prost = { version = "0.9", default-features = false, optional = true }
+cosmrs = { version = "0.7.0", features = ["rpc", "bip32", "cosmwasm"], optional = true}
+prost = { version = "0.10", default-features = false, optional = true }
 flate2 = { version = "1.0.20", optional = true }
 sha2 = { version = "0.9.5", optional = true }
 itertools = { version = "0.10", optional = true }
-cosmwasm-std = { version = "1.0.0-beta8", optional = true }
+cosmwasm-std = { version = "1.0.0", optional = true }
+execute = { path = "../../execute" }

-[dev-dependencies]
 ts-rs = "6.1.2"

 [features]
@@ -54,3 +57,5 @@ nymd-client = [
    "itertools",
    "cosmwasm-std",
 ]
+generate-ts = []
+
@@ -2,16 +2,20 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::{validator_api, ValidatorClientError};
-use coconut_interface::{BlindSignRequestBody, BlindedSignatureResponse, VerificationKeyResponse};
+use coconut_interface::{
+    BlindSignRequestBody, BlindedSignatureResponse, ExecuteReleaseFundsRequestBody,
+    ProposeReleaseFundsRequestBody, ProposeReleaseFundsResponse, VerificationKeyResponse,
+    VerifyCredentialBody, VerifyCredentialResponse,
+};
 use mixnet_contract_common::{GatewayBond, IdentityKeyRef, MixNodeBond};
 use url::Url;

-#[cfg(feature = "nymd-client")]
-use validator_api_requests::models::UptimeResponse;
 use validator_api_requests::models::{
    CoreNodeStatusResponse, MixnodeStatusResponse, RewardEstimationResponse,
    StakeSaturationResponse,
 };
+#[cfg(feature = "nymd-client")]
+use validator_api_requests::models::{MixNodeBondAnnotated, UptimeResponse};

 #[cfg(feature = "nymd-client")]
 use network_defaults::DEFAULT_NETWORK;
@@ -29,8 +33,6 @@ use mixnet_contract_common::{
 };
 #[cfg(feature = "nymd-client")]
 use std::collections::{HashMap, HashSet};
-#[cfg(feature = "nymd-client")]
-use std::str::FromStr;

 #[cfg(feature = "nymd-client")]
 #[must_use]
@@ -39,9 +41,9 @@ pub struct Config {
    network: network_defaults::all::Network,
    api_url: Url,
    nymd_url: Url,
-    mixnet_contract_address: Option<cosmrs::AccountId>,
-    vesting_contract_address: Option<cosmrs::AccountId>,
-    erc20_bridge_contract_address: Option<cosmrs::AccountId>,
+    mixnet_contract_address: cosmrs::AccountId,
+    vesting_contract_address: cosmrs::AccountId,
+    bandwidth_claim_contract_address: cosmrs::AccountId,

    mixnode_page_limit: Option<u32>,
    gateway_page_limit: Option<u32>,
@@ -51,20 +53,22 @@ pub struct Config {

 #[cfg(feature = "nymd-client")]
 impl Config {
-    pub fn new(
-        network: network_defaults::all::Network,
-        nymd_url: Url,
-        api_url: Url,
-        mixnet_contract_address: Option<cosmrs::AccountId>,
-        vesting_contract_address: Option<cosmrs::AccountId>,
-        erc20_bridge_contract_address: Option<cosmrs::AccountId>,
-    ) -> Self {
+    pub fn new(network: network_defaults::all::Network, nymd_url: Url, api_url: Url) -> Self {
        Config {
            network,
            nymd_url,
-            mixnet_contract_address,
-            vesting_contract_address,
-            erc20_bridge_contract_address,
+            mixnet_contract_address: DEFAULT_NETWORK
+                .mixnet_contract_address()
+                .parse()
+                .expect("Error parsing mixnet contract address"),
+            vesting_contract_address: DEFAULT_NETWORK
+                .vesting_contract_address()
+                .parse()
+                .expect("Error parsing vesting contract address"),
+            bandwidth_claim_contract_address: DEFAULT_NETWORK
+                .bandwidth_claim_contract_address()
+                .parse()
+                .expect("Error parsing bandwidth claim contract address"),
            api_url,
            mixnode_page_limit: None,
            gateway_page_limit: None,
@@ -73,6 +77,21 @@ impl Config {
        }
    }

+    pub fn with_mixnode_contract_address(mut self, address: cosmrs::AccountId) -> Self {
+        self.mixnet_contract_address = address;
+        self
+    }
+
+    pub fn with_vesting_contract_address(mut self, address: cosmrs::AccountId) -> Self {
+        self.vesting_contract_address = address;
+        self
+    }
+
+    pub fn with_bandwidth_claim_contract_address(mut self, address: cosmrs::AccountId) -> Self {
+        self.bandwidth_claim_contract_address = address;
+        self
+    }
+
    pub fn with_mixnode_page_limit(mut self, limit: Option<u32>) -> Config {
        self.mixnode_page_limit = limit;
        self
@@ -97,9 +116,9 @@ impl Config {
 #[cfg(feature = "nymd-client")]
 pub struct Client<C> {
    pub network: network_defaults::all::Network,
-    mixnet_contract_address: Option<cosmrs::AccountId>,
-    vesting_contract_address: Option<cosmrs::AccountId>,
-    erc20_bridge_contract_address: Option<cosmrs::AccountId>,
+    mixnet_contract_address: cosmrs::AccountId,
+    vesting_contract_address: cosmrs::AccountId,
+    bandwidth_claim_contract_address: cosmrs::AccountId,
    mnemonic: Option<bip39::Mnemonic>,

    mixnode_page_limit: Option<u32>,
@@ -122,18 +141,18 @@ impl Client<SigningNymdClient> {
        let nymd_client = NymdClient::connect_with_mnemonic(
            config.network,
            config.nymd_url.as_str(),
-            config.mixnet_contract_address.clone(),
-            config.vesting_contract_address.clone(),
-            config.erc20_bridge_contract_address.clone(),
            mnemonic.clone(),
            None,
-        )?;
+        )?
+        .with_mixnet_contract_address(config.mixnet_contract_address.clone())
+        .with_vesting_contract_address(config.vesting_contract_address.clone())
+        .with_bandwidth_claim_contract_address(config.bandwidth_claim_contract_address.clone());

        Ok(Client {
            network: config.network,
            mixnet_contract_address: config.mixnet_contract_address,
            vesting_contract_address: config.vesting_contract_address,
-            erc20_bridge_contract_address: config.erc20_bridge_contract_address,
+            bandwidth_claim_contract_address: config.bandwidth_claim_contract_address,
            mnemonic: Some(mnemonic),
            mixnode_page_limit: config.mixnode_page_limit,
            gateway_page_limit: config.gateway_page_limit,
@@ -148,12 +167,12 @@ impl Client<SigningNymdClient> {
        self.nymd = NymdClient::connect_with_mnemonic(
            self.network,
            new_endpoint.as_ref(),
-            self.mixnet_contract_address.clone(),
-            self.vesting_contract_address.clone(),
-            self.erc20_bridge_contract_address.clone(),
            self.mnemonic.clone().unwrap(),
            None,
-        )?;
+        )?
+        .with_mixnet_contract_address(self.mixnet_contract_address.clone())
+        .with_vesting_contract_address(self.vesting_contract_address.clone())
+        .with_bandwidth_claim_contract_address(self.bandwidth_claim_contract_address.clone());
        Ok(())
    }

@@ -166,32 +185,15 @@ impl Client<SigningNymdClient> {
 impl Client<QueryNymdClient> {
    pub fn new_query(config: Config) -> Result<Client<QueryNymdClient>, ValidatorClientError> {
        let validator_api_client = validator_api::Client::new(config.api_url.clone());
-        let nymd_client = NymdClient::connect(
-            config.nymd_url.as_str(),
-            Some(config.mixnet_contract_address.clone().unwrap_or_else(|| {
-                cosmrs::AccountId::from_str(DEFAULT_NETWORK.mixnet_contract_address()).unwrap()
-            })),
-            Some(config.vesting_contract_address.clone().unwrap_or_else(|| {
-                cosmrs::AccountId::from_str(DEFAULT_NETWORK.vesting_contract_address()).unwrap()
-            })),
-            Some(
-                config
-                    .erc20_bridge_contract_address
-                    .clone()
-                    .unwrap_or_else(|| {
-                        cosmrs::AccountId::from_str(
-                            DEFAULT_NETWORK.bandwidth_claim_contract_address(),
-                        )
-                        .unwrap()
-                    }),
-            ),
-        )?;
+        let nymd_client = NymdClient::connect(config.nymd_url.as_str())?
+            .with_mixnet_contract_address(config.mixnet_contract_address.clone())
+            .with_vesting_contract_address(config.vesting_contract_address.clone());

        Ok(Client {
            network: config.network,
            mixnet_contract_address: config.mixnet_contract_address,
            vesting_contract_address: config.vesting_contract_address,
-            erc20_bridge_contract_address: config.erc20_bridge_contract_address,
+            bandwidth_claim_contract_address: config.bandwidth_claim_contract_address,
            mnemonic: None,
            mixnode_page_limit: config.mixnode_page_limit,
            gateway_page_limit: config.gateway_page_limit,
@@ -203,12 +205,10 @@ impl Client<QueryNymdClient> {
    }

    pub fn change_nymd(&mut self, new_endpoint: Url) -> Result<(), ValidatorClientError> {
-        self.nymd = NymdClient::connect(
-            new_endpoint.as_ref(),
-            self.mixnet_contract_address.clone(),
-            self.vesting_contract_address.clone(),
-            self.erc20_bridge_contract_address.clone(),
-        )?;
+        self.nymd = NymdClient::connect(new_endpoint.as_ref())?
+            .with_mixnet_contract_address(self.mixnet_contract_address.clone())
+            .with_vesting_contract_address(self.vesting_contract_address.clone())
+            .with_bandwidth_claim_contract_address(self.bandwidth_claim_contract_address.clone());
        Ok(())
    }
 }
@@ -222,10 +222,10 @@ impl<C> Client<C> {
    // use case: somebody initialised client without a contract in order to upload and initialise one
    // and now they want to actually use it without making new client
    pub fn set_mixnet_contract_address(&mut self, mixnet_contract_address: cosmrs::AccountId) {
-        self.mixnet_contract_address = Some(mixnet_contract_address)
+        self.mixnet_contract_address = mixnet_contract_address
    }

-    pub fn get_mixnet_contract_address(&self) -> Option<cosmrs::AccountId> {
+    pub fn get_mixnet_contract_address(&self) -> cosmrs::AccountId {
        self.mixnet_contract_address.clone()
    }

@@ -233,18 +233,36 @@ impl<C> Client<C> {
        Ok(self.validator_api.get_mixnodes().await?)
    }

+    pub async fn get_cached_mixnodes_detailed(
+        &self,
+    ) -> Result<Vec<MixNodeBondAnnotated>, ValidatorClientError> {
+        Ok(self.validator_api.get_mixnodes_detailed().await?)
+    }
+
    pub async fn get_cached_rewarded_mixnodes(
        &self,
    ) -> Result<Vec<MixNodeBond>, ValidatorClientError> {
        Ok(self.validator_api.get_rewarded_mixnodes().await?)
    }

+    pub async fn get_cached_rewarded_mixnodes_detailed(
+        &self,
+    ) -> Result<Vec<MixNodeBondAnnotated>, ValidatorClientError> {
+        Ok(self.validator_api.get_rewarded_mixnodes_detailed().await?)
+    }
+
    pub async fn get_cached_active_mixnodes(
        &self,
    ) -> Result<Vec<MixNodeBond>, ValidatorClientError> {
        Ok(self.validator_api.get_active_mixnodes().await?)
    }

+    pub async fn get_cached_active_mixnodes_detailed(
+        &self,
+    ) -> Result<Vec<MixNodeBondAnnotated>, ValidatorClientError> {
+        Ok(self.validator_api.get_active_mixnodes_detailed().await?)
+    }
+
    pub async fn get_cached_gateways(&self) -> Result<Vec<GatewayBond>, ValidatorClientError> {
        Ok(self.validator_api.get_gateways().await?)
    }
@@ -715,4 +733,34 @@ impl ApiClient {
    ) -> Result<VerificationKeyResponse, ValidatorClientError> {
        Ok(self.validator_api.get_coconut_verification_key().await?)
    }
+
+    pub async fn verify_bandwidth_credential(
+        &self,
+        request_body: &VerifyCredentialBody,
+    ) -> Result<VerifyCredentialResponse, ValidatorClientError> {
+        Ok(self
+            .validator_api
+            .verify_bandwidth_credential(request_body)
+            .await?)
+    }
+
+    pub async fn propose_release_funds(
+        &self,
+        request_body: &ProposeReleaseFundsRequestBody,
+    ) -> Result<ProposeReleaseFundsResponse, ValidatorClientError> {
+        Ok(self
+            .validator_api
+            .propose_release_funds(request_body)
+            .await?)
+    }
+
+    pub async fn execute_release_funds(
+        &self,
+        request_body: &ExecuteReleaseFundsRequestBody,
+    ) -> Result<(), ValidatorClientError> {
+        Ok(self
+            .validator_api
+            .execute_release_funds(request_body)
+            .await?)
+    }
 }
@@ -19,7 +19,7 @@ const CONNECTION_TEST_TIMEOUT_SEC: u64 = 2;
 pub async fn run_validator_connection_test<H: BuildHasher + 'static>(
    nymd_urls: impl Iterator<Item = (Network, Url)>,
    api_urls: impl Iterator<Item = (Network, Url)>,
-    mixnet_contract_address: HashMap<Network, Option<cosmrs::AccountId>, H>,
+    mixnet_contract_address: HashMap<Network, cosmrs::AccountId, H>,
 ) -> (
    HashMap<Network, Vec<(Url, bool)>>,
    HashMap<Network, Vec<(Url, bool)>>,
@@ -47,14 +47,15 @@ pub async fn run_validator_connection_test<H: BuildHasher + 'static>(
 fn setup_connection_tests<H: BuildHasher + 'static>(
    nymd_urls: impl Iterator<Item = (Network, Url)>,
    api_urls: impl Iterator<Item = (Network, Url)>,
-    mixnet_contract_address: HashMap<Network, Option<cosmrs::AccountId>, H>,
+    mixnet_contract_address: HashMap<Network, cosmrs::AccountId, H>,
 ) -> impl Iterator<Item = ClientForConnectionTest> {
    let nymd_connection_test_clients = nymd_urls.filter_map(move |(network, url)| {
        let address = mixnet_contract_address
            .get(&network)
            .expect("No configured contract address")
            .clone();
-        NymdClient::<QueryNymdClient>::connect(url.as_str(), address, None, None)
+        NymdClient::<QueryNymdClient>::connect(url.as_str())
+            .map(|client| client.with_mixnet_contract_address(address))
            .map(move |client| ClientForConnectionTest::Nymd(network, url, Box::new(client)))
            .ok()
    });
@@ -0,0 +1,130 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+use serde::{Deserialize, Serialize};
+use std::fmt;
+
+pub use cosmrs::Coin as CosmosCoin;
+pub use cosmwasm_std::Coin as CosmWasmCoin;
+
+#[derive(Serialize, Deserialize, Clone, Copy, Default, Debug, PartialEq)]
+pub struct MismatchedDenoms;
+
+// the reason the coin is created here as opposed to different place in the codebase is that
+// eventually we want to either publish the cosmwasm client separately or commit it to
+// some other project, like cosmrs. Either way, in that case we can't really have
+// a dependency on an internal type
+#[derive(Serialize, Deserialize, Clone, Default, Debug, PartialEq)]
+pub struct Coin {
+    pub amount: u128,
+    pub denom: String,
+}
+
+impl Coin {
+    pub fn new<S: Into<String>>(amount: u128, denom: S) -> Self {
+        Coin {
+            amount,
+            denom: denom.into(),
+        }
+    }
+
+    pub fn try_add(&self, other: &Self) -> Result<Self, MismatchedDenoms> {
+        if self.denom != other.denom {
+            Err(MismatchedDenoms)
+        } else {
+            Ok(Coin {
+                amount: self.amount + other.amount,
+                denom: self.denom.clone(),
+            })
+        }
+    }
+}
+
+impl fmt::Display for Coin {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}{}", self.amount, self.denom)
+    }
+}
+
+impl From<Coin> for CosmosCoin {
+    fn from(coin: Coin) -> Self {
+        assert!(
+            coin.amount <= u64::MAX as u128,
+            "the coin amount is higher than the maximum supported by cosmrs"
+        );
+
+        CosmosCoin {
+            denom: coin
+                .denom
+                .parse()
+                .expect("the coin should have had a valid denom!"),
+            amount: (coin.amount as u64).into(),
+        }
+    }
+}
+
+impl From<CosmosCoin> for Coin {
+    fn from(coin: CosmosCoin) -> Self {
+        Coin {
+            amount: coin
+                .amount
+                .to_string()
+                .parse()
+                .expect("somehow failed to parse string representation of u64"),
+            denom: coin.denom.to_string(),
+        }
+    }
+}
+
+impl From<Coin> for CosmWasmCoin {
+    fn from(coin: Coin) -> Self {
+        CosmWasmCoin::new(coin.amount, coin.denom)
+    }
+}
+
+impl From<CosmWasmCoin> for Coin {
+    fn from(coin: CosmWasmCoin) -> Self {
+        Coin {
+            amount: coin.amount.u128(),
+            denom: coin.denom,
+        }
+    }
+}
+
+pub trait CoinConverter {
+    type Target;
+
+    fn convert_coin(&self) -> Self::Target;
+}
+
+impl CoinConverter for CosmosCoin {
+    type Target = CosmWasmCoin;
+
+    fn convert_coin(&self) -> Self::Target {
+        CosmWasmCoin::new(
+            self.amount
+                .to_string()
+                .parse()
+                .expect("cosmos coin had an invalid amount assigned"),
+            self.denom.to_string(),
+        )
+    }
+}
+
+impl CoinConverter for CosmWasmCoin {
+    type Target = CosmosCoin;
+
+    fn convert_coin(&self) -> Self::Target {
+        assert!(
+            self.amount.u128() <= u64::MAX as u128,
+            "the coin amount is higher than the maximum supported by cosmrs"
+        );
+
+        CosmosCoin {
+            denom: self
+                .denom
+                .parse()
+                .expect("cosmwasm coin had an invalid amount assigned"),
+            amount: (self.amount.u128() as u64).into(),
+        }
+    }
+}
@@ -1,6 +1,7 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

+use crate::nymd::coin::Coin;
 use crate::nymd::cosmwasm_client::helpers::{create_pagination, next_page_key};
 use crate::nymd::cosmwasm_client::types::{
    Account, Code, CodeDetails, Contract, ContractCodeHistoryEntry, ContractCodeId,
@@ -25,8 +26,7 @@ use cosmrs::rpc::{self, HttpClient, Order};
 use cosmrs::tendermint::abci::Code as AbciCode;
 use cosmrs::tendermint::abci::Transaction;
 use cosmrs::tendermint::{abci, block, chain};
-use cosmrs::{tx, AccountId, Coin, Denom, Tx};
-use cosmwasm_std::Coin as CosmWasmCoin;
+use cosmrs::{tx, AccountId, Coin as CosmosCoin, Tx};
 use prost::Message;
 use serde::{Deserialize, Serialize};
 use std::convert::{TryFrom, TryInto};
@@ -121,7 +121,7 @@ pub trait CosmWasmClient: rpc::Client {
    async fn get_balance(
        &self,
        address: &AccountId,
-        search_denom: Denom,
+        search_denom: String,
    ) -> Result<Option<Coin>, NymdError> {
        let path = Some("/cosmos.bank.v1beta1.Query/Balance".parse().unwrap());

@@ -135,7 +135,7 @@ pub trait CosmWasmClient: rpc::Client {
            .await?;

        res.balance
-            .map(TryFrom::try_from)
+            .map(|proto| CosmosCoin::try_from(proto).map(Into::into))
            .transpose()
            .map_err(|_| NymdError::SerializationError("Coin".to_owned()))
    }
@@ -166,16 +166,12 @@ pub trait CosmWasmClient: rpc::Client {

        raw_balances
            .into_iter()
-            .map(TryFrom::try_from)
+            .map(|proto| CosmosCoin::try_from(proto).map(Into::into))
            .collect::<Result<_, _>>()
            .map_err(|_| NymdError::SerializationError("Coins".to_owned()))
    }

-    // this is annoyingly and inconsistently returning `Vec<CosmWasmCoin>` rather than
-    // Vec<Coin>, since cosmrs::Coin can't deal with IBC denoms.
-    // Presumably after https://github.com/cosmos/cosmos-rust/issues/173 is resolved,
-    // the code could be adjusted
-    async fn get_total_supply(&self) -> Result<Vec<CosmWasmCoin>, NymdError> {
+    async fn get_total_supply(&self) -> Result<Vec<Coin>, NymdError> {
        let path = Some("/cosmos.bank.v1beta1.Query/TotalSupply".parse().unwrap());

        let mut supply = Vec::new();
@@ -198,12 +194,7 @@ pub trait CosmWasmClient: rpc::Client {

        supply
            .into_iter()
-            .map(|coin| {
-                coin.amount.parse().map(|amount| CosmWasmCoin {
-                    denom: coin.denom,
-                    amount,
-                })
-            })
+            .map(|proto| CosmosCoin::try_from(proto).map(Into::into))
            .collect::<Result<_, _>>()
            .map_err(|_| NymdError::SerializationError("Coins".to_owned()))
    }
@@ -483,6 +474,9 @@ pub trait CosmWasmClient: rpc::Client {
    // deprecation warning is due to the fact the protobuf files built were based on cosmos-sdk 0.44,
    // where they prefer using tx_bytes directly. However, in 0.42, which we are using at the time
    // of writing this, the option does not work
+    // TODO: we should really stop using the `tx` argument here and use `tx_bytes` exlusively,
+    // however, at the time of writing this update, while our QA and mainnet networks do support it,
+    // sandbox is still running old version of wasmd that lacks support for `tx_bytes`
    #[allow(deprecated)]
    async fn query_simulate(
        &self,
@@ -68,6 +68,7 @@ pub(crate) fn create_pagination(key: Vec<u8>) -> PageRequest {
        offset: 0,
        limit: 0,
        count_total: false,
+        reverse: false,
    }
 }

@@ -4,11 +4,11 @@
 use crate::nymd::error::NymdError;
 use cosmrs::tendermint::abci;
 use itertools::Itertools;
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};

 // it seems that currently validators just emit stringified events (which are also returned as part of deliverTx response)
 // as theirs logs
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Serialize, Deserialize)]
 pub struct Log {
    #[serde(default)]
    // weird thing is that the first msg_index seems to always be undefined on the raw logs
@@ -22,7 +22,7 @@ pub struct Log {

 /// Searches in logs for the first event of the given event type and in that event
 /// for the first attribute with the given attribute key.
-pub(crate) fn find_attribute<'a>(
+pub fn find_attribute<'a>(
    logs: &'a [Log],
    event_type: &str,
    attribute_key: &str,
@@ -1,23 +1,6 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use std::convert::TryInto;
-use std::time::Duration;
-
-use async_trait::async_trait;
-use cosmrs::bank::MsgSend;
-use cosmrs::distribution::MsgWithdrawDelegatorReward;
-use cosmrs::proto::cosmos::tx::signing::v1beta1::SignMode;
-use cosmrs::rpc::endpoint::broadcast;
-use cosmrs::rpc::{Error as TendermintRpcError, HttpClient, HttpClientUrl, SimpleRequest};
-use cosmrs::staking::{MsgDelegate, MsgUndelegate};
-use cosmrs::tx::{self, Msg, SignDoc, SignerInfo};
-use cosmrs::{cosmwasm, rpc, AccountId, Any, Coin, Tx};
-use log::debug;
-use serde::Serialize;
-use sha2::Digest;
-use sha2::Sha256;
-
 use crate::nymd::cosmwasm_client::client::CosmWasmClient;
 use crate::nymd::cosmwasm_client::helpers::{compress_wasm_code, CheckResponse};
 use crate::nymd::cosmwasm_client::logs::{self, parse_raw_logs};
@@ -25,20 +8,49 @@ use crate::nymd::cosmwasm_client::types::*;
 use crate::nymd::error::NymdError;
 use crate::nymd::fee::{Fee, DEFAULT_SIMULATED_GAS_MULTIPLIER};
 use crate::nymd::wallet::DirectSecp256k1HdWallet;
-use crate::nymd::{CosmosCoin, GasPrice, TxResponse};
-
-// we need to have **a** valid secp256k1 signature for simulation purposes.
-// it doesn't matter what it is as long as it parses correctly
-const DUMMY_SECP256K1_SIGNATURE: &[u8] = &[
-    54, 167, 169, 61, 100, 173, 231, 87, 1, 113, 179, 49, 102, 141, 67, 22, 170, 153, 52, 88, 178,
-    159, 200, 11, 37, 138, 76, 221, 187, 70, 104, 123, 98, 216, 190, 249, 149, 81, 1, 158, 0, 220,
-    32, 147, 101, 60, 64, 77, 44, 83, 221, 119, 170, 124, 109, 177, 73, 116, 46, 57, 102, 181, 98,
-    91,
-];
+use crate::nymd::{Coin, GasPrice, TxResponse};
+use async_trait::async_trait;
+use cosmrs::bank::MsgSend;
+use cosmrs::distribution::MsgWithdrawDelegatorReward;
+use cosmrs::proto::cosmos::tx::signing::v1beta1::SignMode;
+use cosmrs::rpc::endpoint::broadcast;
+use cosmrs::rpc::{Error as TendermintRpcError, HttpClient, HttpClientUrl, SimpleRequest};
+use cosmrs::staking::{MsgDelegate, MsgUndelegate};
+use cosmrs::tx::{self, Msg, SignDoc, SignerInfo};
+use cosmrs::{cosmwasm, rpc, AccountId, Any, Tx};
+use log::debug;
+use serde::Serialize;
+use sha2::Digest;
+use sha2::Sha256;
+use std::convert::TryInto;
+use std::time::Duration;

 const DEFAULT_BROADCAST_POLLING_RATE: Duration = Duration::from_secs(4);
 const DEFAULT_BROADCAST_TIMEOUT: Duration = Duration::from_secs(60);

+fn empty_fee() -> tx::Fee {
+    tx::Fee {
+        amount: vec![],
+        gas_limit: Default::default(),
+        payer: None,
+        granter: None,
+    }
+}
+
+fn single_unspecified_signer_auth(
+    public_key: Option<tx::SignerPublicKey>,
+    sequence_number: tx::SequenceNumber,
+) -> tx::AuthInfo {
+    tx::SignerInfo {
+        public_key,
+        mode_info: tx::ModeInfo::Single(tx::mode_info::Single {
+            mode: SignMode::Unspecified,
+        }),
+        sequence: sequence_number,
+    }
+    .auth_info(empty_fee())
+}
+
 #[async_trait]
 pub trait SigningCosmWasmClient: CosmWasmClient {
    fn signer(&self) -> &DirectSecp256k1HdWallet;
@@ -64,33 +76,21 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
        let sequence_response = self.get_sequence(signer_address).await?;

        let partial_tx = Tx {
-            body: tx::Body {
-                messages,
-                memo: memo.into(),
-                timeout_height: 0u32.into(),
-                extension_options: vec![],
-                non_critical_extension_options: vec![],
-            },
-            auth_info: tx::AuthInfo {
-                signer_infos: vec![tx::SignerInfo {
-                    public_key,
-                    mode_info: tx::ModeInfo::Single(tx::mode_info::Single {
-                        mode: SignMode::Unspecified,
-                    }),
-                    sequence: sequence_response.sequence,
-                }],
-                fee: tx::Fee::from_amount_and_gas(
-                    CosmosCoin {
-                        denom: "".parse().unwrap(),
-                        amount: 0u64.into(),
-                    },
-                    0,
-                ),
-            },
-            signatures: vec![DUMMY_SECP256K1_SIGNATURE.try_into().unwrap()],
+            body: tx::Body::new(messages, memo, 0u32),
+            auth_info: single_unspecified_signer_auth(public_key, sequence_response.sequence),
+            signatures: vec![Vec::new()],
        };
-
        self.query_simulate(Some(partial_tx), Vec::new()).await
+
+        // for completion sake, once we're able to transition into using `tx_bytes`,
+        // we might want to use something like this instead:
+        // let tx_raw: tx::Raw = cosmrs::proto::cosmos::tx::v1beta1::TxRaw {
+        //     body_bytes: partial_tx.body.into_bytes().unwrap(),
+        //     auth_info_bytes: partial_tx.auth_info.into_bytes().unwrap(),
+        //     signatures: partial_tx.signatures,
+        // }
+        // .into();
+        // self.query_simulate(None, tx_raw.to_bytes().unwrap()).await
    }

    async fn upload(
@@ -310,7 +310,7 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
            sender: sender_address.clone(),
            contract: contract_address.clone(),
            msg: serde_json::to_vec(msg)?,
-            funds,
+            funds: funds.into_iter().map(Into::into).collect(),
        }
        .to_any()
        .map_err(|_| NymdError::SerializationError("MsgExecuteContract".to_owned()))?;
@@ -324,6 +324,7 @@ pub trait SigningCosmWasmClient: CosmWasmClient {

        Ok(ExecuteResult {
            logs: parse_raw_logs(tx_res.tx_result.log)?,
+            data: tx_res.tx_result.data,
            transaction_hash: tx_res.hash,
            gas_info,
        })
@@ -348,7 +349,7 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
                    sender: sender_address.clone(),
                    contract: contract_address.clone(),
                    msg: serde_json::to_vec(&msg)?,
-                    funds,
+                    funds: funds.into_iter().map(Into::into).collect(),
                }
                .to_any()
                .map_err(|_| NymdError::SerializationError("MsgExecuteContract".to_owned()))
@@ -364,6 +365,7 @@ pub trait SigningCosmWasmClient: CosmWasmClient {

        Ok(ExecuteResult {
            logs: parse_raw_logs(tx_res.tx_result.log)?,
+            data: tx_res.tx_result.data,
            transaction_hash: tx_res.hash,
            gas_info,
        })
@@ -380,7 +382,7 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
        let send_msg = MsgSend {
            from_address: sender_address.clone(),
            to_address: recipient_address.clone(),
-            amount,
+            amount: amount.into_iter().map(Into::into).collect(),
        }
        .to_any()
        .map_err(|_| NymdError::SerializationError("MsgSend".to_owned()))?;
@@ -406,7 +408,7 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
                MsgSend {
                    from_address: sender_address.clone(),
                    to_address,
-                    amount,
+                    amount: amount.into_iter().map(Into::into).collect(),
                }
                .to_any()
                .map_err(|_| NymdError::SerializationError("MsgExecuteContract".to_owned()))
@@ -429,7 +431,7 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
        let delegate_msg = MsgDelegate {
            delegator_address: delegator_address.to_owned(),
            validator_address: validator_address.to_owned(),
-            amount,
+            amount: amount.into(),
        }
        .to_any()
        .map_err(|_| NymdError::SerializationError("MsgDelegate".to_owned()))?;
@@ -450,7 +452,7 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
        let undelegate_msg = MsgUndelegate {
            delegator_address: delegator_address.to_owned(),
            validator_address: validator_address.to_owned(),
-            amount: Some(amount),
+            amount: amount.into(),
        }
        .to_any()
        .map_err(|_| NymdError::SerializationError("MsgUndelegate".to_owned()))?;
@@ -25,9 +25,10 @@ use cosmrs::proto::cosmwasm::wasm::v1::{
    CodeInfoResponse, ContractCodeHistoryEntry as ProtoContractCodeHistoryEntry,
    ContractCodeHistoryOperationType, ContractInfo as ProtoContractInfo,
 };
+use cosmrs::tendermint::abci::Data;
 use cosmrs::tendermint::{abci, chain};
 use cosmrs::tx::{AccountNumber, Gas, SequenceNumber};
-use cosmrs::{tx, AccountId, Any, Coin};
+use cosmrs::{tx, AccountId, Any, Coin as CosmosCoin};
 use prost::Message;
 use serde::Serialize;
 use std::convert::{TryFrom, TryInto};
@@ -106,9 +107,9 @@ impl TryFrom<ProtoModuleAccount> for ModuleAccount {
 #[derive(Debug)]
 pub struct BaseVestingAccount {
    pub base_account: Option<BaseAccount>,
-    pub original_vesting: Vec<Coin>,
-    pub delegated_free: Vec<Coin>,
-    pub delegated_vesting: Vec<Coin>,
+    pub original_vesting: Vec<CosmosCoin>,
+    pub delegated_free: Vec<CosmosCoin>,
+    pub delegated_vesting: Vec<CosmosCoin>,
    pub end_time: i64,
 }

@@ -183,7 +184,7 @@ impl TryFrom<ProtoDelayedVestingAccount> for DelayedVestingAccount {
 #[derive(Debug)]
 pub struct Period {
    pub length: i64,
-    pub amount: Vec<Coin>,
+    pub amount: Vec<CosmosCoin>,
 }

 impl TryFrom<ProtoPeriod> for Period {
@@ -488,7 +489,7 @@ impl TryFrom<ProtoContractCodeHistoryEntry> for ContractCodeHistoryEntry {
    }
 }

-#[derive(Debug)]
+#[derive(Copy, Clone, Debug, Default, Eq, PartialEq)]
 pub struct GasInfo {
    /// GasWanted is the maximum units of work we allow this tx to perform.
    pub gas_wanted: Gas,
@@ -627,7 +628,7 @@ pub struct InstantiateOptions {
    /// created and before the instantiation message is executed by the contract.
    ///
    /// Only native tokens are supported.
-    pub funds: Vec<Coin>,
+    pub funds: Vec<CosmosCoin>,

    /// A bech32 encoded address of an admin account.
    /// Caution: an admin has the privilege to upgrade a contract.
@@ -635,6 +636,15 @@ pub struct InstantiateOptions {
    pub admin: Option<AccountId>,
 }

+impl InstantiateOptions {
+    pub fn new<T: Into<CosmosCoin>>(funds: Vec<T>, admin: Option<AccountId>) -> Self {
+        InstantiateOptions {
+            funds: funds.into_iter().map(Into::into).collect(),
+            admin,
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct InstantiateResult {
    /// The address of the newly instantiated contract
@@ -672,6 +682,8 @@ pub struct MigrateResult {
 pub struct ExecuteResult {
    pub logs: Vec<Log>,

+    pub data: Data,
+
    /// Transaction hash (might be used as transaction ID)
    pub transaction_hash: tx::Hash,

@@ -21,9 +21,12 @@ pub enum NymdError {
    #[error("There was an issue with bip32 - {0}")]
    Bip32Error(#[from] bip32::Error),

-    #[error("There was an issue with bip32 - {0}")]
+    #[error("There was an issue with bip39 - {0}")]
    Bip39Error(#[from] bip39::Error),

+    #[error("There was an issue on the cosmrs side - {0}")]
+    CosmrsError(#[from] cosmrs::Error),
+
    #[error("Failed to derive account address")]
    AccountDerivationError,

@@ -39,10 +42,10 @@ pub enum NymdError {
    #[error("There was an issue with a tendermint RPC request - {0}")]
    TendermintError(#[from] TendermintRpcError),

-    #[error("There was an issue when attempting to serialize data")]
+    #[error("There was an issue when attempting to serialize data ({0})")]
    SerializationError(String),

-    #[error("There was an issue when attempting to deserialize data")]
+    #[error("There was an issue when attempting to deserialize data ({0})")]
    DeserializationError(String),

    #[error("There was an issue when attempting to encode our protobuf data - {0}")]
@@ -121,6 +124,12 @@ pub enum NymdError {

    #[error("Transaction with ID {hash} has been submitted but not yet found on the chain. You might want to check for it later. There was a total wait of {} seconds", .timeout.as_secs())]
    BroadcastTimeout { hash: tx::Hash, timeout: Duration },
+
+    #[error("Cosmwasm std error: {0}")]
+    CosmwasmStdError(#[from] cosmwasm_std::StdError),
+
+    #[error("Coconut interface error: {0}")]
+    CoconutInterfaceError(#[from] coconut_interface::error::CoconutInterfaceError),
 }

 impl NymdError {
@@ -4,7 +4,7 @@
 use crate::nymd::error::NymdError;
 use config::defaults;
 use cosmrs::tx::Gas;
-use cosmrs::{Coin, Denom};
+use cosmrs::Coin;
 use cosmwasm_std::{Decimal, Fraction, Uint128};
 use std::ops::Mul;
 use std::str::FromStr;
@@ -13,11 +13,12 @@ use std::str::FromStr;
 /// the smallest fee token unit, such as 0.012utoken.
 #[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
 pub struct GasPrice {
-    // I really hate the combination of cosmwasm Decimal with cosmos-sdk Denom,
-    // but cosmos-sdk's Decimal is too basic for our needs
+    // I really dislike the usage of cosmwasm Decimal, but I didn't feel like implementing
+    // our own maths subcrate just for the purposes of calculating gas requirements
+    // this should definitely be rectified later on
    pub amount: Decimal,

-    pub denom: Denom,
+    pub denom: String,
 }

 impl<'a> Mul<Gas> for &'a GasPrice {
@@ -44,7 +45,10 @@ impl<'a> Mul<Gas> for &'a GasPrice {

        assert!(amount.u128() <= u64::MAX as u128);
        Coin {
-            denom: self.denom.clone(),
+            denom: self
+                .denom
+                .parse()
+                .expect("the gas price has been created with invalid denom"),
            amount: (amount.u128() as u64).into(),
        }
    }
@@ -63,9 +67,7 @@ impl FromStr for GasPrice {
            .parse()
            .map_err(|_| NymdError::MalformedGasPrice)?;
        let possible_denom = s.chars().skip(amount_len).collect::<String>();
-        let denom = possible_denom
-            .parse()
-            .map_err(|_| NymdError::MalformedGasPrice)?;
+        let denom = possible_denom.trim().to_string();

        Ok(GasPrice { amount, denom })
    }
@@ -106,8 +108,14 @@ mod tests {
        );

        assert!(".25upunk".parse::<GasPrice>().is_err());
-        assert!("0.025 upunk".parse::<GasPrice>().is_err());
-        assert!("0.025UPUNK".parse::<GasPrice>().is_err());
+
+        assert_eq!(
+            "0.025upunk".parse::<GasPrice>().unwrap(),
+            "0.025 upunk".parse().unwrap()
+        );
+
+        let gas: GasPrice = "0.025   upunk    ".parse().unwrap();
+        assert_eq!("upunk", gas.denom);
    }

    #[test]
@@ -1,195 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::nymd::GasPrice;
-use cosmrs::tx::{Fee, Gas};
-use cosmrs::Coin;
-use serde::{Deserialize, Serialize};
-use std::fmt;
-
-#[cfg_attr(test, derive(ts_rs::TS))]
-#[cfg_attr(
-    test,
-    ts(export, export_to = "../../../nym-wallet/src/types/rust/operation.ts")
-)]
-#[derive(Debug, Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, Serialize, Deserialize)]
-pub enum Operation {
-    Upload,
-    Init,
-    Migrate,
-    ChangeAdmin,
-    Send,
-
-    BondMixnode,
-    BondMixnodeOnBehalf,
-    UnbondMixnode,
-    UnbondMixnodeOnBehalf,
-    UpdateMixnodeConfig,
-    DelegateToMixnode,
-    DelegateToMixnodeOnBehalf,
-    UndelegateFromMixnode,
-    UndelegateFromMixnodeOnBehalf,
-
-    BondGateway,
-    BondGatewayOnBehalf,
-    UnbondGateway,
-    UnbondGatewayOnBehalf,
-
-    UpdateContractSettings,
-
-    BeginMixnodeRewarding,
-    FinishMixnodeRewarding,
-
-    TrackUnbondGateway,
-    TrackUnbondMixnode,
-    WithdrawVestedCoins,
-    TrackUndelegation,
-    CreatePeriodicVestingAccount,
-
-    AdvanceCurrentInterval,
-    AdvanceCurrentEpoch,
-    WriteRewardedSet,
-    ClearRewardedSet,
-    UpdateMixnetAddress,
-    CheckpointMixnodes,
-    ReconcileDelegations,
-}
-
-pub(crate) fn calculate_fee(gas_price: &GasPrice, gas_limit: Gas) -> Coin {
-    gas_price * gas_limit
-}
-
-impl fmt::Display for Operation {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match *self {
-            Operation::Upload => f.write_str("Upload"),
-            Operation::Init => f.write_str("Init"),
-            Operation::Migrate => f.write_str("Migrate"),
-            Operation::ChangeAdmin => f.write_str("ChangeAdmin"),
-            Operation::Send => f.write_str("Send"),
-            Operation::BondMixnode => f.write_str("BondMixnode"),
-            Operation::BondMixnodeOnBehalf => f.write_str("BondMixnodeOnBehalf"),
-            Operation::UnbondMixnode => f.write_str("UnbondMixnode"),
-            Operation::UpdateMixnodeConfig => f.write_str("UpdateMixnodeConfig"),
-            Operation::UnbondMixnodeOnBehalf => f.write_str("UnbondMixnodeOnBehalf"),
-            Operation::BondGateway => f.write_str("BondGateway"),
-            Operation::BondGatewayOnBehalf => f.write_str("BondGatewayOnBehalf"),
-            Operation::UnbondGateway => f.write_str("UnbondGateway"),
-            Operation::UnbondGatewayOnBehalf => f.write_str("UnbondGatewayOnBehalf"),
-            Operation::DelegateToMixnode => f.write_str("DelegateToMixnode"),
-            Operation::DelegateToMixnodeOnBehalf => f.write_str("DelegateToMixnodeOnBehalf"),
-            Operation::UndelegateFromMixnode => f.write_str("UndelegateFromMixnode"),
-            Operation::UndelegateFromMixnodeOnBehalf => {
-                f.write_str("UndelegateFromMixnodeOnBehalf")
-            }
-            Operation::UpdateContractSettings => f.write_str("UpdateContractSettings"),
-            Operation::BeginMixnodeRewarding => f.write_str("BeginMixnodeRewarding"),
-            Operation::FinishMixnodeRewarding => f.write_str("FinishMixnodeRewarding"),
-            Operation::TrackUnbondGateway => f.write_str("TrackUnbondGateway"),
-            Operation::TrackUnbondMixnode => f.write_str("TrackUnbondMixnode"),
-            Operation::WithdrawVestedCoins => f.write_str("WithdrawVestedCoins"),
-            Operation::TrackUndelegation => f.write_str("TrackUndelegation"),
-            Operation::CreatePeriodicVestingAccount => f.write_str("CreatePeriodicVestingAccount"),
-            Operation::AdvanceCurrentInterval => f.write_str("AdvanceCurrentInterval"),
-            Operation::WriteRewardedSet => f.write_str("WriteRewardedSet"),
-            Operation::ClearRewardedSet => f.write_str("ClearRewardedSet"),
-            Operation::UpdateMixnetAddress => f.write_str("UpdateMixnetAddress"),
-            Operation::CheckpointMixnodes => f.write_str("CheckpointMixnodes"),
-            Operation::ReconcileDelegations => f.write_str("ReconcileDelegations"),
-            Operation::AdvanceCurrentEpoch => f.write_str("AdvanceCurrentEpoch"),
-        }
-    }
-}
-
-impl Operation {
-    // TODO: some value tweaking
-    pub fn default_gas_limit(&self) -> Gas {
-        match self {
-            Operation::Upload => 3_000_000u64.into(),
-            Operation::Init => 500_000u64.into(),
-            Operation::Migrate => 200_000u64.into(),
-            Operation::ChangeAdmin => 80_000u64.into(),
-            Operation::Send => 80_000u64.into(),
-
-            Operation::BondMixnode => 175_000u64.into(),
-            Operation::BondMixnodeOnBehalf => 200_000u64.into(),
-            Operation::UnbondMixnode => 175_000u64.into(),
-            Operation::UnbondMixnodeOnBehalf => 175_000u64.into(),
-            Operation::UpdateMixnodeConfig => 175_000u64.into(),
-            Operation::DelegateToMixnode => 175_000u64.into(),
-            Operation::DelegateToMixnodeOnBehalf => 175_000u64.into(),
-            Operation::UndelegateFromMixnode => 175_000u64.into(),
-            Operation::UndelegateFromMixnodeOnBehalf => 175_000u64.into(),
-
-            Operation::BondGateway => 175_000u64.into(),
-            Operation::BondGatewayOnBehalf => 200_000u64.into(),
-            Operation::UnbondGateway => 175_000u64.into(),
-            Operation::UnbondGatewayOnBehalf => 200_000u64.into(),
-
-            Operation::UpdateContractSettings => 175_000u64.into(),
-            Operation::BeginMixnodeRewarding => 175_000u64.into(),
-            Operation::FinishMixnodeRewarding => 175_000u64.into(),
-            Operation::TrackUnbondGateway => 175_000u64.into(),
-            Operation::TrackUnbondMixnode => 175_000u64.into(),
-            Operation::WithdrawVestedCoins => 175_000u64.into(),
-            Operation::TrackUndelegation => 175_000u64.into(),
-            Operation::CreatePeriodicVestingAccount => 175_000u64.into(),
-            Operation::AdvanceCurrentInterval => 175_000u64.into(),
-            Operation::WriteRewardedSet => 175_000u64.into(),
-            Operation::ClearRewardedSet => 175_000u64.into(),
-            Operation::UpdateMixnetAddress => 80_000u64.into(),
-            Operation::CheckpointMixnodes => 175_000u64.into(),
-            Operation::ReconcileDelegations => 500_000u64.into(),
-            Operation::AdvanceCurrentEpoch => 175_000u64.into(),
-        }
-    }
-
-    pub(crate) fn determine_custom_fee(gas_price: &GasPrice, gas_limit: Gas) -> Fee {
-        // we need to know 2 of the following 3 parameters (the third one is being implicit) in order to construct Fee:
-        // (source: https://docs.cosmos.network/v0.42/basics/gas-fees.html)
-        // - gas price
-        // - gas limit
-        // - fees
-        let fee = calculate_fee(gas_price, gas_limit);
-        Fee::from_amount_and_gas(fee, gas_limit)
-    }
-
-    pub fn default_fee(&self, gas_price: &GasPrice) -> Fee {
-        Self::determine_custom_fee(gas_price, self.default_gas_limit())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn calculating_fee() {
-        let expected = Coin {
-            denom: "upunk".parse().unwrap(),
-            amount: 1000u64.into(),
-        };
-        let gas_price = "1upunk".parse().unwrap();
-        let gas_limit = 1000u64.into();
-
-        assert_eq!(expected, calculate_fee(&gas_price, gas_limit));
-
-        let expected = Coin {
-            denom: "upunk".parse().unwrap(),
-            amount: 50u64.into(),
-        };
-        let gas_price = "0.05upunk".parse().unwrap();
-        let gas_limit = 1000u64.into();
-
-        assert_eq!(expected, calculate_fee(&gas_price, gas_limit));
-
-        let expected = Coin {
-            denom: "upunk".parse().unwrap(),
-            amount: 100000u64.into(),
-        };
-        let gas_price = "100upunk".parse().unwrap();
-        let gas_limit = 1000u64.into();
-
-        assert_eq!(expected, calculate_fee(&gas_price, gas_limit))
-    }
-}
@@ -1,19 +1,55 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

+use crate::nymd::Coin;
 use cosmrs::tx;
+use serde::{Deserialize, Serialize};
+use std::fmt::{Display, Formatter};

 pub mod gas_price;
-pub mod helpers;

 pub const DEFAULT_SIMULATED_GAS_MULTIPLIER: f32 = 1.3;

-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub enum Fee {
-    Manual(tx::Fee),
+    Manual(#[serde(with = "sealed::TxFee")] tx::Fee),
    Auto(Option<f32>),
 }

+impl Display for Fee {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Fee::Manual(fee) => {
+                write!(f, "Fee in manual mode with ")?;
+                for fee in &fee.amount {
+                    write!(f, "{}{} paid in fees, ", fee.amount, fee.denom)?;
+                }
+                write!(f, "{} set as gas limit, ", fee.gas_limit)?;
+                if let Some(payer) = &fee.payer {
+                    write!(f, "{payer} set as payer, ")?;
+                }
+                if let Some(granter) = &fee.granter {
+                    write!(f, "{granter} set as granter")?;
+                }
+                Ok(())
+            }
+            Fee::Auto(Some(multiplier)) => {
+                write!(f, "Fee in auto mode with {multiplier} simulated multiplier")
+            }
+            Fee::Auto(None) => write!(f, "Fee in auto mode with no custom simulated multiplier"),
+        }
+    }
+}
+
+impl Fee {
+    pub fn try_get_manual_amount(&self) -> Option<Vec<Coin>> {
+        match self {
+            Fee::Manual(tx_fee) => Some(tx_fee.amount.iter().cloned().map(Into::into).collect()),
+            Fee::Auto(_) => None,
+        }
+    }
+}
+
 impl From<tx::Fee> for Fee {
    fn from(fee: tx::Fee) -> Self {
        Fee::Manual(fee)
@@ -31,3 +67,91 @@ impl Default for Fee {
        Fee::Auto(Some(DEFAULT_SIMULATED_GAS_MULTIPLIER))
    }
 }
+
+// a workaround to provide serde implementation for tx::Fee. We don't want to ever expose any of those
+// types to the public and ideally they will get replaced by proper implementation inside comrs
+mod sealed {
+    use cosmrs::tx::{self, Gas};
+    use cosmrs::Coin as CosmosCoin;
+    use cosmrs::{AccountId, Decimal as CosmosDecimal, Denom as CosmosDenom};
+    use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+    fn cosmos_denom_inner_getter(val: &CosmosDenom) -> String {
+        val.as_ref().to_string()
+    }
+
+    #[derive(Serialize, Deserialize)]
+    #[serde(remote = "CosmosDenom")]
+    struct Denom(#[serde(getter = "cosmos_denom_inner_getter")] String);
+
+    impl From<Denom> for CosmosDenom {
+        fn from(val: Denom) -> Self {
+            val.0.parse().unwrap()
+        }
+    }
+
+    fn cosmos_decimal_inner_getter(val: &CosmosDecimal) -> u64 {
+        // haha, this code is so disgusting. I'll make a PR on cosmrs to slightly alleviate those issues...
+        // note: unwrap here is fine as the to_string is just returning a stringified u64 which, well, is a valid u64
+        val.to_string().parse().unwrap()
+    }
+
+    // at the time of writing it the current cosmrs' Decimal is extremely limited...
+    #[derive(Serialize, Deserialize)]
+    #[serde(remote = "CosmosDecimal")]
+    struct Decimal(#[serde(getter = "cosmos_decimal_inner_getter")] u64);
+
+    impl From<Decimal> for CosmosDecimal {
+        fn from(val: Decimal) -> Self {
+            val.0.into()
+        }
+    }
+
+    #[derive(Serialize, Deserialize, Clone)]
+    struct Coin {
+        #[serde(with = "Denom")]
+        denom: CosmosDenom,
+        #[serde(with = "Decimal")]
+        amount: CosmosDecimal,
+    }
+
+    impl From<Coin> for CosmosCoin {
+        fn from(val: Coin) -> Self {
+            CosmosCoin {
+                denom: val.denom,
+                amount: val.amount,
+            }
+        }
+    }
+
+    impl From<CosmosCoin> for Coin {
+        fn from(val: CosmosCoin) -> Self {
+            Coin {
+                denom: val.denom,
+                amount: val.amount,
+            }
+        }
+    }
+
+    fn coin_vec_ser<S: Serializer>(val: &[CosmosCoin], serializer: S) -> Result<S::Ok, S::Error> {
+        let vec: Vec<Coin> = val.iter().cloned().map(Into::into).collect();
+        vec.serialize(serializer)
+    }
+    fn coin_vec_deser<'de, D: Deserializer<'de>>(
+        deserializer: D,
+    ) -> Result<Vec<CosmosCoin>, D::Error> {
+        let vec: Vec<Coin> = Deserialize::deserialize(deserializer)?;
+        Ok(vec.iter().cloned().map(Into::into).collect())
+    }
+
+    #[derive(Serialize, Deserialize)]
+    #[serde(remote = "tx::Fee")]
+    pub(super) struct TxFee {
+        #[serde(serialize_with = "coin_vec_ser")]
+        #[serde(deserialize_with = "coin_vec_deser")]
+        pub amount: Vec<CosmosCoin>,
+        pub gas_limit: Gas,
+        pub payer: Option<AccountId>,
+        pub granter: Option<AccountId>,
+    }
+}
@@ -0,0 +1,49 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+pub use crate::nymd::cosmwasm_client::signing_client::SigningCosmWasmClient;
+use crate::nymd::cosmwasm_client::types::ExecuteResult;
+use crate::nymd::error::NymdError;
+use crate::nymd::{Coin, Fee, NymdClient};
+use coconut_bandwidth_contract_common::{deposit::DepositData, msg::ExecuteMsg};
+
+use async_trait::async_trait;
+
+#[async_trait]
+pub trait CoconutBandwidthSigningClient {
+    async fn deposit(
+        &self,
+        amount: Coin,
+        info: String,
+        verification_key: String,
+        encryption_key: String,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError>;
+}
+
+#[async_trait]
+impl<C: SigningCosmWasmClient + Sync + Send> CoconutBandwidthSigningClient for NymdClient<C> {
+    async fn deposit(
+        &self,
+        amount: Coin,
+        info: String,
+        verification_key: String,
+        encryption_key: String,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier)));
+        let req = ExecuteMsg::DepositFunds {
+            data: DepositData::new(info.to_string(), verification_key, encryption_key),
+        };
+        self.client
+            .execute(
+                self.address(),
+                self.coconut_bandwidth_contract_address(),
+                &req,
+                fee,
+                "CoconutBandwidth::Deposit",
+                vec![amount],
+            )
+            .await
+    }
+}
@@ -1,8 +1,14 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

+mod coconut_bandwidth_signing_client;
+mod multisig_query_client;
+mod multisig_signing_client;
 mod vesting_query_client;
 mod vesting_signing_client;

+pub use coconut_bandwidth_signing_client::CoconutBandwidthSigningClient;
+pub use multisig_query_client::QueryClient;
+pub use multisig_signing_client::MultisigSigningClient;
 pub use vesting_query_client::VestingQueryClient;
 pub use vesting_signing_client::VestingSigningClient;
@@ -0,0 +1,24 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::nymd::error::NymdError;
+use crate::nymd::{CosmWasmClient, NymdClient};
+
+use multisig_contract_common::msg::{ProposalResponse, QueryMsg};
+
+use async_trait::async_trait;
+
+#[async_trait]
+pub trait QueryClient {
+    async fn get_proposal(&self, proposal_id: u64) -> Result<ProposalResponse, NymdError>;
+}
+
+#[async_trait]
+impl<C: CosmWasmClient + Sync + Send> QueryClient for NymdClient<C> {
+    async fn get_proposal(&self, proposal_id: u64) -> Result<ProposalResponse, NymdError> {
+        let request = QueryMsg::Proposal { proposal_id };
+        self.client
+            .query_contract_smart(self.multisig_contract_address(), &request)
+            .await
+    }
+}
@@ -0,0 +1,116 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+pub use crate::nymd::cosmwasm_client::signing_client::SigningCosmWasmClient;
+use crate::nymd::cosmwasm_client::types::ExecuteResult;
+use crate::nymd::error::NymdError;
+use crate::nymd::{Fee, NymdClient};
+
+use coconut_bandwidth_contract_common::msg::ExecuteMsg as CoconutBandwidthExecuteMsg;
+use multisig_contract_common::msg::ExecuteMsg;
+
+use async_trait::async_trait;
+use cosmwasm_std::{to_binary, Coin, CosmosMsg, WasmMsg};
+use cw3::Vote;
+use network_defaults::DEFAULT_NETWORK;
+
+#[async_trait]
+pub trait MultisigSigningClient {
+    async fn propose_release_funds(
+        &self,
+        title: String,
+        blinded_serial_number: String,
+        voucher_value: u128,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError>;
+
+    async fn vote_proposal(
+        &self,
+        proposal_id: u64,
+        yes: bool,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError>;
+
+    async fn execute_proposal(
+        &self,
+        proposal_id: u64,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError>;
+}
+
+#[async_trait]
+impl<C: SigningCosmWasmClient + Sync + Send> MultisigSigningClient for NymdClient<C> {
+    async fn propose_release_funds(
+        &self,
+        title: String,
+        blinded_serial_number: String,
+        voucher_value: u128,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier)));
+        let release_funds_req = CoconutBandwidthExecuteMsg::ReleaseFunds {
+            funds: Coin::new(voucher_value, DEFAULT_NETWORK.mix_denom().base),
+        };
+        let release_funds_msg = CosmosMsg::Wasm(WasmMsg::Execute {
+            contract_addr: self.coconut_bandwidth_contract_address().to_string(),
+            msg: to_binary(&release_funds_req)?,
+            funds: vec![],
+        });
+        let req = ExecuteMsg::Propose {
+            title,
+            description: blinded_serial_number,
+            msgs: vec![release_funds_msg],
+            latest: None,
+        };
+        self.client
+            .execute(
+                self.address(),
+                self.multisig_contract_address(),
+                &req,
+                fee,
+                "Multisig::Propose::Execute::ReleaseFunds",
+                vec![],
+            )
+            .await
+    }
+
+    async fn vote_proposal(
+        &self,
+        proposal_id: u64,
+        vote_yes: bool,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier)));
+        let vote = if vote_yes { Vote::Yes } else { Vote::No };
+        let req = ExecuteMsg::Vote { proposal_id, vote };
+        self.client
+            .execute(
+                self.address(),
+                self.multisig_contract_address(),
+                &req,
+                fee,
+                "Multisig::Vote",
+                vec![],
+            )
+            .await
+    }
+
+    async fn execute_proposal(
+        &self,
+        proposal_id: u64,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier)));
+        let req = ExecuteMsg::Execute { proposal_id };
+        self.client
+            .execute(
+                self.address(),
+                self.multisig_contract_address(),
+                &req,
+                fee,
+                "Multisig::Execute",
+                vec![],
+            )
+            .await
+    }
+}
@@ -1,11 +1,12 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

+use crate::nymd::coin::Coin;
 pub use crate::nymd::cosmwasm_client::client::CosmWasmClient;
 use crate::nymd::error::NymdError;
 use crate::nymd::NymdClient;
 use async_trait::async_trait;
-use cosmwasm_std::{Coin, Timestamp};
+use cosmwasm_std::{Coin as CosmWasmCoin, Timestamp};
 use vesting_contract::vesting::Account;
 use vesting_contract_common::{
    messages::QueryMsg as VestingQueryMsg, OriginalVestingResponse, Period, PledgeData,
@@ -83,8 +84,9 @@ impl<C: CosmWasmClient + Sync + Send> VestingQueryClient for NymdClient<C> {
            block_time,
        };
        self.client
-            .query_contract_smart(self.vesting_contract_address()?, &request)
+            .query_contract_smart::<_, CosmWasmCoin>(self.vesting_contract_address(), &request)
            .await
+            .map(Into::into)
    }

    async fn spendable_coins(
@@ -97,8 +99,9 @@ impl<C: CosmWasmClient + Sync + Send> VestingQueryClient for NymdClient<C> {
            block_time,
        };
        self.client
-            .query_contract_smart(self.vesting_contract_address()?, &request)
+            .query_contract_smart::<_, CosmWasmCoin>(self.vesting_contract_address(), &request)
            .await
+            .map(Into::into)
    }
    async fn vested_coins(
        &self,
@@ -110,8 +113,9 @@ impl<C: CosmWasmClient + Sync + Send> VestingQueryClient for NymdClient<C> {
            block_time,
        };
        self.client
-            .query_contract_smart(self.vesting_contract_address()?, &request)
+            .query_contract_smart::<_, CosmWasmCoin>(self.vesting_contract_address(), &request)
            .await
+            .map(Into::into)
    }
    async fn vesting_coins(
        &self,
@@ -123,8 +127,9 @@ impl<C: CosmWasmClient + Sync + Send> VestingQueryClient for NymdClient<C> {
            block_time,
        };
        self.client
-            .query_contract_smart(self.vesting_contract_address()?, &request)
+            .query_contract_smart::<_, CosmWasmCoin>(self.vesting_contract_address(), &request)
            .await
+            .map(Into::into)
    }

    async fn vesting_start_time(
@@ -135,7 +140,7 @@ impl<C: CosmWasmClient + Sync + Send> VestingQueryClient for NymdClient<C> {
            vesting_account_address: vesting_account_address.to_string(),
        };
        self.client
-            .query_contract_smart(self.vesting_contract_address()?, &request)
+            .query_contract_smart(self.vesting_contract_address(), &request)
            .await
    }

@@ -147,7 +152,7 @@ impl<C: CosmWasmClient + Sync + Send> VestingQueryClient for NymdClient<C> {
            vesting_account_address: vesting_account_address.to_string(),
        };
        self.client
-            .query_contract_smart(self.vesting_contract_address()?, &request)
+            .query_contract_smart(self.vesting_contract_address(), &request)
            .await
    }

@@ -159,7 +164,7 @@ impl<C: CosmWasmClient + Sync + Send> VestingQueryClient for NymdClient<C> {
            vesting_account_address: vesting_account_address.to_string(),
        };
        self.client
-            .query_contract_smart(self.vesting_contract_address()?, &request)
+            .query_contract_smart(self.vesting_contract_address(), &request)
            .await
    }

@@ -173,10 +178,12 @@ impl<C: CosmWasmClient + Sync + Send> VestingQueryClient for NymdClient<C> {
            block_time,
        };
        self.client
-            .query_contract_smart(self.vesting_contract_address()?, &request)
+            .query_contract_smart::<_, CosmWasmCoin>(self.vesting_contract_address(), &request)
            .await
+            .map(Into::into)
    }

+    /// Returns the total amount of delegated tokens that have vested
    async fn delegated_vesting(
        &self,
        vesting_account_address: &str,
@@ -187,8 +194,9 @@ impl<C: CosmWasmClient + Sync + Send> VestingQueryClient for NymdClient<C> {
            block_time,
        };
        self.client
-            .query_contract_smart(self.vesting_contract_address()?, &request)
+            .query_contract_smart::<_, CosmWasmCoin>(self.vesting_contract_address(), &request)
            .await
+            .map(Into::into)
    }

    async fn get_account(&self, address: &str) -> Result<Account, NymdError> {
@@ -196,7 +204,7 @@ impl<C: CosmWasmClient + Sync + Send> VestingQueryClient for NymdClient<C> {
            address: address.to_string(),
        };
        self.client
-            .query_contract_smart(self.vesting_contract_address()?, &request)
+            .query_contract_smart(self.vesting_contract_address(), &request)
            .await
    }
    async fn get_mixnode_pledge(&self, address: &str) -> Result<Option<PledgeData>, NymdError> {
@@ -204,7 +212,7 @@ impl<C: CosmWasmClient + Sync + Send> VestingQueryClient for NymdClient<C> {
            address: address.to_string(),
        };
        self.client
-            .query_contract_smart(self.vesting_contract_address()?, &request)
+            .query_contract_smart(self.vesting_contract_address(), &request)
            .await
    }
    async fn get_gateway_pledge(&self, address: &str) -> Result<Option<PledgeData>, NymdError> {
@@ -212,7 +220,7 @@ impl<C: CosmWasmClient + Sync + Send> VestingQueryClient for NymdClient<C> {
            address: address.to_string(),
        };
        self.client
-            .query_contract_smart(self.vesting_contract_address()?, &request)
+            .query_contract_smart(self.vesting_contract_address(), &request)
            .await
    }

@@ -221,7 +229,7 @@ impl<C: CosmWasmClient + Sync + Send> VestingQueryClient for NymdClient<C> {
            address: address.to_string(),
        };
        self.client
-            .query_contract_smart(self.vesting_contract_address()?, &request)
+            .query_contract_smart(self.vesting_contract_address(), &request)
            .await
    }
 }
@@ -4,10 +4,8 @@
 pub use crate::nymd::cosmwasm_client::signing_client::SigningCosmWasmClient;
 use crate::nymd::cosmwasm_client::types::ExecuteResult;
 use crate::nymd::error::NymdError;
-use crate::nymd::fee::helpers::Operation;
-use crate::nymd::{cosmwasm_coin_to_cosmos_coin, NymdClient};
+use crate::nymd::{Coin, Fee, NymdClient};
 use async_trait::async_trait;
-use cosmwasm_std::Coin;
 use mixnet_contract_common::{Gateway, IdentityKey, IdentityKeyRef, MixNode};
 use vesting_contract_common::messages::{ExecuteMsg as VestingExecuteMsg, VestingSpecification};

@@ -16,23 +14,30 @@ pub trait VestingSigningClient {
    async fn vesting_update_mixnode_config(
        &self,
        profix_margin_percent: u8,
+        fee: Option<Fee>,
    ) -> Result<ExecuteResult, NymdError>;

-    async fn update_mixnet_address(&self, address: &str) -> Result<ExecuteResult, NymdError>;
+    async fn update_mixnet_address(
+        &self,
+        address: &str,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError>;

    async fn vesting_bond_gateway(
        &self,
        gateway: Gateway,
        owner_signature: &str,
        pledge: Coin,
+        fee: Option<Fee>,
    ) -> Result<ExecuteResult, NymdError>;

-    async fn vesting_unbond_gateway(&self) -> Result<ExecuteResult, NymdError>;
+    async fn vesting_unbond_gateway(&self, fee: Option<Fee>) -> Result<ExecuteResult, NymdError>;

    async fn vesting_track_unbond_gateway(
        &self,
        owner: &str,
        amount: Coin,
+        fee: Option<Fee>,
    ) -> Result<ExecuteResult, NymdError>;

    async fn vesting_bond_mixnode(
@@ -40,33 +45,42 @@ pub trait VestingSigningClient {
        mix_node: MixNode,
        owner_signature: &str,
        pledge: Coin,
+        fee: Option<Fee>,
    ) -> Result<ExecuteResult, NymdError>;
-    async fn vesting_unbond_mixnode(&self) -> Result<ExecuteResult, NymdError>;
+    async fn vesting_unbond_mixnode(&self, fee: Option<Fee>) -> Result<ExecuteResult, NymdError>;

    async fn vesting_track_unbond_mixnode(
        &self,
        owner: &str,
        amount: Coin,
+        fee: Option<Fee>,
    ) -> Result<ExecuteResult, NymdError>;

-    async fn withdraw_vested_coins(&self, amount: Coin) -> Result<ExecuteResult, NymdError>;
+    async fn withdraw_vested_coins(
+        &self,
+        amount: Coin,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError>;

    async fn vesting_track_undelegation(
        &self,
        address: &str,
        mix_identity: IdentityKey,
        amount: Coin,
+        fee: Option<Fee>,
    ) -> Result<ExecuteResult, NymdError>;

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

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

    async fn create_periodic_vesting_account(
@@ -75,27 +89,71 @@ pub trait VestingSigningClient {
        staking_address: Option<String>,
        vesting_spec: Option<VestingSpecification>,
        amount: Coin,
+        fee: Option<Fee>,
    ) -> Result<ExecuteResult, NymdError>;
 }

 #[async_trait]
 impl<C: SigningCosmWasmClient + Sync + Send> VestingSigningClient for NymdClient<C> {
+    async fn vesting_update_mixnode_config(
+        &self,
+        profit_margin_percent: u8,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier)));
+        let req = VestingExecuteMsg::UpdateMixnodeConfig {
+            profit_margin_percent,
+        };
+        self.client
+            .execute(
+                self.address(),
+                self.vesting_contract_address(),
+                &req,
+                fee,
+                "VestingContract::UpdateMixnetConfig",
+                vec![],
+            )
+            .await
+    }
+
+    async fn update_mixnet_address(
+        &self,
+        address: &str,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier)));
+        let req = VestingExecuteMsg::UpdateMixnetAddress {
+            address: address.to_string(),
+        };
+        self.client
+            .execute(
+                self.address(),
+                self.vesting_contract_address(),
+                &req,
+                fee,
+                "VestingContract::UpdateMixnetAddress",
+                vec![],
+            )
+            .await
+    }
+
    async fn vesting_bond_gateway(
        &self,
        gateway: Gateway,
        owner_signature: &str,
        pledge: Coin,
+        fee: Option<Fee>,
    ) -> Result<ExecuteResult, NymdError> {
-        let fee = self.operation_fee(Operation::BondGateway);
+        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier)));
        let req = VestingExecuteMsg::BondGateway {
            gateway,
            owner_signature: owner_signature.to_string(),
-            amount: pledge,
+            amount: pledge.into(),
        };
        self.client
            .execute(
                self.address(),
-                self.vesting_contract_address()?,
+                self.vesting_contract_address(),
                &req,
                fee,
                "VestingContract::BondGateway",
@@ -104,13 +162,13 @@ impl<C: SigningCosmWasmClient + Sync + Send> VestingSigningClient for NymdClient
            .await
    }

-    async fn vesting_unbond_gateway(&self) -> Result<ExecuteResult, NymdError> {
-        let fee = self.operation_fee(Operation::UnbondGateway);
+    async fn vesting_unbond_gateway(&self, fee: Option<Fee>) -> Result<ExecuteResult, NymdError> {
+        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier)));
        let req = VestingExecuteMsg::UnbondGateway {};
        self.client
            .execute(
                self.address(),
-                self.vesting_contract_address()?,
+                self.vesting_contract_address(),
                &req,
                fee,
                "VestingContract::UnbondGateway",
@@ -123,16 +181,17 @@ impl<C: SigningCosmWasmClient + Sync + Send> VestingSigningClient for NymdClient
        &self,
        owner: &str,
        amount: Coin,
+        fee: Option<Fee>,
    ) -> Result<ExecuteResult, NymdError> {
-        let fee = self.operation_fee(Operation::TrackUnbondGateway);
+        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier)));
        let req = VestingExecuteMsg::TrackUnbondGateway {
            owner: owner.to_string(),
-            amount,
+            amount: amount.into(),
        };
        self.client
            .execute(
                self.address(),
-                self.vesting_contract_address()?,
+                self.vesting_contract_address(),
                &req,
                fee,
                "VestingContract::TrackUnbondGateway",
@@ -146,17 +205,18 @@ impl<C: SigningCosmWasmClient + Sync + Send> VestingSigningClient for NymdClient
        mix_node: MixNode,
        owner_signature: &str,
        pledge: Coin,
+        fee: Option<Fee>,
    ) -> Result<ExecuteResult, NymdError> {
-        let fee = self.operation_fee(Operation::BondMixnode);
+        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier)));
        let req = VestingExecuteMsg::BondMixnode {
            mix_node,
            owner_signature: owner_signature.to_string(),
-            amount: pledge,
+            amount: pledge.into(),
        };
        self.client
            .execute(
                self.address(),
-                self.vesting_contract_address()?,
+                self.vesting_contract_address(),
                &req,
                fee,
                "VestingContract::BondMixnode",
@@ -165,13 +225,13 @@ impl<C: SigningCosmWasmClient + Sync + Send> VestingSigningClient for NymdClient
            .await
    }

-    async fn vesting_unbond_mixnode(&self) -> Result<ExecuteResult, NymdError> {
-        let fee = self.operation_fee(Operation::UnbondMixnode);
+    async fn vesting_unbond_mixnode(&self, fee: Option<Fee>) -> Result<ExecuteResult, NymdError> {
+        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier)));
        let req = VestingExecuteMsg::UnbondMixnode {};
        self.client
            .execute(
                self.address(),
-                self.vesting_contract_address()?,
+                self.vesting_contract_address(),
                &req,
                fee,
                "VestingContract::UnbondMixnode",
@@ -184,16 +244,17 @@ impl<C: SigningCosmWasmClient + Sync + Send> VestingSigningClient for NymdClient
        &self,
        owner: &str,
        amount: Coin,
+        fee: Option<Fee>,
    ) -> Result<ExecuteResult, NymdError> {
-        let fee = self.operation_fee(Operation::TrackUnbondMixnode);
+        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier)));
        let req = VestingExecuteMsg::TrackUnbondMixnode {
            owner: owner.to_string(),
-            amount,
+            amount: amount.into(),
        };
        self.client
            .execute(
                self.address(),
-                self.vesting_contract_address()?,
+                self.vesting_contract_address(),
                &req,
                fee,
                "VestingContract::TrackUnbondMixnode",
@@ -201,14 +262,19 @@ impl<C: SigningCosmWasmClient + Sync + Send> VestingSigningClient for NymdClient
            )
            .await
    }
-
-    async fn withdraw_vested_coins(&self, amount: Coin) -> Result<ExecuteResult, NymdError> {
-        let fee = self.operation_fee(Operation::WithdrawVestedCoins);
-        let req = VestingExecuteMsg::WithdrawVestedCoins { amount };
+    async fn withdraw_vested_coins(
+        &self,
+        amount: Coin,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier)));
+        let req = VestingExecuteMsg::WithdrawVestedCoins {
+            amount: amount.into(),
+        };
        self.client
            .execute(
                self.address(),
-                self.vesting_contract_address()?,
+                self.vesting_contract_address(),
                &req,
                fee,
                "VestingContract::WithdrawVested",
@@ -216,23 +282,23 @@ impl<C: SigningCosmWasmClient + Sync + Send> VestingSigningClient for NymdClient
            )
            .await
    }
-
    async fn vesting_track_undelegation(
        &self,
        address: &str,
        mix_identity: IdentityKey,
        amount: Coin,
+        fee: Option<Fee>,
    ) -> Result<ExecuteResult, NymdError> {
-        let fee = self.operation_fee(Operation::TrackUndelegation);
+        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier)));
        let req = VestingExecuteMsg::TrackUndelegation {
            owner: address.to_string(),
            mix_identity,
-            amount,
+            amount: amount.into(),
        };
        self.client
            .execute(
                self.address(),
-                self.vesting_contract_address()?,
+                self.vesting_contract_address(),
                &req,
                fee,
                "VestingContract::TrackUndelegation",
@@ -243,17 +309,18 @@ impl<C: SigningCosmWasmClient + Sync + Send> VestingSigningClient for NymdClient
    async fn vesting_delegate_to_mixnode<'a>(
        &self,
        mix_identity: IdentityKeyRef<'a>,
-        amount: &Coin,
+        amount: Coin,
+        fee: Option<Fee>,
    ) -> Result<ExecuteResult, NymdError> {
-        let fee = self.operation_fee(Operation::DelegateToMixnode);
+        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier)));
        let req = VestingExecuteMsg::DelegateToMixnode {
            mix_identity: mix_identity.into(),
-            amount: amount.clone(),
+            amount: amount.into(),
        };
        self.client
            .execute(
                self.address(),
-                self.vesting_contract_address()?,
+                self.vesting_contract_address(),
                &req,
                fee,
                "VestingContract::DelegateToMixnode",
@@ -261,18 +328,20 @@ impl<C: SigningCosmWasmClient + Sync + Send> VestingSigningClient for NymdClient
            )
            .await
    }
+
    async fn vesting_undelegate_from_mixnode<'a>(
        &self,
        mix_identity: IdentityKeyRef<'a>,
+        fee: Option<Fee>,
    ) -> Result<ExecuteResult, NymdError> {
-        let fee = self.operation_fee(Operation::UndelegateFromMixnode);
+        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier)));
        let req = VestingExecuteMsg::UndelegateFromMixnode {
            mix_identity: mix_identity.into(),
        };
        self.client
            .execute(
                self.address(),
-                self.vesting_contract_address()?,
+                self.vesting_contract_address(),
                &req,
                fee,
                "VestingContract::UndelegateFromMixnode",
@@ -280,14 +349,16 @@ impl<C: SigningCosmWasmClient + Sync + Send> VestingSigningClient for NymdClient
            )
            .await
    }
+
    async fn create_periodic_vesting_account(
        &self,
        owner_address: &str,
        staking_address: Option<String>,
        vesting_spec: Option<VestingSpecification>,
        amount: Coin,
+        fee: Option<Fee>,
    ) -> Result<ExecuteResult, NymdError> {
-        let fee = self.operation_fee(Operation::CreatePeriodicVestingAccount);
+        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier)));
        let req = VestingExecuteMsg::CreateAccount {
            owner_address: owner_address.to_string(),
            staking_address,
@@ -296,48 +367,11 @@ impl<C: SigningCosmWasmClient + Sync + Send> VestingSigningClient for NymdClient
        self.client
            .execute(
                self.address(),
-                self.vesting_contract_address()?,
+                self.vesting_contract_address(),
                &req,
                fee,
                "VestingContract::CreatePeriodicVestingAccount",
-                vec![cosmwasm_coin_to_cosmos_coin(amount)],
-            )
-            .await
-    }
-
-    async fn update_mixnet_address(&self, address: &str) -> Result<ExecuteResult, NymdError> {
-        let fee = self.operation_fee(Operation::UpdateMixnetAddress);
-        let req = VestingExecuteMsg::UpdateMixnetAddress {
-            address: address.to_string(),
-        };
-        self.client
-            .execute(
-                self.address(),
-                self.vesting_contract_address()?,
-                &req,
-                fee,
-                "VestingContract::UpdateMixnetAddress",
-                vec![],
-            )
-            .await
-    }
-
-    async fn vesting_update_mixnode_config(
-        &self,
-        profit_margin_percent: u8,
-    ) -> Result<ExecuteResult, NymdError> {
-        let fee = self.operation_fee(Operation::UpdateMixnodeConfig);
-        let req = VestingExecuteMsg::UpdateMixnodeConfig {
-            profit_margin_percent,
-        };
-        self.client
-            .execute(
-                self.address(),
-                self.vesting_contract_address()?,
-                &req,
-                fee,
-                "VestingContract::UpdateMixnetConfig",
-                vec![],
+                vec![amount],
            )
            .await
    }
@@ -3,14 +3,18 @@

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

 pub mod error;
@@ -85,6 +89,16 @@ impl Client {
            .await
    }

+    pub async fn get_mixnodes_detailed(
+        &self,
+    ) -> Result<Vec<MixNodeBondAnnotated>, ValidatorAPIError> {
+        self.query_validator_api(
+            &[routes::API_VERSION, routes::MIXNODES, routes::DETAILED],
+            NO_PARAMS,
+        )
+        .await
+    }
+
    pub async fn get_gateways(&self) -> Result<Vec<GatewayBond>, ValidatorAPIError> {
        self.query_validator_api(&[routes::API_VERSION, routes::GATEWAYS], NO_PARAMS)
            .await
@@ -98,6 +112,21 @@ impl Client {
        .await
    }

+    pub async fn get_active_mixnodes_detailed(
+        &self,
+    ) -> Result<Vec<MixNodeBondAnnotated>, ValidatorAPIError> {
+        self.query_validator_api(
+            &[
+                routes::API_VERSION,
+                routes::MIXNODES,
+                routes::ACTIVE,
+                routes::DETAILED,
+            ],
+            NO_PARAMS,
+        )
+        .await
+    }
+
    pub async fn get_rewarded_mixnodes(&self) -> Result<Vec<MixNodeBond>, ValidatorAPIError> {
        self.query_validator_api(
            &[routes::API_VERSION, routes::MIXNODES, routes::REWARDED],
@@ -106,6 +135,21 @@ impl Client {
        .await
    }

+    pub async fn get_rewarded_mixnodes_detailed(
+        &self,
+    ) -> Result<Vec<MixNodeBondAnnotated>, ValidatorAPIError> {
+        self.query_validator_api(
+            &[
+                routes::API_VERSION,
+                routes::MIXNODES,
+                routes::REWARDED,
+                routes::DETAILED,
+            ],
+            NO_PARAMS,
+        )
+        .await
+    }
+
    pub async fn get_probs_mixnode_rewarded(
        &self,
        mixnode_id: &str,
@@ -331,6 +375,57 @@ impl Client {
        )
        .await
    }
+
+    pub async fn verify_bandwidth_credential(
+        &self,
+        request_body: &VerifyCredentialBody,
+    ) -> Result<VerifyCredentialResponse, ValidatorAPIError> {
+        self.post_validator_api(
+            &[
+                routes::API_VERSION,
+                routes::COCONUT_ROUTES,
+                routes::BANDWIDTH,
+                routes::COCONUT_VERIFY_BANDWIDTH_CREDENTIAL,
+            ],
+            NO_PARAMS,
+            request_body,
+        )
+        .await
+    }
+
+    pub async fn propose_release_funds(
+        &self,
+        request_body: &ProposeReleaseFundsRequestBody,
+    ) -> Result<ProposeReleaseFundsResponse, ValidatorAPIError> {
+        self.post_validator_api(
+            &[
+                routes::API_VERSION,
+                routes::COCONUT_ROUTES,
+                routes::BANDWIDTH,
+                routes::COCONUT_PROPOSE_RELEASE_FUNDS,
+            ],
+            NO_PARAMS,
+            request_body,
+        )
+        .await
+    }
+
+    pub async fn execute_release_funds(
+        &self,
+        request_body: &ExecuteReleaseFundsRequestBody,
+    ) -> Result<(), ValidatorAPIError> {
+        self.post_validator_api(
+            &[
+                routes::API_VERSION,
+                routes::COCONUT_ROUTES,
+                routes::BANDWIDTH,
+                routes::COCONUT_EXECUTE_RELEASE_FUNDS,
+            ],
+            NO_PARAMS,
+            request_body,
+        )
+        .await
+    }
 }

 // utility function that should solve the double slash problem in validator API forever.
@@ -7,6 +7,7 @@ pub const API_VERSION: &str = VALIDATOR_API_VERSION;
 pub const MIXNODES: &str = "mixnodes";
 pub const GATEWAYS: &str = "gateways";

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

@@ -16,6 +17,9 @@ pub const BANDWIDTH: &str = "bandwidth";
 pub const COCONUT_BLIND_SIGN: &str = "blind-sign";
 pub const COCONUT_PARTIAL_BANDWIDTH_CREDENTIAL: &str = "partial-bandwidth-credential";
 pub const COCONUT_VERIFICATION_KEY: &str = "verification-key";
+pub const COCONUT_VERIFY_BANDWIDTH_CREDENTIAL: &str = "verify-bandwidth-credential";
+pub const COCONUT_PROPOSE_RELEASE_FUNDS: &str = "propose-release-funds";
+pub const COCONUT_EXECUTE_RELEASE_FUNDS: &str = "execute-release-funds";

 pub const STATUS_ROUTES: &str = "status";
 pub const MIXNODE: &str = "mixnode";
@@ -1,6 +1,7 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

+use nymcoconut::CoconutError;
 use thiserror::Error;

 #[derive(Debug, Error)]
@@ -11,9 +12,6 @@ pub enum CoconutInterfaceError {
    #[error("Could not decode base 58 string - {0}")]
    MalformedString(#[from] bs58::decode::Error),

-    #[error("Not enough public attributes were specified")]
-    NotEnoughPublicAttributes,
-
-    #[error("Could not recover bandwidth value")]
-    InvalidBandwidth,
+    #[error("Coconut error - {0}")]
+    CoconutError(#[from] CoconutError),
 }
@@ -5,96 +5,158 @@ pub mod error;

 use getset::{CopyGetters, Getters};
 use serde::{Deserialize, Serialize};
-use std::str::FromStr;

 use error::CoconutInterfaceError;

 pub use nymcoconut::*;

-#[derive(Serialize, Deserialize, Getters, CopyGetters, Clone)]
+#[derive(Debug, Serialize, Deserialize, Getters, CopyGetters, Clone, PartialEq)]
 pub struct Credential {
    #[getset(get = "pub")]
    n_params: u32,
    #[getset(get = "pub")]
    theta: Theta,
-    public_attributes: Vec<Vec<u8>>,
-    #[getset(get = "pub")]
-    signature: Signature,
+    voucher_value: u64,
+    voucher_info: String,
 }
 impl Credential {
    pub fn new(
        n_params: u32,
        theta: Theta,
-        voucher_value: String,
+        voucher_value: u64,
        voucher_info: String,
-        signature: &Signature,
    ) -> Credential {
-        let public_attributes = vec![voucher_value.into_bytes(), voucher_info.into_bytes()];
        Credential {
            n_params,
            theta,
-            public_attributes,
-            signature: *signature,
+            voucher_value,
+            voucher_info,
        }
    }

-    pub fn voucher_value(&self) -> Result<u64, CoconutInterfaceError> {
-        let bandwidth_vec = self
-            .public_attributes
-            .get(0)
-            .ok_or(CoconutInterfaceError::NotEnoughPublicAttributes)?
-            .to_owned();
-        let bandwidth_str = String::from_utf8(bandwidth_vec)
-            .map_err(|_| CoconutInterfaceError::InvalidBandwidth)?;
-        let value =
-            u64::from_str(&bandwidth_str).map_err(|_| CoconutInterfaceError::InvalidBandwidth)?;
+    pub fn blinded_serial_number(&self) -> String {
+        self.theta.blinded_serial_number_bs58()
+    }

-        Ok(value)
+    pub fn has_blinded_serial_number(
+        &self,
+        blinded_serial_number_bs58: &str,
+    ) -> Result<bool, CoconutInterfaceError> {
+        Ok(self
+            .theta
+            .has_blinded_serial_number(blinded_serial_number_bs58)?)
+    }
+
+    pub fn voucher_value(&self) -> u64 {
+        self.voucher_value
    }

    pub fn verify(&self, verification_key: &VerificationKey) -> bool {
        let params = Parameters::new(self.n_params).unwrap();
-        let public_attributes = self
-            .public_attributes
-            .iter()
-            .map(hash_to_scalar)
-            .collect::<Vec<Attribute>>();
+        let public_attributes = vec![
+            self.voucher_value.to_string().as_bytes(),
+            self.voucher_info.as_bytes(),
+        ]
+        .iter()
+        .map(hash_to_scalar)
+        .collect::<Vec<Attribute>>();
        nymcoconut::verify_credential(&params, verification_key, &self.theta, &public_attributes)
    }
+
+    pub fn as_bytes(&self) -> Vec<u8> {
+        let n_params_bytes = self.n_params.to_be_bytes();
+        let theta_bytes = self.theta.to_bytes();
+        let theta_bytes_len = theta_bytes.len();
+        let voucher_value_bytes = self.voucher_value.to_be_bytes();
+        let voucher_info_bytes = self.voucher_info.as_bytes();
+        let voucher_info_len = voucher_info_bytes.len();
+
+        let mut bytes = Vec::with_capacity(28 + theta_bytes_len + voucher_info_len);
+        bytes.extend_from_slice(&n_params_bytes);
+        bytes.extend_from_slice(&(theta_bytes_len as u64).to_be_bytes());
+        bytes.extend_from_slice(&theta_bytes);
+        bytes.extend_from_slice(&voucher_value_bytes);
+        bytes.extend_from_slice(voucher_info_bytes);
+
+        bytes
+    }
+
+    pub fn from_bytes(bytes: &[u8]) -> Result<Self, CoconutError> {
+        if bytes.len() < 28 {
+            return Err(CoconutError::Deserialization(String::from(
+                "To few bytes in credential",
+            )));
+        }
+        let mut four_byte = [0u8; 4];
+        let mut eight_byte = [0u8; 8];
+
+        four_byte.copy_from_slice(&bytes[..4]);
+        let n_params = u32::from_be_bytes(four_byte);
+        eight_byte.copy_from_slice(&bytes[4..12]);
+        let theta_len = u64::from_be_bytes(eight_byte);
+        if bytes.len() < 28 + theta_len as usize {
+            return Err(CoconutError::Deserialization(String::from(
+                "To few bytes in credential",
+            )));
+        }
+        let theta = Theta::from_bytes(&bytes[12..12 + theta_len as usize])
+            .map_err(|e| CoconutError::Deserialization(e.to_string()))?;
+        eight_byte.copy_from_slice(&bytes[12 + theta_len as usize..20 + theta_len as usize]);
+        let voucher_value = u64::from_be_bytes(eight_byte);
+        let voucher_info = String::from_utf8(bytes[20 + theta_len as usize..].to_vec())
+            .map_err(|e| CoconutError::Deserialization(e.to_string()))?;
+
+        Ok(Credential {
+            n_params,
+            theta,
+            voucher_value,
+            voucher_info,
+        })
+    }
 }

-#[derive(Serialize, Deserialize, Debug, Getters, CopyGetters)]
+impl Bytable for Credential {
+    fn to_byte_vec(&self) -> Vec<u8> {
+        self.as_bytes()
+    }
+
+    fn try_from_byte_slice(slice: &[u8]) -> Result<Self, CoconutError> {
+        Credential::from_bytes(slice)
+    }
+}
+
+impl Base58 for Credential {}
+
+#[derive(Serialize, Deserialize, Getters, CopyGetters)]
 pub struct VerifyCredentialBody {
    #[getset(get = "pub")]
-    n_params: u32,
+    credential: Credential,
    #[getset(get = "pub")]
-    theta: Theta,
-    public_attributes: Vec<String>,
+    proposal_id: u64,
 }

 impl VerifyCredentialBody {
-    pub fn new(
-        n_params: u32,
-        theta: &Theta,
-        public_attributes: &[Attribute],
-    ) -> VerifyCredentialBody {
+    pub fn new(credential: Credential, proposal_id: u64) -> VerifyCredentialBody {
        VerifyCredentialBody {
-            n_params,
-            theta: theta.clone(),
-            public_attributes: public_attributes
-                .iter()
-                .map(|attr| attr.to_bs58())
-                .collect(),
+            credential,
+            proposal_id,
        }
    }
+}

-    pub fn public_attributes(&self) -> Vec<Attribute> {
-        self.public_attributes
-            .iter()
-            .map(|x| Attribute::try_from_bs58(x).unwrap())
-            .collect()
+#[derive(Debug, Serialize, Deserialize)]
+pub struct VerifyCredentialResponse {
+    pub verification_result: bool,
+}
+
+impl VerifyCredentialResponse {
+    pub fn new(verification_result: bool) -> Self {
+        VerifyCredentialResponse {
+            verification_result,
+        }
    }
 }
+
 //  All strings are base58 encoded representations of structs
 #[derive(Clone, Serialize, Deserialize, Debug, Getters, CopyGetters)]
 pub struct BlindSignRequestBody {
@@ -194,3 +256,86 @@ impl VerificationKeyResponse {
        VerificationKeyResponse { key }
    }
 }
+
+#[derive(Serialize, Deserialize, Getters, CopyGetters)]
+pub struct ProposeReleaseFundsRequestBody {
+    #[getset(get = "pub")]
+    credential: Credential,
+}
+
+impl ProposeReleaseFundsRequestBody {
+    pub fn new(credential: Credential) -> Self {
+        ProposeReleaseFundsRequestBody { credential }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct ProposeReleaseFundsResponse {
+    pub proposal_id: u64,
+}
+
+impl ProposeReleaseFundsResponse {
+    pub fn new(proposal_id: u64) -> Self {
+        ProposeReleaseFundsResponse { proposal_id }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, Getters, CopyGetters)]
+pub struct ExecuteReleaseFundsRequestBody {
+    #[getset(get = "pub")]
+    proposal_id: u64,
+}
+
+impl ExecuteReleaseFundsRequestBody {
+    pub fn new(proposal_id: u64) -> Self {
+        ExecuteReleaseFundsRequestBody { proposal_id }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn serde_coconut_credential() {
+        let voucher_value = 1000000u64;
+        let voucher_info = String::from("BandwidthVoucher");
+        let serial_number =
+            Attribute::try_from_bs58("7Rp3imcuNX3w9se9wm5th8gSvc2czsnMrGsdt5HsrycA").unwrap();
+        let binding_number =
+            Attribute::try_from_bs58("Auf8yVEgyEAWNHaXUZmimS4n9g5YiYnNYqp6F9BtBe9E").unwrap();
+        let signature = Signature::try_from_bs58(
+            "ta3pM9ffj5T6YGbwjSBp2W118rcwyP9PXStc\
+        7ssb91g5GQYMQHhuTNajbdZcjxUFBFL5rhED8EHpRzE8r432ss3qbPBfpNev4CdkfMkQ3wepyM7hy7q1W6Rn9WmFoZL\
+        ZR9j",
+        )
+        .unwrap();
+        let params = Parameters::new(4).unwrap();
+        let verification_key = VerificationKey::try_from_bs58("8CFtVVXdwLy4WHMQPE4\
+        woe89q3DRHoNxBSchftrEjSBPWA4r4xZv4Y9qSvS5x5bMmFtp7BX6ikECAnuXr5EjXWSsgjirZJmpS5XDUynVfht1cD\
+        FWGDvy2XFrRCuoCMotNXi3PoF6wYqdTR9Rqcfoj3i2H5Nid422WBaLtVoC9QNobvpvaqq6vX5PbsSyPayvU8HCXFxM6\
+        JjScYpbRTxQtdwefWLrk3LmXyJQBWi7c2VAhSxu9msp7VTBycqdwQNgxHETStZuwXsozxaGQ2KssVUCaaoYPR4g2RqK\
+        UAvtWwA7pMiAQNcbkXcbsjCgVjWaCpMWC37XA31cLcFf3zbjHD9e5tXjAcqa4M89fbFhuvvSXxowSAZ5NoWrN32kd5d\
+        wxJm1JW3Tt2h6yDDBe84oMy71462dZn7N78DVk2mFNGwBCibrZWA7oUzRBMfYxiQrksoFcou7QfLLd58zoNYmPQPt84\
+        1VpQopEBfdQ7Nf9zoXxBt3zMy7g5NsFGvzh7KTbDUyeeXrdkKJPQBs6dqaizr9sS8CPPmR4uk96vDTRh8CJ5FbSsmb8\
+        nP71dRvvwRZJHGzwYirMo6SXS3ZYxFuiA3mkxYuqDHCwkTWDuRCcAaztrDYRZg7VCMo4Q446AaEso5eqpeWpHZQt53E\
+        ZRpqmNYKASGwMhTeEHPSLgSmtoAAUcaRWpGRzYfd6kzEma8tdGLwyP4rLXgvSvtDLP37dU7YgF3LEXbGAz57U9ATy46\
+        6sroLpHPdaCWB8RF11wvB6Tu196JnJd2KyQBP1iUWP3rtZs3GhAF1QVcxquh8BqDZzAcpQ6wCS1P9c5GxKgww77FVF5\
+        Kp83XtoxSrw3GaYVyKTGxNh3vcKPR31txCjTxPaN2fg7TaPLhoQJX4YaAroFSXqrqbbRsisuHhhCeUP2YwDjHedes9y")
+            .unwrap();
+        let theta = prove_bandwidth_credential(
+            &params,
+            &verification_key,
+            &signature,
+            serial_number,
+            binding_number,
+        )
+        .unwrap();
+        let credential = Credential::new(4, theta, voucher_value, voucher_info);
+
+        let serialized_credential = credential.as_bytes();
+        let deserialized_credential = Credential::from_bytes(&serialized_credential).unwrap();
+
+        assert_eq!(credential, deserialized_credential);
+    }
+}
@@ -15,7 +15,6 @@ pub trait NymConfig: Default + Serialize + DeserializeOwned {
    fn template() -> &'static str;

    fn config_file_name() -> String {
-        log::trace!("NymdConfig::config_file_name");
        "config.toml".to_string()
    }

@@ -23,7 +22,6 @@ pub trait NymConfig: Default + Serialize + DeserializeOwned {

    // default, most probable, implementations; can be easily overridden where required
    fn default_config_directory(id: Option<&str>) -> PathBuf {
-        log::trace!("NymdConfig::default_config_directory");
        if let Some(id) = id {
            Self::default_root_directory().join(id).join("config")
        } else {
@@ -32,7 +30,6 @@ pub trait NymConfig: Default + Serialize + DeserializeOwned {
    }

    fn default_data_directory(id: Option<&str>) -> PathBuf {
-        log::trace!("NymdConfig::default_data_path");
        if let Some(id) = id {
            Self::default_root_directory().join(id).join("data")
        } else {
@@ -41,7 +38,6 @@ pub trait NymConfig: Default + Serialize + DeserializeOwned {
    }

    fn default_config_file_path(id: Option<&str>) -> PathBuf {
-        log::trace!("NymdConfig::default_config_file_path");
        Self::default_config_directory(id).join(Self::config_file_name())
    }

@@ -6,6 +6,6 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [dependencies]
-cosmwasm-std = "1.0.0-beta6"
+cosmwasm-std = "1.0.0"
 schemars = "0.8"
 serde = { version = "1.0.103", default-features = false, features = ["derive"] }
@@ -7,4 +7,4 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [dependencies]
-cosmwasm-std = "1.0.0-beta8"
+cosmwasm-std = "1.0.0"
@@ -7,7 +7,7 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [dependencies]
-cosmwasm-std = "1.0.0-beta8"
+cosmwasm-std = "1.0.0"

 serde = { version = "1.0", features = ["derive"] }
 serde_repr = "0.1"
@@ -18,12 +18,13 @@ fixed = { version = "1.1", features = ["serde"] }
 az = "1.1"
 log = "0.4.14"
 time = { version = "0.3.6", features = ["parsing", "formatting"] }
+ts-rs = "6.1.2"

 contracts-common = { path = "../contracts-common" }

 [dev-dependencies]
 time = { version = "0.3.5", features = ["serde", "macros"] }
-ts-rs = "6.1.2"

 [features]
 default = []
+generate-ts = []
@@ -33,7 +33,7 @@ pub struct Delegation {
    pub node_identity: IdentityKey,
    pub amount: Coin,
    pub block_height: u64,
-    pub proxy: Option<Addr>, // proxy address used to delegate the funds on behalf of anouther address
+    pub proxy: Option<Addr>, // proxy address used to delegate the funds on behalf of another address
 }

 impl Eq for Delegation {}
@@ -23,7 +23,9 @@ pub const CHANGE_REWARDED_SET_EVENT_TYPE: &str = "change_rewarded_set";
 pub const ADVANCE_INTERVAL_EVENT_TYPE: &str = "advance_interval";
 pub const ADVANCE_EPOCH_EVENT_TYPE: &str = "advance_epoch";
 pub const COMPOUND_DELEGATOR_REWARD_EVENT_TYPE: &str = "compound_delegator_reward";
+pub const CLAIM_DELEGATOR_REWARD_EVENT_TYPE: &str = "claim_delegator_reward";
 pub const COMPOUND_OPERATOR_REWARD_EVENT_TYPE: &str = "compound_operator_reward";
+pub const CLAIM_OPERATOR_REWARD_EVENT_TYPE: &str = "claim_operator_reward";
 pub const SNAPSHOT_MIXNODES_EVENT: &str = "snapshot_mixnodes";

 // attributes that are used in multiple places
@@ -151,6 +153,11 @@ pub fn new_compound_operator_reward_event(owner: &Addr, amount: Uint128) -> Even
    event.add_attribute(AMOUNT_KEY, amount.to_string())
 }

+pub fn new_claim_operator_reward_event(owner: &Addr, amount: Uint128) -> Event {
+    let event = Event::new(CLAIM_OPERATOR_REWARD_EVENT_TYPE).add_attribute(OWNER_KEY, owner);
+    event.add_attribute(AMOUNT_KEY, amount.to_string())
+}
+
 pub fn new_compound_delegator_reward_event(
    delegator: &Addr,
    proxy: &Option<Addr>,
@@ -171,6 +178,26 @@ pub fn new_compound_delegator_reward_event(
        .add_attribute(DELEGATOR_KEY, delegator)
 }

+pub fn new_claim_delegator_reward_event(
+    delegator: &Addr,
+    proxy: &Option<Addr>,
+    amount: Uint128,
+    mix_identity: IdentityKeyRef<'_>,
+) -> Event {
+    let mut event =
+        Event::new(CLAIM_DELEGATOR_REWARD_EVENT_TYPE).add_attribute(DELEGATOR_KEY, delegator);
+
+    if let Some(proxy) = proxy {
+        event = event.add_attribute(PROXY_KEY, proxy)
+    }
+
+    // coin implements Display trait and we use that implementation here
+    event
+        .add_attribute(AMOUNT_KEY, amount.to_string())
+        .add_attribute(DELEGATION_TARGET_KEY, mix_identity)
+        .add_attribute(DELEGATOR_KEY, delegator)
+}
+
 pub fn new_undelegation_event(
    delegator: &Addr,
    proxy: &Option<Addr>,
@@ -8,11 +8,6 @@ use serde::{Deserialize, Serialize};
 use std::cmp::Ordering;
 use std::fmt::Display;

-#[cfg_attr(test, derive(ts_rs::TS))]
-#[cfg_attr(
-    test,
-    ts(export, export_to = "../../../nym-wallet/src/types/rust/gateway.ts")
-)]
 #[derive(Clone, Debug, Deserialize, PartialEq, PartialOrd, Serialize, JsonSchema)]
 pub struct Gateway {
    pub host: String,
@@ -14,13 +14,10 @@ use serde_repr::{Deserialize_repr, Serialize_repr};
 use std::cmp::Ordering;
 use std::fmt::Display;

-#[cfg_attr(test, derive(ts_rs::TS))]
+#[cfg_attr(feature = "generate-ts", derive(ts_rs::TS))]
 #[cfg_attr(
-    test,
-    ts(
-        export,
-        export_to = "../../../nym-wallet/src/types/rust/rewardedsetnodestatus.ts"
-    )
+    feature = "generate-ts",
+    ts(export_to = "ts-packages/types/src/types/rust/RewardedSetNodeStatus.ts")
 )]
 #[derive(Clone, Copy, Debug, Deserialize, Serialize, JsonSchema, PartialEq)]
 pub enum RewardedSetNodeStatus {
@@ -40,6 +37,16 @@ pub enum DelegationEvent {
    Undelegate(PendingUndelegate),
 }

+impl DelegationEvent {
+    pub fn delegation_amount(&self) -> Option<Coin> {
+        match self {
+            DelegationEvent::Delegate(delegation) => Some(delegation.amount.clone()),
+            // I think it would be nice to also expose an amount here to know how much we're undelegating
+            DelegationEvent::Undelegate(_) => None,
+        }
+    }
+}
+
 #[derive(Clone, Debug, Deserialize, Serialize, JsonSchema)]
 pub struct PendingUndelegate {
    mix_identity: IdentityKey,
@@ -109,11 +116,6 @@ impl PendingUndelegate {
    }
 }

-#[cfg_attr(test, derive(ts_rs::TS))]
-#[cfg_attr(
-    test,
-    ts(export, export_to = "../../../nym-wallet/src/types/rust/mixnode.ts")
-)]
 #[derive(Clone, Debug, Deserialize, PartialEq, PartialOrd, Serialize, JsonSchema)]
 pub struct MixNode {
    pub host: String,
@@ -318,6 +320,14 @@ impl NodeRewardResult {
    }
 }

+pub struct RewardEstimate {
+    pub total_node_reward: u64,
+    pub operator_reward: u64,
+    pub delegators_reward: u64,
+    pub node_profit: u64,
+    pub operator_cost: u64,
+}
+
 #[derive(Clone, Debug, Deserialize, PartialEq, Serialize, JsonSchema)]
 pub struct MixNodeBond {
    pub pledge_amount: Coin,
@@ -410,63 +420,80 @@ impl MixNodeBond {
            / U128::from_num(circulating_supply)
    }

+    pub fn lambda_ticked(&self, params: &RewardParams) -> U128 {
+        // Ratio of a bond to the token circulating supply
+        self.lambda(params).min(params.one_over_k())
+    }
+
    pub fn lambda(&self, params: &RewardParams) -> U128 {
        // Ratio of a bond to the token circulating supply
-        let pledge_to_circulating_supply_ratio =
-            self.pledge_to_circulating_supply(params.circulating_supply());
-        pledge_to_circulating_supply_ratio.min(params.one_over_k())
+        self.pledge_to_circulating_supply(params.circulating_supply())
+    }
+
+    pub fn sigma_ticked(&self, params: &RewardParams) -> U128 {
+        // Ratio of a delegation to the the token circulating supply
+        self.sigma(params).min(params.one_over_k())
    }

    pub fn sigma(&self, params: &RewardParams) -> U128 {
        // Ratio of a delegation to the the token circulating supply
-        let total_bond_to_circulating_supply_ratio =
-            self.total_bond_to_circulating_supply(params.circulating_supply());
-        total_bond_to_circulating_supply_ratio.min(params.one_over_k())
+        self.total_bond_to_circulating_supply(params.circulating_supply())
    }

    pub fn estimate_reward(
        &self,
        params: &RewardParams,
-    ) -> Result<(u64, u64, u64), MixnetContractError> {
+    ) -> Result<RewardEstimate, MixnetContractError> {
        let total_node_reward = self
            .reward(params)
            .reward()
            .checked_to_num::<u128>()
            .unwrap_or_default();
+        let node_profit = self
+            .node_profit(params)
+            .checked_to_num::<u128>()
+            .unwrap_or_default();
+        let operator_cost = params
+            .node
+            .operator_cost()
+            .checked_to_num::<u128>()
+            .unwrap_or_default();
        let operator_reward = self.operator_reward(params);
        // Total reward has to be the sum of operator and delegator rewards
-        let delegators_reward = total_node_reward - operator_reward;
+        let delegators_reward = node_profit.saturating_sub(operator_reward);

-        Ok((
-            total_node_reward.try_into()?,
-            operator_reward.try_into()?,
-            delegators_reward.try_into()?,
-        ))
+        Ok(RewardEstimate {
+            total_node_reward: total_node_reward.try_into()?,
+            operator_reward: operator_reward.try_into()?,
+            delegators_reward: delegators_reward.try_into()?,
+            node_profit: node_profit.try_into()?,
+            operator_cost: operator_cost.try_into()?,
+        })
    }

+    // keybase://chat/nymtech#dev-core/14473
    pub fn reward(&self, params: &RewardParams) -> NodeRewardResult {
-        let lambda = self.lambda(params);
-        let sigma = self.sigma(params);
+        let lambda_ticked = self.lambda_ticked(params);
+        let sigma_ticked = self.sigma_ticked(params);

        let reward = params.performance()
            * params.epoch_reward_pool()
-            * (sigma * params.omega()
-                + params.alpha() * lambda * sigma * params.rewarded_set_size())
+            * (sigma_ticked * params.omega()
+                + params.alpha() * lambda_ticked * sigma_ticked * params.rewarded_set_size())
            / (ONE + params.alpha());

+        // we only need regular lambda and sigma to calculate operator and delegator rewards
        NodeRewardResult {
            reward,
-            lambda,
-            sigma,
+            lambda: self.lambda(params),
+            sigma: self.sigma(params),
        }
    }

    pub fn node_profit(&self, params: &RewardParams) -> U128 {
-        if self.reward(params).reward() < params.node.operator_cost() {
-            U128::from_num(0u128)
-        } else {
-            self.reward(params).reward() - params.node.operator_cost()
-        }
+        self.reward(params)
+            .reward()
+            .saturating_sub(params.node.operator_cost())
    }

    pub fn operator_reward(&self, params: &RewardParams) -> u128 {
@@ -474,11 +501,9 @@ impl MixNodeBond {
        if reward.sigma == 0 {
            return 0;
        }
-        let profit = if reward.reward < params.node.operator_cost() {
-            U128::from_num(0u128)
-        } else {
-            reward.reward - params.node.operator_cost()
-        };
+
+        let profit = reward.reward.saturating_sub(params.node.operator_cost());
+
        let operator_base_reward = reward.reward.min(params.node.operator_cost());
        // Div by zero checked above
        let operator_reward = (self.profit_margin()
@@ -99,6 +99,17 @@ pub enum ExecuteMsg {
    },
    // AdvanceCurrentInterval {},
    AdvanceCurrentEpoch {},
+    ClaimOperatorReward {},
+    ClaimOperatorRewardOnBehalf {
+        owner: String,
+    },
+    ClaimDelegatorReward {
+        mix_identity: IdentityKey,
+    },
+    ClaimDelegatorRewardOnBehalf {
+        mix_identity: IdentityKey,
+        owner: String,
+    },
 }

 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
@@ -42,7 +42,7 @@ impl NodeEpochRewards {
    }

    pub fn operator_cost(&self) -> U128 {
-        U128::from_num(self.params.uptime.u128() / 100u128 * DEFAULT_OPERATOR_INTERVAL_COST as u128)
+        self.params.operator_cost()
    }

    pub fn node_profit(&self) -> U128 {
@@ -178,11 +178,15 @@ impl NodeRewardParams {
    }

    pub fn operator_cost(&self) -> U128 {
-        U128::from_num(self.uptime.u128() / 100u128 * DEFAULT_OPERATOR_INTERVAL_COST as u128)
+        self.performance() * U128::from_num(DEFAULT_OPERATOR_INTERVAL_COST)
    }

-    pub fn uptime(&self) -> u128 {
-        self.uptime.u128()
+    pub fn uptime(&self) -> Uint128 {
+        self.uptime
+    }
+
+    pub fn performance(&self) -> U128 {
+        U128::from_num(self.uptime.u128()) / U128::from_num(100)
    }

    pub fn set_reward_blockstamp(&mut self, blockstamp: u64) {
@@ -233,7 +237,7 @@ impl RewardParams {
    }

    pub fn performance(&self) -> U128 {
-        U128::from_num(self.node.uptime.u128()) / U128::from_num(100)
+        self.node.performance()
    }

    pub fn set_reward_blockstamp(&mut self, blockstamp: u64) {
@@ -256,8 +260,8 @@ impl RewardParams {
        self.node.reward_blockstamp
    }

-    pub fn uptime(&self) -> u128 {
-        self.node.uptime.u128()
+    pub fn uptime(&self) -> Uint128 {
+        self.node.uptime()
    }

    pub fn one_over_k(&self) -> U128 {
@@ -0,0 +1,14 @@
+[package]
+name = "multisig-contract-common"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+cw-utils = { version = "0.13.1" }
+cw3 = { version = "0.13.1" }
+cw4 = { version = "0.13.1" }
+cosmwasm-std = "1.0.0"
+schemars = "0.8"
+serde = { version = "1.0.103", default-features = false, features = ["derive"] }
@@ -0,0 +1 @@
+pub mod msg;
@@ -1,7 +1,11 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};

 use cosmwasm_std::{CosmosMsg, Empty};
+pub use cw3::ProposalResponse;
 use cw3::Vote;
 use cw4::MemberChangedHookMsg;
 use cw_utils::{Duration, Expiration, Threshold};
@@ -6,12 +6,13 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [dependencies]
-cosmwasm-std = "1.0.0-beta8"
+cosmwasm-std = "1.0.0"
 mixnet-contract-common = { path = "../mixnet-contract" }
 serde = { version = "1.0", features = ["derive"] }
 schemars = "0.8"
-cw-storage-plus = "0.13.2"
+cw-storage-plus = "0.13.4"
 config = { path = "../../config" }
-
-[dev-dependencies]
 ts-rs = "6.1.2"
+
+[features]
+generate-ts = []
@@ -20,6 +20,7 @@ pub const VESTING_UPDATE_MIXNODE_CONFIG_EVENT_TYPE: &str = "vesting_update_mixno
 pub const TRACK_MIXNODE_UNBOND_EVENT_TYPE: &str = "track_mixnode_unbond";
 pub const TRACK_GATEWAY_UNBOND_EVENT_TYPE: &str = "track_gateway_unbond";
 pub const TRACK_UNDELEGATION_EVENT_TYPE: &str = "track_undelegation";
+pub const TRACK_REWARD_EVENT_TYPE: &str = "track_reaward";

 // attributes that are used in multiple places
 pub const OWNER_KEY: &str = "owner";
@@ -136,3 +137,7 @@ pub fn new_track_gateway_unbond_event() -> Event {
 pub fn new_track_undelegation_event() -> Event {
    Event::new(TRACK_UNDELEGATION_EVENT_TYPE)
 }
+
+pub fn new_track_reward_event() -> Event {
+    Event::new(TRACK_REWARD_EVENT_TYPE)
+}
@@ -1,21 +1,23 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
-use config::defaults::DENOM;
+use config::defaults::MIX_DENOM;
 use cosmwasm_std::{Coin, Timestamp};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};

+pub use messages::{ExecuteMsg, InitMsg, MigrateMsg, QueryMsg};
+
 pub mod events;
 pub mod messages;

 pub fn one_ucoin() -> Coin {
-    Coin::new(1, DENOM)
+    Coin::new(1, MIX_DENOM.base)
 }

-#[cfg_attr(test, derive(ts_rs::TS))]
+#[cfg_attr(feature = "generate-ts", derive(ts_rs::TS))]
 #[cfg_attr(
-    test,
-    ts(export, export_to = "../../../nym-wallet/src/types/rust/period.ts")
+    feature = "generate-ts",
+    ts(export_to = "ts-packages/types/src/types/rust/Period.ts")
 )]
 #[derive(Debug, PartialEq, Serialize, Deserialize, Clone, JsonSchema)]
 pub enum Period {
@@ -26,8 +28,8 @@ pub enum Period {

 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
 pub struct PledgeData {
-    amount: Coin,
-    block_time: Timestamp,
+    pub amount: Coin,
+    pub block_time: Timestamp,
 }

 impl PledgeData {
@@ -46,9 +48,9 @@ impl PledgeData {

 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
 pub struct OriginalVestingResponse {
-    amount: Coin,
-    number_of_periods: usize,
-    period_duration: u64,
+    pub amount: Coin,
+    pub number_of_periods: usize,
+    pub period_duration: u64,
 }

 impl OriginalVestingResponse {
@@ -49,6 +49,14 @@ impl VestingSpecification {
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub enum ExecuteMsg {
+    TrackReward {
+        amount: Coin,
+        address: String,
+    },
+    ClaimOperatorReward {},
+    ClaimDelegatorReward {
+        mix_identity: String,
+    },
    CompoundDelegatorReward {
        mix_identity: String,
    },
@@ -12,9 +12,9 @@ nymcoconut = { path = "../nymcoconut" }
 log = "0.4"
 sqlx = { version = "0.5", features = ["runtime-tokio-rustls", "sqlite", "macros", "migrate"]}
 thiserror = "1.0"
-tokio = { version = "1.4", features = [ "rt-multi-thread", "net", "signal", "fs" ] }
+tokio = { version = "1.19.1", features = [ "rt-multi-thread", "net", "signal", "fs" ] }


 [build-dependencies]
 sqlx = { version = "0.5", features = ["runtime-tokio-rustls", "sqlite", "macros", "migrate"] }
-tokio = { version = "1.4", features = ["rt-multi-thread", "macros"] }
+tokio = { version = "1.19.1", features = ["rt-multi-thread", "macros"] }
@@ -7,7 +7,7 @@ edition = "2021"

 [dependencies]
 bls12_381 = { version = "0.5", default-features = false, features = ["pairings", "alloc", "experimental"] }
-cosmrs = { version = "0.4.1", optional = true }
+cosmrs = { version = "0.7.0", optional = true }
 thiserror = "1.0"
 url = "2.2"

@@ -204,7 +204,10 @@ mod test {
                    .to_base58_string(),
            )
            .unwrap(),
-            encryption::KeyPair::new(&mut rng).private_key().clone(),
+            encryption::PrivateKey::from_bytes(
+                &encryption::KeyPair::new(&mut rng).private_key().to_bytes(),
+            )
+            .unwrap(),
        );
        assert!(!BandwidthVoucher::verify_against_plain(
            &[],
@@ -51,12 +51,7 @@ pub async fn obtain_aggregate_verification_key(
    let mut shares = Vec::with_capacity(validators.len());

    let mut client = validator_client::ApiClient::new(validators[0].clone());
-    let response = client.get_coconut_verification_key().await?;
-
-    indices.push(1);
-    shares.push(response.key);
-
-    for (id, validator_url) in validators.iter().enumerate().skip(1) {
+    for (id, validator_url) in validators.iter().enumerate() {
        client.change_validator_api(validator_url.clone());
        let response = client.get_coconut_verification_key().await?;
        indices.push((id + 1) as u64);
@@ -135,14 +130,7 @@ pub async fn obtain_aggregate_signature(
    let mut validators_partial_vks: Vec<VerificationKey> = Vec::with_capacity(validators.len());

    let mut client = validator_client::ApiClient::new(validators[0].clone());
-    let validator_partial_vk = client.get_coconut_verification_key().await?;
-    validators_partial_vks.push(validator_partial_vk.key.clone());
-
-    let first =
-        obtain_partial_credential(params, attributes, &client, &validator_partial_vk.key).await?;
-    shares.push(SignatureShare::new(first, 1));
-
-    for (id, validator_url) in validators.iter().enumerate().skip(1) {
+    for (id, validator_url) in validators.iter().enumerate() {
        client.change_validator_api(validator_url.clone());
        let validator_partial_vk = client.get_coconut_verification_key().await?;
        validators_partial_vks.push(validator_partial_vk.key.clone());
@@ -193,8 +181,7 @@ pub fn prepare_credential_for_spending(
    Ok(Credential::new(
        PUBLIC_ATTRIBUTES + PRIVATE_ATTRIBUTES,
        theta,
-        voucher_value.to_string(),
+        voucher_value,
        voucher_info,
-        signature,
    ))
 }
@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0

 #[cfg(feature = "coconut")]
-use coconut_interface::{error::CoconutInterfaceError, CoconutError};
+use coconut_interface::CoconutError;
 use crypto::asymmetric::encryption::KeyRecoveryError;
 use validator_client::ValidatorClientError;

@@ -20,10 +20,6 @@ pub enum Error {
    #[error("Ran into a coconut error - {0}")]
    CoconutError(#[from] CoconutError),

-    #[cfg(feature = "coconut")]
-    #[error("Ran into a coconut interface error - {0}")]
-    CoconutInterfaceError(#[from] CoconutInterfaceError),
-
    #[error("Ran into a validator client error - {0}")]
    ValidatorClientError(#[from] ValidatorClientError),

@@ -19,6 +19,8 @@ cipher = { version = "0.4.3", optional = true }
 x25519-dalek = { version = "1.1", optional = true }
 ed25519-dalek = { version = "1.0", optional = true }
 rand = { version = "0.7.3", features = ["wasm-bindgen"], optional = true }
+serde_bytes = { version = "0.11.6", optional = true }
+serde_crate = { version = "1.0", optional = true, default_features = false, package = "serde" }
 subtle-encoding = { version = "0.5", features =  ["bech32-preview"]}

 # internal
@@ -30,6 +32,7 @@ config = { path="../../common/config" }
 rand_chacha = "0.2"

 [features]
+serde = ["serde_crate", "serde_bytes", "ed25519-dalek/serde", "x25519-dalek/serde"]
 asymmetric = ["x25519-dalek", "ed25519-dalek"]
 hashing = ["blake3", "digest", "hkdf", "hmac", "generic-array"]
 symmetric = ["aes", "ctr", "cipher", "generic-array"]
@@ -4,6 +4,8 @@
 use pemstore::traits::{PemStorableKey, PemStorableKeyPair};
 #[cfg(feature = "rand")]
 use rand::{CryptoRng, RngCore};
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use std::fmt::{self, Display, Formatter};

 /// Size of a X25519 private key
@@ -127,6 +129,28 @@ impl PublicKey {
    }
 }

+#[cfg(feature = "serde")]
+impl Serialize for PublicKey {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.0.serialize(serializer)
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'d> Deserialize<'d> for PublicKey {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'d>,
+    {
+        Ok(PublicKey(x25519_dalek::PublicKey::deserialize(
+            deserializer,
+        )?))
+    }
+}
+
 impl PemStorableKey for PublicKey {
    type Error = KeyRecoveryError;

@@ -143,7 +167,6 @@ impl PemStorableKey for PublicKey {
    }
 }

-#[derive(Clone)]
 pub struct PrivateKey(x25519_dalek::StaticSecret);

 impl Display for PrivateKey {
@@ -187,6 +210,28 @@ impl PrivateKey {
    }
 }

+#[cfg(feature = "serde")]
+impl Serialize for PrivateKey {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.0.serialize(serializer)
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'d> Deserialize<'d> for PrivateKey {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'d>,
+    {
+        Ok(PrivateKey(x25519_dalek::StaticSecret::deserialize(
+            deserializer,
+        )?))
+    }
+}
+
 impl PemStorableKey for PrivateKey {
    type Error = KeyRecoveryError;

@@ -10,6 +10,13 @@ use pemstore::traits::{PemStorableKey, PemStorableKeyPair};
 use rand::{CryptoRng, RngCore};
 use std::fmt::{self, Display, Formatter};

+#[cfg(feature = "serde")]
+use serde::de::Error as SerdeError;
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+#[cfg(feature = "serde")]
+use serde_bytes::{ByteBuf as SerdeByteBuf, Bytes as SerdeBytes};
+
 #[derive(Debug)]
 pub enum Ed25519RecoveryError {
    MalformedBytes(SignatureError),
@@ -40,6 +47,7 @@ impl fmt::Display for Ed25519RecoveryError {
 impl std::error::Error for Ed25519RecoveryError {}

 /// Keypair for usage in ed25519 EdDSA.
+#[derive(Debug)]
 pub struct KeyPair {
    private_key: PrivateKey,
    public_key: PublicKey,
@@ -135,6 +143,28 @@ impl PublicKey {
    }
 }

+#[cfg(feature = "serde")]
+impl Serialize for PublicKey {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.0.serialize(serializer)
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'d> Deserialize<'d> for PublicKey {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'d>,
+    {
+        Ok(PublicKey(ed25519_dalek::PublicKey::deserialize(
+            deserializer,
+        )?))
+    }
+}
+
 impl PemStorableKey for PublicKey {
    type Error = Ed25519RecoveryError;

@@ -200,6 +230,28 @@ impl PrivateKey {
    }
 }

+#[cfg(feature = "serde")]
+impl Serialize for PrivateKey {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.0.serialize(serializer)
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'d> Deserialize<'d> for PrivateKey {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'d>,
+    {
+        Ok(PrivateKey(ed25519_dalek::SecretKey::deserialize(
+            deserializer,
+        )?))
+    }
+}
+
 impl PemStorableKey for PrivateKey {
    type Error = Ed25519RecoveryError;

@@ -216,7 +268,7 @@ impl PemStorableKey for PrivateKey {
    }
 }

-#[derive(Debug)]
+#[derive(Copy, Clone, Debug)]
 pub struct Signature(ed25519_dalek::Signature);

 impl Signature {
@@ -237,3 +289,24 @@ impl Signature {
        Ok(Signature(ed25519_dalek::Signature::from_bytes(bytes)?))
    }
 }
+
+#[cfg(feature = "serde")]
+impl Serialize for Signature {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        SerdeBytes::new(&self.to_bytes()).serialize(serializer)
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'d> Deserialize<'d> for Signature {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'d>,
+    {
+        let bytes = <SerdeByteBuf>::deserialize(deserializer)?;
+        Signature::from_bytes(bytes.as_ref()).map_err(SerdeError::custom)
+    }
+}
@@ -29,5 +29,5 @@ pub use blake3;
 #[cfg(feature = "symmetric")]
 pub use ctr;

-// TODO: this function uses all three modules: asymmetric crypto, symmetric crypto and derives key...,
-// so I don't know where to put it...
+#[cfg(feature = "serde")]
+extern crate serde_crate as serde;
@@ -0,0 +1,11 @@
+[package]
+name = "execute"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+syn = { version = "1", features = ["full"] }
+quote = "1"
@@ -0,0 +1,110 @@
+use proc_macro::TokenStream;
+use quote::quote;
+use syn::{
+    parse_macro_input, Block, ExprMethodCall, FnArg, Ident, ItemFn, LitStr, ReturnType, Token,
+    VisPublic, Visibility,
+};
+
+#[proc_macro_attribute]
+pub fn execute(attr: TokenStream, item: TokenStream) -> TokenStream {
+    let f = parse_macro_input!(item as ItemFn);
+    let target = parse_macro_input!(attr as LitStr).value();
+
+    let cl = if target == "mixnet" {
+        quote! {self.mixnet_contract_address()}
+    } else if target == "vesting" {
+        quote! {self.vesting_contract_address()}
+    } else {
+        panic!("Only `mixnet` and `vesting` targets are supported!")
+    };
+    let cl = proc_macro::TokenStream::from(cl);
+    let cl = parse_macro_input!(cl as ExprMethodCall);
+
+    let orig_f = f.clone();
+    let mut execute_f = f.clone();
+    let mut simulate_f = f.clone();
+    let name = f.sig.ident;
+    let name_str = name.to_string();
+    let call_args = f.sig.inputs.into_iter().filter_map(|arg| match arg {
+        FnArg::Receiver(_) => None,
+        FnArg::Typed(arg) => Some(arg.pat),
+    });
+    let execute_args = call_args.clone();
+    let simulate_args = call_args;
+
+    execute_f.sig.asyncness = Some(Token![async](execute_f.sig.ident.span()));
+    simulate_f.sig.asyncness = Some(Token![async](simulate_f.sig.ident.span()));
+
+    execute_f.vis = Visibility::Public(VisPublic {
+        pub_token: Token![pub](execute_f.sig.ident.span()),
+    });
+    simulate_f.vis = Visibility::Public(VisPublic {
+        pub_token: Token![pub](simulate_f.sig.ident.span()),
+    });
+
+    execute_f.sig.ident = Ident::new(
+        &format!("execute{}", execute_f.sig.ident),
+        execute_f.sig.ident.span(),
+    );
+
+    simulate_f.sig.ident = Ident::new(
+        &format!("simulate{}", simulate_f.sig.ident),
+        simulate_f.sig.ident.span(),
+    );
+
+    let execute_output = quote! {
+        -> Result<ExecuteResult, NymdError>
+    };
+    let o_ts = proc_macro::TokenStream::from(execute_output);
+    execute_f.sig.output = parse_macro_input!(o_ts as ReturnType);
+
+    let simulate_output = quote! {
+        -> Result<SimulateResponse, NymdError>
+    };
+    let o_ts = proc_macro::TokenStream::from(simulate_output);
+    simulate_f.sig.output = parse_macro_input!(o_ts as ReturnType);
+
+    let simulate_block = quote! {
+        {
+            let (msg, _fee) = self.#name(#(#simulate_args),*);
+            let msg = self.wrap_contract_execute_message(
+                #cl,
+                &msg,
+                vec![],
+            )?;
+
+            self.simulate(vec![msg]).await
+        }
+    };
+
+    let ts = proc_macro::TokenStream::from(simulate_block);
+    simulate_f.block = Box::new(parse_macro_input!(ts as Block));
+
+    let execute_block = quote! {
+        {
+            let (req, fee) = self.#name(#(#execute_args),*);
+            let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier)));
+            self.client
+                .execute(
+                    self.address(),
+                    #cl,
+                    &req,
+                    fee,
+                    #name_str,
+                    vec![],
+                )
+                .await
+        }
+    };
+
+    let ts = proc_macro::TokenStream::from(execute_block);
+    execute_f.block = Box::new(parse_macro_input!(ts as Block));
+
+    let out = quote! {
+        #orig_f
+        #execute_f
+        #simulate_f
+    };
+
+    out.into()
+}
@@ -14,8 +14,8 @@ humantime-serde = "1.0"
 log = "0.4"
 rand = "0.8"
 serde = { version = "1.0", features = ["derive"] }
-tokio = { version = "1.4", features = ["time", "macros", "rt", "net", "io-util"] }
-tokio-util = { version = "0.6", features = ["codec"] }
+tokio = { version = "1.19.1", features = ["time", "macros", "rt", "net", "io-util"] }
+tokio-util = { version = "0.7.3", features = ["codec"] }
 url = "2.2"

 crypto =  { path = "../crypto" }
@@ -5,7 +5,8 @@ use serde::{Deserialize, Serialize};
 use std::{collections::HashMap, fmt, str::FromStr};

 use crate::{
-    DefaultNetworkDetails, ValidatorDetails, MAINNET_DEFAULTS, QA_DEFAULTS, SANDBOX_DEFAULTS,
+    DefaultNetworkDetails, DenomDetails, DenomDetailsOwned, ValidatorDetails, MAINNET_DEFAULTS,
+    QA_DEFAULTS, SANDBOX_DEFAULTS,
 };

 use thiserror::Error;
@@ -24,7 +25,7 @@ pub enum Network {
 }

 impl Network {
-    fn details(&self) -> &DefaultNetworkDetails<'_> {
+    fn details(&self) -> &DefaultNetworkDetails {
        match self {
            Self::QA => &QA_DEFAULTS,
            Self::SANDBOX => &SANDBOX_DEFAULTS,
@@ -36,8 +37,12 @@ impl Network {
        self.details().bech32_prefix
    }

-    pub fn denom(&self) -> &str {
-        self.details().denom
+    pub fn mix_denom(&self) -> &DenomDetails {
+        &self.details().mix_denom
+    }
+
+    pub fn stake_denom(&self) -> &DenomDetails {
+        &self.details().stake_denom
    }

    pub fn mixnet_contract_address(&self) -> &str {
@@ -52,12 +57,16 @@ impl Network {
        self.details().bandwidth_claim_contract_address
    }

-    pub fn rewarding_validator_address(&self) -> &str {
-        self.details().rewarding_validator_address
+    pub fn coconut_bandwidth_contract_address(&self) -> &str {
+        self.details().coconut_bandwidth_contract_address
    }

-    pub fn stats_provider_network_address(&self) -> &str {
-        self.details().stats_provider_network_address
+    pub fn multisig_contract_address(&self) -> &str {
+        self.details().multisig_contract_address
+    }
+
+    pub fn rewarding_validator_address(&self) -> &str {
+        self.details().rewarding_validator_address
    }

    pub fn validators(&self) -> impl Iterator<Item = &ValidatorDetails> {
@@ -93,28 +102,34 @@ impl fmt::Display for Network {
 #[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)]
 pub struct NetworkDetails {
    bech32_prefix: String,
-    denom: String,
+    mix_denom: DenomDetailsOwned,
+    stake_denom: DenomDetailsOwned,
    mixnet_contract_address: String,
    vesting_contract_address: String,
    bandwidth_claim_contract_address: String,
-    rewarding_validator_address: String,
    validators: Vec<ValidatorDetails>,
 }

-impl From<&DefaultNetworkDetails<'_>> for NetworkDetails {
-    fn from(details: &DefaultNetworkDetails<'_>) -> Self {
+impl From<&DefaultNetworkDetails> for NetworkDetails {
+    fn from(details: &DefaultNetworkDetails) -> Self {
        NetworkDetails {
            bech32_prefix: details.bech32_prefix.into(),
-            denom: details.denom.into(),
+            mix_denom: details.mix_denom.into(),
+            stake_denom: details.stake_denom.into(),
            mixnet_contract_address: details.mixnet_contract_address.into(),
            vesting_contract_address: details.vesting_contract_address.into(),
            bandwidth_claim_contract_address: details.bandwidth_claim_contract_address.into(),
-            rewarding_validator_address: details.rewarding_validator_address.into(),
            validators: details.validators.clone(),
        }
    }
 }

+impl NetworkDetails {
+    pub fn base_mix_denom(&self) -> &str {
+        &self.mix_denom.base
+    }
+}
+
 #[derive(Clone, Debug, Default, Deserialize, Serialize, PartialEq, Eq)]
 pub struct SupportedNetworks {
    networks: HashMap<Network, NetworkDetails>,
@@ -139,7 +154,7 @@ impl SupportedNetworks {
    pub fn denom(&self, network: Network) -> Option<&str> {
        self.networks
            .get(&network)
-            .map(|network_details| network_details.denom.as_str())
+            .map(|network_details| network_details.base_mix_denom())
    }

    pub fn mixnet_contract_address(&self, network: Network) -> Option<&str> {
@@ -160,12 +175,6 @@ impl SupportedNetworks {
            .map(|network_details| network_details.bandwidth_claim_contract_address.as_str())
    }

-    pub fn rewarding_validator_address(&self, network: Network) -> Option<&str> {
-        self.networks
-            .get(&network)
-            .map(|network_details| network_details.rewarding_validator_address.as_str())
-    }
-
    pub fn validators(&self, network: Network) -> impl Iterator<Item = &ValidatorDetails> {
        self.networks
            .get(&network)
@@ -17,21 +17,24 @@ pub mod sandbox;
 cfg_if::cfg_if! {
    if #[cfg(network = "mainnet")] {
        pub const DEFAULT_NETWORK: all::Network = all::Network::MAINNET;
-        pub const DENOM: &str = mainnet::DENOM;
+        pub const MIX_DENOM: DenomDetails = mainnet::MIX_DENOM;
+        pub const STAKE_DENOM: DenomDetails = mainnet::STAKE_DENOM;

        pub const ETH_CONTRACT_ADDRESS: [u8; 20] = mainnet::_ETH_CONTRACT_ADDRESS;
        pub const ETH_ERC20_CONTRACT_ADDRESS: [u8; 20] = mainnet::_ETH_ERC20_CONTRACT_ADDRESS;

    } else if #[cfg(network = "qa")] {
        pub const DEFAULT_NETWORK: all::Network = all::Network::QA;
-        pub const DENOM: &str = qa::DENOM;
+        pub const MIX_DENOM: DenomDetails = qa::MIX_DENOM;
+        pub const STAKE_DENOM: DenomDetails = qa::STAKE_DENOM;

        pub const ETH_CONTRACT_ADDRESS: [u8; 20] = qa::_ETH_CONTRACT_ADDRESS;
        pub const ETH_ERC20_CONTRACT_ADDRESS: [u8; 20] = qa::_ETH_ERC20_CONTRACT_ADDRESS;

    } else if #[cfg(network = "sandbox")] {
        pub const DEFAULT_NETWORK: all::Network = all::Network::SANDBOX;
-        pub const DENOM: &str = sandbox::DENOM;
+        pub const MIX_DENOM: DenomDetails = sandbox::MIX_DENOM;
+        pub const STAKE_DENOM: DenomDetails = sandbox::STAKE_DENOM;

        pub const ETH_CONTRACT_ADDRESS: [u8; 20] = sandbox::_ETH_CONTRACT_ADDRESS;
        pub const ETH_ERC20_CONTRACT_ADDRESS: [u8; 20] = sandbox::_ETH_ERC20_CONTRACT_ADDRESS;
@@ -42,52 +45,94 @@ cfg_if::cfg_if! {
 // future. If we do this, and also get rid of the references we could potentially unify with
 // `NetworkDetails`.
 #[derive(Debug)]
-pub struct DefaultNetworkDetails<'a> {
-    bech32_prefix: &'a str,
-    denom: &'a str,
-    mixnet_contract_address: &'a str,
-    vesting_contract_address: &'a str,
-    bandwidth_claim_contract_address: &'a str,
-    rewarding_validator_address: &'a str,
-    stats_provider_network_address: &'a str,
+pub struct DefaultNetworkDetails {
+    bech32_prefix: &'static str,
+    mix_denom: DenomDetails,
+    stake_denom: DenomDetails,
+    mixnet_contract_address: &'static str,
+    vesting_contract_address: &'static str,
+    bandwidth_claim_contract_address: &'static str,
+    coconut_bandwidth_contract_address: &'static str,
+    multisig_contract_address: &'static str,
+    rewarding_validator_address: &'static str,
    validators: Vec<ValidatorDetails>,
 }

-static MAINNET_DEFAULTS: Lazy<DefaultNetworkDetails<'static>> =
-    Lazy::new(|| DefaultNetworkDetails {
-        bech32_prefix: mainnet::BECH32_PREFIX,
-        denom: mainnet::DENOM,
-        mixnet_contract_address: mainnet::MIXNET_CONTRACT_ADDRESS,
-        vesting_contract_address: mainnet::VESTING_CONTRACT_ADDRESS,
-        bandwidth_claim_contract_address: mainnet::BANDWIDTH_CLAIM_CONTRACT_ADDRESS,
-        rewarding_validator_address: mainnet::REWARDING_VALIDATOR_ADDRESS,
-        stats_provider_network_address: mainnet::STATS_PROVIDER_CLIENT_ADDRESS,
-        validators: mainnet::validators(),
-    });
+static MAINNET_DEFAULTS: Lazy<DefaultNetworkDetails> = Lazy::new(|| DefaultNetworkDetails {
+    bech32_prefix: mainnet::BECH32_PREFIX,
+    mix_denom: mainnet::MIX_DENOM,
+    stake_denom: mainnet::STAKE_DENOM,
+    mixnet_contract_address: mainnet::MIXNET_CONTRACT_ADDRESS,
+    vesting_contract_address: mainnet::VESTING_CONTRACT_ADDRESS,
+    bandwidth_claim_contract_address: mainnet::BANDWIDTH_CLAIM_CONTRACT_ADDRESS,
+    coconut_bandwidth_contract_address: mainnet::COCONUT_BANDWIDTH_CONTRACT_ADDRESS,
+    multisig_contract_address: mainnet::MULTISIG_CONTRACT_ADDRESS,
+    rewarding_validator_address: mainnet::REWARDING_VALIDATOR_ADDRESS,
+    validators: mainnet::validators(),
+});

-static SANDBOX_DEFAULTS: Lazy<DefaultNetworkDetails<'static>> =
-    Lazy::new(|| DefaultNetworkDetails {
-        bech32_prefix: sandbox::BECH32_PREFIX,
-        denom: sandbox::DENOM,
-        mixnet_contract_address: sandbox::MIXNET_CONTRACT_ADDRESS,
-        vesting_contract_address: sandbox::VESTING_CONTRACT_ADDRESS,
-        bandwidth_claim_contract_address: sandbox::BANDWIDTH_CLAIM_CONTRACT_ADDRESS,
-        rewarding_validator_address: sandbox::REWARDING_VALIDATOR_ADDRESS,
-        stats_provider_network_address: sandbox::STATS_PROVIDER_CLIENT_ADDRESS,
-        validators: sandbox::validators(),
-    });
+static SANDBOX_DEFAULTS: Lazy<DefaultNetworkDetails> = Lazy::new(|| DefaultNetworkDetails {
+    bech32_prefix: sandbox::BECH32_PREFIX,
+    mix_denom: sandbox::MIX_DENOM,
+    stake_denom: sandbox::STAKE_DENOM,
+    mixnet_contract_address: sandbox::MIXNET_CONTRACT_ADDRESS,
+    vesting_contract_address: sandbox::VESTING_CONTRACT_ADDRESS,
+    bandwidth_claim_contract_address: sandbox::BANDWIDTH_CLAIM_CONTRACT_ADDRESS,
+    coconut_bandwidth_contract_address: sandbox::COCONUT_BANDWIDTH_CONTRACT_ADDRESS,
+    multisig_contract_address: sandbox::MULTISIG_CONTRACT_ADDRESS,
+    rewarding_validator_address: sandbox::REWARDING_VALIDATOR_ADDRESS,
+    validators: sandbox::validators(),
+});

-static QA_DEFAULTS: Lazy<DefaultNetworkDetails<'static>> = Lazy::new(|| DefaultNetworkDetails {
+static QA_DEFAULTS: Lazy<DefaultNetworkDetails> = Lazy::new(|| DefaultNetworkDetails {
    bech32_prefix: qa::BECH32_PREFIX,
-    denom: qa::DENOM,
+    mix_denom: qa::MIX_DENOM,
+    stake_denom: qa::STAKE_DENOM,
    mixnet_contract_address: qa::MIXNET_CONTRACT_ADDRESS,
    vesting_contract_address: qa::VESTING_CONTRACT_ADDRESS,
    bandwidth_claim_contract_address: qa::BANDWIDTH_CLAIM_CONTRACT_ADDRESS,
+    coconut_bandwidth_contract_address: qa::COCONUT_BANDWIDTH_CONTRACT_ADDRESS,
+    multisig_contract_address: qa::MULTISIG_CONTRACT_ADDRESS,
    rewarding_validator_address: qa::REWARDING_VALIDATOR_ADDRESS,
-    stats_provider_network_address: qa::STATS_PROVIDER_CLIENT_ADDRESS,
    validators: qa::validators(),
 });

+#[derive(Debug, Copy, Serialize, Deserialize, Clone, PartialEq, Eq)]
+pub struct DenomDetails {
+    pub base: &'static str,
+    pub display: &'static str,
+    // i.e. display_amount * 10^display_exponent = base_amount
+    pub display_exponent: u32,
+}
+
+impl DenomDetails {
+    pub const fn new(base: &'static str, display: &'static str, display_exponent: u32) -> Self {
+        DenomDetails {
+            base,
+            display,
+            display_exponent,
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
+pub struct DenomDetailsOwned {
+    pub base: String,
+    pub display: String,
+    // i.e. display_amount * 10^display_exponent = base_amount
+    pub display_exponent: u32,
+}
+
+impl From<DenomDetails> for DenomDetailsOwned {
+    fn from(details: DenomDetails) -> Self {
+        DenomDetailsOwned {
+            base: details.base.to_owned(),
+            display: details.display.to_owned(),
+            display_exponent: details.display_exponent,
+        }
+    }
+}
+
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
 pub struct ValidatorDetails {
    // it is assumed those values are always valid since they're being provided in our defaults file
@@ -147,7 +192,7 @@ pub const ETH_ERC20_APPROVE_FUNCTION_NAME: &str = "approve";

 // Ethereum constants used for token bridge
 /// How much bandwidth (in bytes) one token can buy
-const BYTES_PER_TOKEN: u64 = 1024 * 1024 * 1024;
+pub const BYTES_PER_UTOKEN: u64 = 1024;

 /// Threshold for claiming more bandwidth: 1 MB
 pub const REMAINING_BANDWIDTH_THRESHOLD: i64 = 1024 * 1024;
@@ -156,7 +201,7 @@ pub const TOKENS_TO_BURN: u64 = 1;
 /// How many ERC20 utokens should be burned to buy bandwidth
 pub const UTOKENS_TO_BURN: u64 = TOKENS_TO_BURN * 1000000;
 /// Default bandwidth (in bytes) that we try to buy
-pub const BANDWIDTH_VALUE: u64 = TOKENS_TO_BURN * BYTES_PER_TOKEN;
+pub const BANDWIDTH_VALUE: u64 = UTOKENS_TO_BURN * BYTES_PER_UTOKEN;

 pub const VOUCHER_INFO: &str = "BandwidthVoucher";

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

-use crate::ValidatorDetails;
+use crate::{DenomDetails, ValidatorDetails};

 pub(crate) const BECH32_PREFIX: &str = "n";
 pub const DENOM: &str = "unym";

+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";
 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 =
+    "n19lc9u84cz0yz3fww5283nucc9yvr8gsjmgeul0";
+pub(crate) const MULTISIG_CONTRACT_ADDRESS: &str = "n19lc9u84cz0yz3fww5283nucc9yvr8gsjmgeul0";
 pub(crate) const _ETH_CONTRACT_ADDRESS: [u8; 20] =
    hex_literal::hex!("0000000000000000000000000000000000000000");
 pub(crate) const _ETH_ERC20_CONTRACT_ADDRESS: [u8; 20] =
    hex_literal::hex!("0000000000000000000000000000000000000000");
 pub(crate) const REWARDING_VALIDATOR_ADDRESS: &str = "n10yyd98e2tuwu0f7ypz9dy3hhjw7v772q6287gy";

-pub(crate) const STATS_PROVIDER_CLIENT_ADDRESS: &str = "3V3me68qkEYNNShSQ5yLkrzC8rUJmcmtrTFbLKPqytEZ.7dGmnRAheEozNeGAsp9LXM8oPgS5YgJraNmYguj2t7Bn@BNjYZPxzcJwczXHHgBxCAyVJKxN6LPteDRrKapxWmexv";
-
 pub(crate) fn validators() -> Vec<ValidatorDetails> {
    vec![ValidatorDetails::new(
        "https://rpc.nyx.nodes.guru/",
@@ -1,25 +1,29 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::ValidatorDetails;
+use crate::{DenomDetails, ValidatorDetails};

 pub(crate) const BECH32_PREFIX: &str = "n";
 pub const DENOM: &str = "unym";

+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 =
    "n1suhgf5svhu4usrurvxzlgn54ksxmn8gljarjtxqnapv8kjnp4nrsd3qaep";
 pub(crate) const VESTING_CONTRACT_ADDRESS: &str =
    "n1xr3rq8yvd7qplsw5yx90ftsr2zdhg4e9z60h5duusgxpv72hud3sjkxkav";
 pub(crate) const BANDWIDTH_CLAIM_CONTRACT_ADDRESS: &str =
    "n19lc9u84cz0yz3fww5283nucc9yvr8gsjmgeul0";
+pub(crate) const COCONUT_BANDWIDTH_CONTRACT_ADDRESS: &str =
+    "n1ghd753shjuwexxywmgs4xz7x2q732vcn7ty4yw";
+pub(crate) const MULTISIG_CONTRACT_ADDRESS: &str = "n17p9rzwnnfxcjp32un9ug7yhhzgtkhvl988qccs";
 pub(crate) const _ETH_CONTRACT_ADDRESS: [u8; 20] =
    hex_literal::hex!("0000000000000000000000000000000000000000");
 pub(crate) const _ETH_ERC20_CONTRACT_ADDRESS: [u8; 20] =
    hex_literal::hex!("0000000000000000000000000000000000000000");
 pub(crate) const REWARDING_VALIDATOR_ADDRESS: &str = "n1tfzd4qz3a45u8p4mr5zmzv66457uwjgcl05jdq";

-pub(crate) const STATS_PROVIDER_CLIENT_ADDRESS: &str = "BLFPkyQ68xtR3TmrUWJZUKJF4SVwJR23wzQEmLHi2QcZ.5zms2X4ANsgY1VB4iC9kTqvbsHWmWUNSuvTtYr4Cp5qT@ExyJVqTSrgHTwzXm2r9RawfF5qYpvZjSVN2dLTs6bnWH";
-
 pub(crate) fn validators() -> Vec<ValidatorDetails> {
    vec![ValidatorDetails::new(
        "https://qa-validator.nymtech.net",
@@ -1,23 +1,27 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::ValidatorDetails;
+use crate::{DenomDetails, ValidatorDetails};

 pub(crate) const BECH32_PREFIX: &str = "nymt";
 pub const DENOM: &str = "unymt";

+pub const MIX_DENOM: DenomDetails = DenomDetails::new("unymt", "nymt", 6);
+pub const STAKE_DENOM: DenomDetails = DenomDetails::new("unyxt", "nyxt", 6);
+
 pub(crate) const MIXNET_CONTRACT_ADDRESS: &str = "nymt1ghd753shjuwexxywmgs4xz7x2q732vcnstz02j";
 pub(crate) const VESTING_CONTRACT_ADDRESS: &str = "nymt14ejqjyq8um4p3xfqj74yld5waqljf88fn549lh";
 pub(crate) const BANDWIDTH_CLAIM_CONTRACT_ADDRESS: &str =
    "nymt17p9rzwnnfxcjp32un9ug7yhhzgtkhvl9f8xzkv";
+pub(crate) const COCONUT_BANDWIDTH_CONTRACT_ADDRESS: &str =
+    "nymt1nz0r0au8aj6dc00wmm3ufy4g4k86rjzlgq608r";
+pub(crate) const MULTISIG_CONTRACT_ADDRESS: &str = "nymt1k8re7jwz6rnnwrktnejdwkwnncte7ek7kk6fvg";
 pub(crate) const _ETH_CONTRACT_ADDRESS: [u8; 20] =
    hex_literal::hex!("8e0DcFF7F3085235C32E845f3667aEB3f1e83133");
 pub(crate) const _ETH_ERC20_CONTRACT_ADDRESS: [u8; 20] =
    hex_literal::hex!("E8883BAeF3869e14E4823F46662e81D4F7d2A81F");
 pub(crate) const REWARDING_VALIDATOR_ADDRESS: &str = "nymt1jh0s6qu6tuw9ut438836mmn7f3f2wencrnmdj4";

-pub(crate) const STATS_PROVIDER_CLIENT_ADDRESS: &str = "HqYWvCcB4sswYiyMj5Q8H5oc71kLf96vfrLK3npM7stH.CoeC5dcqurgdxr5zcgU77nZBSBCc8ntCiwUivQ9TX3KT@E3mvZTHQCdBvhfr178Swx9g4QG3kkRUun7YnToLMcMbM";
-
 pub(crate) fn validators() -> Vec<ValidatorDetails> {
    vec![ValidatorDetails::new(
        "https://sandbox-validator.nymtech.net",
@@ -7,6 +7,6 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [dependencies]
-tokio = { version = "1.4", features = [] }
-tokio-stream = "0.1" # this one seems to be a thing until `Stream` trait is stabilised in stdlib
-tokio-util = { version = "0.6", features = ["time"] }
+tokio = { version = "1.19.1", features = [] }
+tokio-stream = "0.1.9" # this one seems to be a thing until `Stream` trait is stabilised in stdlib
+tokio-util = { version = "0.7.3", features = ["time"] }
@@ -327,8 +327,7 @@ impl ProofCmCs {
    }
 }

-#[derive(Debug)]
-#[cfg_attr(test, derive(PartialEq))]
+#[derive(Debug, PartialEq)]
 pub struct ProofKappaZeta {
    // c
    challenge: Scalar,
@@ -0,0 +1,49 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use bls12_381::G2Projective;
+use group::Curve;
+use std::convert::TryFrom;
+use std::convert::TryInto;
+
+use crate::error::{CoconutError, Result};
+use crate::traits::{Base58, Bytable};
+use crate::utils::try_deserialize_g2_projective;
+
+pub struct BlindedSerialNumber {
+    pub(crate) inner: G2Projective,
+}
+
+impl TryFrom<&[u8]> for BlindedSerialNumber {
+    type Error = CoconutError;
+
+    fn try_from(bytes: &[u8]) -> Result<Self> {
+        if bytes.len() != 96 {
+            return Err(
+                CoconutError::Deserialization(
+                    format!("Tried to deserialize blinded serial number with incorrect number of bytes, expected 96, got {}", bytes.len()),
+                ));
+        }
+
+        let inner = try_deserialize_g2_projective(
+            &bytes.try_into().unwrap(),
+            CoconutError::Deserialization(
+                "failed to deserialize the blinded serial number (zeta)".to_string(),
+            ),
+        )?;
+
+        Ok(BlindedSerialNumber { inner })
+    }
+}
+
+impl Bytable for BlindedSerialNumber {
+    fn to_byte_vec(&self) -> Vec<u8> {
+        self.inner.to_affine().to_compressed().to_vec()
+    }
+
+    fn try_from_byte_slice(slice: &[u8]) -> Result<Self> {
+        Self::try_from(slice)
+    }
+}
+
+impl Base58 for BlindedSerialNumber {}
@@ -19,6 +19,7 @@ use crate::utils::try_deserialize_g1_projective;
 use crate::Attribute;

 pub mod aggregation;
+pub mod double_use;
 pub mod issuance;
 pub mod keygen;
 pub mod setup;
@@ -27,8 +28,7 @@ pub mod verification;
 pub type SignerIndex = u64;

 // (h, s)
-#[derive(Debug, Clone, Copy)]
-#[cfg_attr(test, derive(PartialEq))]
+#[derive(Debug, Clone, Copy, PartialEq)]
 pub struct Signature(pub(crate) G1Projective, pub(crate) G1Projective);

 pub type PartialSignature = Signature;
@@ -10,6 +10,7 @@ use group::{Curve, Group};

 use crate::error::{CoconutError, Result};
 use crate::proofs::ProofKappaZeta;
+use crate::scheme::double_use::BlindedSerialNumber;
 use crate::scheme::setup::Parameters;
 use crate::scheme::Signature;
 use crate::scheme::VerificationKey;
@@ -19,8 +20,7 @@ use crate::Attribute;

 // TODO NAMING: this whole thing
 // Theta
-#[derive(Debug)]
-#[cfg_attr(test, derive(PartialEq))]
+#[derive(Debug, PartialEq)]
 pub struct Theta {
    // blinded_message (kappa)
    pub blinded_message: G2Projective,
@@ -81,6 +81,12 @@ impl Theta {
        )
    }

+    pub fn has_blinded_serial_number(&self, blinded_serial_number_bs58: &str) -> Result<bool> {
+        let blinded_serial_number = BlindedSerialNumber::try_from_bs58(blinded_serial_number_bs58)?;
+        let ret = self.blinded_serial_number.eq(&blinded_serial_number.inner);
+        Ok(ret)
+    }
+
    // blinded message (kappa)  || blinded serial number (zeta) || credential || pi_v
    pub fn to_bytes(&self) -> Vec<u8> {
        let blinded_message_bytes = self.blinded_message.to_affine().to_compressed();
@@ -100,6 +106,13 @@ impl Theta {
    pub fn from_bytes(bytes: &[u8]) -> Result<Theta> {
        Theta::try_from(bytes)
    }
+
+    pub fn blinded_serial_number_bs58(&self) -> String {
+        let blinded_serial_nuumber = BlindedSerialNumber {
+            inner: self.blinded_serial_number,
+        };
+        blinded_serial_nuumber.to_bs58()
+    }
 }

 impl Bytable for Theta {
@@ -33,5 +33,5 @@ mixnet-contract-common = { path = "../cosmwasm-smart-contracts/mixnet-contract"
 path = "framing"

 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio]
-version = "1.4"
+version = "1.19.1"
 features = ["sync"]
@@ -8,7 +8,7 @@ edition = "2021"

 [dependencies]
 bytes = "1.0"
-tokio-util = { version = "0.6", features = ["codec"] }
+tokio-util = { version = "0.7.3", features = ["codec"] }

 nymsphinx-types = { path = "../types" }
 nymsphinx-params = { path = "../params" }
@@ -8,8 +8,8 @@ edition = "2021"

 [dependencies]
 bytes = "1.0"
-tokio = { version = "1.4", features = [ "net", "io-util", "sync", "macros", "time", "rt-multi-thread" ] }
-tokio-util = { version = "0.6", features = [ "io" ] } # reason for getting this guy is to to able to port to tokio 1.X more quickly by being able to use
+tokio = { version = "1.19.1", features = [ "net", "io-util", "sync", "macros", "time", "rt-multi-thread" ] }
+tokio-util = { version = "0.7.3", features = [ "io" ] } # reason for getting this guy is to to able to port to tokio 1.X more quickly by being able to use
 # their `read_buf` [from the util crate] replacement rather than having to rethink/reimplement `AvailableReader` with the new AsyncRead trait definition.
 # In the long run, the dependency should probably get removed in favour of pure-tokio implementation, but for time being it's fine.
 futures = "0.3"
@@ -18,4 +18,4 @@ socks5-requests = { path = "../requests" }
 ordered-buffer = { path = "../ordered-buffer" }

 [dev-dependencies]
-tokio-test = "0.4"
+tokio-test = "0.4.2"
@@ -32,6 +32,26 @@ impl Message {
    const REQUEST_FLAG: u8 = 0;
    const RESPONSE_FLAG: u8 = 1;

+    pub fn conn_id(&self) -> u64 {
+        match self {
+            Message::Request(req) => match req {
+                Request::Connect(c) => c.conn_id,
+                Request::Send(conn_id, _, _) => *conn_id,
+            },
+            Message::Response(resp) => resp.connection_id,
+        }
+    }
+
+    pub fn size(&self) -> usize {
+        match self {
+            Message::Request(req) => match req {
+                Request::Connect(_) => 0,
+                Request::Send(_, data, _) => data.len(),
+            },
+            Message::Response(resp) => resp.data.len(),
+        }
+    }
+
    pub fn try_from_bytes(b: &[u8]) -> Result<Message, MessageError> {
        if b.is_empty() {
            return Err(MessageError::NoData);
@@ -0,0 +1,15 @@
+# Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+# SPDX-License-Identifier: Apache-2.0
+
+[package]
+name = "statistics"
+version = "1.0.1"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+reqwest = "0.11"
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1"
+thiserror = "1"
@@ -0,0 +1,40 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::error::StatsError;
+use crate::StatsMessage;
+
+pub const DEFAULT_STATISTICS_SERVICE_ADDRESS: &str = "127.0.0.1";
+pub const DEFAULT_STATISTICS_SERVICE_PORT: u16 = 8090;
+
+pub const STATISTICS_SERVICE_VERSION: &str = "/v1";
+pub const STATISTICS_SERVICE_API_STATISTICS: &str = "statistic";
+
+pub fn build_statistics_request_bytes(msg: StatsMessage) -> Result<Vec<u8>, StatsError> {
+    let json_msg = msg.to_json()?;
+
+    let req = reqwest::Request::new(
+        reqwest::Method::POST,
+        reqwest::Url::parse(&format!(
+            "http://{}:{}/{}/{}",
+            DEFAULT_STATISTICS_SERVICE_ADDRESS,
+            DEFAULT_STATISTICS_SERVICE_PORT,
+            STATISTICS_SERVICE_VERSION,
+            STATISTICS_SERVICE_API_STATISTICS
+        ))
+        .unwrap(),
+    );
+    let data = format!(
+        "{} {} {:?}\n\
+        Content-Type: application/json\n\
+        Content-Length: {}\n\n\
+        {}\n",
+        req.method().as_str(),
+        req.url().as_str(),
+        req.version(),
+        json_msg.len(),
+        json_msg
+    );
+
+    Ok(data.into_bytes())
+}
@@ -0,0 +1,10 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum StatsError {
+    #[error("Serde JSON error: {0}")]
+    SerdeJsonError(#[from] serde_json::Error),
+}
@@ -0,0 +1,43 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use serde::{Deserialize, Serialize};
+
+use error::StatsError;
+
+pub mod api;
+pub mod error;
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct StatsMessage {
+    pub stats_data: Vec<StatsServiceData>,
+    pub interval_seconds: u32,
+    pub timestamp: String,
+}
+
+impl StatsMessage {
+    pub fn to_json(&self) -> Result<String, StatsError> {
+        Ok(serde_json::to_string(self)?)
+    }
+
+    pub fn from_json(s: &str) -> Result<Self, StatsError> {
+        Ok(serde_json::from_str(s)?)
+    }
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct StatsServiceData {
+    pub requested_service: String,
+    pub request_bytes: u32,
+    pub response_bytes: u32,
+}
+
+impl StatsServiceData {
+    pub fn new(requested_service: String, request_bytes: u32, response_bytes: u32) -> Self {
+        StatsServiceData {
+            requested_service,
+            request_bytes,
+            response_bytes,
+        }
+    }
+}
--- a/Show More
+++ b/Show More