Put circulating supply back as Option

Merge pull request #1363 from nymtech/feature/reorder-delegation-table-columns
reorder delegation table columns
2022-06-15 00:03:13 +02:00 · 2022-06-14 18:40:14 +01:00 · 2022-06-14 17:21:07 +01:00 · 2022-06-14 16:52:45 +01:00 · 2022-06-14 16:47:21 +01:00 · 2022-06-14 16:34:17 +01:00
363 changed files with 33115 additions and 13993 deletions
@@ -0,0 +1,59 @@
+name: CI for nym-connect
+
+on:
+  push:
+    paths:
+      - 'nym-connect/**'
+
+defaults:
+  run:
+    working-directory: nym-connect
+
+jobs:
+  build:
+    runs-on: custom-runner-linux
+    steps:
+    - uses: actions/checkout@v2
+    - name: Install rsync
+      run: sudo apt-get install rsync
+    - uses: rlespinasse/github-slug-action@v3.x
+    - uses: actions/setup-node@v2
+      with:
+        node-version: '16'
+    - name: Install Yarn
+      run: npm install -g yarn
+    - run: yarn
+      continue-on-error: true
+    - name: Set environment from the example
+      run: cp .env.sample .env
+    - run: yarn storybook:build
+    - name: Deploy branch to CI www
+      continue-on-error: true
+      uses: easingthemes/ssh-deploy@main
+      env:
+        SSH_PRIVATE_KEY: ${{ secrets.CI_WWW_SSH_PRIVATE_KEY }}
+        ARGS: "-rltgoDzvO --delete"
+        SOURCE: "nym-connect/storybook-static/"
+        REMOTE_HOST: ${{ secrets.CI_WWW_REMOTE_HOST }}
+        REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
+        TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/nym-connect-${{ env.GITHUB_REF_SLUG }}
+        EXCLUDE: "/dist/, /node_modules/"
+    - name: Keybase - Node Install
+      run: npm install
+      working-directory: .github/workflows/support-files
+#    - name: Keybase - Send Notification
+#      env:
+#        NYM_NOTIFICATION_KIND: nym-connect
+#        NYM_PROJECT_NAME: "nym-connect"
+#        NYM_CI_WWW_BASE: "${{ secrets.NYM_CI_WWW_BASE }}"
+#        NYM_CI_WWW_LOCATION: "nym-connect-${{ env.GITHUB_REF_SLUG }}"
+#        GIT_COMMIT_MESSAGE: "${{ github.event.head_commit.message }}"
+#        GIT_BRANCH: "${GITHUB_REF##*/}"
+#        KEYBASE_NYMBOT_USERNAME: "${{ secrets.KEYBASE_NYMBOT_USERNAME }}"
+#        KEYBASE_NYMBOT_PAPERKEY: "${{ secrets.KEYBASE_NYMBOT_PAPERKEY }}"
+#        KEYBASE_NYMBOT_TEAM: "${{ secrets.KEYBASE_NYMBOT_TEAM }}"
+#        KEYBASE_NYM_CHANNEL: "ci-nym-connect"
+#        IS_SUCCESS: "${{ job.status == 'success' }}"
+#      uses: docker://keybaseio/client:stable-node
+#      with:
+#        args: .github/workflows/support-files/notifications/entry_point.sh
@@ -66,6 +66,7 @@ jobs:
          APPLE_PASSWORD: ${{ secrets.APPLE_PASSWORD }}
          TAURI_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
          TAURI_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
+          ADMIN_ADDRESS: ${{ secrets.WALLET_ADMIN_ADDRESS }}
        run: yarn && yarn build

      - name: Upload to release based on tag name
@@ -44,6 +44,7 @@ jobs:
        env:
          TAURI_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
          TAURI_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
+          ADMIN_ADDRESS: ${{ secrets.WALLET_ADMIN_ADDRESS }}
      - name: Upload to release based on tag name
        uses: softprops/action-gh-release@v1
        with:
@@ -65,6 +65,7 @@ jobs:
          WINDOWS_CERTIFICATE_PASSWORD: ${{ secrets.WINDOWS_CERTIFICATE_PASSWORD }}
          TAURI_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
          TAURI_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
+          ADMIN_ADDRESS: ${{ secrets.WALLET_ADMIN_ADDRESS }}
        run: yarn build

      - name: Upload to release based on tag name
@@ -3,7 +3,7 @@ require('dotenv').config();
 const Bot = require('keybase-bot');

 let context = {
-  kinds: ['nym-wallet', 'ts-packages', 'network-explorer', 'nightly'],
+  kinds: ['nym-wallet', 'ts-packages', 'network-explorer', 'nightly', 'nym-connect'],
 };

 /**
@@ -0,0 +1,29 @@
+const Handlebars = require('handlebars');
+const fs = require('fs');
+const path = require('path');
+
+async function addToContextAndValidate(context) {
+  if (!context.env.NYM_CI_WWW_LOCATION) {
+    throw new Error('Please ensure the env var NYM_CI_WWW_LOCATION is set');
+  }
+  if (!context.env.NYM_CI_WWW_BASE) {
+    throw new Error('Please ensure the env var NYM_CI_WWW_BASE is set');
+  }
+}
+
+async function getMessageBody(context) {
+  const source = fs
+    .readFileSync(
+      context.env.IS_SUCCESS === 'true'
+        ? path.resolve(__dirname, 'templates', 'success')
+        : path.resolve(__dirname, 'templates', 'failure'),
+    )
+    .toString();
+  const template = Handlebars.compile(source);
+  return template(context);
+}
+
+module.exports = {
+  addToContextAndValidate,
+  getMessageBody,
+};
@@ -0,0 +1,11 @@
+🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥
+> :rocket: {{ env.NYM_PROJECT_NAME }}
+> 🔴 **FAILURE** :cry:
+> `branch` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/tree/{{ env.GIT_BRANCH_NAME }}
+> `commit` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/commit/{{ env.GITHUB_SHA }}
+> `build ` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/actions/runs/{{ env.GITHUB_RUN_ID }}
+
+Commit message:
+```
+{{ env.GIT_COMMIT_MESSAGE }}
+```
@@ -0,0 +1,11 @@
+🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩
+> :rocket: {{ env.NYM_PROJECT_NAME }}  ➡️➡️➡️➡️➡️ **View storybook:** https://{{ env.NYM_CI_WWW_LOCATION }}.{{ env.NYM_CI_WWW_BASE }}/
+> ✅ **SUCCESS**
+> `branch` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/tree/{{ env.GIT_BRANCH_NAME }}
+> `commit` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/commit/{{ env.GITHUB_SHA }}
+> `build ` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/actions/runs/{{ env.GITHUB_RUN_ID }}
+
+Commit message by `{{ env.GITHUB_ACTOR }}` at {{ timestamp }}:
+```
+{{ env.GIT_COMMIT_MESSAGE }}
+```
@@ -6,21 +6,20 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://

 ### Added

+- nym-connect: initial proof-of-concept of a UI around the socks5 client was added.
 - 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`.
+- mixnet-contrat: Added staking_supply field to ContractStateParams.
+- network-explorer-ui: Upgrade to React Router 6
+- rewarding: replace circulating supply with staking supply in reward calculations ([#1324])
 - 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.
 - network-statistics: a new mixnet service that aggregates and exposes anonymized data about mixnet services ([#1328])

 ### Fixed
@@ -34,6 +33,7 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://
 - 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])
+- validator: fixed local docker-compose setup to work on Apple M1 ([#1329])

 ### Changed

@@ -57,7 +57,22 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://
 [#1302]: https://github.com/nymtech/nym/pull/1302
 [#1318]: https://github.com/nymtech/nym/pull/1318
 [#1322]: https://github.com/nymtech/nym/pull/1322
+[#1324]: https://github.com/nymtech/nym/pull/1324
 [#1328]: https://github.com/nymtech/nym/pull/1328
+[#1329]: https://github.com/nymtech/nym/pull/1329
+
+## [nym-wallet-v1.0.5](https://github.com/nymtech/nym/tree/nym-wallet-v1.0.5) (2022-06-14)
+
+- 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.
+- wallet: new delegation and rewards UI
+- wallet: show version in nav bar
+- wallet: contract admin route put back
+- wallet: staking_supply field to StateParams
+- wallet: show transaction hash for redeeming or compounding rewards

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

@@ -2852,6 +2852,7 @@ dependencies = [
 "nymsphinx-types",
 "rand 0.8.5",
 "serde",
+ "task",
 "tokio",
 "tokio-util 0.7.3",
 "url",
@@ -1,11 +1,11 @@
 test: build clippy-all cargo-test wasm fmt
 no-clippy: build cargo-test wasm fmt
 happy: fmt clippy-happy test
-clippy-all: clippy-all-main clippy-all-contracts clippy-all-wallet
-clippy-happy: clippy-happy-main clippy-happy-contracts clippy-happy-wallet
-cargo-test: test-main test-contracts test-wallet
-build: build-contracts build-wallet build-main
-fmt: fmt-main fmt-contracts fmt-wallet
+clippy-all: clippy-all-main clippy-all-contracts clippy-all-wallet clippy-all-connect
+clippy-happy: clippy-happy-main clippy-happy-contracts clippy-happy-wallet clippy-happy-connect
+cargo-test: test-main test-contracts test-wallet test-connect
+build: build-contracts build-wallet build-main build-connect
+fmt: fmt-main fmt-contracts fmt-wallet fmt-connect

 clippy-happy-main:
 	cargo clippy
@@ -16,6 +16,9 @@ clippy-happy-contracts:
 clippy-happy-wallet:
 	cargo clippy --manifest-path nym-wallet/Cargo.toml

+clippy-happy-connect:
+	cargo clippy --manifest-path nym-connect/Cargo.toml
+
 clippy-all-main:
 	cargo clippy --workspace --all-features -- -D warnings

@@ -25,6 +28,9 @@ clippy-all-contracts:
 clippy-all-wallet:
 	cargo clippy --workspace --manifest-path nym-wallet/Cargo.toml --all-features -- -D warnings

+clippy-all-connect:
+	cargo clippy --workspace --manifest-path nym-connect/Cargo.toml --all-features -- -D warnings
+
 test-main:
 	cargo test --all-features --workspace

@@ -34,6 +40,9 @@ test-contracts:
 test-wallet:
 	cargo test --manifest-path nym-wallet/Cargo.toml --all-features

+test-connect:
+	cargo test --manifest-path nym-connect/Cargo.toml --all-features
+
 build-main:
 	cargo build --workspace

@@ -43,6 +52,9 @@ build-contracts:
 build-wallet:
 	cargo build --manifest-path nym-wallet/Cargo.toml --workspace

+build-connect:
+	cargo build --manifest-path nym-connect/Cargo.toml --workspace
+
 fmt-main:
 	cargo fmt --all

@@ -52,6 +64,9 @@ fmt-contracts:
 fmt-wallet:
 	cargo fmt --manifest-path nym-wallet/Cargo.toml --all

+fmt-connect:
+	cargo fmt --manifest-path nym-connect/Cargo.toml --all
+
 wasm:
 	RUSTFLAGS='-C link-arg=-s' cargo build --manifest-path contracts/Cargo.toml --release --target wasm32-unknown-unknown

@@ -0,0 +1,8 @@
+Update fonts by doing the following:
+
+1. Go to https://fonts.google.com/specimen/Open+Sans
+2. Add all the styles you want and select `@import`
+3. Copy the url (e.g. curl https://fonts.googleapis.com/css2\?family\=Open+Sans:ital,wght@0,300\;0,400\;0,500\;0,600\;0,700\;0,800\;1,300\;1,400\;1,500\;1,600\;1,700\;1,800\&display\=swap)
+4. Run `curl curl https://fonts.googleapis.com/css2\?family\=Open+Sans:ital,wght@0,300\;0,400\;0,500\;0,600\;0,700\;0,800\;1,300\;1,400\;1,500\;1,600\;1,700\;1,800\&display\=swap`
+5. Use the response as the CSS import directives and download the font files for each font weight
+6. Remember to delete any old font files
@@ -0,0 +1,96 @@
+@font-face {
+    font-family: 'Open Sans';
+    font-style: italic;
+    font-weight: 300;
+    font-stretch: normal;
+    font-display: swap;
+    src: url(./memQYaGs126MiZpBA-UFUIcVXSCEkx2cmqvXlWq8tWZ0Pw86hd0Rk5hkaVc.ttf) format('truetype');
+}
+@font-face {
+    font-family: 'Open Sans';
+    font-style: italic;
+    font-weight: 400;
+    font-stretch: normal;
+    font-display: swap;
+    src: url(./memQYaGs126MiZpBA-UFUIcVXSCEkx2cmqvXlWq8tWZ0Pw86hd0Rk8ZkaVc.ttf) format('truetype');
+}
+@font-face {
+    font-family: 'Open Sans';
+    font-style: italic;
+    font-weight: 500;
+    font-stretch: normal;
+    font-display: swap;
+    src: url(./memQYaGs126MiZpBA-UFUIcVXSCEkx2cmqvXlWq8tWZ0Pw86hd0Rk_RkaVc.ttf) format('truetype');
+}
+@font-face {
+    font-family: 'Open Sans';
+    font-style: italic;
+    font-weight: 600;
+    font-stretch: normal;
+    font-display: swap;
+    src: url(./memQYaGs126MiZpBA-UFUIcVXSCEkx2cmqvXlWq8tWZ0Pw86hd0RkxhjaVc.ttf) format('truetype');
+}
+@font-face {
+    font-family: 'Open Sans';
+    font-style: italic;
+    font-weight: 700;
+    font-stretch: normal;
+    font-display: swap;
+    src: url(./memQYaGs126MiZpBA-UFUIcVXSCEkx2cmqvXlWq8tWZ0Pw86hd0RkyFjaVc.ttf) format('truetype');
+}
+@font-face {
+    font-family: 'Open Sans';
+    font-style: italic;
+    font-weight: 800;
+    font-stretch: normal;
+    font-display: swap;
+    src: url(./memQYaGs126MiZpBA-UFUIcVXSCEkx2cmqvXlWq8tWZ0Pw86hd0Rk0ZjaVc.ttf) format('truetype');
+}
+@font-face {
+    font-family: 'Open Sans';
+    font-style: normal;
+    font-weight: 300;
+    font-stretch: normal;
+    font-display: swap;
+    src: url(./memSYaGs126MiZpBA-UvWbX2vVnXBbObj2OVZyOOSr4dVJWUgsiH0C4n.ttf) format('truetype');
+}
+@font-face {
+    font-family: 'Open Sans';
+    font-style: normal;
+    font-weight: 400;
+    font-stretch: normal;
+    font-display: swap;
+    src: url(./memSYaGs126MiZpBA-UvWbX2vVnXBbObj2OVZyOOSr4dVJWUgsjZ0C4n.ttf) format('truetype');
+}
+@font-face {
+    font-family: 'Open Sans';
+    font-style: normal;
+    font-weight: 500;
+    font-stretch: normal;
+    font-display: swap;
+    src: url(./memSYaGs126MiZpBA-UvWbX2vVnXBbObj2OVZyOOSr4dVJWUgsjr0C4n.ttf) format('truetype');
+}
+@font-face {
+    font-family: 'Open Sans';
+    font-style: normal;
+    font-weight: 600;
+    font-stretch: normal;
+    font-display: swap;
+    src: url(./memSYaGs126MiZpBA-UvWbX2vVnXBbObj2OVZyOOSr4dVJWUgsgH1y4n.ttf) format('truetype');
+}
+@font-face {
+    font-family: 'Open Sans';
+    font-style: normal;
+    font-weight: 700;
+    font-stretch: normal;
+    font-display: swap;
+    src: url(./memSYaGs126MiZpBA-UvWbX2vVnXBbObj2OVZyOOSr4dVJWUgsg-1y4n.ttf) format('truetype');
+}
+@font-face {
+    font-family: 'Open Sans';
+    font-style: normal;
+    font-weight: 800;
+    font-stretch: normal;
+    font-display: swap;
+    src: url(./memSYaGs126MiZpBA-UvWbX2vVnXBbObj2OVZyOOSr4dVJWUgshZ1y4n.ttf) format('truetype');
+}
@@ -345,7 +345,7 @@ pub struct Client<T> {
    nym_root_directory: PathBuf,

    #[serde(skip)]
-    super_struct: PhantomData<*const T>,
+    super_struct: PhantomData<T>,
 }

 impl<T: NymConfig> Default for Client<T> {
@@ -8,7 +8,7 @@ use url::Url;
 use crate::error::Result;
 use crate::{MNEMONIC, NYMD_URL};

-use network_defaults::{DEFAULT_NETWORK, MIX_DENOM, VOUCHER_INFO};
+use network_defaults::{DEFAULT_NETWORK, DENOM, VOUCHER_INFO};
 use validator_client::nymd::traits::CoconutBandwidthSigningClient;
 use validator_client::nymd::{Coin, Fee, NymdClient, SigningNymdClient};

@@ -34,7 +34,7 @@ impl Client {
        encryption_key: String,
        fee: Option<Fee>,
    ) -> Result<String> {
-        let amount = Coin::new(amount as u128, MIX_DENOM.base.to_string());
+        let amount = Coin::new(amount as u128, DENOM.to_string());
        Ok(self
            .nymd_client
            .deposit(
@@ -20,6 +20,7 @@ use client_core::client::topology_control::{
 use client_core::config::persistence::key_pathfinder::ClientKeyPathfinder;
 use crypto::asymmetric::identity;
 use futures::channel::mpsc;
+use futures::StreamExt;
 use gateway_client::bandwidth::BandwidthController;
 use gateway_client::{
    AcknowledgementReceiver, AcknowledgementSender, GatewayClient, MixnetMessageReceiver,
@@ -35,7 +36,17 @@ use crate::socks::{
    server::SphinxSocksServer,
 };

-pub(crate) mod config;
+pub mod config;
+
+// Channels used to control the main task from outside
+pub type Socks5ControlMessageSender = mpsc::UnboundedSender<Socks5ControlMessage>;
+pub type Socks5ControlMessageReceiver = mpsc::UnboundedReceiver<Socks5ControlMessage>;
+
+#[derive(Debug)]
+pub enum Socks5ControlMessage {
+    /// Tell the main task to stop
+    Stop,
+}

 pub struct NymClient {
    /// Client configuration options, including, among other things, packet sending rates,
@@ -272,6 +283,20 @@ impl NymClient {
        );
    }

+    // Variant of `run_forever` that listends for remote control messages
+    pub async fn run_and_listen(&mut self, mut receiver: Socks5ControlMessageReceiver) {
+        self.start().await;
+        tokio::select! {
+            message = receiver.next() =>  match message {
+                Some(Socks5ControlMessage::Stop) => {
+                    log::info!("Received: {:?}", message);
+                    log::info!("Shutting down");
+                }
+                None => log::info!("none"),
+            }
+        }
+    }
+
    pub async fn start(&mut self) {
        info!("Starting nym client");
        // channels for inter-component communication
@@ -88,7 +88,8 @@ pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
    app
 }

-async fn register_with_gateway(
+// TODO: make this private again after refactoring the config setup
+pub async fn register_with_gateway(
    gateway: &gateway::Node,
    our_identity: Arc<identity::KeyPair>,
 ) -> Arc<SharedKeys> {
@@ -110,7 +111,8 @@ async fn register_with_gateway(
        .expect("failed to register with the gateway!")
 }

-async fn gateway_details(
+// TODO: make this private again after refactoring the config setup
+pub async fn gateway_details(
    validator_servers: Vec<Url>,
    chosen_gateway_id: Option<&str>,
 ) -> gateway::Node {
@@ -144,7 +146,8 @@ async fn gateway_details(
    }
 }

-fn show_address(config: &Config) {
+// TODO: make this private again after refactoring the config setup
+pub fn show_address(config: &Config) {
    fn load_identity_keys(pathfinder: &ClientKeyPathfinder) -> identity::KeyPair {
        let identity_keypair: identity::KeyPair =
            pemstore::load_keypair(&pemstore::KeyPairPath::new(
@@ -5,7 +5,7 @@ use crate::client::config::Config;
 use clap::ArgMatches;
 use url::Url;

-pub(crate) mod init;
+pub mod init;
 pub(crate) mod run;
 pub(crate) mod upgrade;

@@ -2,4 +2,9 @@
 // SPDX-License-Identifier: Apache-2.0

 pub mod client;
+// This is only used as we reach into the init functions in nym-connect. We need to refactor the
+// init functions so that nym-connect can just call the same init function as the regular socks5
+// client.
+#[allow(unused)]
+pub mod commands;
 pub mod socks;
@@ -43,6 +43,7 @@ itertools = { version = "0.10", optional = true }
 cosmwasm-std = { version = "1.0.0", optional = true }
 execute = { path = "../../execute" }

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

 [features]
@@ -26,7 +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 as CosmosCoin, Tx};
+use cosmrs::{tx, AccountId, Coin as CosmosCoin, Denom, 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: String,
+        search_denom: Denom,
    ) -> Result<Option<Coin>, NymdError> {
        let path = Some("/cosmos.bank.v1beta1.Query/Balance".parse().unwrap());

@@ -1,10 +1,8 @@
 // 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;

@@ -16,40 +14,6 @@ pub enum 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)
@@ -134,7 +134,7 @@ impl NymdClient<SigningNymdClient> {
    where
        U: TryInto<HttpClientUrl, Error = TendermintRpcError>,
    {
-        let denom = network.mix_denom().base;
+        let denom = network.denom();
        let client_address = signer
            .try_derive_accounts()?
            .into_iter()
@@ -176,7 +176,7 @@ impl NymdClient<SigningNymdClient> {
        U: TryInto<HttpClientUrl, Error = TendermintRpcError>,
    {
        let prefix = network.bech32_prefix();
-        let denom = network.mix_denom().base;
+        let denom = network.denom();
        let wallet = DirectSecp256k1HdWallet::from_mnemonic(prefix, mnemonic)?;
        let client_address = wallet
            .try_derive_accounts()?
@@ -338,7 +338,7 @@ impl<C> NymdClient<C> {
    pub async fn get_balance(
        &self,
        address: &AccountId,
-        denom: String,
+        denom: Denom,
    ) -> Result<Option<Coin>, NymdError>
    where
        C: CosmWasmClient + Sync,
@@ -49,7 +49,7 @@ impl<C: SigningCosmWasmClient + Sync + Send> MultisigSigningClient for NymdClien
    ) -> 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),
+            funds: Coin::new(voucher_value, DEFAULT_NETWORK.denom()),
        };
        let release_funds_msg = CosmosMsg::Wasm(WasmMsg::Execute {
            contract_addr: self.coconut_bandwidth_contract_address().to_string(),
@@ -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 another address
+    pub proxy: Option<Addr>, // proxy address used to delegate the funds on behalf of anouther address
 }

 impl Eq for Delegation {}
@@ -37,16 +37,6 @@ 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,
@@ -230,9 +220,9 @@ impl DelegatorRewardParams {

        // change all values into their fixed representations
        let delegation_amount = U128::from_num(delegation_amount.u128());
-        let circulating_supply = U128::from_num(self.reward_params.circulating_supply());
+        let staking_supply = U128::from_num(self.reward_params.staking_supply());

-        let scaled_delegation_amount = delegation_amount / circulating_supply;
+        let scaled_delegation_amount = delegation_amount / staking_supply;

        // Div by zero checked above
        let delegator_reward =
@@ -402,22 +392,21 @@ impl MixNodeBond {
        self.total_delegation.clone()
    }

-    pub fn stake_saturation(&self, circulating_supply: u128, rewarded_set_size: u32) -> U128 {
-        self.total_bond_to_circulating_supply(circulating_supply)
-            * U128::from_num(rewarded_set_size)
+    pub fn stake_saturation(&self, staking_supply: u128, rewarded_set_size: u32) -> U128 {
+        self.total_bond_to_staking_supply(staking_supply) * U128::from_num(rewarded_set_size)
    }

    // TODO: There is an effect here when adding accumulted rewards to the total bond, ie accumulated rewards will not
    // affect lambda, but will affect sigma, in turn over time, if left unclaimed operator rewards will not compound, but
    // behave similarly to delegations.
    // The question is should this be taken into account when calculating operator rewards?
-    pub fn pledge_to_circulating_supply(&self, circulating_supply: u128) -> U128 {
-        U128::from_num(self.pledge_amount().amount.u128()) / U128::from_num(circulating_supply)
+    pub fn pledge_to_staking_supply(&self, staking_supply: u128) -> U128 {
+        U128::from_num(self.pledge_amount().amount.u128()) / U128::from_num(staking_supply)
    }

-    pub fn total_bond_to_circulating_supply(&self, circulating_supply: u128) -> U128 {
+    pub fn total_bond_to_staking_supply(&self, staking_supply: u128) -> U128 {
        U128::from_num(self.pledge_amount().amount.u128() + self.total_delegation().amount.u128())
-            / U128::from_num(circulating_supply)
+            / U128::from_num(staking_supply)
    }

    pub fn lambda_ticked(&self, params: &RewardParams) -> U128 {
@@ -427,7 +416,7 @@ impl MixNodeBond {

    pub fn lambda(&self, params: &RewardParams) -> U128 {
        // Ratio of a bond to the token circulating supply
-        self.pledge_to_circulating_supply(params.circulating_supply())
+        self.pledge_to_staking_supply(params.staking_supply())
    }

    pub fn sigma_ticked(&self, params: &RewardParams) -> U128 {
@@ -437,7 +426,7 @@ impl MixNodeBond {

    pub fn sigma(&self, params: &RewardParams) -> U128 {
        // Ratio of a delegation to the the token circulating supply
-        self.total_bond_to_circulating_supply(params.circulating_supply())
+        self.total_bond_to_staking_supply(params.staking_supply())
    }

    pub fn estimate_reward(
@@ -525,9 +514,8 @@ impl MixNodeBond {
    }

    pub fn sigma_ratio(&self, params: &RewardParams) -> U128 {
-        if self.total_bond_to_circulating_supply(params.circulating_supply()) < params.one_over_k()
-        {
-            self.total_bond_to_circulating_supply(params.circulating_supply())
+        if self.total_bond_to_staking_supply(params.staking_supply()) < params.one_over_k() {
+            self.total_bond_to_staking_supply(params.staking_supply())
        } else {
            params.one_over_k()
        }
@@ -78,9 +78,9 @@ impl NodeEpochRewards {
    ) -> Result<Uint128, MixnetContractError> {
        // change all values into their fixed representations
        let delegation_amount = U128::from_num(delegation_amount.u128());
-        let circulating_supply = U128::from_num(epoch_reward_params.circulating_supply());
+        let staking_supply = U128::from_num(epoch_reward_params.staking_supply());

-        let scaled_delegation_amount = delegation_amount / circulating_supply;
+        let scaled_delegation_amount = delegation_amount / staking_supply;

        let check_div_by_zero =
            if let Some(value) = scaled_delegation_amount.checked_div(self.sigma()) {
@@ -105,7 +105,8 @@ pub struct EpochRewardParams {
    epoch_reward_pool: Uint128,
    rewarded_set_size: Uint128,
    active_set_size: Uint128,
-    circulating_supply: Uint128,
+    circulating_supply: Option<Uint128>,
+    staking_supply: Option<Uint128>,
    sybil_resistance_percent: u8,
    active_set_work_factor: u8,
 }
@@ -115,7 +116,7 @@ impl EpochRewardParams {
        epoch_reward_pool: u128,
        rewarded_set_size: u128,
        active_set_size: u128,
-        circulating_supply: u128,
+        staking_supply: u128,
        sybil_resistance_percent: u8,
        active_set_work_factor: u8,
    ) -> EpochRewardParams {
@@ -123,7 +124,8 @@ impl EpochRewardParams {
            epoch_reward_pool: Uint128::new(epoch_reward_pool),
            rewarded_set_size: Uint128::new(rewarded_set_size),
            active_set_size: Uint128::new(active_set_size),
-            circulating_supply: Uint128::new(circulating_supply),
+            circulating_supply: None,
+            staking_supply: Some(Uint128::new(staking_supply)),
            sybil_resistance_percent,
            active_set_work_factor,
        }
@@ -136,7 +138,8 @@ impl EpochRewardParams {
    pub fn new_empty() -> Self {
        EpochRewardParams {
            epoch_reward_pool: Uint128::new(0),
-            circulating_supply: Uint128::new(0),
+            staking_supply: Some(Uint128::new(0)),
+            circulating_supply: None,
            sybil_resistance_percent: 0,
            rewarded_set_size: Uint128::new(0),
            active_set_size: Uint128::new(0),
@@ -152,8 +155,14 @@ impl EpochRewardParams {
        self.active_set_size.u128()
    }

-    pub fn circulating_supply(&self) -> u128 {
-        self.circulating_supply.u128()
+    pub fn staking_supply(&self) -> u128 {
+        if let Some(s) = self.staking_supply {
+            s.u128()
+        } else if let Some(c) = self.circulating_supply {
+            c.u128()
+        } else {
+            0
+        }
    }

    pub fn epoch_reward_pool(&self) -> u128 {
@@ -252,8 +261,8 @@ impl RewardParams {
        self.epoch.rewarded_set_size.u128()
    }

-    pub fn circulating_supply(&self) -> u128 {
-        self.epoch.circulating_supply.u128()
+    pub fn staking_supply(&self) -> u128 {
+        self.epoch.staking_supply()
    }

    pub fn reward_blockstamp(&self) -> u64 {
@@ -43,6 +43,7 @@ pub struct ContractStateParams {
    // subset of rewarded mixnodes that are actively receiving mix traffic
    // used to handle shorter-term (e.g. hourly) fluctuations of demand
    pub mixnode_active_set_size: u32,
+    pub staking_supply: Uint128,
 }

 impl Display for ContractStateParams {
@@ -1,6 +1,6 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
-use config::defaults::MIX_DENOM;
+use config::defaults::DENOM;
 use cosmwasm_std::{Coin, Timestamp};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
@@ -11,7 +11,7 @@ pub mod events;
 pub mod messages;

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

 #[cfg_attr(feature = "generate-ts", derive(ts_rs::TS))]
@@ -28,8 +28,8 @@ pub enum Period {

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

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

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

 impl OriginalVestingResponse {
@@ -26,5 +26,6 @@ nymsphinx-forwarding = { path = "../nymsphinx/forwarding" }
 nymsphinx-framing = { path = "../nymsphinx/framing" }
 nymsphinx-params = { path = "../nymsphinx/params" }
 nymsphinx-types = { path = "../nymsphinx/types" }
+task = { path = "../task" }
 validator-client = { path = "../client-libs/validator-client" }
 version-checker = { path = "../version-checker" }
@@ -24,6 +24,8 @@ pub enum RttError {
    ConnectionWriteTimeout(String),

    UnexpectedReplySequence,
+
+    ShutdownReceived,
 }

 impl Display for RttError {
@@ -69,6 +71,9 @@ impl Display for RttError {
                f,
                "The received reply packet had an unexpected sequence number"
            ),
+            RttError::ShutdownReceived => {
+                write!(f, "Shutdown signal received")
+            }
        }
    }
 }
@@ -11,6 +11,7 @@ use std::fmt::{Display, Formatter};
 use std::net::SocketAddr;
 use std::sync::Arc;
 use std::{fmt, io, process};
+use task::ShutdownListener;
 use tokio::io::AsyncWriteExt;
 use tokio::net::{TcpListener, TcpStream};
 use tokio_util::codec::{Decoder, Encoder, Framed};
@@ -18,13 +19,19 @@ use tokio_util::codec::{Decoder, Encoder, Framed};
 pub(crate) struct PacketListener {
    address: SocketAddr,
    connection_handler: Arc<ConnectionHandler>,
+    shutdown: ShutdownListener,
 }

 impl PacketListener {
-    pub(crate) fn new(address: SocketAddr, identity: Arc<identity::KeyPair>) -> Self {
+    pub(crate) fn new(
+        address: SocketAddr,
+        identity: Arc<identity::KeyPair>,
+        shutdown: ShutdownListener,
+    ) -> Self {
        PacketListener {
            address,
            connection_handler: Arc::new(ConnectionHandler { identity }),
+            shutdown,
        }
    }
 }
@@ -34,24 +41,37 @@ impl PacketListener {
        let listener = match TcpListener::bind(self.address).await {
            Ok(listener) => listener,
            Err(err) => {
-                error!("Failed to bind to {} - {}. Are you sure nothing else is running on the specified port and your user has sufficient permission to bind to the requested address?", self.address, err);
+                error!(
+                    "Failed to bind to {} - {}. Are you sure nothing else is running on the specified port and your user has sufficient permission to bind to the requested address?",
+                    self.address, err
+                );
                process::exit(1);
            }
        };

        info!("Started listening for echo packets on {}", self.address);

-        loop {
+        let mut shutdown_listener = self.shutdown.clone();
+
+        while !shutdown_listener.is_shutdown() {
            // cloning the arc as each accepted socket is handled in separate task
            let connection_handler = Arc::clone(&self.connection_handler);
+            let handler_shutdown_listener = self.shutdown.clone();

-            match listener.accept().await {
-                Ok((socket, remote_addr)) => {
-                    debug!("New verloc connection from {}", remote_addr);
+            tokio::select! {
+                socket = listener.accept() => {
+                    match socket {
+                        Ok((socket, remote_addr)) => {
+                            debug!("New verloc connection from {}", remote_addr);

-                    tokio::spawn(connection_handler.handle_connection(socket, remote_addr));
+                            tokio::spawn(connection_handler.handle_connection(socket, remote_addr, handler_shutdown_listener));
+                        }
+                        Err(err) => warn!("Failed to accept incoming connection - {:?}", err),
+                    }
+                },
+                _ = shutdown_listener.recv() => {
+                    log::trace!("PacketListener: Received shutdown");
                }
-                Err(err) => warn!("Failed to accept incoming connection - {:?}", err),
            }
        }
    }
@@ -67,34 +87,46 @@ impl ConnectionHandler {
        packet.construct_reply(self.identity.private_key())
    }

-    pub(crate) async fn handle_connection(self: Arc<Self>, conn: TcpStream, remote: SocketAddr) {
+    pub(crate) async fn handle_connection(
+        self: Arc<Self>,
+        conn: TcpStream,
+        remote: SocketAddr,
+        mut shutdown_listener: ShutdownListener,
+    ) {
        debug!("Starting connection handler for {:?}", remote);

        let mut framed_conn = Framed::new(conn, EchoPacketCodec);
-        while let Some(echo_packet) = framed_conn.next().await {
-            // handle echo packet
-            let reply_packet = match echo_packet {
-                Ok(echo_packet) => self.handle_echo_packet(echo_packet),
-                Err(err) => {
-                    error!(
-                        "The socket connection got corrupted with error: {}. Closing the socket",
-                        err
-                    );
-                    return;
-                }
-            };
+        while !shutdown_listener.is_shutdown() {
+            tokio::select! {
+                Some(echo_packet) = framed_conn.next() => {
+                    // handle echo packet
+                    let reply_packet = match echo_packet {
+                        Ok(echo_packet) => self.handle_echo_packet(echo_packet),
+                        Err(err) => {
+                            error!(
+                                "The socket connection got corrupted with error: {}. Closing the socket",
+                                err
+                            );
+                            return;
+                        }
+                    };

-            // write back the reply (note the lack of framing)
-            if let Err(err) = framed_conn
-                .get_mut()
-                .write_all(reply_packet.to_bytes().as_ref())
-                .await
-            {
-                error!(
-                    "Failed to write reply packet back to the sender - {}. Closing the socket on our end",
-                    err
-                );
-                return;
+                    // write back the reply (note the lack of framing)
+                    if let Err(err) = framed_conn
+                        .get_mut()
+                        .write_all(reply_packet.to_bytes().as_ref())
+                        .await
+                    {
+                        error!(
+                            "Failed to write reply packet back to the sender - {}. Closing the socket on our end",
+                            err
+                        );
+                        return;
+                    }
+                },
+                _ = shutdown_listener.recv() => {
+                    trace!("ConnectionHandler: Shutdown received");
+                }
            }
        }
    }
@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::verloc::listener::PacketListener;
-pub use crate::verloc::measurement::{AtomicVerlocResult, Verloc, VerlocResult};
 use crate::verloc::sender::{PacketSender, TestedNode};
 use crypto::asymmetric::identity;
 use futures::stream::FuturesUnordered;
@@ -13,11 +12,14 @@ use rand::thread_rng;
 use std::net::{SocketAddr, ToSocketAddrs};
 use std::sync::Arc;
 use std::time::Duration;
+use task::ShutdownListener;
 use tokio::task::JoinHandle;
 use tokio::time::sleep;
 use url::Url;
 use version_checker::parse_version;

+pub use crate::verloc::measurement::{AtomicVerlocResult, Verloc, VerlocResult};
+
 pub mod error;
 pub(crate) mod listener;
 pub(crate) mod measurement;
@@ -137,9 +139,10 @@ impl ConfigBuilder {

    pub fn build(self) -> Config {
        // panics here are fine as those are only ever constructed at the initial setup
-        if self.0.validator_api_urls.is_empty() {
-            panic!("at least one validator endpoint must be provided")
-        }
+        assert!(
+            !self.0.validator_api_urls.is_empty(),
+            "at least one validator endpoint must be provided",
+        );
        self.0
    }
 }
@@ -165,6 +168,7 @@ pub struct VerlocMeasurer {
    config: Config,
    packet_sender: Arc<PacketSender>,
    packet_listener: Arc<PacketListener>,
+    shutdown_listener: ShutdownListener,

    currently_used_api: usize,

@@ -177,7 +181,11 @@ pub struct VerlocMeasurer {
 }

 impl VerlocMeasurer {
-    pub fn new(mut config: Config, identity: Arc<identity::KeyPair>) -> Self {
+    pub fn new(
+        mut config: Config,
+        identity: Arc<identity::KeyPair>,
+        shutdown_listener: ShutdownListener,
+    ) -> Self {
        config.validator_api_urls.shuffle(&mut thread_rng());

        VerlocMeasurer {
@@ -187,11 +195,14 @@ impl VerlocMeasurer {
                config.packet_timeout,
                config.connection_timeout,
                config.delay_between_packets,
+                shutdown_listener.clone(),
            )),
            packet_listener: Arc::new(PacketListener::new(
                config.listening_address,
                Arc::clone(&identity),
+                shutdown_listener.clone(),
            )),
+            shutdown_listener,
            currently_used_api: 0,
            validator_client: validator_client::ApiClient::new(
                config.validator_api_urls[0].clone(),
@@ -222,7 +233,11 @@ impl VerlocMeasurer {
        tokio::spawn(packet_listener.run())
    }

-    async fn perform_measurement(&self, nodes_to_test: Vec<TestedNode>) {
+    async fn perform_measurement(&self, nodes_to_test: Vec<TestedNode>) -> MeasurementOutcome {
+        log::trace!("Performing measurements");
+
+        let mut shutdown_listener = self.shutdown_listener.clone();
+
        for chunk in nodes_to_test.chunks(self.config.tested_nodes_batch_size) {
            let mut chunk_results = Vec::with_capacity(chunk.len());

@@ -246,33 +261,44 @@ impl VerlocMeasurer {
                .collect::<FuturesUnordered<_>>();

            // exhaust the results
-            while let Some(result) = measurement_chunk.next().await {
-                // if we receive JoinError it means the task failed to get executed, so either there's a bigger issue with tokio
-                // or there was a panic inside the task itself. In either case, we should just terminate ourselves.
-                let execution_result = result.expect("the measurement task panicked!");
-                let measurement_result = match execution_result.0 {
-                    Err(err) => {
-                        debug!(
-                            "Failed to perform measurement for {} - {}",
-                            execution_result.1.to_base58_string(),
-                            err
-                        );
-                        None
+            while !shutdown_listener.is_shutdown() {
+                tokio::select! {
+                    Some(result) = measurement_chunk.next() => {
+                        // if we receive JoinError it means the task failed to get executed, so either there's a bigger issue with tokio
+                        // or there was a panic inside the task itself. In either case, we should just terminate ourselves.
+                        let execution_result = result.expect("the measurement task panicked!");
+                        let measurement_result = match execution_result.0 {
+                            Err(err) => {
+                                debug!(
+                                    "Failed to perform measurement for {} - {}",
+                                    execution_result.1.to_base58_string(),
+                                    err
+                                );
+                                None
+                            }
+                            Ok(result) => Some(result),
+                        };
+                        chunk_results.push(Verloc::new(execution_result.1, measurement_result));
+                    },
+                    _ = shutdown_listener.recv() => {
+                        trace!("Shutdown received while measuring");
+                        return MeasurementOutcome::Shutdown;
                    }
-                    Ok(result) => Some(result),
-                };
-                chunk_results.push(Verloc::new(execution_result.1, measurement_result));
+                }
            }

            // update the results vector with chunks as they become available (by default every 50 nodes)
            self.results.append_results(chunk_results).await;
        }
+
+        MeasurementOutcome::Done
    }

    pub async fn run(&mut self) {
        self.start_listening();
-        loop {
-            info!(target: "verloc", "Starting verloc measurements");
+
+        while !self.shutdown_listener.is_shutdown() {
+            info!("Starting verloc measurements");
            // TODO: should we also measure gateways?

            let all_mixes = match self.validator_client.get_cached_mixnodes().await {
@@ -322,13 +348,32 @@ impl VerlocMeasurer {
            // on start of each run remove old results
            self.results.reset_results(tested_nodes.len()).await;

-            self.perform_measurement(tested_nodes).await;
+            if let MeasurementOutcome::Shutdown = self.perform_measurement(tested_nodes).await {
+                log::trace!("Shutting down after aborting measurements");
+                break;
+            }

            // write current time to "run finished" field
            self.results.finish_measurements().await;

-            info!(target: "verloc", "Finished performing verloc measurements. The next one will happen in {:?}", self.config.testing_interval);
-            sleep(self.config.testing_interval).await
+            info!(
+                "Finished performing verloc measurements. The next one will happen in {:?}",
+                self.config.testing_interval
+            );
+
+            tokio::select! {
+                _ = sleep(self.config.testing_interval) => {},
+                _ = self.shutdown_listener.recv() => {
+                    log::trace!("Shutdown received while sleeping");
+                }
+            }
        }
+
+        log::trace!("Verloc: Exiting");
    }
 }
+
+enum MeasurementOutcome {
+    Done,
+    Shutdown,
+}
@@ -7,10 +7,11 @@ use crate::verloc::packet::{EchoPacket, ReplyPacket};
 use crypto::asymmetric::identity;
 use log::*;
 use rand::{thread_rng, Rng};
-use std::io;
 use std::net::SocketAddr;
 use std::sync::Arc;
 use std::time::Duration;
+use std::{fmt, io};
+use task::ShutdownListener;
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use tokio::net::TcpStream;
 use tokio::time::sleep;
@@ -27,6 +28,16 @@ impl TestedNode {
    }
 }

+impl fmt::Display for TestedNode {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "TestedNode(id: {}, address: {})",
+            self.identity, self.address
+        )
+    }
+}
+
 pub(crate) struct PacketSender {
    identity: Arc<identity::KeyPair>,
    // timeout for receiving before sending new one
@@ -34,6 +45,7 @@ pub(crate) struct PacketSender {
    packet_timeout: Duration,
    connection_timeout: Duration,
    delay_between_packets: Duration,
+    shutdown_listener: ShutdownListener,
 }

 impl PacketSender {
@@ -43,6 +55,7 @@ impl PacketSender {
        packet_timeout: Duration,
        connection_timeout: Duration,
        delay_between_packets: Duration,
+        shutdown_listener: ShutdownListener,
    ) -> Self {
        PacketSender {
            identity,
@@ -50,6 +63,7 @@ impl PacketSender {
            packet_timeout,
            connection_timeout,
            delay_between_packets,
+            shutdown_listener,
        }
    }

@@ -69,6 +83,8 @@ impl PacketSender {
        self: Arc<Self>,
        tested_node: TestedNode,
    ) -> Result<Measurement, RttError> {
+        let mut shutdown_listener = self.shutdown_listener.clone();
+
        let mut conn = match tokio::time::timeout(
            self.connection_timeout,
            TcpStream::connect(tested_node.address),
@@ -98,35 +114,40 @@ impl PacketSender {
            let start = tokio::time::Instant::now();
            // TODO: should we get the start time after or before actually sending the data?
            // there's going to definitely some scheduler and network stack bias here
-            match tokio::time::timeout(
-                self.packet_timeout,
-                conn.write_all(packet.to_bytes().as_ref()),
-            )
-            .await
-            {
-                Err(_timeout) => {
-                    let identity_string = tested_node.identity.to_base58_string();
-                    debug!(
-                        "failed to write echo packet to {} within {:?}. Stopping the test.",
-                        identity_string, self.packet_timeout
-                    );
-                    return Err(RttError::UnexpectedConnectionFailureWrite(
-                        identity_string,
-                        io::ErrorKind::TimedOut.into(),
-                    ));
-                }
-                Ok(Err(err)) => {
-                    let identity_string = tested_node.identity.to_base58_string();
-                    debug!(
-                        "failed to write echo packet to {} - {}. Stopping the test.",
-                        identity_string, err
-                    );
-                    return Err(RttError::UnexpectedConnectionFailureWrite(
-                        identity_string,
-                        err,
-                    ));
-                }
-                Ok(Ok(_)) => {}
+            let packet_bytes = packet.to_bytes();
+
+            tokio::select! {
+                write = tokio::time::timeout(self.packet_timeout, conn.write_all(packet_bytes.as_ref())) => {
+                    match write {
+                        Err(_timeout) => {
+                            let identity_string = tested_node.identity.to_base58_string();
+                            debug!(
+                                "failed to write echo packet to {} within {:?}. Stopping the test.",
+                                identity_string, self.packet_timeout
+                            );
+                            return Err(RttError::UnexpectedConnectionFailureWrite(
+                                identity_string,
+                                io::ErrorKind::TimedOut.into(),
+                            ));
+                        }
+                        Ok(Err(err)) => {
+                            let identity_string = tested_node.identity.to_base58_string();
+                            debug!(
+                                "failed to write echo packet to {} - {}. Stopping the test.",
+                                identity_string, err
+                            );
+                            return Err(RttError::UnexpectedConnectionFailureWrite(
+                                identity_string,
+                                err,
+                            ));
+                        }
+                        Ok(Ok(_)) => {}
+                        }
+                },
+                _ = shutdown_listener.recv() => {
+                    log::trace!("PacketSender: Received shutdown while sending");
+                    return Err(RttError::ShutdownReceived);
+                },
            }

            // there's absolutely no need to put a codec on ReplyPackets as we know exactly
@@ -147,21 +168,28 @@ impl PacketSender {
                ReplyPacket::try_from_bytes(&buf, &tested_node.identity)
            };

-            let reply_packet =
-                match tokio::time::timeout(self.packet_timeout, reply_packet_future).await {
-                    Ok(reply_packet) => reply_packet,
-                    Err(_timeout) => {
-                        // TODO: should we continue regardless (with the rest of the packets, or abandon the whole thing?)
-                        // Note: if we decide to continue, it would increase the complexity of the whole thing
-                        debug!(
-                        "failed to receive reply to our echo packet within {:?}. Stopping the test",
-                        self.packet_timeout
-                    );
-                        return Err(RttError::ConnectionReadTimeout(
-                            tested_node.identity.to_base58_string(),
-                        ));
+            let reply_packet = tokio::select! {
+                reply = tokio::time::timeout(self.packet_timeout, reply_packet_future) => {
+                    match reply {
+                        Ok(reply_packet) => reply_packet,
+                        Err(_timeout) => {
+                            // TODO: should we continue regardless (with the rest of the packets, or abandon the whole thing?)
+                            // Note: if we decide to continue, it would increase the complexity of the whole thing
+                            debug!(
+                                "failed to receive reply to our echo packet within {:?}. Stopping the test",
+                                self.packet_timeout
+                            );
+                            return Err(RttError::ConnectionReadTimeout(
+                                tested_node.identity.to_base58_string(),
+                            ));
+                        }
                    }
-                };
+                },
+                _ = shutdown_listener.recv() => {
+                    log::trace!("PacketSender: Received shutdown while waiting for reply");
+                    return Err(RttError::ShutdownReceived);
+                }
+            };

            let reply_packet = reply_packet?;
            // make sure it's actually the expected packet...
@@ -5,8 +5,7 @@ use serde::{Deserialize, Serialize};
 use std::{collections::HashMap, fmt, str::FromStr};

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

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

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

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

    pub fn mixnet_contract_address(&self) -> &str {
@@ -102,20 +97,18 @@ impl fmt::Display for Network {
 #[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)]
 pub struct NetworkDetails {
    bech32_prefix: String,
-    mix_denom: DenomDetailsOwned,
-    stake_denom: DenomDetailsOwned,
+    denom: String,
    mixnet_contract_address: String,
    vesting_contract_address: String,
    bandwidth_claim_contract_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(),
-            mix_denom: details.mix_denom.into(),
-            stake_denom: details.stake_denom.into(),
+            denom: details.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(),
@@ -124,12 +117,6 @@ impl From<&DefaultNetworkDetails> for NetworkDetails {
    }
 }

-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>,
@@ -154,7 +141,7 @@ impl SupportedNetworks {
    pub fn denom(&self, network: Network) -> Option<&str> {
        self.networks
            .get(&network)
-            .map(|network_details| network_details.base_mix_denom())
+            .map(|network_details| network_details.denom.as_str())
    }

    pub fn mixnet_contract_address(&self, network: Network) -> Option<&str> {
@@ -17,24 +17,24 @@ pub mod sandbox;
 cfg_if::cfg_if! {
    if #[cfg(network = "mainnet")] {
        pub const DEFAULT_NETWORK: all::Network = all::Network::MAINNET;
-        pub const MIX_DENOM: DenomDetails = mainnet::MIX_DENOM;
-        pub const STAKE_DENOM: DenomDetails = mainnet::STAKE_DENOM;
+        pub const DENOM: &str = mainnet::DENOM;
+        pub const STAKE_DENOM: &str = 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 MIX_DENOM: DenomDetails = qa::MIX_DENOM;
-        pub const STAKE_DENOM: DenomDetails = qa::STAKE_DENOM;
+        pub const DENOM: &str = qa::DENOM;
+        pub const STAKE_DENOM: &str = 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 MIX_DENOM: DenomDetails = sandbox::MIX_DENOM;
-        pub const STAKE_DENOM: DenomDetails = sandbox::STAKE_DENOM;
+        pub const DENOM: &str = sandbox::DENOM;
+        pub const STAKE_DENOM: &str = 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;
@@ -45,49 +45,47 @@ 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 {
-    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,
+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,
+    coconut_bandwidth_contract_address: &'a str,
+    multisig_contract_address: &'a str,
+    rewarding_validator_address: &'a str,
    validators: Vec<ValidatorDetails>,
 }

-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 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,
+        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> = 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 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,
+        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> = Lazy::new(|| DefaultNetworkDetails {
+static QA_DEFAULTS: Lazy<DefaultNetworkDetails<'static>> = Lazy::new(|| DefaultNetworkDetails {
    bech32_prefix: qa::BECH32_PREFIX,
-    mix_denom: qa::MIX_DENOM,
-    stake_denom: qa::STAKE_DENOM,
+    denom: qa::DENOM,
    mixnet_contract_address: qa::MIXNET_CONTRACT_ADDRESS,
    vesting_contract_address: qa::VESTING_CONTRACT_ADDRESS,
    bandwidth_claim_contract_address: qa::BANDWIDTH_CLAIM_CONTRACT_ADDRESS,
@@ -97,42 +95,6 @@ static QA_DEFAULTS: Lazy<DefaultNetworkDetails> = Lazy::new(|| DefaultNetworkDet
    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
@@ -1,13 +1,11 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::{DenomDetails, ValidatorDetails};
+use crate::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 const STAKE_DENOM: &str = "unyx";

 pub(crate) const MIXNET_CONTRACT_ADDRESS: &str =
    "n14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9sjyvg3g";
@@ -1,13 +1,11 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::{DenomDetails, ValidatorDetails};
+use crate::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 const STAKE_DENOM: &str = "unyx";

 pub(crate) const MIXNET_CONTRACT_ADDRESS: &str =
    "n1suhgf5svhu4usrurvxzlgn54ksxmn8gljarjtxqnapv8kjnp4nrsd3qaep";
@@ -1,13 +1,11 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::{DenomDetails, ValidatorDetails};
+use crate::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 const STAKE_DENOM: &str = "unyxt";

 pub(crate) const MIXNET_CONTRACT_ADDRESS: &str = "nymt1ghd753shjuwexxywmgs4xz7x2q732vcnstz02j";
 pub(crate) const VESTING_CONTRACT_ADDRESS: &str = "nymt14ejqjyq8um4p3xfqj74yld5waqljf88fn549lh";
@@ -1,4 +1,4 @@
-use crate::currency::{DecCoin, Denom};
+use crate::currency::{CurrencyDenom, MajorCurrencyAmount};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};

@@ -9,16 +9,13 @@ use serde::{Deserialize, Serialize};
 )]
 #[derive(Serialize, Deserialize, JsonSchema)]
 pub struct Account {
-    // TODO: discuss with @MS whether it makes sense:
-    // 1. why are we restricting to single denom here? What if user holds both stake and mix currencies?
-    // 2. what's the `contract_address`? is it mixnet? vesting? coconut? why does it relate to an account anyway?
    pub contract_address: String,
    pub client_address: String,
-    pub denom: Denom,
+    pub denom: CurrencyDenom,
 }

 impl Account {
-    pub fn new(contract_address: String, client_address: String, denom: Denom) -> Self {
+    pub fn new(contract_address: String, client_address: String, denom: CurrencyDenom) -> Self {
        Account {
            contract_address,
            client_address,
@@ -56,15 +53,6 @@ pub struct AccountEntry {
 )]
 #[derive(Serialize, Deserialize)]
 pub struct Balance {
-    pub amount: DecCoin,
+    pub amount: MajorCurrencyAmount,
    pub printable_balance: String,
 }
-
-impl Balance {
-    pub fn new(amount: DecCoin) -> Self {
-        Balance {
-            printable_balance: amount.to_string(),
-            amount,
-        }
-    }
-}
@@ -1,26 +1,22 @@
 use crate::error::TypesError;
-use config::defaults::all::Network;
-use config::defaults::DenomDetails;
-use cosmwasm_std::Fraction;
+use cosmrs::Denom as CosmosDenom;
+use cosmwasm_std::Coin as CosmWasmCoin;
 use cosmwasm_std::{Decimal, Uint128};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use std::cmp::Ordering;
-use std::collections::HashMap;
 use std::convert::TryFrom;
 use std::fmt::{Display, Formatter};
+use std::ops::{Add, Mul};
+use std::str::FromStr;
 use strum::{Display, EnumString, EnumVariantNames};
-use validator_client::nymd::Coin;
-
-#[cfg(feature = "generate-ts")]
-use ts_rs::{Dependency, TS};
+use validator_client::nymd::{Coin, CosmosCoin};

 #[cfg_attr(feature = "generate-ts", derive(ts_rs::TS))]
 #[cfg_attr(
    feature = "generate-ts",
    ts(export_to = "ts-packages/types/src/types/rust/CurrencyDenom.ts")
 )]
-#[cfg_attr(feature = "generate-ts", ts(rename_all = "lowercase"))]
+#[cfg_attr(feature = "generate-ts", ts(rename_all = "UPPERCASE"))]
 #[derive(
    Display,
    Serialize,
@@ -32,8 +28,9 @@ use ts_rs::{Dependency, TS};
    PartialEq,
    JsonSchema,
 )]
-#[serde(rename_all = "lowercase")]
-#[strum(serialize_all = "lowercase")]
+#[serde(rename_all = "UPPERCASE")]
+#[strum(serialize_all = "UPPERCASE")]
+// TODO: this shouldn't be an enum...
 pub enum CurrencyDenom {
    #[strum(ascii_case_insensitive)]
    Nym,
@@ -45,460 +42,448 @@ pub enum CurrencyDenom {
    Nyxt,
 }

-pub type Denom = String;
-
-#[derive(Debug, Default)]
-pub struct RegisteredCoins(HashMap<Denom, CoinMetadata>);
-
-impl RegisteredCoins {
-    pub fn default_denoms(network: Network) -> Self {
-        let mut network_coins = HashMap::new();
-        network_coins.insert(
-            network.mix_denom().base.into(),
-            (*network.mix_denom()).into(),
-        );
-        network_coins.insert(
-            network.stake_denom().base.into(),
-            (*network.stake_denom()).into(),
-        );
-        RegisteredCoins(network_coins)
-    }
-
-    pub fn insert(&mut self, denom: Denom, metadata: CoinMetadata) -> Option<CoinMetadata> {
-        self.0.insert(denom, metadata)
-    }
-
-    pub fn remove(&mut self, denom: &Denom) -> Option<CoinMetadata> {
-        self.0.remove(denom)
-    }
-
-    pub fn attempt_convert_to_base_coin(&self, coin: DecCoin) -> Result<Coin, TypesError> {
-        // check if this is already in the base denom
-        if self.0.contains_key(&coin.denom) {
-            // if we're converting a base DecCoin it CANNOT fail, unless somebody is providing
-            // bullshit data on purpose : )
-            return coin.try_into();
-        } else {
-            // TODO: this kinda suggests we may need a better data structure
-            for registered_coin in self.0.values() {
-                if let Some(exponent) = registered_coin.get_exponent(&coin.denom) {
-                    let amount = try_convert_decimal_to_u128(coin.try_scale_up_value(exponent)?)?;
-                    return Ok(Coin::new(amount, &registered_coin.base));
-                }
-            }
+impl CurrencyDenom {
+    pub fn parse(value: &str) -> Result<CurrencyDenom, TypesError> {
+        let mut denom = value.to_string();
+        if denom.starts_with('u') {
+            denom = denom[1..].to_string();
        }
-        Err(TypesError::UnknownCoinDenom(coin.denom))
-    }
-
-    pub fn attempt_convert_to_display_dec_coin(&self, coin: Coin) -> Result<DecCoin, TypesError> {
-        for registered_coin in self.0.values() {
-            if let Some(exponent) = registered_coin.get_exponent(&coin.denom) {
-                // if this fails it means we haven't registered our display denom which honestly should never be the case
-                // unless somebody is rocking their own custom network
-                let display_exponent = registered_coin
-                    .get_exponent(&registered_coin.display)
-                    .ok_or_else(|| TypesError::UnknownCoinDenom(coin.denom.clone()))?;
-
-                return match exponent.cmp(&display_exponent) {
-                    Ordering::Greater => {
-                        // we need to scale up, unlikely to ever be needed but included for completion sake,
-                        // for example if we decided to created knym with exponent 9 and wanted to convert to nym with exponent 6
-                        Ok(DecCoin::new_scaled_up(
-                            coin.amount,
-                            &registered_coin.display,
-                            exponent - display_exponent,
-                        )?)
-                    }
-                    // we're already in the display denom
-                    Ordering::Equal => Ok(coin.into()),
-                    Ordering::Less => {
-                        // we need to scale down, the most common case, for example we're in base unym with exponent 0 and want to convert to nym with exponent 6
-                        Ok(DecCoin::new_scaled_down(
-                            coin.amount,
-                            &registered_coin.display,
-                            display_exponent - exponent,
-                        )?)
-                    }
-                };
-            }
-        }
-
-        Err(TypesError::UnknownCoinDenom(coin.denom))
-    }
-}
-
-// TODO: should this live here?
-// attempts to replicate cosmos-sdk's coin metadata
-// https://docs.cosmos.network/master/architecture/adr-024-coin-metadata.html
-// this way we could more easily handle multiple coin types simultaneously (like nym/nyx/nymt/nyx + local currencies)
-#[derive(Debug)]
-pub struct DenomUnit {
-    pub denom: Denom,
-    pub exponent: u32,
-    // pub aliases: Vec<String>,
-}
-
-impl DenomUnit {
-    pub fn new(denom: Denom, exponent: u32) -> Self {
-        DenomUnit { denom, exponent }
-    }
-}
-
-#[derive(Debug)]
-pub struct CoinMetadata {
-    pub denom_units: Vec<DenomUnit>,
-    pub base: Denom,
-    pub display: Denom,
-}
-
-impl CoinMetadata {
-    pub fn new(denom_units: Vec<DenomUnit>, base: Denom, display: Denom) -> Self {
-        CoinMetadata {
-            denom_units,
-            base,
-            display,
+        match CurrencyDenom::from_str(&denom) {
+            Ok(res) => Ok(res),
+            Err(_e) => Err(TypesError::InvalidDenom(value.to_string())),
        }
    }
+}

-    pub fn get_exponent(&self, denom: &str) -> Option<u32> {
-        self.denom_units
-            .iter()
-            .find(|denom_unit| denom_unit.denom == denom)
-            .map(|denom_unit| denom_unit.exponent)
+impl TryFrom<CosmosDenom> for CurrencyDenom {
+    type Error = TypesError;
+
+    fn try_from(value: CosmosDenom) -> Result<Self, Self::Error> {
+        CurrencyDenom::parse(&value.to_string())
    }
 }

-impl From<DenomDetails> for CoinMetadata {
-    fn from(denom_details: DenomDetails) -> Self {
-        CoinMetadata::new(
-            vec![
-                DenomUnit::new(denom_details.base.into(), 0),
-                DenomUnit::new(denom_details.display.into(), denom_details.display_exponent),
-            ],
-            denom_details.base.into(),
-            denom_details.display.into(),
-        )
-    }
+#[cfg_attr(feature = "generate-ts", derive(ts_rs::TS))]
+#[cfg_attr(
+    feature = "generate-ts",
+    ts(export_to = "ts-packages/types/src/types/rust/CurrencyStringMajorAmount.ts")
+)]
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
+pub struct MajorAmountString(String); // see https://github.com/Aleph-Alpha/ts-rs/issues/51 for exporting type aliases
+
+#[cfg_attr(feature = "generate-ts", derive(ts_rs::TS))]
+#[cfg_attr(
+    feature = "generate-ts",
+    ts(export_to = "ts-packages/types/src/types/rust/Currency.ts")
+)]
+// #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
+pub struct MajorCurrencyAmount {
+    // temporarly going back to original impl to speed up merge
+    pub amount: MajorAmountString,
+    pub denom: CurrencyDenom,
+    // // temporary...
+    // #[cfg_attr(feature = "generate-ts", ts(skip))]
+    // pub coin: Coin,
 }

+// impl JsonSchema for MajorCurrencyAmount {
+//     fn schema_name() -> String {
+//         todo!()
+//     }
+//
+//     fn json_schema(gen: &mut SchemaGenerator) -> Schema {
+//         todo!()
+//     }
+// }
+
 // tries to semi-replicate cosmos-sdk's DecCoin for being able to handle tokens with decimal amounts
 // https://github.com/cosmos/cosmos-sdk/blob/v0.45.4/types/dec_coin.go
-#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
 pub struct DecCoin {
-    pub denom: Denom,
-    // Decimal is already serialized to string and using string in its schema, so lets also go straight to string for ts_rs
-    // todo: is `Decimal` the correct type to use? Do we want to depend on cosmwasm_std here?
-    pub amount: Decimal,
+    //
 }

-// I had to implement it manually to correctly set dependencies
-#[cfg(feature = "generate-ts")]
-impl TS for DecCoin {
-    const EXPORT_TO: Option<&'static str> = Some("ts-packages/types/src/types/rust/DecCoin.ts");
-
-    fn decl() -> String {
-        format!("type {} = {};", Self::name(), Self::inline())
-    }
-
-    fn name() -> String {
-        "DecCoin".into()
-    }
-
-    fn inline() -> String {
-        "{ denom: CurrencyDenom, amount: string }".into()
-    }
-
-    fn dependencies() -> Vec<Dependency> {
-        vec![Dependency::from_ty::<CurrencyDenom>()
-            .expect("TS was incorrectly defined on `CurrencyDenom`")]
-    }
-
-    fn transparent() -> bool {
-        false
-    }
-}
-
-impl DecCoin {
-    pub fn new_base<S: Into<String>>(amount: impl Into<Uint128>, denom: S) -> Self {
-        DecCoin {
-            denom: denom.into(),
-            amount: Decimal::from_atomics(amount, 0).unwrap(),
+impl MajorCurrencyAmount {
+    pub fn new(amount: &str, denom: CurrencyDenom) -> MajorCurrencyAmount {
+        MajorCurrencyAmount {
+            amount: MajorAmountString(amount.to_string()),
+            denom,
        }
    }

-    pub fn zero<S: Into<String>>(denom: S) -> Self {
-        DecCoin {
-            denom: denom.into(),
-            amount: Decimal::zero(),
-        }
+    pub fn zero(denom: &CurrencyDenom) -> MajorCurrencyAmount {
+        MajorCurrencyAmount::new("0", denom.clone())
    }
+    //
+    // pub fn from_cosmrs_coin(coin: &CosmosCoin) -> Result<MajorCurrencyAmount, TypesError> {
+    //     MajorCurrencyAmount::from_cosmrs_decimal_and_denom(coin.amount, coin.denom.to_string())
+    // }
+    //
+    // pub fn from_minor_uint128_and_denom(
+    //     amount_minor: Uint128,
+    //     denom_minor: &str,
+    // ) -> Result<MajorCurrencyAmount, TypesError> {
+    //     MajorCurrencyAmount::from_minor_decimal_and_denom(
+    //         Decimal::from_atomics(amount_minor, 0)?,
+    //         denom_minor,
+    //     )
+    // }
+    //
+    // pub fn from_minor_decimal_and_denom(
+    //     amount_minor: Decimal,
+    //     denom_minor: &str,
+    // ) -> Result<MajorCurrencyAmount, TypesError> {
+    //     if !(denom_minor.starts_with('u') || denom_minor.starts_with('U')) {
+    //         return Err(TypesError::InvalidDenom(denom_minor.to_string()));
+    //     }
+    //     let major = amount_minor / Uint128::from(1_000_000u64);
+    //     if let Ok(denom) = CurrencyDenom::from_str(&denom_minor[1..].to_string()) {
+    //         return Ok(MajorCurrencyAmount {
+    //             amount: MajorAmountString(major.to_string()),
+    //             denom,
+    //         });
+    //     }
+    //     Err(TypesError::InvalidDenom(denom_minor.to_string()))
+    // }
+    // pub fn from_decimal_and_denom(
+    //     amount: Decimal,
+    //     denom: String,
+    // ) -> Result<MajorCurrencyAmount, TypesError> {
+    //     if denom.starts_with('u') || denom.starts_with('U') {
+    //         return MajorCurrencyAmount::from_minor_decimal_and_denom(amount, &denom);
+    //     }
+    //     if let Ok(denom) = CurrencyDenom::from_str(denom.as_str()) {
+    //         return Ok(MajorCurrencyAmount {
+    //             amount: MajorAmountString(amount.to_string()),
+    //             denom,
+    //         });
+    //     }
+    //     Err(TypesError::InvalidDenom(denom))
+    // }
+    // pub fn from_cosmrs_decimal_and_denom(
+    //     amount: CosmosDecimal,
+    //     denom: String,
+    // ) -> Result<MajorCurrencyAmount, TypesError> {
+    //     if denom.starts_with('u') || denom.starts_with('U') {
+    //         return match Decimal::from_str(&amount.to_string()) {
+    //             Ok(amount) => MajorCurrencyAmount::from_minor_decimal_and_denom(amount, &denom),
+    //             Err(_e) => Err(TypesError::InvalidAmount(amount.to_string())),
+    //         };
+    //     }
+    //
+    //     if let Ok(denom) = CurrencyDenom::from_str(denom.as_str()) {
+    //         return Ok(MajorCurrencyAmount {
+    //             amount: MajorAmountString(amount.to_string()),
+    //             denom,
+    //         });
+    //     }
+    //     Err(TypesError::InvalidDenom(denom))
+    // }
+    //
+    // pub fn into_cosmos_coin(self) -> CosmosCoin {
+    //     self.coin.into()
+    // }
+    //
+    // pub fn to_minor_uint128(&self) -> Result<Uint128, TypesError> {
+    //     if self.amount.0.contains('.') {
+    //         // has a decimal point (Cosmos assumes "." is the decimal separator)
+    //         let parts = self.amount.0.split('.');
+    //         let str = parts.collect_vec();
+    //         if str.is_empty() || str.len() > 2 {
+    //             return Err(TypesError::InvalidAmount("Amount is invalid".to_string()));
+    //         }
+    //         if str.len() == 2 {
+    //             // has a decimal, so check decimal places first
+    //             if str[1].len() > 6 {
+    //                 return Err(TypesError::InvalidDenom(
+    //                     "Amount is invalid, only 6 decimal places of precision are allowed"
+    //                         .to_string(),
+    //                 ));
+    //             }
+    //
+    //             // so multiple whole part by 1e6 and add decimal part
+    //             let whole_part = Uint128::from_str(str[0])? * Uint128::from(1_000_000u64);
+    //
+    //             // TODO: has Rust got anything that deals with fixed point values, or parsing from format strings? Leading zeroes are causing issues
+    //             return match format!("0.{}", str[1]).parse::<f64>() {
+    //                 Ok(decimal_part_float) => {
+    //                     // this makes an assumption that 6 decimal places of f64 can never lose precision
+    //                     let truncated = (decimal_part_float * 1_000_000.).trunc() as u32;
+    //                     let decimal_part = Uint128::from(truncated);
+    //                     let sum = whole_part + decimal_part;
+    //                     Ok(sum)
+    //                 }
+    //                 Err(_e) => Err(TypesError::InvalidAmount(
+    //                     "Amount decimal part is invalid".to_string(),
+    //                 )),
+    //             };
+    //         }
+    //     }
+    //
+    //     let major = Uint128::from_str(&self.amount.0)?;
+    //     let scaled = major * Uint128::new(1_000_000u128);
+    //     Ok(scaled)
+    // }

-    pub fn new_scaled_up<S: Into<String>>(
-        base_amount: impl Into<Uint128>,
-        denom: S,
-        exponent: u32,
-    ) -> Result<Self, TypesError> {
-        let base_amount = Decimal::from_atomics(base_amount, 0).unwrap();
-        Ok(DecCoin {
-            denom: denom.into(),
-            amount: try_scale_up_decimal(base_amount, exponent)?,
-        })
-    }
-
-    pub fn new_scaled_down<S: Into<String>>(
-        base_amount: impl Into<Uint128>,
-        denom: S,
-        exponent: u32,
-    ) -> Result<Self, TypesError> {
-        let base_amount = Decimal::from_atomics(base_amount, 0).unwrap();
-        Ok(DecCoin {
-            denom: denom.into(),
-            amount: try_scale_down_decimal(base_amount, exponent)?,
-        })
-    }
-
-    pub fn try_scale_down_value(&self, exponent: u32) -> Result<Decimal, TypesError> {
-        try_scale_down_decimal(self.amount, exponent)
-    }
-
-    pub fn try_scale_up_value(&self, exponent: u32) -> Result<Decimal, TypesError> {
-        try_scale_up_decimal(self.amount, exponent)
-    }
+    // pub fn denom_to_string(&self) -> String {
+    //     self.denom.to_string()
+    // }
 }

-// TODO: should thoese live here?
-pub fn try_scale_down_decimal(dec: Decimal, exponent: u32) -> Result<Decimal, TypesError> {
-    let rhs = 10u128
-        .checked_pow(exponent)
-        .ok_or(TypesError::UnsupportedExponent(exponent))?;
-    let denominator = dec
-        .denominator()
-        .checked_mul(rhs.into())
-        .map_err(|_| TypesError::UnsupportedExponent(exponent))?;
-
-    Ok(Decimal::from_ratio(dec.numerator(), denominator))
-}
-
-pub fn try_scale_up_decimal(dec: Decimal, exponent: u32) -> Result<Decimal, TypesError> {
-    let rhs = 10u128
-        .checked_pow(exponent)
-        .ok_or(TypesError::UnsupportedExponent(exponent))?;
-    let denominator = dec
-        .denominator()
-        .checked_div(rhs.into())
-        .map_err(|_| TypesError::UnsupportedExponent(exponent))?;
-
-    Ok(Decimal::from_ratio(dec.numerator(), denominator))
-}
-
-pub fn try_convert_decimal_to_u128(dec: Decimal) -> Result<u128, TypesError> {
-    let whole = dec.numerator() / dec.denominator();
-
-    // unwrap is fine as we're not dividing by zero here
-    let fractional = (dec.numerator()).checked_rem(dec.denominator()).unwrap();
-
-    // we cannot convert as we'd lose our decimal places
-    // (for example if somebody attempted to represent our gas price (WHICH YOU SHOULDN'T DO) as DecCoin)
-    if fractional != Uint128::zero() {
-        return Err(TypesError::LossyCoinConversion);
-    }
-    Ok(whole.u128())
-}
-
-// TODO: adjust the implementation to as required by @MS or @FT
-impl Display for DecCoin {
+impl Display for MajorCurrencyAmount {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}{}", self.amount, self.denom)
+        write!(f, "{} {}", self.amount.0, self.denom)
    }
 }

-impl From<Coin> for DecCoin {
+// TODO: cleanup after merge
+impl From<CosmosCoin> for MajorCurrencyAmount {
+    fn from(c: CosmosCoin) -> Self {
+        MajorCurrencyAmount::from(Coin::from(c))
+    }
+}
+
+impl From<CosmWasmCoin> for MajorCurrencyAmount {
+    fn from(c: CosmWasmCoin) -> Self {
+        MajorCurrencyAmount::from(Coin::from(c))
+    }
+}
+
+impl From<Coin> for MajorCurrencyAmount {
    fn from(coin: Coin) -> Self {
-        DecCoin::new_base(coin.amount, coin.denom)
+        // current assumption: MajorCurrencyAmount is represented as decimal with 6 decimal points
+        // unwrap is fine as we haven't exceeded decimal range since our coins are at max 1B in value
+        // (this is a weak assumption, but for solving this merge conflict it's good enough temporary workaround)
+        let amount = Decimal::from_atomics(coin.amount, 6).unwrap();
+        MajorCurrencyAmount {
+            amount: MajorAmountString(amount.to_string()),
+            denom: CurrencyDenom::parse(&coin.denom).expect("this will go away after the merge..."),
+        }
    }
 }

-// this conversion assumes same denomination
-impl TryFrom<DecCoin> for Coin {
-    type Error = TypesError;
+// temporary...
+impl From<MajorCurrencyAmount> for CosmosCoin {
+    fn from(c: MajorCurrencyAmount) -> CosmosCoin {
+        let c: Coin = c.into();
+        c.into()
+    }
+}

-    fn try_from(value: DecCoin) -> Result<Self, Self::Error> {
-        Ok(Coin {
-            amount: try_convert_decimal_to_u128(value.try_scale_down_value(0)?)?,
-            denom: value.denom,
-        })
+impl From<MajorCurrencyAmount> for CosmWasmCoin {
+    fn from(c: MajorCurrencyAmount) -> CosmWasmCoin {
+        let c: Coin = c.into();
+        c.into()
+    }
+}
+
+impl From<MajorCurrencyAmount> for Coin {
+    fn from(c: MajorCurrencyAmount) -> Coin {
+        let decimal: Decimal = c
+            .amount
+            .0
+            .parse()
+            .expect("stringified amount should have been a valid decimal");
+
+        // again, temporary
+        let exp = Uint128::new(1000000);
+        let val = decimal.mul(exp);
+
+        // again, terrible assumption for denom, but it works temporarily...
+        Coin {
+            amount: val.u128(),
+            denom: format!("u{}", c.denom).to_lowercase(),
+        }
+    }
+}
+
+impl Add for MajorCurrencyAmount {
+    type Output = Self;
+
+    fn add(self, rhs: Self) -> Self::Output {
+        // again, temporary workaround to help with merge
+        (Coin::from(self).try_add(&Coin::from(rhs)))
+            .expect("provided coins had different denoms")
+            .into()
    }
 }

 #[cfg(test)]
 mod test {
    use super::*;
-    use std::convert::TryFrom;
+    use cosmrs::Coin as CosmosCoin;
+    use cosmrs::Decimal as CosmosDecimal;
+    use cosmrs::Denom as CosmosDenom;
+    use cosmwasm_std::Coin as CosmWasmCoin;
+    use cosmwasm_std::Decimal as CosmWasmDecimal;
+    use serde_json::json;
+    use std::str::FromStr;
    use std::string::ToString;

    #[test]
-    fn dec_value_scale_down() {
-        let dec = DecCoin {
-            denom: "foo".to_string(),
-            amount: "1234007000".parse().unwrap(),
-        };
+    fn json_to_major_currency_amount() {
+        let nym = json!({
+            "amount": "1",
+            "denom": "NYM"
+        });
+        let nymt = json!({
+            "amount": "1",
+            "denom": "NYMT"
+        });

+        let test_nym_amount = MajorCurrencyAmount::new("1", CurrencyDenom::Nym);
+        let test_nymt_amount = MajorCurrencyAmount::new("1", CurrencyDenom::Nymt);
+
+        let nym_amount = serde_json::from_value::<MajorCurrencyAmount>(nym).unwrap();
+        let nymt_amount = serde_json::from_value::<MajorCurrencyAmount>(nymt).unwrap();
+
+        assert_eq!(nym_amount, test_nym_amount);
+        assert_eq!(nymt_amount, test_nymt_amount);
+    }
+
+    #[test]
+    fn minor_amount_json_to_major_currency_amount() {
+        let one_micro_nym = json!({
+            "amount": "0.000001",
+            "denom": "NYM"
+        });
+
+        let expected_nym_amount = MajorCurrencyAmount::new("0.000001", CurrencyDenom::Nym);
+        let actual_nym_amount =
+            serde_json::from_value::<MajorCurrencyAmount>(one_micro_nym).unwrap();
+
+        assert_eq!(expected_nym_amount, actual_nym_amount);
+    }
+
+    #[test]
+    fn denom_from_str() {
+        assert_eq!(CurrencyDenom::from_str("nym").unwrap(), CurrencyDenom::Nym);
        assert_eq!(
-            "1234007000".parse::<Decimal>().unwrap(),
-            dec.try_scale_down_value(0).unwrap()
+            CurrencyDenom::from_str("nymt").unwrap(),
+            CurrencyDenom::Nymt
        );
+        assert_eq!(CurrencyDenom::from_str("NYM").unwrap(), CurrencyDenom::Nym);
        assert_eq!(
-            "123400700".parse::<Decimal>().unwrap(),
-            dec.try_scale_down_value(1).unwrap()
+            CurrencyDenom::from_str("NYMT").unwrap(),
+            CurrencyDenom::Nymt
        );
+        assert_eq!(CurrencyDenom::from_str("NyM").unwrap(), CurrencyDenom::Nym);
        assert_eq!(
-            "12340070".parse::<Decimal>().unwrap(),
-            dec.try_scale_down_value(2).unwrap()
-        );
-        assert_eq!(
-            "123400.7".parse::<Decimal>().unwrap(),
-            dec.try_scale_down_value(4).unwrap()
+            CurrencyDenom::from_str("NYmt").unwrap(),
+            CurrencyDenom::Nymt
        );

-        let dec = DecCoin {
-            denom: "foo".to_string(),
-            amount: "10000000000".parse().unwrap(),
-        };
+        assert!(matches!(
+            CurrencyDenom::from_str("foo").unwrap_err(),
+            strum::ParseError::VariantNotFound,
+        ));

+        // denominations must all be major
+        assert!(matches!(
+            CurrencyDenom::from_str("unym").unwrap_err(),
+            strum::ParseError::VariantNotFound,
+        ));
+        assert!(matches!(
+            CurrencyDenom::from_str("unymt").unwrap_err(),
+            strum::ParseError::VariantNotFound,
+        ));
+    }
+
+    #[test]
+    fn to_string() {
        assert_eq!(
-            "100".parse::<Decimal>().unwrap(),
-            dec.try_scale_down_value(8).unwrap()
+            MajorCurrencyAmount::new("1", CurrencyDenom::Nym).to_string(),
+            "1 NYM"
        );
        assert_eq!(
-            "1".parse::<Decimal>().unwrap(),
-            dec.try_scale_down_value(10).unwrap()
+            MajorCurrencyAmount::new("1", CurrencyDenom::Nymt).to_string(),
+            "1 NYMT"
        );
        assert_eq!(
-            "0.01".parse::<Decimal>().unwrap(),
-            dec.try_scale_down_value(12).unwrap()
+            MajorCurrencyAmount::new("1000000000000", CurrencyDenom::Nym).to_string(),
+            "1000000000000 NYM"
        );
    }

    #[test]
-    fn dec_value_scale_up() {
-        let dec = DecCoin {
-            denom: "foo".to_string(),
-            amount: "1234.56".parse().unwrap(),
+    fn minor_coin_to_major_currency() {
+        let cosmos_coin = CosmosCoin {
+            amount: CosmosDecimal::from(1u64),
+            denom: CosmosDenom::from_str("unym").unwrap(),
        };
+        let c = MajorCurrencyAmount::from(cosmos_coin);
+        assert_eq!(c, MajorCurrencyAmount::new("0.000001", CurrencyDenom::Nym));
+    }

-        assert_eq!(
-            "1234.56".parse::<Decimal>().unwrap(),
-            dec.try_scale_up_value(0).unwrap()
-        );
-        assert_eq!(
-            "12345.6".parse::<Decimal>().unwrap(),
-            dec.try_scale_up_value(1).unwrap()
-        );
-        assert_eq!(
-            "123456".parse::<Decimal>().unwrap(),
-            dec.try_scale_up_value(2).unwrap()
-        );
-        assert_eq!(
-            "1234560".parse::<Decimal>().unwrap(),
-            dec.try_scale_up_value(3).unwrap()
-        );
-        assert_eq!(
-            "12345600".parse::<Decimal>().unwrap(),
-            dec.try_scale_up_value(4).unwrap()
-        );
-
-        let dec = DecCoin {
-            denom: "foo".to_string(),
-            amount: "0.00000123".parse().unwrap(),
+    #[test]
+    fn minor_cosmwasm_coin_to_major_currency() {
+        let coin = CosmWasmCoin {
+            amount: Uint128::from(1u64),
+            denom: "unym".to_string(),
        };
-
-        assert_eq!(
-            "0.0000123".parse::<Decimal>().unwrap(),
-            dec.try_scale_up_value(1).unwrap()
-        );
-        assert_eq!(
-            "0.000123".parse::<Decimal>().unwrap(),
-            dec.try_scale_up_value(2).unwrap()
-        );
-        assert_eq!(
-            "123".parse::<Decimal>().unwrap(),
-            dec.try_scale_up_value(8).unwrap()
-        );
-        assert_eq!(
-            "1230".parse::<Decimal>().unwrap(),
-            dec.try_scale_up_value(9).unwrap()
-        );
-        assert_eq!(
-            "12300".parse::<Decimal>().unwrap(),
-            dec.try_scale_up_value(10).unwrap()
+        println!(
+            "from_atomics = {}",
+            CosmWasmDecimal::from_atomics(coin.amount, 6).unwrap()
        );
+        let c: MajorCurrencyAmount = coin.into();
+        assert_eq!(c, MajorCurrencyAmount::new("0.000001", CurrencyDenom::Nym));
    }

    #[test]
-    fn coin_to_dec_coin() {
-        let coin = Coin::new(123, "foo");
-        let dec = DecCoin::from(coin.clone());
-        assert_eq!(coin.denom, dec.denom);
-        assert_eq!(dec.amount, Decimal::from_atomics(coin.amount, 0).unwrap());
-    }
-
-    #[test]
-    fn dec_coin_to_coin() {
-        let dec = DecCoin {
-            denom: "foo".to_string(),
-            amount: "123".parse().unwrap(),
+    fn minor_cosmwasm_coin_to_major_currency_2() {
+        let coin = CosmWasmCoin {
+            amount: Uint128::from(1_000_000u64),
+            denom: "unym".to_string(),
        };
-        let coin = Coin::try_from(dec.clone()).unwrap();
-        assert_eq!(dec.denom, coin.denom);
-        assert_eq!(coin.amount, 123u128);
+        println!(
+            "from_atomics = {:?}",
+            CosmWasmDecimal::from_atomics(coin.amount, 6)
+                .unwrap()
+                .to_string()
+        );
+        let c: MajorCurrencyAmount = coin.into();
+        assert_eq!(c, MajorCurrencyAmount::new("1", CurrencyDenom::Nym));
    }

    #[test]
-    fn converting_to_display() {
-        let reg = RegisteredCoins::default_denoms(Network::MAINNET);
-        let values = vec![
-            (1u128, "0.000001"),
-            (10u128, "0.00001"),
-            (100u128, "0.0001"),
-            (1000u128, "0.001"),
-            (10000u128, "0.01"),
-            (100000u128, "0.1"),
-            (1000000u128, "1"),
-            (1234567u128, "1.234567"),
-            (123456700u128, "123.4567"),
-        ];
-
-        for (raw, expected) in values {
-            let coin = Coin::new(raw, Network::MAINNET.mix_denom().base);
-            let display = reg.attempt_convert_to_display_dec_coin(coin).unwrap();
-            assert_eq!(Network::MAINNET.mix_denom().display, display.denom);
-            assert_eq!(expected, display.amount.to_string());
-        }
+    fn major_currency_to_minor_cosmos_coin() {
+        let expected_cosmos_coin = CosmosCoin {
+            amount: CosmosDecimal::from(1u64),
+            denom: CosmosDenom::from_str("unym").unwrap(),
+        };
+        let c = MajorCurrencyAmount::new("0.000001", CurrencyDenom::Nym);
+        let minor_cosmos_coin = c.into();
+        assert_eq!(expected_cosmos_coin, minor_cosmos_coin);
+        assert_eq!("unym", minor_cosmos_coin.denom.to_string());
    }

    #[test]
-    fn converting_to_base() {
-        let reg = RegisteredCoins::default_denoms(Network::MAINNET);
-        let values = vec![
-            (1u128, "0.000001"),
-            (10u128, "0.00001"),
-            (100u128, "0.0001"),
-            (1000u128, "0.001"),
-            (10000u128, "0.01"),
-            (100000u128, "0.1"),
-            (1000000u128, "1"),
-            (1234567u128, "1.234567"),
-            (123456700u128, "123.4567"),
-        ];
+    fn major_currency_to_minor_cosmos_coin_2() {
+        let expected_cosmos_coin = CosmosCoin {
+            amount: CosmosDecimal::from(1000000u64),
+            denom: CosmosDenom::from_str("unym").unwrap(),
+        };
+        let c = MajorCurrencyAmount::new("1", CurrencyDenom::Nym);
+        let minor_cosmos_coin = c.into();
+        assert_eq!(expected_cosmos_coin, minor_cosmos_coin);
+        assert_eq!("unym", minor_cosmos_coin.denom.to_string());
+    }

-        for (expected, raw_display) in values {
-            let coin = DecCoin {
-                denom: Network::MAINNET.mix_denom().display.into(),
-                amount: raw_display.parse().unwrap(),
-            };
-            let base = reg.attempt_convert_to_base_coin(coin).unwrap();
-            assert_eq!(Network::MAINNET.mix_denom().base, base.denom);
-            assert_eq!(expected, base.amount);
-        }
+    #[test]
+    fn minor_cosmos_coin_to_major_currency_string() {
+        // check minor cosmos coin is converted to major value
+        let cosmos_coin = CosmosCoin {
+            amount: CosmosDecimal::from(1u64),
+            denom: CosmosDenom::from_str("unym").unwrap(),
+        };
+        let c = MajorCurrencyAmount::from(cosmos_coin);
+        assert_eq!(c.to_string(), "0.000001 NYM");
+    }
+
+    #[test]
+    fn denom_to_string() {
+        let c = MajorCurrencyAmount::new("1", CurrencyDenom::Nym);
+        let denom = c.denom.to_string();
+        assert_eq!(denom, "NYM".to_string());
    }
 }
@@ -1,10 +1,13 @@
-use crate::currency::{DecCoin, RegisteredCoins};
-use crate::error::TypesError;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+
+use log::error;
 use mixnet_contract_common::mixnode::DelegationEvent as ContractDelegationEvent;
 use mixnet_contract_common::mixnode::PendingUndelegate as ContractPendingUndelegate;
 use mixnet_contract_common::Delegation as MixnetContractDelegation;
-use schemars::JsonSchema;
-use serde::{Deserialize, Serialize};
+
+use crate::currency::MajorCurrencyAmount;
+use crate::error::TypesError;

 #[cfg_attr(feature = "generate-ts", derive(ts_rs::TS))]
 #[cfg_attr(
@@ -15,22 +18,31 @@ use serde::{Deserialize, Serialize};
 pub struct Delegation {
    pub owner: String,
    pub node_identity: String,
-    pub amount: DecCoin,
+    pub amount: MajorCurrencyAmount,
    pub block_height: u64,
-    pub proxy: Option<String>, // proxy address used to delegate the funds on behalf of another address
+    pub proxy: Option<String>, // proxy address used to delegate the funds on behalf of anouther address
 }

-impl Delegation {
-    pub fn from_mixnet_contract(
-        delegation: MixnetContractDelegation,
-        reg: &RegisteredCoins,
-    ) -> Result<Self, TypesError> {
+impl TryFrom<MixnetContractDelegation> for Delegation {
+    type Error = TypesError;
+
+    fn try_from(value: MixnetContractDelegation) -> Result<Self, Self::Error> {
+        let MixnetContractDelegation {
+            owner,
+            node_identity,
+            amount,
+            block_height,
+            proxy,
+        } = value;
+
+        let amount: MajorCurrencyAmount = amount.into();
+
        Ok(Delegation {
-            owner: delegation.owner.to_string(),
-            node_identity: delegation.node_identity,
-            amount: reg.attempt_convert_to_display_dec_coin(delegation.amount.into())?,
-            block_height: delegation.block_height,
-            proxy: delegation.proxy.map(|d| d.to_string()),
+            owner: owner.into_string(),
+            node_identity,
+            amount,
+            block_height,
+            proxy: proxy.map(|p| p.into_string()),
        })
    }
 }
@@ -42,7 +54,7 @@ impl Delegation {
 )]
 #[derive(Clone, Debug, Deserialize, Serialize, PartialEq, JsonSchema)]
 pub struct DelegationRecord {
-    pub amount: DecCoin,
+    pub amount: MajorCurrencyAmount,
    pub block_height: u64,
    pub delegated_on_iso_datetime: String,
 }
@@ -56,16 +68,16 @@ pub struct DelegationRecord {
 pub struct DelegationWithEverything {
    pub owner: String,
    pub node_identity: String,
-    pub amount: DecCoin,
-    pub total_delegation: Option<DecCoin>,
-    pub pledge_amount: Option<DecCoin>,
+    pub amount: MajorCurrencyAmount,
+    pub total_delegation: Option<MajorCurrencyAmount>,
+    pub pledge_amount: Option<MajorCurrencyAmount>,
    pub block_height: u64,
    pub delegated_on_iso_datetime: String,
    pub profit_margin_percent: Option<u8>,
    pub avg_uptime_percent: Option<u8>,
    pub stake_saturation: Option<f32>,
    pub proxy: Option<String>,
-    pub accumulated_rewards: Option<DecCoin>,
+    pub accumulated_rewards: Option<MajorCurrencyAmount>,
    pub pending_events: Vec<DelegationEvent>,
    pub history: Vec<DelegationRecord>,
 }
@@ -79,7 +91,34 @@ pub struct DelegationWithEverything {
 pub struct DelegationResult {
    source_address: String,
    target_address: String,
-    amount: Option<DecCoin>,
+    amount: Option<MajorCurrencyAmount>,
+}
+
+impl DelegationResult {
+    pub fn new(
+        source_address: &str,
+        target_address: &str,
+        amount: Option<MajorCurrencyAmount>,
+    ) -> DelegationResult {
+        DelegationResult {
+            source_address: source_address.to_string(),
+            target_address: target_address.to_string(),
+            amount,
+        }
+    }
+}
+
+impl TryFrom<MixnetContractDelegation> for DelegationResult {
+    type Error = TypesError;
+
+    fn try_from(delegation: MixnetContractDelegation) -> Result<Self, Self::Error> {
+        let amount: MajorCurrencyAmount = delegation.amount.clone().into();
+        Ok(DelegationResult {
+            source_address: delegation.owner().to_string(),
+            target_address: delegation.node_identity(),
+            amount: Some(amount),
+        })
+    }
 }

 #[cfg_attr(feature = "generate-ts", derive(ts_rs::TS))]
@@ -103,31 +142,33 @@ pub struct DelegationEvent {
    pub kind: DelegationEventKind,
    pub node_identity: String,
    pub address: String,
-    pub amount: Option<DecCoin>,
+    pub amount: Option<MajorCurrencyAmount>,
    pub block_height: u64,
 }

-impl DelegationEvent {
-    pub fn from_mixnet_contract(
-        event: ContractDelegationEvent,
-        reg: &RegisteredCoins,
-    ) -> Result<Self, TypesError> {
-        Ok(match event {
-            ContractDelegationEvent::Delegate(delegation) => DelegationEvent {
-                kind: DelegationEventKind::Delegate,
-                block_height: delegation.block_height,
-                address: delegation.owner.into_string(),
-                node_identity: delegation.node_identity,
-                amount: Some(reg.attempt_convert_to_display_dec_coin(delegation.amount.into())?),
-            },
-            ContractDelegationEvent::Undelegate(pending_undelegate) => DelegationEvent {
+impl TryFrom<ContractDelegationEvent> for DelegationEvent {
+    type Error = TypesError;
+
+    fn try_from(event: ContractDelegationEvent) -> Result<Self, Self::Error> {
+        match event {
+            ContractDelegationEvent::Delegate(delegation) => {
+                let amount: MajorCurrencyAmount = delegation.amount.into();
+                Ok(DelegationEvent {
+                    kind: DelegationEventKind::Delegate,
+                    block_height: delegation.block_height,
+                    address: delegation.owner.into_string(),
+                    node_identity: delegation.node_identity,
+                    amount: Some(amount),
+                })
+            }
+            ContractDelegationEvent::Undelegate(pending_undelegate) => Ok(DelegationEvent {
                kind: DelegationEventKind::Undelegate,
                block_height: pending_undelegate.block_height(),
                address: pending_undelegate.delegate().into_string(),
                node_identity: pending_undelegate.mix_identity(),
                amount: None,
-            },
-        })
+            }),
+        }
    }
 }

@@ -155,6 +196,30 @@ impl From<ContractPendingUndelegate> for PendingUndelegate {
    }
 }

+pub fn from_contract_delegation_events(
+    events: Vec<ContractDelegationEvent>,
+) -> Result<Vec<DelegationEvent>, TypesError> {
+    let (events, errors): (Vec<_>, Vec<_>) = events
+        .into_iter()
+        .map(|delegation_event| delegation_event.try_into())
+        .partition(Result::is_ok);
+
+    if errors.is_empty() {
+        let events = events
+            .into_iter()
+            .filter_map(|e| e.ok())
+            .collect::<Vec<DelegationEvent>>();
+        return Ok(events);
+    }
+    let errors = errors
+        .into_iter()
+        .filter_map(|e| e.err())
+        .collect::<Vec<TypesError>>();
+
+    error!("Failed to convert delegations: {:?}", errors);
+    Err(TypesError::DelegationsInvalid)
+}
+
 #[cfg_attr(feature = "generate-ts", derive(ts_rs::TS))]
 #[cfg_attr(
    feature = "generate-ts",
@@ -163,6 +228,6 @@ impl From<ContractPendingUndelegate> for PendingUndelegate {
 #[derive(Deserialize, Serialize)]
 pub struct DelegationsSummaryResponse {
    pub delegations: Vec<DelegationWithEverything>,
-    pub total_delegations: DecCoin,
-    pub total_rewards: DecCoin,
+    pub total_delegations: MajorCurrencyAmount,
+    pub total_rewards: MajorCurrencyAmount,
 }
@@ -4,7 +4,6 @@ use thiserror::Error;
 use validator_client::validator_api::error::ValidatorAPIError;
 use validator_client::{nymd::error::NymdError, ValidatorClientError};

-// TODO: ask @MS why this even exists
 #[derive(Error, Debug)]
 pub enum TypesError {
    #[error("{source}")]
@@ -62,12 +61,6 @@ pub enum TypesError {
    InvalidGatewayBond(),
    #[error("Invalid delegations")]
    DelegationsInvalid,
-    #[error("Attempted to use too huge currency exponent ({0})")]
-    UnsupportedExponent(u32),
-    #[error("Attempted to convert coin that would have resulted in loss of precision")]
-    LossyCoinConversion,
-    #[error("The provided coin has an unknown denomination - {0}")]
-    UnknownCoinDenom(String),
 }

 impl Serialize for TypesError {
@@ -1,7 +1,9 @@
-use crate::currency::DecCoin;
 use serde::{Deserialize, Serialize};
+
 use validator_client::nymd::Fee;

+use crate::currency::MajorCurrencyAmount;
+
 #[cfg_attr(feature = "generate-ts", derive(ts_rs::TS))]
 #[cfg_attr(
    feature = "generate-ts",
@@ -10,13 +12,7 @@ use validator_client::nymd::Fee;
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct FeeDetails {
    // expected to be used by the wallet in order to display detailed fee information to the user
-    pub amount: Option<DecCoin>,
+    pub amount: Option<MajorCurrencyAmount>,
    #[cfg_attr(feature = "generate-ts", ts(skip))]
    pub fee: Fee,
 }
-
-impl FeeDetails {
-    pub fn new(amount: Option<DecCoin>, fee: Fee) -> Self {
-        FeeDetails { amount, fee }
-    }
-}
@@ -1,29 +1,48 @@
+use crate::currency::MajorCurrencyAmount;
+use crate::error::TypesError;
 use cosmrs::tx::Gas as CosmrsGas;
 use serde::{Deserialize, Serialize};
 use validator_client::nymd::cosmwasm_client::types::GasInfo as ValidatorClientGasInfo;
+use validator_client::nymd::GasPrice;

 #[cfg_attr(feature = "generate-ts", derive(ts_rs::TS))]
 #[cfg_attr(
    feature = "generate-ts",
    ts(export_to = "ts-packages/types/src/types/rust/Gas.ts")
 )]
-#[derive(Deserialize, Serialize, Copy, Clone, Debug)]
+#[derive(Deserialize, Serialize, Clone)]
 pub struct Gas {
    /// units of gas used
    pub gas_units: u64,
+    //
+    // /// gas units converted to fee as major coin amount
+    // pub amount: MajorCurrencyAmount,
 }

 impl Gas {
-    pub fn from_u64(value: u64) -> Gas {
-        Gas { gas_units: value }
-    }
-}
+    pub fn from_cosmrs_gas(value: CosmrsGas, _denom_minor: &str) -> Result<Gas, TypesError> {
+        Ok(Gas {
+            gas_units: value.value(),
+        })

-impl From<CosmrsGas> for Gas {
-    fn from(gas: CosmrsGas) -> Self {
-        Gas {
-            gas_units: gas.value(),
-        }
+        // // TODO: use simulator struct to do conversion to fee
+        // let value_u128 = Uint128::from(value.value());
+        // let amount = Decimal::new(value_u128) * Decimal::from_str("0.0025")?;
+        // Ok(Gas {
+        //     gas_units: value.value(),
+        //     amount: MajorCurrencyAmount::from_minor_decimal_and_denom(amount, denom_minor)?,
+        // })
+    }
+    pub fn from_u64(value: u64, _denom_minor: &str) -> Result<Gas, TypesError> {
+        Ok(Gas { gas_units: value })
+        // todo!()
+        // // TODO: use simulator struct to do conversion to fee
+        // let value_u128 = Uint128::from(value);
+        // let amount = Decimal::new(value_u128) * Decimal::from_str("0.0025")?;
+        // Ok(Gas {
+        //     gas_units: value,
+        //     amount: MajorCurrencyAmount::from_minor_decimal_and_denom(amount, denom_minor)?,
+        // })
    }
 }

@@ -32,29 +51,44 @@ impl From<CosmrsGas> for Gas {
    feature = "generate-ts",
    ts(export_to = "ts-packages/types/src/types/rust/GasInfo.ts")
 )]
-#[derive(Deserialize, Serialize, Copy, Clone, Debug)]
+#[derive(Deserialize, Serialize)]
 pub struct GasInfo {
    /// GasWanted is the maximum units of work we allow this tx to perform.
-    pub gas_wanted: Gas,
+    pub gas_wanted: u64,

    /// GasUsed is the amount of gas actually consumed.
-    pub gas_used: Gas,
-}
+    pub gas_used: u64,

-impl From<ValidatorClientGasInfo> for GasInfo {
-    fn from(info: ValidatorClientGasInfo) -> Self {
-        GasInfo {
-            gas_wanted: info.gas_wanted.into(),
-            gas_used: info.gas_used.into(),
-        }
-    }
+    /// gas units converted to fee as major coin amount
+    pub fee: MajorCurrencyAmount,
 }

 impl GasInfo {
-    pub fn from_u64(gas_wanted: u64, gas_used: u64) -> GasInfo {
-        GasInfo {
-            gas_wanted: Gas::from_u64(gas_wanted),
-            gas_used: Gas::from_u64(gas_used),
-        }
+    pub fn from_validator_client_gas_info(
+        value: ValidatorClientGasInfo,
+        denom_minor: &str,
+    ) -> Result<GasInfo, TypesError> {
+        // terrible workaround, but I don't want to break the current flow (just yet)
+        let gas_price = GasPrice::new_with_default_price(denom_minor)?;
+        let fee = (&gas_price) * value.gas_used;
+        Ok(GasInfo {
+            gas_wanted: value.gas_wanted.value(),
+            gas_used: value.gas_used.value(),
+            fee: fee.into(),
+        })
+    }
+    pub fn from_u64(
+        gas_wanted: u64,
+        gas_used: u64,
+        denom_minor: &str,
+    ) -> Result<GasInfo, TypesError> {
+        // terrible workaround, but I don't want to break the current flow (just yet)
+        let gas_price = GasPrice::new_with_default_price(denom_minor)?;
+        let fee = (&gas_price) * CosmrsGas::from(gas_used);
+        Ok(GasInfo {
+            gas_wanted,
+            gas_used,
+            fee: fee.into(),
+        })
    }
 }
@@ -1,4 +1,4 @@
-use crate::currency::{DecCoin, RegisteredCoins};
+use crate::currency::MajorCurrencyAmount;
 use crate::error::TypesError;
 use mixnet_contract_common::{
    Gateway as MixnetContractGateway, GatewayBond as MixnetContractGatewayBond,
@@ -54,7 +54,7 @@ impl From<MixnetContractGateway> for Gateway {
 )]
 #[derive(Clone, Debug, Deserialize, PartialEq, Serialize, JsonSchema)]
 pub struct GatewayBond {
-    pub pledge_amount: DecCoin,
+    pub pledge_amount: MajorCurrencyAmount,
    pub owner: String,
    pub block_height: u64,
    pub gateway: Gateway,
@@ -63,15 +63,38 @@ pub struct GatewayBond {

 impl GatewayBond {
    pub fn from_mixnet_contract_gateway_bond(
-        bond: MixnetContractGatewayBond,
-        reg: &RegisteredCoins,
-    ) -> Result<GatewayBond, TypesError> {
+        bond: Option<MixnetContractGatewayBond>,
+    ) -> Result<Option<GatewayBond>, TypesError> {
+        match bond {
+            Some(bond) => {
+                let bond: GatewayBond = bond.try_into()?;
+                Ok(Some(bond))
+            }
+            None => Ok(None),
+        }
+    }
+}
+
+impl TryFrom<MixnetContractGatewayBond> for GatewayBond {
+    type Error = TypesError;
+
+    fn try_from(value: MixnetContractGatewayBond) -> Result<Self, Self::Error> {
+        let MixnetContractGatewayBond {
+            pledge_amount,
+            owner,
+            block_height,
+            gateway,
+            proxy,
+        } = value;
+
+        let pledge_amount: MajorCurrencyAmount = pledge_amount.into();
+
        Ok(GatewayBond {
-            pledge_amount: reg.attempt_convert_to_display_dec_coin(bond.pledge_amount.into())?,
-            owner: bond.owner.to_string(),
-            block_height: bond.block_height,
-            gateway: bond.gateway.into(),
-            proxy: bond.proxy.map(|p| p.into_string()),
+            pledge_amount,
+            owner: owner.into_string(),
+            block_height,
+            gateway: gateway.into(),
+            proxy: proxy.map(|p| p.into_string()),
        })
    }
 }
@@ -1,11 +1,11 @@
-use crate::currency::{DecCoin, RegisteredCoins};
+use crate::currency::MajorCurrencyAmount;
 use crate::error::TypesError;
 use mixnet_contract_common::{
-    MixNode as MixnetContractMixNode, MixNodeBond as MixnetContractMixNodeBond,
+    Coin as CosmWasmCoin, MixNode as MixnetContractMixNode,
+    MixNodeBond as MixnetContractMixNodeBond,
 };
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use validator_client::nymd::Coin;

 #[cfg_attr(feature = "generate-ts", derive(ts_rs::TS))]
 #[cfg_attr(
@@ -58,39 +58,67 @@ impl From<MixnetContractMixNode> for MixNode {
 )]
 #[derive(Clone, Debug, Deserialize, PartialEq, Serialize, JsonSchema)]
 pub struct MixNodeBond {
-    pub pledge_amount: DecCoin,
-    pub total_delegation: DecCoin,
+    pub pledge_amount: MajorCurrencyAmount,
+    pub total_delegation: MajorCurrencyAmount,
    pub owner: String,
    pub layer: String,
    pub block_height: u64,
    pub mix_node: MixNode,
    pub proxy: Option<String>,
-    pub accumulated_rewards: Option<DecCoin>,
+    pub accumulated_rewards: Option<MajorCurrencyAmount>,
 }

 impl MixNodeBond {
    pub fn from_mixnet_contract_mixnode_bond(
-        bond: MixnetContractMixNodeBond,
-        reg: &RegisteredCoins,
-    ) -> Result<MixNodeBond, TypesError> {
-        let denom = bond.pledge_amount.denom.clone();
+        bond: Option<MixnetContractMixNodeBond>,
+    ) -> Result<Option<MixNodeBond>, TypesError> {
+        match bond {
+            Some(bond) => {
+                let bond: MixNodeBond = bond.try_into()?;
+                Ok(Some(bond))
+            }
+            None => Ok(None),
+        }
+    }
+}
+
+impl TryFrom<MixnetContractMixNodeBond> for MixNodeBond {
+    type Error = TypesError;
+
+    fn try_from(value: MixnetContractMixNodeBond) -> Result<Self, Self::Error> {
+        let MixnetContractMixNodeBond {
+            pledge_amount,
+            total_delegation,
+            owner,
+            layer,
+            block_height,
+            mix_node,
+            proxy,
+            accumulated_rewards,
+        } = value;
+
+        if pledge_amount.denom != total_delegation.denom {
+            return Err(TypesError::InvalidDenom(
+                "The pledge and delegation denominations do not match".to_string(),
+            ));
+        }
+
+        let denom = total_delegation.denom.clone();
+
+        let pledge_amount: MajorCurrencyAmount = pledge_amount.into();
+        let total_delegation: MajorCurrencyAmount = total_delegation.into();
+        let accumulated_rewards: Option<MajorCurrencyAmount> =
+            accumulated_rewards.map(|r| CosmWasmCoin::new(r.u128(), denom).into());
+
        Ok(MixNodeBond {
-            pledge_amount: reg.attempt_convert_to_display_dec_coin(bond.pledge_amount.into())?,
-            total_delegation: reg
-                .attempt_convert_to_display_dec_coin(bond.total_delegation.into())?,
-            owner: bond.owner.into_string(),
-            layer: bond.layer.into(),
-            block_height: bond.block_height,
-            mix_node: bond.mix_node.into(),
-            proxy: bond.proxy.map(|p| p.to_string()),
-            accumulated_rewards: bond
-                .accumulated_rewards
-                .map(|reward| {
-                    // here we're making an assumption that rewards always use the same denom as the pledge
-                    // (which I think is a reasonable assumption)
-                    reg.attempt_convert_to_display_dec_coin(Coin::new(reward.u128(), denom))
-                })
-                .transpose()?,
+            pledge_amount,
+            total_delegation,
+            owner: owner.into_string(),
+            layer: layer.into(),
+            block_height,
+            mix_node: mix_node.into(),
+            proxy: proxy.map(|p| p.into_string()),
+            accumulated_rewards,
        })
    }
 }
@@ -1,6 +1,6 @@
-use crate::currency::DecCoin;
+use crate::currency::MajorCurrencyAmount;
 use crate::error::TypesError;
-use crate::gas::{Gas, GasInfo};
+use crate::gas::GasInfo;
 use serde::{Deserialize, Serialize};
 use validator_client::nymd::cosmwasm_client::types::ExecuteResult;
 use validator_client::nymd::TxResponse;
@@ -15,23 +15,31 @@ pub struct SendTxResult {
    pub block_height: u64,
    pub code: u32,
    pub details: TransactionDetails,
-    pub gas_used: Gas,
-    pub gas_wanted: Gas,
+    pub gas_used: u64,
+    pub gas_wanted: u64,
    pub tx_hash: String,
-    pub fee: Option<DecCoin>,
+    // pub fee: MajorCurrencyAmount,
 }

 impl SendTxResult {
-    pub fn new(t: TxResponse, details: TransactionDetails, fee: Option<DecCoin>) -> SendTxResult {
-        SendTxResult {
+    pub fn new(
+        t: TxResponse,
+        details: TransactionDetails,
+        _denom_minor: &str,
+    ) -> Result<SendTxResult, TypesError> {
+        Ok(SendTxResult {
            block_height: t.height.value(),
            code: t.tx_result.code.value(),
            details,
-            gas_used: t.tx_result.gas_used.into(),
-            gas_wanted: t.tx_result.gas_wanted.into(),
+            gas_used: t.tx_result.gas_used.value(),
+            gas_wanted: t.tx_result.gas_wanted.value(),
            tx_hash: t.hash.to_string(),
-            fee,
-        }
+            // that is completely wrong: fee is what you told the validator to use beforehand
+            // fee: MajorCurrencyAmount::from_decimal_and_denom(
+            //     Decimal::new(Uint128::from(t.tx_result.gas_used.value())),
+            //     denom_minor.to_string(),
+            // )?,
+        })
    }
 }

@@ -42,21 +50,11 @@ impl SendTxResult {
 )]
 #[derive(Deserialize, Serialize, Debug)]
 pub struct TransactionDetails {
-    pub amount: DecCoin,
+    pub amount: MajorCurrencyAmount,
    pub from_address: String,
    pub to_address: String,
 }

-impl TransactionDetails {
-    pub fn new(amount: DecCoin, from_address: String, to_address: String) -> Self {
-        TransactionDetails {
-            amount,
-            from_address,
-            to_address,
-        }
-    }
-}
-
 #[cfg_attr(feature = "generate-ts", derive(ts_rs::TS))]
 #[cfg_attr(
    feature = "generate-ts",
@@ -68,16 +66,18 @@ pub struct TransactionExecuteResult {
    pub data_json: String,
    pub transaction_hash: String,
    pub gas_info: GasInfo,
-    pub fee: Option<DecCoin>,
+    pub fee: MajorCurrencyAmount,
 }

 impl TransactionExecuteResult {
    pub fn from_execute_result(
        value: ExecuteResult,
-        fee: Option<DecCoin>,
+        denom_minor: &str,
    ) -> Result<TransactionExecuteResult, TypesError> {
+        let gas_info = GasInfo::from_validator_client_gas_info(value.gas_info, denom_minor)?;
+        let fee = gas_info.fee.clone();
        Ok(TransactionExecuteResult {
-            gas_info: value.gas_info.into(),
+            gas_info,
            transaction_hash: value.transaction_hash.to_string(),
            data_json: ::serde_json::to_string_pretty(&value.data)?,
            logs_json: ::serde_json::to_string_pretty(&value.logs)?,
@@ -97,24 +97,30 @@ pub struct RpcTransactionResponse {
    pub tx_result_json: String,
    pub block_height: u64,
    pub transaction_hash: String,
-    pub gas_used: Gas,
-    pub gas_wanted: Gas,
-    pub fee: Option<DecCoin>,
+    pub gas_info: GasInfo,
+    // pub fee: MajorCurrencyAmount,
 }

 impl RpcTransactionResponse {
    pub fn from_tx_response(
-        t: &TxResponse,
-        fee: Option<DecCoin>,
+        value: &TxResponse,
+        denom_minor: &str,
    ) -> Result<RpcTransactionResponse, TypesError> {
        Ok(RpcTransactionResponse {
-            index: t.index,
-            gas_used: t.tx_result.gas_used.into(),
-            gas_wanted: t.tx_result.gas_wanted.into(),
-            transaction_hash: t.hash.to_string(),
-            tx_result_json: ::serde_json::to_string_pretty(&t.tx_result)?,
-            block_height: t.height.value(),
-            fee,
+            index: value.index,
+            gas_info: GasInfo::from_u64(
+                value.tx_result.gas_wanted.value(),
+                value.tx_result.gas_used.value(),
+                denom_minor,
+            )?,
+            transaction_hash: value.hash.to_string(),
+            tx_result_json: ::serde_json::to_string_pretty(&value.tx_result)?,
+            block_height: value.height.value(),
+            // wrong
+            // fee: MajorCurrencyAmount::from_decimal_and_denom(
+            //     Decimal::new(Uint128::from(value.tx_result.gas_used.value())),
+            //     denom_minor.to_string(),
+            // )?,
        })
    }
 }
@@ -1,10 +1,10 @@
-use crate::currency::{DecCoin, RegisteredCoins};
+use crate::currency::MajorCurrencyAmount;
 use crate::error::TypesError;
 use serde::{Deserialize, Serialize};
-use vesting_contract::vesting::Account as ContractVestingAccount;
-use vesting_contract::vesting::VestingPeriod as ContractVestingPeriod;
-use vesting_contract_common::OriginalVestingResponse as ContractOriginalVestingResponse;
-use vesting_contract_common::PledgeData as ContractPledgeData;
+use vesting_contract::vesting::Account as VestingAccount;
+use vesting_contract::vesting::VestingPeriod as VestingVestingPeriod;
+use vesting_contract_common::OriginalVestingResponse as VestingOriginalVestingResponse;
+use vesting_contract_common::PledgeData as VestingPledgeData;

 #[cfg_attr(feature = "generate-ts", derive(ts_rs::TS))]
 #[cfg_attr(
@@ -13,22 +13,28 @@ use vesting_contract_common::PledgeData as ContractPledgeData;
 )]
 #[derive(Serialize, Deserialize, Debug)]
 pub struct PledgeData {
-    pub amount: DecCoin,
+    pub amount: MajorCurrencyAmount,
    pub block_time: u64,
 }

-impl PledgeData {
-    pub fn from_vesting_contract(
-        pledge: ContractPledgeData,
-        reg: &RegisteredCoins,
-    ) -> Result<Self, TypesError> {
-        Ok(PledgeData {
-            amount: reg.attempt_convert_to_display_dec_coin(pledge.amount.into())?,
-            block_time: pledge.block_time.seconds(),
+impl TryFrom<VestingPledgeData> for PledgeData {
+    type Error = TypesError;
+
+    fn try_from(data: VestingPledgeData) -> Result<Self, Self::Error> {
+        let amount: MajorCurrencyAmount = data.amount().into();
+        Ok(Self {
+            amount,
+            block_time: data.block_time().seconds(),
        })
    }
 }

+impl PledgeData {
+    pub fn and_then(data: VestingPledgeData) -> Option<Self> {
+        data.try_into().ok()
+    }
+}
+
 #[cfg_attr(feature = "generate-ts", derive(ts_rs::TS))]
 #[cfg_attr(
    feature = "generate-ts",
@@ -36,20 +42,20 @@ impl PledgeData {
 )]
 #[derive(Serialize, Deserialize, Debug)]
 pub struct OriginalVestingResponse {
-    amount: DecCoin,
+    amount: MajorCurrencyAmount,
    number_of_periods: usize,
    period_duration: u64,
 }

-impl OriginalVestingResponse {
-    pub fn from_vesting_contract(
-        res: ContractOriginalVestingResponse,
-        reg: &RegisteredCoins,
-    ) -> Result<Self, TypesError> {
-        Ok(OriginalVestingResponse {
-            amount: reg.attempt_convert_to_display_dec_coin(res.amount.into())?,
-            number_of_periods: res.number_of_periods,
-            period_duration: res.period_duration,
+impl TryFrom<VestingOriginalVestingResponse> for OriginalVestingResponse {
+    type Error = TypesError;
+
+    fn try_from(data: VestingOriginalVestingResponse) -> Result<Self, Self::Error> {
+        let amount = data.amount().into();
+        Ok(Self {
+            amount,
+            number_of_periods: data.number_of_periods(),
+            period_duration: data.period_duration(),
        })
    }
 }
@@ -65,20 +71,24 @@ pub struct VestingAccountInfo {
    staking_address: Option<String>,
    start_time: u64,
    periods: Vec<VestingPeriod>,
-    amount: DecCoin,
+    amount: MajorCurrencyAmount,
 }

-impl VestingAccountInfo {
-    pub fn from_vesting_contract(
-        account: ContractVestingAccount,
-        reg: &RegisteredCoins,
-    ) -> Result<Self, TypesError> {
-        Ok(VestingAccountInfo {
+impl TryFrom<VestingAccount> for VestingAccountInfo {
+    type Error = TypesError;
+
+    fn try_from(account: VestingAccount) -> Result<Self, Self::Error> {
+        let mut periods = Vec::new();
+        for period in account.periods() {
+            periods.push(period.into());
+        }
+        let amount: MajorCurrencyAmount = account.coin().into();
+        Ok(Self {
            owner_address: account.owner_address().to_string(),
            staking_address: account.staking_address().map(|a| a.to_string()),
            start_time: account.start_time().seconds(),
-            periods: account.periods().into_iter().map(Into::into).collect(),
-            amount: reg.attempt_convert_to_display_dec_coin(account.coin.into())?,
+            periods,
+            amount,
        })
    }
 }
@@ -94,8 +104,8 @@ pub struct VestingPeriod {
    period_seconds: u64,
 }

-impl From<ContractVestingPeriod> for VestingPeriod {
-    fn from(period: ContractVestingPeriod) -> Self {
+impl From<VestingVestingPeriod> for VestingPeriod {
+    fn from(period: VestingVestingPeriod) -> Self {
        Self {
            start_time: period.start_time,
            period_seconds: period.period_seconds,
@@ -468,9 +468,9 @@ dependencies = [

 [[package]]
 name = "cw2"
-version = "0.13.1"
+version = "0.13.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d686da2d2b3b646bea15d448dc25c3e132097a7c40ef9ba7b4db741375b6181f"
+checksum = "04cf4639517490dd36b333bbd6c4fbd92e325fd0acf4683b41753bc5eb63bfc1"
 dependencies = [
 "cosmwasm-std",
 "cw-storage-plus",
@@ -480,9 +480,9 @@ dependencies = [

 [[package]]
 name = "cw3"
-version = "0.13.1"
+version = "0.13.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b7c7a87aed0637432c9ec39a691e533e18006dd400c67bce9f0ad643de7d52c"
+checksum = "fe19462a7f644ba60c19d3443cb90d00c50d9b6b3b0a3a7fca93df8261af979b"
 dependencies = [
 "cosmwasm-std",
 "cw-utils",
@@ -492,9 +492,9 @@ dependencies = [

 [[package]]
 name = "cw3-fixed-multisig"
-version = "0.13.1"
+version = "0.13.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "666afbb3bcaefc697047a0be8c4c5015be053a8456d27dd26e0b8ab114f6f5dd"
+checksum = "df54aa54c13f405ec4ab36b6217538bc957d439eee58f89312db05a79caf6706"
 dependencies = [
 "cosmwasm-std",
 "cw-storage-plus",
@@ -528,9 +528,9 @@ dependencies = [

 [[package]]
 name = "cw4"
-version = "0.13.1"
+version = "0.13.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "51d51b6e05094bfb91029f5baf5d1f39ee10f16fd61f8bf0e6f6632a5dbfb7f9"
+checksum = "0acc3549d5ce11c6901b3a676f2e2628684722197054d97cd0101ea174ed5cbd"
 dependencies = [
 "cosmwasm-std",
 "cw-storage-plus",
@@ -1,867 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-version = 3
-
-[[package]]
-name = "base64"
-version = "0.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "904dfeac50f3cdaba28fc6f57fdcddb75f49ed61346676a78c4ffe55877802fd"
-
-[[package]]
-name = "block-buffer"
-version = "0.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0940dc441f31689269e10ac70eb1002a3a1d3ad1390e030043662eb7fe4688b"
-dependencies = [
- "block-padding",
- "byte-tools",
- "byteorder",
- "generic-array 0.12.4",
-]
-
-[[package]]
-name = "block-buffer"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4152116fd6e9dadb291ae18fc1ec3575ed6d84c29642d97890f4b4a3417297e4"
-dependencies = [
- "generic-array 0.14.4",
-]
-
-[[package]]
-name = "block-padding"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa79dedbb091f449f1f39e53edf88d5dbe95f895dae6135a8d7b881fb5af73f5"
-dependencies = [
- "byte-tools",
-]
-
-[[package]]
-name = "byte-tools"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3b5ca7a04898ad4bcd41c90c5285445ff5b791899bb1b0abdd2a2aa791211d7"
-
-[[package]]
-name = "byteorder"
-version = "1.4.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
-
-[[package]]
-name = "cfg-if"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
-
-[[package]]
-name = "config"
-version = "0.1.0"
-dependencies = [
- "handlebars",
- "humantime-serde",
- "network-defaults",
- "serde",
- "toml",
- "url",
-]
-
-[[package]]
-name = "const-oid"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fdab415d6744056100f40250a66bc430c1a46f7a02e20bc11c94c79a0f0464df"
-
-[[package]]
-name = "cosmos_contract"
-version = "0.1.0"
-dependencies = [
- "config",
- "cosmwasm-std",
- "cosmwasm-storage",
- "erc20-bridge-contract",
- "schemars",
- "serde",
- "thiserror",
-]
-
-[[package]]
-name = "cosmwasm-crypto"
-version = "1.0.0-beta2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c16b255449b3f5cd7fa4b79acd5225b5185655261087a3d8aaac44f88a0e23e9"
-dependencies = [
- "digest 0.9.0",
- "ed25519-zebra",
- "k256",
- "rand_core 0.5.1",
- "thiserror",
-]
-
-[[package]]
-name = "cosmwasm-derive"
-version = "1.0.0-beta2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "abad1a6ff427a2f66890a4dce6354b4563cd07cee91a942300e011c921c09ed2"
-dependencies = [
- "syn",
-]
-
-[[package]]
-name = "cosmwasm-std"
-version = "1.0.0-beta2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1660ee3d5734672e1eb4f0ceda403e2d83345e15143a48845f340f3252ce99a6"
-dependencies = [
- "base64",
- "cosmwasm-crypto",
- "cosmwasm-derive",
- "schemars",
- "serde",
- "serde-json-wasm",
- "thiserror",
- "uint",
-]
-
-[[package]]
-name = "cosmwasm-storage"
-version = "1.0.0-beta2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf3b4efe3b4f86df668520a02e9a29c23eea99b64dfcacb0e59b98346418af7f"
-dependencies = [
- "cosmwasm-std",
- "serde",
-]
-
-[[package]]
-name = "cpufeatures"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95059428f66df56b63431fdb4e1947ed2190586af5c5a8a8b71122bdf5a7f469"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "crunchy"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"
-
-[[package]]
-name = "crypto-bigint"
-version = "0.2.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d12477e115c0d570c12a2dfd859f80b55b60ddb5075df210d3af06d133a69f45"
-dependencies = [
- "generic-array 0.14.4",
- "rand_core 0.6.3",
- "subtle",
- "zeroize",
-]
-
-[[package]]
-name = "crypto-mac"
-version = "0.11.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1d1a86f49236c215f271d40892d5fc950490551400b02ef360692c29815c714"
-dependencies = [
- "generic-array 0.14.4",
- "subtle",
-]
-
-[[package]]
-name = "curve25519-dalek"
-version = "3.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b9fdf9972b2bd6af2d913799d9ebc165ea4d2e65878e329d9c6b372c4491b61"
-dependencies = [
- "byteorder",
- "digest 0.9.0",
- "rand_core 0.5.1",
- "subtle",
- "zeroize",
-]
-
-[[package]]
-name = "der"
-version = "0.4.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28e98c534e9c8a0483aa01d6f6913bc063de254311bd267c9cf535e9b70e15b2"
-dependencies = [
- "const-oid",
-]
-
-[[package]]
-name = "digest"
-version = "0.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3d0c8c8752312f9713efd397ff63acb9f85585afbf179282e720e7704954dd5"
-dependencies = [
- "generic-array 0.12.4",
-]
-
-[[package]]
-name = "digest"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3dd60d1080a57a05ab032377049e0591415d2b31afd7028356dbf3cc6dcb066"
-dependencies = [
- "generic-array 0.14.4",
-]
-
-[[package]]
-name = "dyn-clone"
-version = "1.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee2626afccd7561a06cf1367e2950c4718ea04565e20fb5029b6c7d8ad09abcf"
-
-[[package]]
-name = "ecdsa"
-version = "0.12.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43ee23aa5b4f68c7a092b5c3beb25f50c406adc75e2363634f242f28ab255372"
-dependencies = [
- "der",
- "elliptic-curve",
- "hmac",
- "signature",
-]
-
-[[package]]
-name = "ed25519-zebra"
-version = "2.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0a128b76af6dd4b427e34a6fd43dc78dbfe73672ec41ff615a2414c1a0ad0409"
-dependencies = [
- "curve25519-dalek",
- "hex",
- "rand_core 0.5.1",
- "serde",
- "sha2",
- "thiserror",
-]
-
-[[package]]
-name = "elliptic-curve"
-version = "0.10.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "beca177dcb8eb540133e7680baff45e7cc4d93bf22002676cec549f82343721b"
-dependencies = [
- "crypto-bigint",
- "ff",
- "generic-array 0.14.4",
- "group",
- "pkcs8",
- "rand_core 0.6.3",
- "subtle",
- "zeroize",
-]
-
-[[package]]
-name = "erc20-bridge-contract"
-version = "0.1.0"
-dependencies = [
- "schemars",
- "serde",
-]
-
-[[package]]
-name = "fake-simd"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e88a8acf291dafb59c2d96e8f59828f3838bb1a70398823ade51a84de6a6deed"
-
-[[package]]
-name = "ff"
-version = "0.10.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d0f40b2dcd8bc322217a5f6559ae5f9e9d1de202a2ecee2e9eafcbece7562a4f"
-dependencies = [
- "rand_core 0.6.3",
- "subtle",
-]
-
-[[package]]
-name = "form_urlencoded"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5fc25a87fa4fd2094bffb06925852034d90a17f0d1e05197d4956d3555752191"
-dependencies = [
- "matches",
- "percent-encoding",
-]
-
-[[package]]
-name = "generic-array"
-version = "0.12.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ffdf9f34f1447443d37393cc6c2b8313aebddcd96906caf34e54c68d8e57d7bd"
-dependencies = [
- "typenum",
-]
-
-[[package]]
-name = "generic-array"
-version = "0.14.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "501466ecc8a30d1d3b7fc9229b122b2ce8ed6e9d9223f1138d4babb253e51817"
-dependencies = [
- "typenum",
- "version_check",
-]
-
-[[package]]
-name = "getrandom"
-version = "0.1.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8fc3cb4d91f53b50155bdcfd23f6a4c39ae1969c2ae85982b135750cccaf5fce"
-dependencies = [
- "cfg-if",
- "libc",
- "wasi 0.9.0+wasi-snapshot-preview1",
-]
-
-[[package]]
-name = "getrandom"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fcd999463524c52659517fe2cea98493cfe485d10565e7b0fb07dbba7ad2753"
-dependencies = [
- "cfg-if",
- "libc",
- "wasi 0.10.2+wasi-snapshot-preview1",
-]
-
-[[package]]
-name = "group"
-version = "0.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c363a5301b8f153d80747126a04b3c82073b9fe3130571a9d170cacdeaf7912"
-dependencies = [
- "ff",
- "rand_core 0.6.3",
- "subtle",
-]
-
-[[package]]
-name = "handlebars"
-version = "3.5.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4498fc115fa7d34de968184e473529abb40eeb6be8bc5f7faba3d08c316cb3e3"
-dependencies = [
- "log",
- "pest",
- "pest_derive",
- "quick-error",
- "serde",
- "serde_json",
-]
-
-[[package]]
-name = "hex"
-version = "0.4.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
-
-[[package]]
-name = "hex-literal"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "21e4590e13640f19f249fe3e4eca5113bc4289f2497710378190e7f4bd96f45b"
-
-[[package]]
-name = "hmac"
-version = "0.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a2a2320eb7ec0ebe8da8f744d7812d9fc4cb4d09344ac01898dbcb6a20ae69b"
-dependencies = [
- "crypto-mac",
- "digest 0.9.0",
-]
-
-[[package]]
-name = "humantime"
-version = "2.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
-
-[[package]]
-name = "humantime-serde"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac34a56cfd4acddb469cc7fff187ed5ac36f498ba085caf8bbc725e3ff474058"
-dependencies = [
- "humantime",
- "serde",
-]
-
-[[package]]
-name = "idna"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "418a0a6fab821475f634efe3ccc45c013f742efe03d853e8d3355d5cb850ecf8"
-dependencies = [
- "matches",
- "unicode-bidi",
- "unicode-normalization",
-]
-
-[[package]]
-name = "itoa"
-version = "0.4.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b71991ff56294aa922b450139ee08b3bfc70982c6b2c7562771375cf73542dd4"
-
-[[package]]
-name = "k256"
-version = "0.9.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "903ae2481bcdfdb7b68e0a9baa4b7c9aff600b9ae2e8e5bb5833b8c91ab851ea"
-dependencies = [
- "cfg-if",
- "ecdsa",
- "elliptic-curve",
- "sha2",
-]
-
-[[package]]
-name = "libc"
-version = "0.2.103"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd8f7255a17a627354f321ef0055d63b898c6fb27eff628af4d1b66b7331edf6"
-
-[[package]]
-name = "log"
-version = "0.4.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710"
-dependencies = [
- "cfg-if",
-]
-
-[[package]]
-name = "maplit"
-version = "1.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e2e65a1a2e43cfcb47a895c4c8b10d1f4a61097f9f254f183aee60cad9c651d"
-
-[[package]]
-name = "matches"
-version = "0.1.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a3e378b66a060d48947b590737b30a1be76706c8dd7b8ba0f2fe3989c68a853f"
-
-[[package]]
-name = "network-defaults"
-version = "0.1.0"
-dependencies = [
- "hex-literal",
- "serde",
- "time",
- "url",
-]
-
-[[package]]
-name = "opaque-debug"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2839e79665f131bdb5782e51f2c6c9599c133c6098982a54c794358bf432529c"
-
-[[package]]
-name = "opaque-debug"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "624a8340c38c1b80fd549087862da4ba43e08858af025b236e509b6649fc13d5"
-
-[[package]]
-name = "percent-encoding"
-version = "2.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e"
-
-[[package]]
-name = "pest"
-version = "2.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "10f4872ae94d7b90ae48754df22fd42ad52ce740b8f370b03da4835417403e53"
-dependencies = [
- "ucd-trie",
-]
-
-[[package]]
-name = "pest_derive"
-version = "2.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "833d1ae558dc601e9a60366421196a8d94bc0ac980476d0b67e1d0988d72b2d0"
-dependencies = [
- "pest",
- "pest_generator",
-]
-
-[[package]]
-name = "pest_generator"
-version = "2.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "99b8db626e31e5b81787b9783425769681b347011cc59471e33ea46d2ea0cf55"
-dependencies = [
- "pest",
- "pest_meta",
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "pest_meta"
-version = "2.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "54be6e404f5317079812fc8f9f5279de376d8856929e21c184ecf6bbd692a11d"
-dependencies = [
- "maplit",
- "pest",
- "sha-1",
-]
-
-[[package]]
-name = "pkcs8"
-version = "0.7.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee3ef9b64d26bad0536099c816c6734379e45bbd5f14798def6809e5cc350447"
-dependencies = [
- "der",
- "spki",
-]
-
-[[package]]
-name = "proc-macro2"
-version = "1.0.29"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9f5105d4fdaab20335ca9565e106a5d9b82b6219b5ba735731124ac6711d23d"
-dependencies = [
- "unicode-xid",
-]
-
-[[package]]
-name = "quick-error"
-version = "2.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a993555f31e5a609f617c12db6250dedcac1b0a85076912c436e6fc9b2c8e6a3"
-
-[[package]]
-name = "quote"
-version = "1.0.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38bc8cc6a5f2e3655e0899c1b848643b2562f853f114bfec7be120678e3ace05"
-dependencies = [
- "proc-macro2",
-]
-
-[[package]]
-name = "rand_core"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19"
-dependencies = [
- "getrandom 0.1.16",
-]
-
-[[package]]
-name = "rand_core"
-version = "0.6.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7"
-dependencies = [
- "getrandom 0.2.3",
-]
-
-[[package]]
-name = "ryu"
-version = "1.0.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "71d301d4193d031abdd79ff7e3dd721168a9572ef3fe51a1517aba235bd8f86e"
-
-[[package]]
-name = "schemars"
-version = "0.8.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7a48d098c2a7fdf5740b19deb1181b4fb8a9e68e03ae517c14cde04b5725409"
-dependencies = [
- "dyn-clone",
- "schemars_derive",
- "serde",
- "serde_json",
-]
-
-[[package]]
-name = "schemars_derive"
-version = "0.8.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a9ea2a613fe4cd7118b2bb101a25d8ae6192e1975179b67b2f17afd11e70ac8"
-dependencies = [
- "proc-macro2",
- "quote",
- "serde_derive_internals",
- "syn",
-]
-
-[[package]]
-name = "serde"
-version = "1.0.130"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f12d06de37cf59146fbdecab66aa99f9fe4f78722e3607577a5375d66bd0c913"
-dependencies = [
- "serde_derive",
-]
-
-[[package]]
-name = "serde-json-wasm"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50eef3672ec8fa45f3457fd423ba131117786784a895548021976117c1ded449"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "serde_derive"
-version = "1.0.130"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7bc1a1ab1961464eae040d96713baa5a724a8152c1222492465b54322ec508b"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "serde_derive_internals"
-version = "0.25.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1dbab34ca63057a1f15280bdf3c39f2b1eb1b54c17e98360e511637aef7418c6"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "serde_json"
-version = "1.0.68"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0f690853975602e1bfe1ccbf50504d67174e3bcf340f23b5ea9992e0587a52d8"
-dependencies = [
- "itoa",
- "ryu",
- "serde",
-]
-
-[[package]]
-name = "sha-1"
-version = "0.8.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7d94d0bede923b3cea61f3f1ff57ff8cdfd77b400fb8f9998949e0cf04163df"
-dependencies = [
- "block-buffer 0.7.3",
- "digest 0.8.1",
- "fake-simd",
- "opaque-debug 0.2.3",
-]
-
-[[package]]
-name = "sha2"
-version = "0.9.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b69f9a4c9740d74c5baa3fd2e547f9525fa8088a8a958e0ca2409a514e33f5fa"
-dependencies = [
- "block-buffer 0.9.0",
- "cfg-if",
- "cpufeatures",
- "digest 0.9.0",
- "opaque-debug 0.3.0",
-]
-
-[[package]]
-name = "signature"
-version = "1.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c19772be3c4dd2ceaacf03cb41d5885f2a02c4d8804884918e3a258480803335"
-dependencies = [
- "digest 0.9.0",
- "rand_core 0.6.3",
-]
-
-[[package]]
-name = "spki"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c01a0c15da1b0b0e1494112e7af814a678fec9bd157881b49beac661e9b6f32"
-dependencies = [
- "der",
-]
-
-[[package]]
-name = "static_assertions"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
-
-[[package]]
-name = "subtle"
-version = "2.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6bdef32e8150c2a081110b42772ffe7d7c9032b606bc226c8260fd97e0976601"
-
-[[package]]
-name = "syn"
-version = "1.0.65"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3a1d708c221c5a612956ef9f75b37e454e88d1f7b899fbd3a18d4252012d663"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-xid",
-]
-
-[[package]]
-name = "thiserror"
-version = "1.0.29"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "602eca064b2d83369e2b2f34b09c70b605402801927c65c11071ac911d299b88"
-dependencies = [
- "thiserror-impl",
-]
-
-[[package]]
-name = "thiserror-impl"
-version = "1.0.29"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bad553cc2c78e8de258400763a647e80e6d1b31ee237275d756f6836d204494c"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "time"
-version = "0.3.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "99beeb0daeac2bd1e86ac2c21caddecb244b39a093594da1a661ec2060c7aedd"
-dependencies = [
- "libc",
- "time-macros",
-]
-
-[[package]]
-name = "time-macros"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "25eb0ca3468fc0acc11828786797f6ef9aa1555e4a211a60d64cc8e4d1be47d6"
-
-[[package]]
-name = "tinyvec"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f83b2a3d4d9091d0abd7eba4dc2710b1718583bd4d8992e2190720ea38f391f7"
-dependencies = [
- "tinyvec_macros",
-]
-
-[[package]]
-name = "tinyvec_macros"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cda74da7e1a664f795bb1f8a87ec406fb89a02522cf6e50620d016add6dbbf5c"
-
-[[package]]
-name = "toml"
-version = "0.5.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a31142970826733df8241ef35dc040ef98c679ab14d7c3e54d827099b3acecaa"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "typenum"
-version = "1.14.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b63708a265f51345575b27fe43f9500ad611579e764c79edbc2037b1121959ec"
-
-[[package]]
-name = "ucd-trie"
-version = "0.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56dee185309b50d1f11bfedef0fe6d036842e3fb77413abef29f8f8d1c5d4c1c"
-
-[[package]]
-name = "uint"
-version = "0.9.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6470ab50f482bde894a037a57064480a246dbfdd5960bd65a44824693f08da5f"
-dependencies = [
- "byteorder",
- "crunchy",
- "hex",
- "static_assertions",
-]
-
-[[package]]
-name = "unicode-bidi"
-version = "0.3.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a01404663e3db436ed2746d9fefef640d868edae3cceb81c3b8d5732fda678f"
-
-[[package]]
-name = "unicode-normalization"
-version = "0.1.19"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d54590932941a9e9266f0832deed84ebe1bf2e4c9e4a3554d393d18f5e854bf9"
-dependencies = [
- "tinyvec",
-]
-
-[[package]]
-name = "unicode-xid"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"
-
-[[package]]
-name = "url"
-version = "2.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a507c383b2d33b5fc35d1861e77e6b383d158b2da5e14fe51b83dfedf6fd578c"
-dependencies = [
- "form_urlencoded",
- "idna",
- "matches",
- "percent-encoding",
-]
-
-[[package]]
-name = "version_check"
-version = "0.9.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5fecdca9a5291cc2b8dcf7dc02453fee791a280f3743cb0905f8822ae463b3fe"
-
-[[package]]
-name = "wasi"
-version = "0.9.0+wasi-snapshot-preview1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519"
-
-[[package]]
-name = "wasi"
-version = "0.10.2+wasi-snapshot-preview1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6"
-
-[[package]]
-name = "zeroize"
-version = "1.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4756f7db3f7b5574938c3eb1c117038b8e07f95ee6718c0efad4ac21508f1efd"
@@ -62,7 +62,7 @@ pub fn migrate(_deps: DepsMut<'_>, _env: Env, _msg: MigrateMsg) -> Result<Respon
 pub mod tests {
    use super::*;
    use bandwidth_claim_contract::payment::PagedPaymentResponse;
-    use config::defaults::MIX_DENOM;
+    use config::defaults::DENOM;
    use cosmwasm_std::testing::{mock_dependencies, mock_env, mock_info};
    use cosmwasm_std::{coins, from_binary};

@@ -91,11 +91,11 @@ pub mod tests {

        // Contract balance should match what we initialized it as
        assert_eq!(
-            coins(0, MIX_DENOM.base),
+            coins(0, DENOM),
            vec![deps
                .as_ref()
                .querier
-                .query_balance(env.contract.address, MIX_DENOM.base)
+                .query_balance(env.contract.address, DENOM)
                .unwrap()]
        );
    }
@@ -1,867 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-version = 3
-
-[[package]]
-name = "base64"
-version = "0.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "904dfeac50f3cdaba28fc6f57fdcddb75f49ed61346676a78c4ffe55877802fd"
-
-[[package]]
-name = "block-buffer"
-version = "0.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0940dc441f31689269e10ac70eb1002a3a1d3ad1390e030043662eb7fe4688b"
-dependencies = [
- "block-padding",
- "byte-tools",
- "byteorder",
- "generic-array 0.12.4",
-]
-
-[[package]]
-name = "block-buffer"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4152116fd6e9dadb291ae18fc1ec3575ed6d84c29642d97890f4b4a3417297e4"
-dependencies = [
- "generic-array 0.14.4",
-]
-
-[[package]]
-name = "block-padding"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa79dedbb091f449f1f39e53edf88d5dbe95f895dae6135a8d7b881fb5af73f5"
-dependencies = [
- "byte-tools",
-]
-
-[[package]]
-name = "byte-tools"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3b5ca7a04898ad4bcd41c90c5285445ff5b791899bb1b0abdd2a2aa791211d7"
-
-[[package]]
-name = "byteorder"
-version = "1.4.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
-
-[[package]]
-name = "cfg-if"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
-
-[[package]]
-name = "config"
-version = "0.1.0"
-dependencies = [
- "handlebars",
- "humantime-serde",
- "network-defaults",
- "serde",
- "toml",
- "url",
-]
-
-[[package]]
-name = "const-oid"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fdab415d6744056100f40250a66bc430c1a46f7a02e20bc11c94c79a0f0464df"
-
-[[package]]
-name = "cosmos_contract"
-version = "0.1.0"
-dependencies = [
- "config",
- "cosmwasm-std",
- "cosmwasm-storage",
- "erc20-bridge-contract",
- "schemars",
- "serde",
- "thiserror",
-]
-
-[[package]]
-name = "cosmwasm-crypto"
-version = "1.0.0-beta2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c16b255449b3f5cd7fa4b79acd5225b5185655261087a3d8aaac44f88a0e23e9"
-dependencies = [
- "digest 0.9.0",
- "ed25519-zebra",
- "k256",
- "rand_core 0.5.1",
- "thiserror",
-]
-
-[[package]]
-name = "cosmwasm-derive"
-version = "1.0.0-beta2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "abad1a6ff427a2f66890a4dce6354b4563cd07cee91a942300e011c921c09ed2"
-dependencies = [
- "syn",
-]
-
-[[package]]
-name = "cosmwasm-std"
-version = "1.0.0-beta2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1660ee3d5734672e1eb4f0ceda403e2d83345e15143a48845f340f3252ce99a6"
-dependencies = [
- "base64",
- "cosmwasm-crypto",
- "cosmwasm-derive",
- "schemars",
- "serde",
- "serde-json-wasm",
- "thiserror",
- "uint",
-]
-
-[[package]]
-name = "cosmwasm-storage"
-version = "1.0.0-beta2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf3b4efe3b4f86df668520a02e9a29c23eea99b64dfcacb0e59b98346418af7f"
-dependencies = [
- "cosmwasm-std",
- "serde",
-]
-
-[[package]]
-name = "cpufeatures"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95059428f66df56b63431fdb4e1947ed2190586af5c5a8a8b71122bdf5a7f469"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "crunchy"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"
-
-[[package]]
-name = "crypto-bigint"
-version = "0.2.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d12477e115c0d570c12a2dfd859f80b55b60ddb5075df210d3af06d133a69f45"
-dependencies = [
- "generic-array 0.14.4",
- "rand_core 0.6.3",
- "subtle",
- "zeroize",
-]
-
-[[package]]
-name = "crypto-mac"
-version = "0.11.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1d1a86f49236c215f271d40892d5fc950490551400b02ef360692c29815c714"
-dependencies = [
- "generic-array 0.14.4",
- "subtle",
-]
-
-[[package]]
-name = "curve25519-dalek"
-version = "3.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b9fdf9972b2bd6af2d913799d9ebc165ea4d2e65878e329d9c6b372c4491b61"
-dependencies = [
- "byteorder",
- "digest 0.9.0",
- "rand_core 0.5.1",
- "subtle",
- "zeroize",
-]
-
-[[package]]
-name = "der"
-version = "0.4.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28e98c534e9c8a0483aa01d6f6913bc063de254311bd267c9cf535e9b70e15b2"
-dependencies = [
- "const-oid",
-]
-
-[[package]]
-name = "digest"
-version = "0.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3d0c8c8752312f9713efd397ff63acb9f85585afbf179282e720e7704954dd5"
-dependencies = [
- "generic-array 0.12.4",
-]
-
-[[package]]
-name = "digest"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3dd60d1080a57a05ab032377049e0591415d2b31afd7028356dbf3cc6dcb066"
-dependencies = [
- "generic-array 0.14.4",
-]
-
-[[package]]
-name = "dyn-clone"
-version = "1.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee2626afccd7561a06cf1367e2950c4718ea04565e20fb5029b6c7d8ad09abcf"
-
-[[package]]
-name = "ecdsa"
-version = "0.12.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43ee23aa5b4f68c7a092b5c3beb25f50c406adc75e2363634f242f28ab255372"
-dependencies = [
- "der",
- "elliptic-curve",
- "hmac",
- "signature",
-]
-
-[[package]]
-name = "ed25519-zebra"
-version = "2.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0a128b76af6dd4b427e34a6fd43dc78dbfe73672ec41ff615a2414c1a0ad0409"
-dependencies = [
- "curve25519-dalek",
- "hex",
- "rand_core 0.5.1",
- "serde",
- "sha2",
- "thiserror",
-]
-
-[[package]]
-name = "elliptic-curve"
-version = "0.10.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "beca177dcb8eb540133e7680baff45e7cc4d93bf22002676cec549f82343721b"
-dependencies = [
- "crypto-bigint",
- "ff",
- "generic-array 0.14.4",
- "group",
- "pkcs8",
- "rand_core 0.6.3",
- "subtle",
- "zeroize",
-]
-
-[[package]]
-name = "erc20-bridge-contract"
-version = "0.1.0"
-dependencies = [
- "schemars",
- "serde",
-]
-
-[[package]]
-name = "fake-simd"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e88a8acf291dafb59c2d96e8f59828f3838bb1a70398823ade51a84de6a6deed"
-
-[[package]]
-name = "ff"
-version = "0.10.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d0f40b2dcd8bc322217a5f6559ae5f9e9d1de202a2ecee2e9eafcbece7562a4f"
-dependencies = [
- "rand_core 0.6.3",
- "subtle",
-]
-
-[[package]]
-name = "form_urlencoded"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5fc25a87fa4fd2094bffb06925852034d90a17f0d1e05197d4956d3555752191"
-dependencies = [
- "matches",
- "percent-encoding",
-]
-
-[[package]]
-name = "generic-array"
-version = "0.12.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ffdf9f34f1447443d37393cc6c2b8313aebddcd96906caf34e54c68d8e57d7bd"
-dependencies = [
- "typenum",
-]
-
-[[package]]
-name = "generic-array"
-version = "0.14.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "501466ecc8a30d1d3b7fc9229b122b2ce8ed6e9d9223f1138d4babb253e51817"
-dependencies = [
- "typenum",
- "version_check",
-]
-
-[[package]]
-name = "getrandom"
-version = "0.1.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8fc3cb4d91f53b50155bdcfd23f6a4c39ae1969c2ae85982b135750cccaf5fce"
-dependencies = [
- "cfg-if",
- "libc",
- "wasi 0.9.0+wasi-snapshot-preview1",
-]
-
-[[package]]
-name = "getrandom"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fcd999463524c52659517fe2cea98493cfe485d10565e7b0fb07dbba7ad2753"
-dependencies = [
- "cfg-if",
- "libc",
- "wasi 0.10.2+wasi-snapshot-preview1",
-]
-
-[[package]]
-name = "group"
-version = "0.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c363a5301b8f153d80747126a04b3c82073b9fe3130571a9d170cacdeaf7912"
-dependencies = [
- "ff",
- "rand_core 0.6.3",
- "subtle",
-]
-
-[[package]]
-name = "handlebars"
-version = "3.5.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4498fc115fa7d34de968184e473529abb40eeb6be8bc5f7faba3d08c316cb3e3"
-dependencies = [
- "log",
- "pest",
- "pest_derive",
- "quick-error",
- "serde",
- "serde_json",
-]
-
-[[package]]
-name = "hex"
-version = "0.4.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
-
-[[package]]
-name = "hex-literal"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "21e4590e13640f19f249fe3e4eca5113bc4289f2497710378190e7f4bd96f45b"
-
-[[package]]
-name = "hmac"
-version = "0.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a2a2320eb7ec0ebe8da8f744d7812d9fc4cb4d09344ac01898dbcb6a20ae69b"
-dependencies = [
- "crypto-mac",
- "digest 0.9.0",
-]
-
-[[package]]
-name = "humantime"
-version = "2.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
-
-[[package]]
-name = "humantime-serde"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac34a56cfd4acddb469cc7fff187ed5ac36f498ba085caf8bbc725e3ff474058"
-dependencies = [
- "humantime",
- "serde",
-]
-
-[[package]]
-name = "idna"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "418a0a6fab821475f634efe3ccc45c013f742efe03d853e8d3355d5cb850ecf8"
-dependencies = [
- "matches",
- "unicode-bidi",
- "unicode-normalization",
-]
-
-[[package]]
-name = "itoa"
-version = "0.4.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b71991ff56294aa922b450139ee08b3bfc70982c6b2c7562771375cf73542dd4"
-
-[[package]]
-name = "k256"
-version = "0.9.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "903ae2481bcdfdb7b68e0a9baa4b7c9aff600b9ae2e8e5bb5833b8c91ab851ea"
-dependencies = [
- "cfg-if",
- "ecdsa",
- "elliptic-curve",
- "sha2",
-]
-
-[[package]]
-name = "libc"
-version = "0.2.103"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd8f7255a17a627354f321ef0055d63b898c6fb27eff628af4d1b66b7331edf6"
-
-[[package]]
-name = "log"
-version = "0.4.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710"
-dependencies = [
- "cfg-if",
-]
-
-[[package]]
-name = "maplit"
-version = "1.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e2e65a1a2e43cfcb47a895c4c8b10d1f4a61097f9f254f183aee60cad9c651d"
-
-[[package]]
-name = "matches"
-version = "0.1.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a3e378b66a060d48947b590737b30a1be76706c8dd7b8ba0f2fe3989c68a853f"
-
-[[package]]
-name = "network-defaults"
-version = "0.1.0"
-dependencies = [
- "hex-literal",
- "serde",
- "time",
- "url",
-]
-
-[[package]]
-name = "opaque-debug"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2839e79665f131bdb5782e51f2c6c9599c133c6098982a54c794358bf432529c"
-
-[[package]]
-name = "opaque-debug"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "624a8340c38c1b80fd549087862da4ba43e08858af025b236e509b6649fc13d5"
-
-[[package]]
-name = "percent-encoding"
-version = "2.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e"
-
-[[package]]
-name = "pest"
-version = "2.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "10f4872ae94d7b90ae48754df22fd42ad52ce740b8f370b03da4835417403e53"
-dependencies = [
- "ucd-trie",
-]
-
-[[package]]
-name = "pest_derive"
-version = "2.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "833d1ae558dc601e9a60366421196a8d94bc0ac980476d0b67e1d0988d72b2d0"
-dependencies = [
- "pest",
- "pest_generator",
-]
-
-[[package]]
-name = "pest_generator"
-version = "2.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "99b8db626e31e5b81787b9783425769681b347011cc59471e33ea46d2ea0cf55"
-dependencies = [
- "pest",
- "pest_meta",
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "pest_meta"
-version = "2.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "54be6e404f5317079812fc8f9f5279de376d8856929e21c184ecf6bbd692a11d"
-dependencies = [
- "maplit",
- "pest",
- "sha-1",
-]
-
-[[package]]
-name = "pkcs8"
-version = "0.7.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee3ef9b64d26bad0536099c816c6734379e45bbd5f14798def6809e5cc350447"
-dependencies = [
- "der",
- "spki",
-]
-
-[[package]]
-name = "proc-macro2"
-version = "1.0.29"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9f5105d4fdaab20335ca9565e106a5d9b82b6219b5ba735731124ac6711d23d"
-dependencies = [
- "unicode-xid",
-]
-
-[[package]]
-name = "quick-error"
-version = "2.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a993555f31e5a609f617c12db6250dedcac1b0a85076912c436e6fc9b2c8e6a3"
-
-[[package]]
-name = "quote"
-version = "1.0.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38bc8cc6a5f2e3655e0899c1b848643b2562f853f114bfec7be120678e3ace05"
-dependencies = [
- "proc-macro2",
-]
-
-[[package]]
-name = "rand_core"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19"
-dependencies = [
- "getrandom 0.1.16",
-]
-
-[[package]]
-name = "rand_core"
-version = "0.6.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7"
-dependencies = [
- "getrandom 0.2.3",
-]
-
-[[package]]
-name = "ryu"
-version = "1.0.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "71d301d4193d031abdd79ff7e3dd721168a9572ef3fe51a1517aba235bd8f86e"
-
-[[package]]
-name = "schemars"
-version = "0.8.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7a48d098c2a7fdf5740b19deb1181b4fb8a9e68e03ae517c14cde04b5725409"
-dependencies = [
- "dyn-clone",
- "schemars_derive",
- "serde",
- "serde_json",
-]
-
-[[package]]
-name = "schemars_derive"
-version = "0.8.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a9ea2a613fe4cd7118b2bb101a25d8ae6192e1975179b67b2f17afd11e70ac8"
-dependencies = [
- "proc-macro2",
- "quote",
- "serde_derive_internals",
- "syn",
-]
-
-[[package]]
-name = "serde"
-version = "1.0.130"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f12d06de37cf59146fbdecab66aa99f9fe4f78722e3607577a5375d66bd0c913"
-dependencies = [
- "serde_derive",
-]
-
-[[package]]
-name = "serde-json-wasm"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50eef3672ec8fa45f3457fd423ba131117786784a895548021976117c1ded449"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "serde_derive"
-version = "1.0.130"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7bc1a1ab1961464eae040d96713baa5a724a8152c1222492465b54322ec508b"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "serde_derive_internals"
-version = "0.25.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1dbab34ca63057a1f15280bdf3c39f2b1eb1b54c17e98360e511637aef7418c6"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "serde_json"
-version = "1.0.68"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0f690853975602e1bfe1ccbf50504d67174e3bcf340f23b5ea9992e0587a52d8"
-dependencies = [
- "itoa",
- "ryu",
- "serde",
-]
-
-[[package]]
-name = "sha-1"
-version = "0.8.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7d94d0bede923b3cea61f3f1ff57ff8cdfd77b400fb8f9998949e0cf04163df"
-dependencies = [
- "block-buffer 0.7.3",
- "digest 0.8.1",
- "fake-simd",
- "opaque-debug 0.2.3",
-]
-
-[[package]]
-name = "sha2"
-version = "0.9.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b69f9a4c9740d74c5baa3fd2e547f9525fa8088a8a958e0ca2409a514e33f5fa"
-dependencies = [
- "block-buffer 0.9.0",
- "cfg-if",
- "cpufeatures",
- "digest 0.9.0",
- "opaque-debug 0.3.0",
-]
-
-[[package]]
-name = "signature"
-version = "1.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c19772be3c4dd2ceaacf03cb41d5885f2a02c4d8804884918e3a258480803335"
-dependencies = [
- "digest 0.9.0",
- "rand_core 0.6.3",
-]
-
-[[package]]
-name = "spki"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c01a0c15da1b0b0e1494112e7af814a678fec9bd157881b49beac661e9b6f32"
-dependencies = [
- "der",
-]
-
-[[package]]
-name = "static_assertions"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
-
-[[package]]
-name = "subtle"
-version = "2.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6bdef32e8150c2a081110b42772ffe7d7c9032b606bc226c8260fd97e0976601"
-
-[[package]]
-name = "syn"
-version = "1.0.65"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3a1d708c221c5a612956ef9f75b37e454e88d1f7b899fbd3a18d4252012d663"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-xid",
-]
-
-[[package]]
-name = "thiserror"
-version = "1.0.29"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "602eca064b2d83369e2b2f34b09c70b605402801927c65c11071ac911d299b88"
-dependencies = [
- "thiserror-impl",
-]
-
-[[package]]
-name = "thiserror-impl"
-version = "1.0.29"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bad553cc2c78e8de258400763a647e80e6d1b31ee237275d756f6836d204494c"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "time"
-version = "0.3.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "99beeb0daeac2bd1e86ac2c21caddecb244b39a093594da1a661ec2060c7aedd"
-dependencies = [
- "libc",
- "time-macros",
-]
-
-[[package]]
-name = "time-macros"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "25eb0ca3468fc0acc11828786797f6ef9aa1555e4a211a60d64cc8e4d1be47d6"
-
-[[package]]
-name = "tinyvec"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f83b2a3d4d9091d0abd7eba4dc2710b1718583bd4d8992e2190720ea38f391f7"
-dependencies = [
- "tinyvec_macros",
-]
-
-[[package]]
-name = "tinyvec_macros"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cda74da7e1a664f795bb1f8a87ec406fb89a02522cf6e50620d016add6dbbf5c"
-
-[[package]]
-name = "toml"
-version = "0.5.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a31142970826733df8241ef35dc040ef98c679ab14d7c3e54d827099b3acecaa"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "typenum"
-version = "1.14.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b63708a265f51345575b27fe43f9500ad611579e764c79edbc2037b1121959ec"
-
-[[package]]
-name = "ucd-trie"
-version = "0.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56dee185309b50d1f11bfedef0fe6d036842e3fb77413abef29f8f8d1c5d4c1c"
-
-[[package]]
-name = "uint"
-version = "0.9.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6470ab50f482bde894a037a57064480a246dbfdd5960bd65a44824693f08da5f"
-dependencies = [
- "byteorder",
- "crunchy",
- "hex",
- "static_assertions",
-]
-
-[[package]]
-name = "unicode-bidi"
-version = "0.3.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a01404663e3db436ed2746d9fefef640d868edae3cceb81c3b8d5732fda678f"
-
-[[package]]
-name = "unicode-normalization"
-version = "0.1.19"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d54590932941a9e9266f0832deed84ebe1bf2e4c9e4a3554d393d18f5e854bf9"
-dependencies = [
- "tinyvec",
-]
-
-[[package]]
-name = "unicode-xid"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"
-
-[[package]]
-name = "url"
-version = "2.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a507c383b2d33b5fc35d1861e77e6b383d158b2da5e14fe51b83dfedf6fd578c"
-dependencies = [
- "form_urlencoded",
- "idna",
- "matches",
- "percent-encoding",
-]
-
-[[package]]
-name = "version_check"
-version = "0.9.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5fecdca9a5291cc2b8dcf7dc02453fee791a280f3743cb0905f8822ae463b3fe"
-
-[[package]]
-name = "wasi"
-version = "0.9.0+wasi-snapshot-preview1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519"
-
-[[package]]
-name = "wasi"
-version = "0.10.2+wasi-snapshot-preview1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6"
-
-[[package]]
-name = "zeroize"
-version = "1.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4756f7db3f7b5574938c3eb1c117038b8e07f95ee6718c0efad4ac21508f1efd"
@@ -63,10 +63,11 @@ mod tests {
    use super::*;
    use crate::support::tests::helpers::*;
    use coconut_bandwidth_contract_common::deposit::DepositData;
-    use config::defaults::MIX_DENOM;
+    use config::defaults::DENOM;
    use cosmwasm_std::testing::{mock_dependencies, mock_env, mock_info};
    use cosmwasm_std::{coins, Addr};
    use cw_multi_test::Executor;
+    use serde::de::Unexpected::Str;

    #[test]
    fn initialize_contract() {
@@ -83,20 +84,20 @@ mod tests {

        // Contract balance should be 0
        assert_eq!(
-            coins(0, MIX_DENOM.base),
+            coins(0, DENOM),
            vec![deps
                .as_ref()
                .querier
-                .query_balance(env.contract.address, MIX_DENOM.base)
+                .query_balance(env.contract.address, DENOM)
                .unwrap()]
        );
    }

    #[test]
    fn deposit_and_release() {
-        let init_funds = coins(10, MIX_DENOM.base);
-        let deposit_funds = coins(1, MIX_DENOM.base);
-        let release_funds = coins(2, MIX_DENOM.base);
+        let init_funds = coins(10, DENOM);
+        let deposit_funds = coins(1, DENOM);
+        let release_funds = coins(2, DENOM);
        let mut app = mock_app(&init_funds);
        let multisig_addr = String::from(MULTISIG_CONTRACT);
        let pool_addr = String::from(POOL_CONTRACT);
@@ -156,7 +157,7 @@ mod tests {
            &[],
        )
        .unwrap();
-        let pool_bal = app.wrap().query_balance(pool_addr, MIX_DENOM.base).unwrap();
+        let pool_bal = app.wrap().query_balance(pool_addr, DENOM).unwrap();
        assert_eq!(pool_bal, deposit_funds[0]);
    }
 }
@@ -5,7 +5,7 @@ use cosmwasm_std::StdError;
 use cw_controllers::AdminError;
 use thiserror::Error;

-use config::defaults::MIX_DENOM;
+use config::defaults::DENOM;

 /// Custom errors for contract failure conditions.
 ///
@@ -22,7 +22,7 @@ pub enum ContractError {
    #[error("No coin was sent for voucher")]
    NoCoin,

-    #[error("Wrong coin denomination, you must send {}", MIX_DENOM.base)]
+    #[error("Wrong coin denomination, you must send {}", DENOM)]
    WrongDenom,

    #[error("There aren't enough funds in the contract")]
@@ -4,6 +4,7 @@
 #[cfg(test)]
 pub mod helpers {
    pub const OWNER: &str = "admin0001";
+    pub const SOMEBODY: &str = "somebody";
    pub const MULTISIG_CONTRACT: &str = "multisig contract address";
    pub const POOL_CONTRACT: &str = "mix pool contract address";

@@ -11,7 +11,7 @@ use coconut_bandwidth_contract_common::events::{
    DEPOSITED_FUNDS_EVENT_TYPE, DEPOSIT_ENCRYPTION_KEY, DEPOSIT_IDENTITY_KEY, DEPOSIT_INFO,
    DEPOSIT_VALUE,
 };
-use config::defaults::MIX_DENOM;
+use config::defaults::DENOM;

 pub(crate) fn deposit_funds(
    _deps: DepsMut<'_>,
@@ -25,7 +25,7 @@ pub(crate) fn deposit_funds(
    if info.funds.len() > 1 {
        return Err(ContractError::MultipleDenoms);
    }
-    if info.funds[0].denom != MIX_DENOM.base {
+    if info.funds[0].denom != DENOM {
        return Err(ContractError::WrongDenom);
    }

@@ -45,12 +45,10 @@ pub(crate) fn release_funds(
    info: MessageInfo,
    funds: Coin,
 ) -> Result<Response, ContractError> {
-    if funds.denom != MIX_DENOM.base {
+    if funds.denom != DENOM {
        return Err(ContractError::WrongDenom);
    }
-    let current_balance = deps
-        .querier
-        .query_balance(env.contract.address, MIX_DENOM.base)?;
+    let current_balance = deps.querier.query_balance(env.contract.address, DENOM)?;
    if funds.amount > current_balance.amount {
        return Err(ContractError::NotEnoughFunds);
    }
@@ -92,7 +90,7 @@ mod tests {
            Err(ContractError::NoCoin)
        );

-        let coin = Coin::new(1000000, MIX_DENOM.base);
+        let coin = Coin::new(1000000, DENOM);
        let second_coin = Coin::new(1000000, "some_denom");

        let info = mock_info("requester", &[coin, second_coin.clone()]);
@@ -122,7 +120,7 @@ mod tests {
            verification_key.clone(),
            encryption_key.clone(),
        );
-        let coin = Coin::new(deposit_value, MIX_DENOM.base);
+        let coin = Coin::new(deposit_value, DENOM);
        let info = mock_info("requester", &[coin]);

        let tx = deposit_funds(deps.as_mut(), env.clone(), info, data).unwrap();
@@ -171,7 +169,7 @@ mod tests {
        let mut deps = helpers::init_contract();
        let env = mock_env();
        let invalid_admin = "invalid admin";
-        let funds = Coin::new(1, MIX_DENOM.base);
+        let funds = Coin::new(1, DENOM);

        let err = release_funds(
            deps.as_mut(),
@@ -207,7 +205,7 @@ mod tests {
    fn valid_release() {
        let mut deps = helpers::init_contract();
        let env = mock_env();
-        let coin = Coin::new(1, MIX_DENOM.base);
+        let coin = Coin::new(1, DENOM);

        deps.querier
            .update_balance(env.contract.address.clone(), vec![coin.clone()]);
@@ -57,6 +57,8 @@ pub const INITIAL_ACTIVE_SET_WORK_FACTOR: u8 = 10;
 pub const DEFAULT_FIRST_INTERVAL_START: OffsetDateTime =
    time::macros::datetime!(2022-01-01 12:00 UTC);

+pub const INITIAL_STAKING_SUPPLY: Uint128 = Uint128::new(100_000_000_000_000);
+
 pub fn debug_with_visibility<S: Into<String>>(api: &dyn Api, msg: S) {
    api.debug(&*format!("\n\n\n=========================================\n{}\n=========================================\n\n\n", msg.into()));
 }
@@ -70,6 +72,7 @@ fn default_initial_state(owner: Addr, rewarding_validator_address: Addr) -> Cont
            minimum_gateway_pledge: INITIAL_GATEWAY_PLEDGE,
            mixnode_rewarded_set_size: INITIAL_MIXNODE_REWARDED_SET_SIZE,
            mixnode_active_set_size: INITIAL_MIXNODE_ACTIVE_SET_SIZE,
+            staking_supply: INITIAL_STAKING_SUPPLY,
        },
    }
 }
@@ -432,7 +435,52 @@ pub fn query(deps: Deps<'_>, env: Env, msg: QueryMsg) -> Result<QueryResponse, C
    Ok(query_res?)
 }

-fn deal_with_zero_delegations(deps: DepsMut<'_>) -> Result<(), ContractError> {
+fn migrate_contract_state_params(deps: DepsMut<'_>) -> Result<(), ContractError> {
+    use crate::mixnet_contract_settings::storage::CONTRACT_STATE;
+    use cw_storage_plus::Item;
+    use serde::{Deserialize, Serialize};
+
+    #[derive(Serialize, Deserialize)]
+    struct OldContractState {
+        pub owner: Addr,
+        pub rewarding_validator_address: Addr,
+        pub params: OldContractStateParams,
+    }
+
+    #[derive(Serialize, Deserialize)]
+    struct OldContractStateParams {
+        pub minimum_mixnode_pledge: Uint128,
+        pub minimum_gateway_pledge: Uint128,
+        pub mixnode_rewarded_set_size: u32,
+        pub mixnode_active_set_size: u32,
+    }
+
+    const OLD_CONTRACT_STATE: Item<'_, OldContractState> = Item::new("config");
+
+    let old_contract_state = OLD_CONTRACT_STATE.load(deps.storage)?;
+
+    let old_params = old_contract_state.params;
+
+    let new_params = ContractStateParams {
+        minimum_mixnode_pledge: old_params.minimum_mixnode_pledge,
+        minimum_gateway_pledge: old_params.minimum_gateway_pledge,
+        mixnode_rewarded_set_size: old_params.mixnode_rewarded_set_size,
+        mixnode_active_set_size: old_params.mixnode_active_set_size,
+        staking_supply: INITIAL_STAKING_SUPPLY,
+    };
+
+    let new_contract_state = ContractState {
+        owner: old_contract_state.owner,
+        rewarding_validator_address: old_contract_state.rewarding_validator_address,
+        params: new_params,
+    };
+
+    CONTRACT_STATE.save(deps.storage, &new_contract_state)?;
+
+    Ok(())
+}
+
+fn _deal_with_zero_delegations(deps: DepsMut<'_>) -> Result<(), ContractError> {
    // if there exists any delegation of 0 value, remove it
    let zero_delegations = delegations()
        .range(deps.storage, None, None, cosmwasm_std::Order::Ascending)
@@ -466,7 +514,7 @@ fn deal_with_zero_delegations(deps: DepsMut<'_>) -> Result<(), ContractError> {

 #[entry_point]
 pub fn migrate(deps: DepsMut<'_>, _env: Env, _msg: MigrateMsg) -> Result<Response, ContractError> {
-    deal_with_zero_delegations(deps)?;
+    migrate_contract_state_params(deps)?;

    Ok(Default::default())
 }
@@ -475,8 +523,7 @@ pub fn migrate(deps: DepsMut<'_>, _env: Env, _msg: MigrateMsg) -> Result<Respons
 pub mod tests {
    use super::*;
    use crate::support::tests;
-    use config::defaults::DEFAULT_NETWORK;
-    use config::defaults::MIX_DENOM;
+    use config::defaults::{DEFAULT_NETWORK, DENOM};
    use cosmwasm_std::testing::{mock_dependencies, mock_env, mock_info};
    use cosmwasm_std::{coins, from_binary};
    use mixnet_contract_common::PagedMixnodeResponse;
@@ -508,7 +555,7 @@ pub mod tests {

        // Contract balance should match what we initialized it as
        assert_eq!(
-            coins(0, MIX_DENOM.base),
+            coins(0, DENOM),
            tests::queries::query_contract_balance(env.contract.address, deps)
        );
    }
@@ -200,7 +200,7 @@ pub(crate) fn query_mixnode_delegations_paged(
 pub(crate) mod tests {
    use super::*;
    use crate::support::tests::test_helpers;
-    use config::defaults::MIX_DENOM;
+    use config::defaults::DENOM;
    use cosmwasm_std::{coin, Addr, Storage};
    use rand::Rng;

@@ -385,7 +385,7 @@ pub(crate) mod tests {
        let delegation = Delegation::new(
            delegation_owner.clone(),
            node_identity.clone(),
-            coin(1234, MIX_DENOM.base),
+            coin(1234, DENOM),
            1234,
            None,
        );
@@ -433,7 +433,7 @@ pub(crate) mod tests {
        let delegation = Delegation::new(
            delegation_owner2,
            node_identity1.clone(),
-            coin(1234, MIX_DENOM.base),
+            coin(1234, DENOM),
            1234,
            None,
        );
@@ -460,7 +460,7 @@ pub(crate) mod tests {
        let delegation = Delegation::new(
            delegation_owner1.clone(),
            node_identity2,
-            coin(1234, MIX_DENOM.base),
+            coin(1234, DENOM),
            1234,
            None,
        );
@@ -77,7 +77,7 @@ mod tests {
    mod reverse_mix_delegations {
        use super::*;
        use crate::support::tests::test_helpers;
-        use config::defaults::MIX_DENOM;
+        use config::defaults::DENOM;
        use cosmwasm_std::testing::mock_env;
        use cosmwasm_std::{coin, Order};
        use mixnet_contract_common::Delegation;
@@ -87,7 +87,7 @@ mod tests {
            let mut deps = test_helpers::init_contract();
            let node_identity: IdentityKey = "foo".into();
            let delegation_owner = Addr::unchecked("bar");
-            let delegation = coin(12345, MIX_DENOM.base);
+            let delegation = coin(12345, DENOM);

            let dummy_data = Delegation::new(
                delegation_owner.clone(),
@@ -125,7 +125,7 @@ mod tests {
            let node_identity2: IdentityKey = "foo2".into();
            let delegation_owner1 = Addr::unchecked("bar");
            let delegation_owner2 = Addr::unchecked("bar2");
-            let delegation = coin(12345, MIX_DENOM.base);
+            let delegation = coin(12345, DENOM);

            assert!(test_helpers::read_delegation(
                deps.as_ref().storage,
@@ -6,7 +6,7 @@ use super::storage::{self, PENDING_DELEGATION_EVENTS};
 use crate::error::ContractError;
 use crate::mixnet_contract_settings::storage as mixnet_params_storage;
 use crate::mixnodes::storage as mixnodes_storage;
-use config::defaults::MIX_DENOM;
+use config::defaults::DENOM;
 use cosmwasm_std::{
    coins, wasm_execute, Addr, Api, BankMsg, Coin, DepsMut, Env, Event, MessageInfo, Order,
    Response, Storage, Uint128, WasmMsg,
@@ -85,7 +85,7 @@ fn validate_delegation_stake(mut delegation: Vec<Coin>) -> Result<Coin, Contract
    }

    // check that the denomination is correct
-    if delegation[0].denom != MIX_DENOM.base {
+    if delegation[0].denom != DENOM {
        return Err(ContractError::WrongDenom {});
    }

@@ -389,7 +389,7 @@ pub(crate) fn try_reconcile_undelegation(
                .as_ref()
                .unwrap_or(&pending_undelegate.delegate())
                .to_string(),
-            amount: coins(total_funds.u128(), MIX_DENOM.base),
+            amount: coins(total_funds.u128(), DENOM),
        })
    } else {
        None
@@ -401,7 +401,7 @@ pub(crate) fn try_reconcile_undelegation(
        let msg = Some(VestingContractExecuteMsg::TrackUndelegation {
            owner: pending_undelegate.delegate().as_str().to_string(),
            mix_identity: pending_undelegate.mix_identity(),
-            amount: Coin::new(total_funds.u128(), MIX_DENOM.base),
+            amount: Coin::new(total_funds.u128(), DENOM),
        });

        wasm_msg = Some(wasm_execute(proxy, &msg, vec![one_ucoin()])?);
@@ -492,7 +492,7 @@ mod tests {
            assert_eq!(
                Err(ContractError::MultipleDenoms),
                validate_delegation_stake(vec![
-                    coin(123, MIX_DENOM.base),
+                    coin(123, DENOM),
                    coin(123, "BTC"),
                    coin(123, "DOGE")
                ])
@@ -511,16 +511,16 @@ mod tests {
        fn stake_coin_must_have_value_greater_than_zero() {
            assert_eq!(
                Err(ContractError::EmptyDelegation),
-                validate_delegation_stake(coins(0, MIX_DENOM.base))
+                validate_delegation_stake(coins(0, DENOM))
            )
        }

        #[test]
        fn stake_can_have_any_positive_value() {
            // this might change in the future, but right now an arbitrary (positive) value can be delegated
-            assert!(validate_delegation_stake(coins(1, MIX_DENOM.base)).is_ok());
-            assert!(validate_delegation_stake(coins(123, MIX_DENOM.base)).is_ok());
-            assert!(validate_delegation_stake(coins(10000000000, MIX_DENOM.base)).is_ok());
+            assert!(validate_delegation_stake(coins(1, DENOM)).is_ok());
+            assert!(validate_delegation_stake(coins(123, DENOM)).is_ok());
+            assert!(validate_delegation_stake(coins(10000000000, DENOM)).is_ok());
        }
    }

@@ -543,7 +543,7 @@ mod tests {
                try_delegate_to_mixnode(
                    deps.as_mut(),
                    mock_env(),
-                    mock_info("sender", &coins(123, MIX_DENOM.base)),
+                    mock_info("sender", &coins(123, DENOM)),
                    "non-existent-mix-identity".into(),
                )
            );
@@ -559,7 +559,7 @@ mod tests {
                deps.as_mut(),
            );
            let delegation_owner = Addr::unchecked("sender");
-            let delegation = coin(123, MIX_DENOM.base);
+            let delegation = coin(123, DENOM);
            assert!(try_delegate_to_mixnode(
                deps.as_mut(),
                mock_env(),
@@ -616,7 +616,7 @@ mod tests {
                try_delegate_to_mixnode(
                    deps.as_mut(),
                    mock_env(),
-                    mock_info(delegation_owner.as_str(), &coins(123, MIX_DENOM.base)),
+                    mock_info(delegation_owner.as_str(), &coins(123, DENOM)),
                    identity,
                )
            );
@@ -637,7 +637,7 @@ mod tests {
                tests::fixtures::good_mixnode_pledge(),
                deps.as_mut(),
            );
-            let delegation = coin(123, MIX_DENOM.base);
+            let delegation = coin(123, DENOM);
            let delegation_owner = Addr::unchecked("sender");
            assert!(try_delegate_to_mixnode(
                deps.as_mut(),
@@ -687,8 +687,8 @@ mod tests {
                deps.as_mut(),
            );
            let delegation_owner = Addr::unchecked("sender");
-            let delegation1 = coin(100, MIX_DENOM.base);
-            let delegation2 = coin(50, MIX_DENOM.base);
+            let delegation1 = coin(100, DENOM);
+            let delegation2 = coin(50, DENOM);

            let mut env = mock_env();

@@ -715,7 +715,7 @@ mod tests {
            // let expected = Delegation::new(
            //     delegation_owner.clone(),
            //     identity.clone(),
-            //     coin(delegation1.amount.u128() + delegation2.amount.u128(), MIX_DENOM.base),
+            //     coin(delegation1.amount.u128() + delegation2.amount.u128(), DENOM),
            //     mock_env().block.height,
            //     None,
            // );
@@ -750,7 +750,7 @@ mod tests {
                deps.as_mut(),
            );
            let delegation_owner = Addr::unchecked("sender");
-            let delegation = coin(100, MIX_DENOM.base);
+            let delegation = coin(100, DENOM);
            let env1 = mock_env();
            let mut env2 = mock_env();
            let initial_height = env1.block.height;
@@ -815,8 +815,8 @@ mod tests {
            );
            let delegation_owner1 = Addr::unchecked("sender1");
            let delegation_owner2 = Addr::unchecked("sender2");
-            let delegation1 = coin(100, MIX_DENOM.base);
-            let delegation2 = coin(120, MIX_DENOM.base);
+            let delegation1 = coin(100, DENOM);
+            let delegation2 = coin(120, DENOM);
            let env1 = mock_env();
            let mut env2 = mock_env();
            let initial_height = env1.block.height;
@@ -891,7 +891,7 @@ mod tests {
            try_delegate_to_mixnode(
                deps.as_mut(),
                mock_env(),
-                mock_info(delegation_owner.as_str(), &coins(100, MIX_DENOM.base)),
+                mock_info(delegation_owner.as_str(), &coins(100, DENOM)),
                identity.clone(),
            )
            .unwrap();
@@ -903,7 +903,7 @@ mod tests {
                try_delegate_to_mixnode(
                    deps.as_mut(),
                    mock_env(),
-                    mock_info(delegation_owner.as_str(), &coins(50, MIX_DENOM.base)),
+                    mock_info(delegation_owner.as_str(), &coins(50, DENOM)),
                    identity,
                )
            );
@@ -928,14 +928,14 @@ mod tests {
            assert!(try_delegate_to_mixnode(
                deps.as_mut(),
                mock_env(),
-                mock_info(delegation_owner.as_str(), &coins(123, MIX_DENOM.base)),
+                mock_info(delegation_owner.as_str(), &coins(123, DENOM)),
                identity1.clone(),
            )
            .is_ok());
            assert!(try_delegate_to_mixnode(
                deps.as_mut(),
                mock_env(),
-                mock_info(delegation_owner.as_str(), &coins(42, MIX_DENOM.base)),
+                mock_info(delegation_owner.as_str(), &coins(42, DENOM)),
                identity2.clone(),
            )
            .is_ok());
@@ -945,7 +945,7 @@ mod tests {
            let expected1 = Delegation::new(
                delegation_owner.clone(),
                identity1.clone(),
-                coin(123, MIX_DENOM.base),
+                coin(123, DENOM),
                mock_env().block.height,
                None,
            );
@@ -953,7 +953,7 @@ mod tests {
            let expected2 = Delegation::new(
                delegation_owner.clone(),
                identity2.clone(),
-                coin(42, MIX_DENOM.base),
+                coin(42, DENOM),
                mock_env().block.height,
                None,
            );
@@ -989,8 +989,8 @@ mod tests {
                tests::fixtures::good_mixnode_pledge(),
                deps.as_mut(),
            );
-            let delegation1 = coin(123, MIX_DENOM.base);
-            let delegation2 = coin(234, MIX_DENOM.base);
+            let delegation1 = coin(123, DENOM);
+            let delegation2 = coin(234, DENOM);
            assert!(try_delegate_to_mixnode(
                deps.as_mut(),
                mock_env(),
@@ -1026,7 +1026,7 @@ mod tests {
                deps.as_mut(),
            );
            let delegation_owner = Addr::unchecked("sender");
-            let delegation_amount = coin(100, MIX_DENOM.base);
+            let delegation_amount = coin(100, DENOM);
            try_delegate_to_mixnode(
                deps.as_mut(),
                mock_env(),
@@ -1118,7 +1118,7 @@ mod tests {
            try_delegate_to_mixnode(
                deps.as_mut(),
                mock_env(),
-                mock_info(delegation_owner.as_str(), &coins(100, MIX_DENOM.base)),
+                mock_info(delegation_owner.as_str(), &coins(100, DENOM)),
                identity.clone(),
            )
            .unwrap();
@@ -1137,7 +1137,7 @@ mod tests {
            let expected_response = Response::new()
                .add_message(BankMsg::Send {
                    to_address: delegation_owner.clone().into(),
-                    amount: coins(100, MIX_DENOM.base),
+                    amount: coins(100, DENOM),
                })
                .add_event(new_undelegation_event(
                    &delegation_owner,
@@ -1188,14 +1188,14 @@ mod tests {
            try_delegate_to_mixnode(
                deps.as_mut(),
                mock_env(),
-                mock_info(delegation_owner.as_str(), &coins(100, MIX_DENOM.base)),
+                mock_info(delegation_owner.as_str(), &coins(100, DENOM)),
                identity.clone(),
            )
            .unwrap();

            _try_reconcile_all_delegation_events(&mut deps.storage, &deps.api).unwrap();

-            let _delegation = query_mixnode_delegation(
+            let delegation = query_mixnode_delegation(
                &deps.storage,
                &deps.api,
                identity.clone(),
@@ -1207,7 +1207,7 @@ mod tests {
            let expected_response = Response::new()
                .add_message(BankMsg::Send {
                    to_address: delegation_owner.clone().into(),
-                    amount: coins(100, MIX_DENOM.base),
+                    amount: coins(100, DENOM),
                })
                .add_event(new_undelegation_event(
                    &delegation_owner,
@@ -1251,8 +1251,8 @@ mod tests {
            );
            let delegation_owner1 = Addr::unchecked("sender1");
            let delegation_owner2 = Addr::unchecked("sender2");
-            let delegation1 = coin(123, MIX_DENOM.base);
-            let delegation2 = coin(234, MIX_DENOM.base);
+            let delegation1 = coin(123, DENOM);
+            let delegation2 = coin(234, DENOM);
            assert!(try_delegate_to_mixnode(
                deps.as_mut(),
                mock_env(),
@@ -1,7 +1,7 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use config::defaults::MIX_DENOM;
+use config::defaults::DENOM;
 use cosmwasm_std::{Addr, StdError};
 use mixnet_contract_common::{error::MixnetContractError, IdentityKey};
 use thiserror::Error;
@@ -33,13 +33,13 @@ pub enum ContractError {
    #[error("MIXNET ({}): Unauthorized", line!())]
    Unauthorized,

-    #[error("MIXNET ({}): Wrong coin denomination, you must send {}", line!(), MIX_DENOM.base)]
+    #[error("MIXNET ({}): Wrong coin denomination, you must send {}", line!(), DENOM)]
    WrongDenom,

    #[error("MIXNET ({}): Received multiple coin types during staking", line!())]
    MultipleDenoms,

-    #[error("MIXNET ({}): No coin was sent for the bonding, you must send {}", line!(), MIX_DENOM.base)]
+    #[error("MIXNET ({}): No coin was sent for the bonding, you must send {}", line!(), DENOM)]
    NoBondFound,

    #[error("MIXNET ({}): Provided active set size is bigger than the rewarded set", line!())]
@@ -36,7 +36,7 @@ pub(crate) fn gateways<'a>() -> IndexedMap<'a, IdentityKeyRef<'a>, GatewayBond,
 mod tests {
    use super::super::storage;
    use crate::support::tests;
-    use config::defaults::MIX_DENOM;
+    use config::defaults::DENOM;
    use cosmwasm_std::testing::MockStorage;
    use cosmwasm_std::StdResult;
    use cosmwasm_std::Storage;
@@ -84,7 +84,7 @@ mod tests {
        let pledge_amount = 1000;

        let gateway_bond = GatewayBond {
-            pledge_amount: coin(pledge_amount, MIX_DENOM.base),
+            pledge_amount: coin(pledge_amount, DENOM),
            owner: node_owner,
            block_height: 12_345,
            gateway: Gateway {
@@ -5,7 +5,7 @@ use super::storage;
 use crate::error::ContractError;
 use crate::mixnet_contract_settings::storage as mixnet_params_storage;
 use crate::support::helpers::{ensure_no_existing_bond, validate_node_identity_signature};
-use config::defaults::MIX_DENOM;
+use config::defaults::DENOM;
 use cosmwasm_std::{
    wasm_execute, Addr, BankMsg, Coin, DepsMut, Env, MessageInfo, Response, Uint128,
 };
@@ -203,7 +203,7 @@ fn validate_gateway_pledge(
    }

    // check that the denomination is correct
-    if pledge[0].denom != MIX_DENOM.base {
+    if pledge[0].denom != DENOM {
        return Err(ContractError::WrongDenom {});
    }

@@ -226,7 +226,7 @@ pub mod tests {
    use crate::gateways::transactions::validate_gateway_pledge;
    use crate::support::tests;
    use crate::support::tests::test_helpers;
-    use config::defaults::MIX_DENOM;
+    use config::defaults::DENOM;
    use cosmwasm_std::testing::{mock_env, mock_info};
    use cosmwasm_std::{coins, BankMsg, Response};
    use cosmwasm_std::{from_binary, Addr, Uint128};
@@ -238,7 +238,7 @@ pub mod tests {

        // if we fail validation (by say not sending enough funds
        let insufficient_bond = Into::<u128>::into(INITIAL_GATEWAY_PLEDGE) - 1;
-        let info = mock_info("anyone", &coins(insufficient_bond, MIX_DENOM.base));
+        let info = mock_info("anyone", &coins(insufficient_bond, DENOM));
        let (msg, _) = tests::messages::valid_bond_gateway_msg("anyone");

        // we are informed that we didn't send enough funds
@@ -5,7 +5,7 @@ use super::storage;
 use cosmwasm_std::{Deps, StdResult};
 use mixnet_contract_common::{ContractStateParams, MixnetContractVersion};

-pub(crate) fn query_contract_settings_params(deps: Deps<'_>) -> StdResult<ContractStateParams> {
+pub fn query_contract_settings_params(deps: Deps<'_>) -> StdResult<ContractStateParams> {
    storage::CONTRACT_STATE
        .load(deps.storage)
        .map(|settings| settings.params)
@@ -51,6 +51,7 @@ pub(crate) mod tests {
                minimum_gateway_pledge: 456u128.into(),
                mixnode_rewarded_set_size: 1000,
                mixnode_active_set_size: 500,
+                staking_supply: 1000000u128.into(),
            },
        };

@@ -64,7 +64,7 @@ pub(crate) fn try_update_contract_settings(
 #[cfg(test)]
 pub mod tests {
    use super::*;
-    use crate::contract::{INITIAL_GATEWAY_PLEDGE, INITIAL_MIXNODE_PLEDGE};
+    use crate::contract::{INITIAL_GATEWAY_PLEDGE, INITIAL_MIXNODE_PLEDGE, INITIAL_STAKING_SUPPLY};
    use crate::error::ContractError;
    use crate::mixnet_contract_settings::queries::query_rewarding_validator_address;
    use crate::mixnet_contract_settings::transactions::try_update_contract_settings;
@@ -114,6 +114,7 @@ pub mod tests {
            minimum_gateway_pledge: INITIAL_GATEWAY_PLEDGE,
            mixnode_rewarded_set_size: 100,
            mixnode_active_set_size: 50,
+            staking_supply: INITIAL_STAKING_SUPPLY,
        };

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

-use config::defaults::MIX_DENOM;
+use config::defaults::DENOM;
 use cosmwasm_std::{StdResult, Storage, Uint128};
 use cw_storage_plus::{Index, IndexList, IndexedSnapshotMap, Map, Strategy, UniqueIndex};
 use mixnet_contract_common::{
@@ -171,7 +171,7 @@ pub(crate) fn read_full_mixnode_bond(
            Ok(Some(MixNodeBond {
                pledge_amount: stored_bond.pledge_amount,
                total_delegation: Coin {
-                    denom: MIX_DENOM.base.to_owned(),
+                    denom: DENOM.to_owned(),
                    amount: total_delegation.unwrap_or_default(),
                },
                owner: stored_bond.owner,
@@ -190,7 +190,7 @@ mod tests {
    use super::super::storage;
    use super::*;
    use crate::support::tests;
-    use config::defaults::MIX_DENOM;
+    use config::defaults::DENOM;
    use cosmwasm_std::testing::MockStorage;
    use cosmwasm_std::{coin, Addr, Uint128};
    use mixnet_contract_common::{IdentityKey, MixNode};
@@ -223,7 +223,7 @@ mod tests {
        let pledge_value = 1000000000;

        let mixnode_bond = StoredMixnodeBond {
-            pledge_amount: coin(pledge_value, MIX_DENOM.base),
+            pledge_amount: coin(pledge_value, DENOM),
            owner: node_owner,
            layer: Layer::One,
            block_height: 12_345,
@@ -7,7 +7,7 @@ use crate::mixnet_contract_settings::storage as mixnet_params_storage;
 use crate::mixnodes::layer_queries::query_layer_distribution;
 use crate::mixnodes::storage::StoredMixnodeBond;
 use crate::support::helpers::{ensure_no_existing_bond, validate_node_identity_signature};
-use config::defaults::MIX_DENOM;
+use config::defaults::DENOM;
 use cosmwasm_std::{
    wasm_execute, Addr, BankMsg, Coin, DepsMut, Env, MessageInfo, Response, Storage, Uint128,
 };
@@ -364,7 +364,7 @@ fn validate_mixnode_pledge(
    }

    // check that the denomination is correct
-    if pledge[0].denom != MIX_DENOM.base {
+    if pledge[0].denom != DENOM {
        return Err(ContractError::WrongDenom {});
    }

@@ -381,13 +381,15 @@ fn validate_mixnode_pledge(

 #[cfg(test)]
 pub mod tests {
+    use std::f64::MIN;
+
    use super::*;
    use crate::contract::{execute, query, INITIAL_MIXNODE_PLEDGE};
    use crate::error::ContractError;
    use crate::mixnodes::transactions::validate_mixnode_pledge;
    use crate::support::tests;
    use crate::support::tests::test_helpers;
-    use config::defaults::MIX_DENOM;
+    use config::defaults::DENOM;
    use cosmwasm_std::testing::{mock_env, mock_info};
    use cosmwasm_std::{coins, BankMsg, Response};
    use cosmwasm_std::{from_binary, Addr, Uint128};
@@ -402,7 +404,7 @@ pub mod tests {

        // if we don't send enough funds
        let insufficient_bond = Into::<u128>::into(INITIAL_MIXNODE_PLEDGE) - 1;
-        let info = mock_info("anyone", &coins(insufficient_bond, MIX_DENOM.base));
+        let info = mock_info("anyone", &coins(insufficient_bond, DENOM));
        let (msg, _) = tests::messages::valid_bond_mixnode_msg("anyone");

        // we are informed that we didn't send enough funds
@@ -79,7 +79,7 @@ pub(crate) mod tests {
        use crate::delegations::transactions::try_delegate_to_mixnode;
        use crate::interval::storage::{save_epoch, save_epoch_reward_params};
        use crate::rewards::transactions::try_reward_mixnode;
-        use config::defaults::MIX_DENOM;
+        use config::defaults::DENOM;
        use cosmwasm_std::{coin, Addr};
        use mixnet_contract_common::{
            Interval, RewardingResult, RewardingStatus, MIXNODE_DELEGATORS_PAGE_LIMIT,
@@ -181,10 +181,7 @@ pub(crate) mod tests {
                try_delegate_to_mixnode(
                    deps.as_mut(),
                    env.clone(),
-                    mock_info(
-                        &*format!("delegator{:04}", i),
-                        &[coin(200_000000, MIX_DENOM.base)],
-                    ),
+                    mock_info(&*format!("delegator{:04}", i), &[coin(200_000000, DENOM)]),
                    node_identity.clone(),
                )
                .unwrap();
@@ -42,10 +42,21 @@ pub fn incr_reward_pool(
    })
 }

-pub fn decr_reward_pool(
-    storage: &mut dyn Storage,
-    amount: Uint128,
-) -> Result<Uint128, ContractError> {
+pub fn reward_accounting(storage: &mut dyn Storage, amount: Uint128) -> Result<(), ContractError> {
+    decr_reward_pool(storage, amount)?;
+    incr_staking_supply(storage, amount)?;
+    Ok(())
+}
+
+fn incr_staking_supply(storage: &mut dyn Storage, amount: Uint128) -> Result<(), ContractError> {
+    let mut contract_state =
+        crate::mixnet_contract_settings::storage::CONTRACT_STATE.load(storage)?;
+    contract_state.params.staking_supply += amount;
+    crate::mixnet_contract_settings::storage::CONTRACT_STATE.save(storage, &contract_state)?;
+    Ok(())
+}
+
+fn decr_reward_pool(storage: &mut dyn Storage, amount: Uint128) -> Result<Uint128, ContractError> {
    REWARD_POOL.update(storage, |current_pool| {
        let stake = current_pool
            .checked_sub(amount)
@@ -14,7 +14,7 @@ use crate::mixnodes::storage::mixnodes;
 use crate::mixnodes::storage::{self as mixnodes_storage, StoredMixnodeBond};
 use crate::rewards::helpers;
 use crate::support::helpers::is_authorized;
-use config::defaults::MIX_DENOM;
+use config::defaults::DENOM;
 use cosmwasm_std::{
    coins, wasm_execute, Addr, Api, BankMsg, Coin, DepsMut, Env, MessageInfo, Order, Response,
    Storage, Uint128,
@@ -105,7 +105,7 @@ fn _try_claim_operator_reward(

    let return_tokens = BankMsg::Send {
        to_address: proxy.as_ref().unwrap_or(&owner).to_string(),
-        amount: coins(reward.u128(), MIX_DENOM.base),
+        amount: coins(reward.u128(), DENOM),
    };

    let mut response = Response::default()
@@ -115,7 +115,7 @@ fn _try_claim_operator_reward(
    if let Some(proxy) = proxy {
        let msg = Some(VestingContractExecuteMsg::TrackReward {
            address: owner.to_string(),
-            amount: Coin::new(reward.u128(), MIX_DENOM.base),
+            amount: Coin::new(reward.u128(), DENOM),
        });

        let wasm_msg = wasm_execute(proxy, &msg, vec![one_ucoin()])?;
@@ -153,7 +153,7 @@ pub fn _try_claim_delegator_reward(

    let return_tokens = BankMsg::Send {
        to_address: proxy.as_ref().unwrap_or(&owner).to_string(),
-        amount: coins(reward.u128(), MIX_DENOM.base),
+        amount: coins(reward.u128(), DENOM),
    };

    let mut response =
@@ -169,7 +169,7 @@ pub fn _try_claim_delegator_reward(
    if let Some(proxy) = proxy {
        let msg = Some(VestingContractExecuteMsg::TrackReward {
            address: owner.to_string(),
-            amount: Coin::new(reward.u128(), MIX_DENOM.base),
+            amount: Coin::new(reward.u128(), DENOM),
        });

        let wasm_msg = wasm_execute(proxy, &msg, vec![one_ucoin()])?;
@@ -436,7 +436,7 @@ pub fn _try_compound_delegator_reward(
            owner_address,
            Coin {
                amount: compounded_delegation,
-                denom: MIX_DENOM.base.to_string(),
+                denom: DENOM.to_string(),
            },
            proxy,
        )?;
@@ -678,7 +678,7 @@ pub(crate) fn try_reward_mixnode(
    )?;

    // Take rewards out of the rewarding pool
-    storage::decr_reward_pool(deps.storage, stored_node_result.reward())?;
+    storage::reward_accounting(deps.storage, stored_node_result.reward())?;

    let rewarding_result = RewardingResult {
        node_reward: stored_node_result.reward(),
@@ -721,7 +721,7 @@ pub mod tests {
    use crate::support::tests;
    use crate::support::tests::test_helpers;
    use az::CheckedCast;
-    use config::defaults::MIX_DENOM;
+    use config::defaults::DENOM;
    use cosmwasm_std::testing::{mock_env, mock_info};
    use cosmwasm_std::{coin, coins, Addr, StdError, Timestamp, Uint128};
    use mixnet_contract_common::events::{
@@ -737,7 +737,7 @@ pub mod tests {
        let mut deps = test_helpers::init_contract();
        let mut env = mock_env();
        let sender = rewarding_validator_address(&deps.storage).unwrap();
-        let info = mock_info(&sender, &coins(1000, MIX_DENOM.base));
+        let info = mock_info(&sender, &coins(1000, DENOM));
        crate::interval::transactions::init_epoch(&mut deps.storage, env.clone()).unwrap();

        // bond the node
@@ -878,7 +878,7 @@ pub mod tests {
        let initial_bond = 10000_000000;
        let initial_delegation = 20000_000000;
        let mixnode_bond = StoredMixnodeBond {
-            pledge_amount: coin(initial_bond, MIX_DENOM.base),
+            pledge_amount: coin(initial_bond, DENOM),
            owner: node_owner,
            layer: Layer::One,
            block_height: env.block.height,
@@ -918,7 +918,7 @@ pub mod tests {
                &Delegation::new(
                    Addr::unchecked("delegator"),
                    node_identity.clone(),
-                    coin(initial_delegation, MIX_DENOM.base),
+                    coin(initial_delegation, DENOM),
                    env.block.height,
                    None,
                ),
@@ -1098,7 +1098,7 @@ pub mod tests {
        assert_eq!(circulating_supply, 750_000_000_000_000u128);

        let sender = Addr::unchecked("alice");
-        let stake = coins(10_000_000_000, MIX_DENOM.base);
+        let stake = coins(10_000_000_000, DENOM);

        let keypair = crypto::asymmetric::identity::KeyPair::new(&mut thread_rng());
        let owner_signature = keypair
@@ -1151,14 +1151,14 @@ pub mod tests {
        let node_owner: Addr = Addr::unchecked("johnny");
        let node_identity_2 = test_helpers::add_mixnode(
            node_owner.as_str(),
-            coins(10_000_000_000, MIX_DENOM.base),
+            coins(10_000_000_000, DENOM),
            deps.as_mut(),
        );

        try_delegate_to_mixnode(
            deps.as_mut(),
            mock_env(),
-            mock_info("alice_d1", &[coin(8000_000000, MIX_DENOM.base)]),
+            mock_info("alice_d1", &[coin(8000_000000, DENOM)]),
            node_identity_1.clone(),
        )
        .unwrap();
@@ -1166,7 +1166,7 @@ pub mod tests {
        try_delegate_to_mixnode(
            deps.as_mut(),
            mock_env(),
-            mock_info("alice_d2", &[coin(2000_000000, MIX_DENOM.base)]),
+            mock_info("alice_d2", &[coin(2000_000000, DENOM)]),
            node_identity_1.clone(),
        )
        .unwrap();
@@ -1174,7 +1174,7 @@ pub mod tests {
        try_delegate_to_mixnode(
            deps.as_mut(),
            mock_env(),
-            mock_info("bob_d1", &[coin(8000_000000, MIX_DENOM.base)]),
+            mock_info("bob_d1", &[coin(8000_000000, DENOM)]),
            node_identity_2.clone(),
        )
        .unwrap();
@@ -1182,7 +1182,7 @@ pub mod tests {
        try_delegate_to_mixnode(
            deps.as_mut(),
            mock_env(),
-            mock_info("bob_d2", &[coin(2000_000000, MIX_DENOM.base)]),
+            mock_info("bob_d2", &[coin(2000_000000, DENOM)]),
            node_identity_2.clone(),
        )
        .unwrap();
@@ -1190,14 +1190,14 @@ pub mod tests {
        let node_owner: Addr = Addr::unchecked("alicebob");
        let node_identity_3 = test_helpers::add_mixnode(
            node_owner.as_str(),
-            coins(10_000_000_000 * 2, MIX_DENOM.base),
+            coins(10_000_000_000 * 2, DENOM),
            deps.as_mut(),
        );

        try_delegate_to_mixnode(
            deps.as_mut(),
            mock_env(),
-            mock_info("alicebob_d1", &[coin(8000_000000 * 2, MIX_DENOM.base)]),
+            mock_info("alicebob_d1", &[coin(8000_000000 * 2, DENOM)]),
            node_identity_3.clone(),
        )
        .unwrap();
@@ -1205,7 +1205,7 @@ pub mod tests {
        try_delegate_to_mixnode(
            deps.as_mut(),
            mock_env(),
-            mock_info("alicebob_d2", &[coin(2000_000000 * 2, MIX_DENOM.base)]),
+            mock_info("alicebob_d2", &[coin(2000_000000 * 2, DENOM)]),
            node_identity_3.clone(),
        )
        .unwrap();
@@ -1216,6 +1216,7 @@ pub mod tests {
        )
        .unwrap();

+        let info = mock_info(rewarding_validator_address.as_ref(), &[]);
        env.block.height += 2 * constants::MINIMUM_BLOCK_AGE_FOR_REWARDING;

        let mix_1 = mixnodes_storage::read_full_mixnode_bond(&deps.storage, &node_identity_1)
@@ -1304,7 +1305,7 @@ pub mod tests {
        try_delegate_to_mixnode(
            deps.as_mut(),
            env.clone(),
-            mock_info("alice_d1", &[coin(8000_000000, MIX_DENOM.base)]),
+            mock_info("alice_d1", &[coin(8000_000000, DENOM)]),
            node_identity_1.clone(),
        )
        .unwrap();
@@ -1505,7 +1506,7 @@ pub mod tests {
        );
        assert_eq!(mix_2_reward_result.reward().int(), 129557u128);

-        let _mix_3_reward_result = mix_3.reward(&params3);
+        let mix_3_reward_result = mix_3.reward(&params3);

        // assert_eq!(mix_3_reward_result.reward().int(), mix_1_reward_result.reward().int() + mix_2_reward_result.reward().int());
    }
@@ -1532,14 +1533,14 @@ pub mod tests {
        let node_owner: Addr = Addr::unchecked("alice");
        let node_identity = test_helpers::add_mixnode(
            node_owner.as_str(),
-            coins(10_000_000_000, MIX_DENOM.base),
+            coins(10_000_000_000, DENOM),
            deps.as_mut(),
        );

        try_delegate_to_mixnode(
            deps.as_mut(),
            mock_env(),
-            mock_info("alice_d1", &[coin(8000_000000, MIX_DENOM.base)]),
+            mock_info("alice_d1", &[coin(8000_000000, DENOM)]),
            node_identity.clone(),
        )
        .unwrap();
@@ -1547,7 +1548,7 @@ pub mod tests {
        try_delegate_to_mixnode(
            deps.as_mut(),
            mock_env(),
-            mock_info("alice_d2", &[coin(2000_000000, MIX_DENOM.base)]),
+            mock_info("alice_d2", &[coin(2000_000000, DENOM)]),
            node_identity.clone(),
        )
        .unwrap();
@@ -1697,7 +1698,7 @@ pub mod tests {
            #[allow(clippy::inconsistent_digit_grouping)]
            let node_identity = test_helpers::add_mixnode(
                node_owner.as_str(),
-                coins(10000_000_000, MIX_DENOM.base),
+                coins(10000_000_000, DENOM),
                deps.as_mut(),
            );

@@ -1724,7 +1725,7 @@ pub mod tests {
            #[allow(clippy::inconsistent_digit_grouping)]
            let node_identity = test_helpers::add_mixnode(
                node_owner.as_str(),
-                coins(10000_000_000, MIX_DENOM.base),
+                coins(10000_000_000, DENOM),
                deps.as_mut(),
            );

@@ -1732,10 +1733,7 @@ pub mod tests {
                try_delegate_to_mixnode(
                    deps.as_mut(),
                    env.clone(),
-                    mock_info(
-                        &*format!("delegator{:04}", i),
-                        &[coin(2000_000000, MIX_DENOM.base)],
-                    ),
+                    mock_info(&*format!("delegator{:04}", i), &[coin(2000_000000, DENOM)]),
                    node_identity.clone(),
                )
                .unwrap();
@@ -1,7 +1,7 @@
 use crate::contract::INITIAL_MIXNODE_PLEDGE;
 use crate::mixnodes::storage as mixnodes_storage;
 use crate::{mixnodes::storage::StoredMixnodeBond, support::tests};
-use config::defaults::MIX_DENOM;
+use config::defaults::DENOM;
 use cosmwasm_std::{coin, Addr, Coin};
 use mixnet_contract_common::reward_params::NodeRewardParams;
 use mixnet_contract_common::{Gateway, GatewayBond, Layer, MixNode};
@@ -37,7 +37,7 @@ pub fn gateway_bond_fixture(owner: &str) -> GatewayBond {
        ..tests::fixtures::gateway_fixture()
    };
    GatewayBond::new(
-        coin(50, MIX_DENOM.base),
+        coin(50, DENOM),
        Addr::unchecked(owner),
        12_345,
        gateway,
@@ -47,7 +47,7 @@ pub fn gateway_bond_fixture(owner: &str) -> GatewayBond {

 pub(crate) fn stored_mixnode_bond_fixture(owner: &str) -> mixnodes_storage::StoredMixnodeBond {
    StoredMixnodeBond::new(
-        coin(50, MIX_DENOM.base),
+        coin(50, DENOM),
        Addr::unchecked(owner),
        Layer::One,
        12_345,
@@ -64,14 +64,14 @@ pub(crate) fn stored_mixnode_bond_fixture(owner: &str) -> mixnodes_storage::Stor

 pub fn good_mixnode_pledge() -> Vec<Coin> {
    vec![Coin {
-        denom: MIX_DENOM.base.to_string(),
+        denom: DENOM.to_string(),
        amount: INITIAL_MIXNODE_PLEDGE,
    }]
 }

 pub fn good_gateway_pledge() -> Vec<Coin> {
    vec![Coin {
-        denom: MIX_DENOM.base.to_string(),
+        denom: DENOM.to_string(),
        amount: INITIAL_MIXNODE_PLEDGE,
    }]
 }
@@ -17,7 +17,7 @@ pub mod test_helpers {
    use crate::mixnodes::storage as mixnodes_storage;
    use crate::mixnodes::transactions::try_add_mixnode;
    use crate::support::tests;
-    use config::defaults::{DEFAULT_NETWORK, MIX_DENOM};
+    use config::defaults::{DEFAULT_NETWORK, DENOM};
    use cosmwasm_std::testing::mock_dependencies;
    use cosmwasm_std::testing::mock_env;
    use cosmwasm_std::testing::mock_info;
@@ -111,7 +111,7 @@ pub mod test_helpers {
        let delegation = Delegation {
            owner: Addr::unchecked(owner.into()),
            node_identity: mix.into(),
-            amount: coin(12345, MIX_DENOM.base),
+            amount: coin(12345, DENOM),
            block_height: block_height,
            proxy: None,
        };
@@ -1,4 +1,4 @@
-use config::defaults::MIX_DENOM;
+use config::defaults::DENOM;
 use cosmwasm_std::{
    from_binary,
    testing::{mock_env, MockApi, MockQuerier, MockStorage},
@@ -45,5 +45,5 @@ pub fn query_contract_balance(
    deps: OwnedDeps<MockStorage, MockApi, MockQuerier>,
 ) -> Vec<Coin> {
    let querier = deps.as_ref().querier;
-    vec![querier.query_balance(address, MIX_DENOM.base).unwrap()]
+    vec![querier.query_balance(address, DENOM).unwrap()]
 }
@@ -17,12 +17,12 @@ crate-type = ["cdylib", "rlib"]
 library = []

 [dependencies]
-cw-utils = { version = "0.13.1" }
-cw2 = { version = "0.13.1" }
-cw3 = { version = "0.13.1" }
-cw3-fixed-multisig = { version = "0.13.1", features = ["library"] }
-cw4 = { version = "0.13.1" }
-cw-storage-plus = { version = "0.13.1" }
+cw-utils = { version = "0.13.2" }
+cw2 = { version = "0.13.2" }
+cw3 = { version = "0.13.2" }
+cw3-fixed-multisig = { version = "0.13.2", features = ["library"] }
+cw4 = { version = "0.13.2" }
+cw-storage-plus = { version = "0.13.2" }
 cosmwasm-std = { version = "1.0.0" }
 schemars = "0.8.1"
 serde = { version = "1.0.103", default-features = false, features = ["derive"] }
@@ -24,11 +24,11 @@ crate-type = ["cdylib", "rlib"]
 library = []

 [dependencies]
-cw-utils = { version = "0.13.1" }
-cw2 = { version = "0.13.1" }
-cw4 = { version = "0.13.1" }
-cw-controllers = { version = "0.13.1" }
-cw-storage-plus = { version = "0.13.1" }
+cw-utils = { version = "0.13.2" }
+cw2 = { version = "0.13.2" }
+cw4 = { version = "0.13.2" }
+cw-controllers = { version = "0.13.2" }
+cw-storage-plus = { version = "0.13.2" }
 cosmwasm-std = { version = "1.0.0" }
 schemars = "0.8.1"
 serde = { version = "1.0.103", default-features = false, features = ["derive"] }
@@ -1,908 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-version = 3
-
-[[package]]
-name = "az"
-version = "1.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9d6dff4a1892b54d70af377bf7a17064192e822865791d812957f21e3108c325"
-
-[[package]]
-name = "base64"
-version = "0.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "904dfeac50f3cdaba28fc6f57fdcddb75f49ed61346676a78c4ffe55877802fd"
-
-[[package]]
-name = "block-buffer"
-version = "0.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0940dc441f31689269e10ac70eb1002a3a1d3ad1390e030043662eb7fe4688b"
-dependencies = [
- "block-padding",
- "byte-tools",
- "byteorder",
- "generic-array 0.12.4",
-]
-
-[[package]]
-name = "block-buffer"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4152116fd6e9dadb291ae18fc1ec3575ed6d84c29642d97890f4b4a3417297e4"
-dependencies = [
- "generic-array 0.14.4",
-]
-
-[[package]]
-name = "block-padding"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa79dedbb091f449f1f39e53edf88d5dbe95f895dae6135a8d7b881fb5af73f5"
-dependencies = [
- "byte-tools",
-]
-
-[[package]]
-name = "byte-tools"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3b5ca7a04898ad4bcd41c90c5285445ff5b791899bb1b0abdd2a2aa791211d7"
-
-[[package]]
-name = "bytemuck"
-version = "1.7.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72957246c41db82b8ef88a5486143830adeb8227ef9837740bdec67724cf2c5b"
-
-[[package]]
-name = "byteorder"
-version = "1.4.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
-
-[[package]]
-name = "cfg-if"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
-
-[[package]]
-name = "config"
-version = "0.1.0"
-dependencies = [
- "handlebars",
- "humantime-serde",
- "network-defaults",
- "serde",
- "toml",
- "url",
-]
-
-[[package]]
-name = "const-oid"
-version = "0.6.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9d6f2aa4d0537bcc1c74df8755072bd31c1ef1a3a1b85a68e8404a8c353b7b8b"
-
-[[package]]
-name = "cosmwasm-crypto"
-version = "0.14.1"
-source = "git+https://github.com/jstuczyn/cosmwasm?branch=0.14.1-updatedk256#308781cd5f33b0e996176c6b500793d3648c0f7b"
-dependencies = [
- "digest 0.9.0",
- "ed25519-zebra",
- "k256",
- "rand_core 0.5.1",
- "thiserror",
-]
-
-[[package]]
-name = "cosmwasm-derive"
-version = "0.14.1"
-source = "git+https://github.com/jstuczyn/cosmwasm?branch=0.14.1-updatedk256#308781cd5f33b0e996176c6b500793d3648c0f7b"
-dependencies = [
- "syn",
-]
-
-[[package]]
-name = "cosmwasm-std"
-version = "0.14.1"
-source = "git+https://github.com/jstuczyn/cosmwasm?branch=0.14.1-updatedk256#308781cd5f33b0e996176c6b500793d3648c0f7b"
-dependencies = [
- "base64",
- "cosmwasm-crypto",
- "cosmwasm-derive",
- "schemars",
- "serde",
- "serde-json-wasm",
- "thiserror",
- "uint",
-]
-
-[[package]]
-name = "cosmwasm-storage"
-version = "0.14.1"
-source = "git+https://github.com/jstuczyn/cosmwasm?branch=0.14.1-updatedk256#308781cd5f33b0e996176c6b500793d3648c0f7b"
-dependencies = [
- "cosmwasm-std",
- "serde",
-]
-
-[[package]]
-name = "cpufeatures"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95059428f66df56b63431fdb4e1947ed2190586af5c5a8a8b71122bdf5a7f469"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "crunchy"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"
-
-[[package]]
-name = "crypto-bigint"
-version = "0.2.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f83bd3bb4314701c568e340cd8cf78c975aa0ca79e03d3f6d1677d5b0c9c0c03"
-dependencies = [
- "generic-array 0.14.4",
- "rand_core 0.6.3",
- "subtle",
- "zeroize",
-]
-
-[[package]]
-name = "crypto-mac"
-version = "0.11.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1d1a86f49236c215f271d40892d5fc950490551400b02ef360692c29815c714"
-dependencies = [
- "generic-array 0.14.4",
- "subtle",
-]
-
-[[package]]
-name = "curve25519-dalek"
-version = "3.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b9fdf9972b2bd6af2d913799d9ebc165ea4d2e65878e329d9c6b372c4491b61"
-dependencies = [
- "byteorder",
- "digest 0.9.0",
- "rand_core 0.5.1",
- "subtle",
- "zeroize",
-]
-
-[[package]]
-name = "der"
-version = "0.4.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28e98c534e9c8a0483aa01d6f6913bc063de254311bd267c9cf535e9b70e15b2"
-dependencies = [
- "const-oid",
-]
-
-[[package]]
-name = "digest"
-version = "0.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3d0c8c8752312f9713efd397ff63acb9f85585afbf179282e720e7704954dd5"
-dependencies = [
- "generic-array 0.12.4",
-]
-
-[[package]]
-name = "digest"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3dd60d1080a57a05ab032377049e0591415d2b31afd7028356dbf3cc6dcb066"
-dependencies = [
- "generic-array 0.14.4",
-]
-
-[[package]]
-name = "dyn-clone"
-version = "1.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee2626afccd7561a06cf1367e2950c4718ea04565e20fb5029b6c7d8ad09abcf"
-
-[[package]]
-name = "ecdsa"
-version = "0.12.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43ee23aa5b4f68c7a092b5c3beb25f50c406adc75e2363634f242f28ab255372"
-dependencies = [
- "der",
- "elliptic-curve",
- "hmac",
- "signature",
-]
-
-[[package]]
-name = "ed25519-zebra"
-version = "2.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0a128b76af6dd4b427e34a6fd43dc78dbfe73672ec41ff615a2414c1a0ad0409"
-dependencies = [
- "curve25519-dalek",
- "hex",
- "rand_core 0.5.1",
- "serde",
- "sha2",
- "thiserror",
-]
-
-[[package]]
-name = "elliptic-curve"
-version = "0.10.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "beca177dcb8eb540133e7680baff45e7cc4d93bf22002676cec549f82343721b"
-dependencies = [
- "crypto-bigint",
- "ff",
- "generic-array 0.14.4",
- "group",
- "pkcs8",
- "rand_core 0.6.3",
- "subtle",
- "zeroize",
-]
-
-[[package]]
-name = "fake-simd"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e88a8acf291dafb59c2d96e8f59828f3838bb1a70398823ade51a84de6a6deed"
-
-[[package]]
-name = "ff"
-version = "0.10.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d0f40b2dcd8bc322217a5f6559ae5f9e9d1de202a2ecee2e9eafcbece7562a4f"
-dependencies = [
- "rand_core 0.6.3",
- "subtle",
-]
-
-[[package]]
-name = "fixed"
-version = "1.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d333a26ec13a023c6dff4b7584de4d323cfee2e508f5dd2bbee6669e4f7efdf"
-dependencies = [
- "az",
- "bytemuck",
- "half",
- "typenum",
-]
-
-[[package]]
-name = "form_urlencoded"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5fc25a87fa4fd2094bffb06925852034d90a17f0d1e05197d4956d3555752191"
-dependencies = [
- "matches",
- "percent-encoding",
-]
-
-[[package]]
-name = "generic-array"
-version = "0.12.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ffdf9f34f1447443d37393cc6c2b8313aebddcd96906caf34e54c68d8e57d7bd"
-dependencies = [
- "typenum",
-]
-
-[[package]]
-name = "generic-array"
-version = "0.14.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "501466ecc8a30d1d3b7fc9229b122b2ce8ed6e9d9223f1138d4babb253e51817"
-dependencies = [
- "typenum",
- "version_check",
-]
-
-[[package]]
-name = "getrandom"
-version = "0.1.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8fc3cb4d91f53b50155bdcfd23f6a4c39ae1969c2ae85982b135750cccaf5fce"
-dependencies = [
- "cfg-if",
- "libc",
- "wasi 0.9.0+wasi-snapshot-preview1",
-]
-
-[[package]]
-name = "getrandom"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fcd999463524c52659517fe2cea98493cfe485d10565e7b0fb07dbba7ad2753"
-dependencies = [
- "cfg-if",
- "libc",
- "wasi 0.10.2+wasi-snapshot-preview1",
-]
-
-[[package]]
-name = "group"
-version = "0.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c363a5301b8f153d80747126a04b3c82073b9fe3130571a9d170cacdeaf7912"
-dependencies = [
- "ff",
- "rand_core 0.6.3",
- "subtle",
-]
-
-[[package]]
-name = "half"
-version = "1.8.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eabb4a44450da02c90444cf74558da904edde8fb4e9035a9a6a4e15445af0bd7"
-
-[[package]]
-name = "handlebars"
-version = "3.5.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4498fc115fa7d34de968184e473529abb40eeb6be8bc5f7faba3d08c316cb3e3"
-dependencies = [
- "log",
- "pest",
- "pest_derive",
- "quick-error",
- "serde",
- "serde_json",
-]
-
-[[package]]
-name = "hex"
-version = "0.4.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
-
-[[package]]
-name = "hex-literal"
-version = "0.3.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ebdb29d2ea9ed0083cd8cece49bbd968021bd99b0849edb4a9a7ee0fdf6a4e0"
-
-[[package]]
-name = "hmac"
-version = "0.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a2a2320eb7ec0ebe8da8f744d7812d9fc4cb4d09344ac01898dbcb6a20ae69b"
-dependencies = [
- "crypto-mac",
- "digest 0.9.0",
-]
-
-[[package]]
-name = "humantime"
-version = "2.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
-
-[[package]]
-name = "humantime-serde"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac34a56cfd4acddb469cc7fff187ed5ac36f498ba085caf8bbc725e3ff474058"
-dependencies = [
- "humantime",
- "serde",
-]
-
-[[package]]
-name = "idna"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "418a0a6fab821475f634efe3ccc45c013f742efe03d853e8d3355d5cb850ecf8"
-dependencies = [
- "matches",
- "unicode-bidi",
- "unicode-normalization",
-]
-
-[[package]]
-name = "itoa"
-version = "0.4.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b71991ff56294aa922b450139ee08b3bfc70982c6b2c7562771375cf73542dd4"
-
-[[package]]
-name = "k256"
-version = "0.9.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "903ae2481bcdfdb7b68e0a9baa4b7c9aff600b9ae2e8e5bb5833b8c91ab851ea"
-dependencies = [
- "cfg-if",
- "ecdsa",
- "elliptic-curve",
- "sha2",
-]
-
-[[package]]
-name = "libc"
-version = "0.2.107"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fbe5e23404da5b4f555ef85ebed98fb4083e55a00c317800bc2a50ede9f3d219"
-
-[[package]]
-name = "log"
-version = "0.4.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710"
-dependencies = [
- "cfg-if",
-]
-
-[[package]]
-name = "maplit"
-version = "1.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e2e65a1a2e43cfcb47a895c4c8b10d1f4a61097f9f254f183aee60cad9c651d"
-
-[[package]]
-name = "matches"
-version = "0.1.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a3e378b66a060d48947b590737b30a1be76706c8dd7b8ba0f2fe3989c68a853f"
-
-[[package]]
-name = "mixnet-contract"
-version = "0.1.0"
-dependencies = [
- "az",
- "cosmwasm-std",
- "fixed",
- "log",
- "network-defaults",
- "schemars",
- "serde",
- "serde_repr",
- "thiserror",
-]
-
-[[package]]
-name = "network-defaults"
-version = "0.1.0"
-dependencies = [
- "hex-literal",
- "serde",
- "time",
- "url",
-]
-
-[[package]]
-name = "opaque-debug"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2839e79665f131bdb5782e51f2c6c9599c133c6098982a54c794358bf432529c"
-
-[[package]]
-name = "opaque-debug"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "624a8340c38c1b80fd549087862da4ba43e08858af025b236e509b6649fc13d5"
-
-[[package]]
-name = "percent-encoding"
-version = "2.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e"
-
-[[package]]
-name = "pest"
-version = "2.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "10f4872ae94d7b90ae48754df22fd42ad52ce740b8f370b03da4835417403e53"
-dependencies = [
- "ucd-trie",
-]
-
-[[package]]
-name = "pest_derive"
-version = "2.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "833d1ae558dc601e9a60366421196a8d94bc0ac980476d0b67e1d0988d72b2d0"
-dependencies = [
- "pest",
- "pest_generator",
-]
-
-[[package]]
-name = "pest_generator"
-version = "2.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "99b8db626e31e5b81787b9783425769681b347011cc59471e33ea46d2ea0cf55"
-dependencies = [
- "pest",
- "pest_meta",
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "pest_meta"
-version = "2.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "54be6e404f5317079812fc8f9f5279de376d8856929e21c184ecf6bbd692a11d"
-dependencies = [
- "maplit",
- "pest",
- "sha-1",
-]
-
-[[package]]
-name = "pkcs8"
-version = "0.7.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee3ef9b64d26bad0536099c816c6734379e45bbd5f14798def6809e5cc350447"
-dependencies = [
- "der",
- "spki",
-]
-
-[[package]]
-name = "proc-macro2"
-version = "1.0.32"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba508cc11742c0dc5c1659771673afbab7a0efab23aa17e854cbab0837ed0b43"
-dependencies = [
- "unicode-xid",
-]
-
-[[package]]
-name = "quick-error"
-version = "2.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a993555f31e5a609f617c12db6250dedcac1b0a85076912c436e6fc9b2c8e6a3"
-
-[[package]]
-name = "quote"
-version = "1.0.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38bc8cc6a5f2e3655e0899c1b848643b2562f853f114bfec7be120678e3ace05"
-dependencies = [
- "proc-macro2",
-]
-
-[[package]]
-name = "rand_core"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19"
-dependencies = [
- "getrandom 0.1.16",
-]
-
-[[package]]
-name = "rand_core"
-version = "0.6.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7"
-dependencies = [
- "getrandom 0.2.3",
-]
-
-[[package]]
-name = "ryu"
-version = "1.0.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "71d301d4193d031abdd79ff7e3dd721168a9572ef3fe51a1517aba235bd8f86e"
-
-[[package]]
-name = "schemars"
-version = "0.8.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "271ac0c667b8229adf70f0f957697c96fafd7486ab7481e15dc5e45e3e6a4368"
-dependencies = [
- "dyn-clone",
- "schemars_derive",
- "serde",
- "serde_json",
-]
-
-[[package]]
-name = "schemars_derive"
-version = "0.8.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ebda811090b257411540779860bc09bf321bc587f58d2c5864309d1566214e7"
-dependencies = [
- "proc-macro2",
- "quote",
- "serde_derive_internals",
- "syn",
-]
-
-[[package]]
-name = "serde"
-version = "1.0.130"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f12d06de37cf59146fbdecab66aa99f9fe4f78722e3607577a5375d66bd0c913"
-dependencies = [
- "serde_derive",
-]
-
-[[package]]
-name = "serde-json-wasm"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50eef3672ec8fa45f3457fd423ba131117786784a895548021976117c1ded449"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "serde_derive"
-version = "1.0.130"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7bc1a1ab1961464eae040d96713baa5a724a8152c1222492465b54322ec508b"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "serde_derive_internals"
-version = "0.25.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1dbab34ca63057a1f15280bdf3c39f2b1eb1b54c17e98360e511637aef7418c6"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "serde_json"
-version = "1.0.70"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e277c495ac6cd1a01a58d0a0c574568b4d1ddf14f59965c6a58b8d96400b54f3"
-dependencies = [
- "itoa",
- "ryu",
- "serde",
-]
-
-[[package]]
-name = "serde_repr"
-version = "0.1.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "98d0516900518c29efa217c298fa1f4e6c6ffc85ae29fd7f4ee48f176e1a9ed5"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "sha-1"
-version = "0.8.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7d94d0bede923b3cea61f3f1ff57ff8cdfd77b400fb8f9998949e0cf04163df"
-dependencies = [
- "block-buffer 0.7.3",
- "digest 0.8.1",
- "fake-simd",
- "opaque-debug 0.2.3",
-]
-
-[[package]]
-name = "sha2"
-version = "0.9.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b69f9a4c9740d74c5baa3fd2e547f9525fa8088a8a958e0ca2409a514e33f5fa"
-dependencies = [
- "block-buffer 0.9.0",
- "cfg-if",
- "cpufeatures",
- "digest 0.9.0",
- "opaque-debug 0.3.0",
-]
-
-[[package]]
-name = "signature"
-version = "1.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2807892cfa58e081aa1f1111391c7a0649d4fa127a4ffbe34bcbfb35a1171a4"
-dependencies = [
- "digest 0.9.0",
- "rand_core 0.6.3",
-]
-
-[[package]]
-name = "spki"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c01a0c15da1b0b0e1494112e7af814a678fec9bd157881b49beac661e9b6f32"
-dependencies = [
- "der",
-]
-
-[[package]]
-name = "static_assertions"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
-
-[[package]]
-name = "subtle"
-version = "2.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6bdef32e8150c2a081110b42772ffe7d7c9032b606bc226c8260fd97e0976601"
-
-[[package]]
-name = "syn"
-version = "1.0.81"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2afee18b8beb5a596ecb4a2dce128c719b4ba399d34126b9e4396e3f9860966"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-xid",
-]
-
-[[package]]
-name = "thiserror"
-version = "1.0.30"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "854babe52e4df1653706b98fcfc05843010039b406875930a70e4d9644e5c417"
-dependencies = [
- "thiserror-impl",
-]
-
-[[package]]
-name = "thiserror-impl"
-version = "1.0.30"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aa32fd3f627f367fe16f893e2597ae3c05020f8bba2666a4e6ea73d377e5714b"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "time"
-version = "0.3.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41effe7cfa8af36f439fac33861b66b049edc6f9a32331e2312660529c1c24ad"
-dependencies = [
- "libc",
- "time-macros",
-]
-
-[[package]]
-name = "time-macros"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "25eb0ca3468fc0acc11828786797f6ef9aa1555e4a211a60d64cc8e4d1be47d6"
-
-[[package]]
-name = "tinyvec"
-version = "1.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c1c1d5a42b6245520c249549ec267180beaffcc0615401ac8e31853d4b6d8d2"
-dependencies = [
- "tinyvec_macros",
-]
-
-[[package]]
-name = "tinyvec_macros"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cda74da7e1a664f795bb1f8a87ec406fb89a02522cf6e50620d016add6dbbf5c"
-
-[[package]]
-name = "toml"
-version = "0.5.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a31142970826733df8241ef35dc040ef98c679ab14d7c3e54d827099b3acecaa"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "typenum"
-version = "1.14.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b63708a265f51345575b27fe43f9500ad611579e764c79edbc2037b1121959ec"
-
-[[package]]
-name = "ucd-trie"
-version = "0.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56dee185309b50d1f11bfedef0fe6d036842e3fb77413abef29f8f8d1c5d4c1c"
-
-[[package]]
-name = "uint"
-version = "0.9.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6470ab50f482bde894a037a57064480a246dbfdd5960bd65a44824693f08da5f"
-dependencies = [
- "byteorder",
- "crunchy",
- "hex",
- "static_assertions",
-]
-
-[[package]]
-name = "unicode-bidi"
-version = "0.3.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a01404663e3db436ed2746d9fefef640d868edae3cceb81c3b8d5732fda678f"
-
-[[package]]
-name = "unicode-normalization"
-version = "0.1.19"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d54590932941a9e9266f0832deed84ebe1bf2e4c9e4a3554d393d18f5e854bf9"
-dependencies = [
- "tinyvec",
-]
-
-[[package]]
-name = "unicode-xid"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"
-
-[[package]]
-name = "url"
-version = "2.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a507c383b2d33b5fc35d1861e77e6b383d158b2da5e14fe51b83dfedf6fd578c"
-dependencies = [
- "form_urlencoded",
- "idna",
- "matches",
- "percent-encoding",
-]
-
-[[package]]
-name = "version_check"
-version = "0.9.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5fecdca9a5291cc2b8dcf7dc02453fee791a280f3743cb0905f8822ae463b3fe"
-
-[[package]]
-name = "vesting-contracts"
-version = "0.1.0"
-dependencies = [
- "config",
- "cosmwasm-std",
- "cosmwasm-storage",
- "mixnet-contract",
-]
-
-[[package]]
-name = "wasi"
-version = "0.9.0+wasi-snapshot-preview1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519"
-
-[[package]]
-name = "wasi"
-version = "0.10.2+wasi-snapshot-preview1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6"
-
-[[package]]
-name = "zeroize"
-version = "1.4.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d68d9dcec5f9b43a30d38c49f91dfedfaac384cb8f085faca366c26207dd1619"
@@ -4,7 +4,7 @@ use crate::traits::{
    DelegatingAccount, GatewayBondingAccount, MixnodeBondingAccount, VestingAccount,
 };
 use crate::vesting::{populate_vesting_periods, Account};
-use config::defaults::MIX_DENOM;
+use config::defaults::DENOM;
 use cosmwasm_std::{
    coin, entry_point, to_binary, BankMsg, Coin, Deps, DepsMut, Env, MessageInfo, QueryResponse,
    Response, Timestamp,
@@ -147,11 +147,8 @@ pub fn try_withdraw_vested_coins(
    info: MessageInfo,
    deps: DepsMut<'_>,
 ) -> Result<Response, ContractError> {
-    if amount.denom != MIX_DENOM.base {
-        return Err(ContractError::WrongDenom(
-            amount.denom,
-            MIX_DENOM.base.to_string(),
-        ));
+    if amount.denom != DENOM {
+        return Err(ContractError::WrongDenom(amount.denom, DENOM.to_string()));
    }

    let address = info.sender.clone();
@@ -614,10 +611,10 @@ fn validate_funds(funds: &[Coin]) -> Result<Coin, ContractError> {
        return Err(ContractError::MultipleDenoms);
    }

-    if funds[0].denom != MIX_DENOM.base {
+    if funds[0].denom != DENOM {
        return Err(ContractError::WrongDenom(
            funds[0].denom.clone(),
-            MIX_DENOM.base.to_string(),
+            DENOM.to_string(),
        ));
    }

@@ -2,7 +2,7 @@
 pub mod helpers {
    use crate::contract::instantiate;
    use crate::vesting::{populate_vesting_periods, Account};
-    use config::defaults::MIX_DENOM;
+    use config::defaults::DENOM;
    use cosmwasm_std::testing::{mock_dependencies, mock_env, mock_info, MockApi, MockQuerier};
    use cosmwasm_std::{Addr, Coin, Empty, Env, MemoryStorage, OwnedDeps, Storage, Uint128};
    use vesting_contract_common::messages::{InitMsg, VestingSpecification};
@@ -31,7 +31,7 @@ pub mod helpers {
            Some(Addr::unchecked("staking")),
            Coin {
                amount: Uint128::new(1_000_000_000_000),
-                denom: MIX_DENOM.base.to_string(),
+                denom: DENOM.to_string(),
            },
            start_time_ts,
            periods,
@@ -50,7 +50,7 @@ pub mod helpers {
            Some(Addr::unchecked("staking")),
            Coin {
                amount: Uint128::new(1_000_000_000_000),
-                denom: MIX_DENOM.base.to_string(),
+                denom: DENOM.to_string(),
            },
            start_time,
            periods,
@@ -25,11 +25,11 @@ fn generate_storage_key(storage: &mut dyn Storage) -> Result<u32, ContractError>

 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
 pub struct Account {
-    pub owner_address: Addr,
-    pub staking_address: Option<Addr>,
-    pub start_time: Timestamp,
-    pub periods: Vec<VestingPeriod>,
-    pub coin: Coin,
+    owner_address: Addr,
+    staking_address: Option<Addr>,
+    start_time: Timestamp,
+    periods: Vec<VestingPeriod>,
+    coin: Coin,
    storage_key: u32,
 }

@@ -1,7 +1,7 @@
 use crate::errors::ContractError;
 use crate::storage::{delete_account, save_account, DELEGATIONS};
 use crate::traits::VestingAccount;
-use config::defaults::MIX_DENOM;
+use config::defaults::DENOM;
 use cosmwasm_std::{Addr, Coin, Env, Order, Storage, Timestamp, Uint128};
 use vesting_contract_common::{OriginalVestingResponse, Period};

@@ -38,7 +38,7 @@ impl VestingAccount for Account {
                            .u128(),
                    ),
            ),
-            denom: MIX_DENOM.base.to_string(),
+            denom: DENOM.to_string(),
        })
    }

@@ -54,7 +54,7 @@ impl VestingAccount for Account {
                    .u128()
                    .saturating_sub(self.locked_coins(block_time, env, storage)?.amount.u128()),
            ),
-            denom: MIX_DENOM.base.to_string(),
+            denom: DENOM.to_string(),
        })
    }

@@ -69,15 +69,15 @@ impl VestingAccount for Account {
        let amount = match period {
            Period::Before => Coin {
                amount: Uint128::new(0),
-                denom: MIX_DENOM.base.to_string(),
+                denom: DENOM.to_string(),
            },
            Period::In(idx) => Coin {
                amount: Uint128::new(self.tokens_per_period()? * idx as u128),
-                denom: MIX_DENOM.base.to_string(),
+                denom: DENOM.to_string(),
            },
            Period::After => Coin {
                amount: self.coin.amount,
-                denom: MIX_DENOM.base.to_string(),
+                denom: DENOM.to_string(),
            },
        };
        Ok(amount)
@@ -91,7 +91,7 @@ impl VestingAccount for Account {
        Ok(Coin {
            amount: self.get_original_vesting().amount().amount
                - self.get_vested_coins(block_time, env)?.amount,
-            denom: MIX_DENOM.base.to_string(),
+            denom: DENOM.to_string(),
        })
    }

@@ -143,7 +143,7 @@ impl VestingAccount for Account {

        Ok(Coin {
            amount,
-            denom: MIX_DENOM.base.to_string(),
+            denom: DENOM.to_string(),
        })
    }

@@ -161,7 +161,7 @@ impl VestingAccount for Account {

        Ok(Coin {
            amount,
-            denom: MIX_DENOM.base.to_string(),
+            denom: DENOM.to_string(),
        })
    }

@@ -197,7 +197,7 @@ impl VestingAccount for Account {

        Ok(Coin {
            amount,
-            denom: MIX_DENOM.base.to_string(),
+            denom: DENOM.to_string(),
        })
    }

@@ -217,12 +217,12 @@ impl VestingAccount for Account {
            let amount = bond.amount().amount - bonded_free.amount;
            Ok(Coin {
                amount,
-                denom: MIX_DENOM.base.to_string(),
+                denom: DENOM.to_string(),
            })
        } else {
            Ok(Coin {
                amount: Uint128::zero(),
-                denom: MIX_DENOM.base.to_string(),
+                denom: DENOM.to_string(),
            })
        }
    }
@@ -44,7 +44,7 @@ mod tests {
    use crate::traits::DelegatingAccount;
    use crate::traits::VestingAccount;
    use crate::traits::{GatewayBondingAccount, MixnodeBondingAccount};
-    use config::defaults::MIX_DENOM;
+    use config::defaults::DENOM;
    use cosmwasm_std::testing::{mock_env, mock_info};
    use cosmwasm_std::{coins, Addr, Coin, Timestamp, Uint128};
    use mixnet_contract_common::{Gateway, MixNode};
@@ -55,7 +55,7 @@ mod tests {
    fn test_account_creation() {
        let mut deps = init_contract();
        let env = mock_env();
-        let info = mock_info("not_admin", &coins(1_000_000_000_000, MIX_DENOM.base));
+        let info = mock_info("not_admin", &coins(1_000_000_000_000, DENOM));
        let msg = ExecuteMsg::CreateAccount {
            owner_address: "owner".to_string(),
            staking_address: Some("staking".to_string()),
@@ -65,7 +65,7 @@ mod tests {
        let response = execute(deps.as_mut(), env.clone(), info.clone(), msg.clone());
        assert!(response.is_err());

-        let info = mock_info("admin", &coins(1_000_000_000_000, MIX_DENOM.base));
+        let info = mock_info("admin", &coins(1_000_000_000_000, DENOM));
        let _response = execute(deps.as_mut(), env.clone(), info.clone(), msg.clone());
        let created_account = load_account(&Addr::unchecked("owner"), &deps.storage)
            .unwrap()
@@ -131,7 +131,7 @@ mod tests {
        let msg = ExecuteMsg::WithdrawVestedCoins {
            amount: Coin {
                amount: Uint128::new(1),
-                denom: MIX_DENOM.base.to_string(),
+                denom: DENOM.to_string(),
            },
        };
        let info = mock_info("new_owner", &[]);
@@ -262,7 +262,7 @@ mod tests {

        let delegation = Coin {
            amount: Uint128::new(500_000_000_000),
-            denom: MIX_DENOM.base.to_string(),
+            denom: DENOM.to_string(),
        };

        let ok = account.try_delegate_to_mixnode(
@@ -388,7 +388,7 @@ mod tests {
            "alice".to_string(),
            Coin {
                amount: Uint128::new(1_000_000_000_001),
-                denom: MIX_DENOM.base.to_string(),
+                denom: DENOM.to_string(),
            },
            &env,
            &mut deps.storage,
@@ -399,7 +399,7 @@ mod tests {
            "alice".to_string(),
            Coin {
                amount: Uint128::new(500_000_000_000),
-                denom: MIX_DENOM.base.to_string(),
+                denom: DENOM.to_string(),
            },
            &env,
            &mut deps.storage,
@@ -414,7 +414,7 @@ mod tests {
            "alice".to_string(),
            Coin {
                amount: Uint128::new(500_000_000_001),
-                denom: MIX_DENOM.base.to_string(),
+                denom: DENOM.to_string(),
            },
            &env,
            &mut deps.storage,
@@ -510,7 +510,7 @@ mod tests {
            "alice".to_string(),
            Coin {
                amount: Uint128::new(1_000_000_000_001),
-                denom: MIX_DENOM.base.to_string(),
+                denom: DENOM.to_string(),
            },
            &env,
            &mut deps.storage,
@@ -522,7 +522,7 @@ mod tests {
            "alice".to_string(),
            Coin {
                amount: Uint128::new(500_000_000_000),
-                denom: MIX_DENOM.base.to_string(),
+                denom: DENOM.to_string(),
            },
            &env,
            &mut deps.storage,
@@ -538,7 +538,7 @@ mod tests {
            "alice".to_string(),
            Coin {
                amount: Uint128::new(500_000_000_001),
-                denom: MIX_DENOM.base.to_string(),
+                denom: DENOM.to_string(),
            },
            &env,
            &mut deps.storage,
@@ -630,7 +630,7 @@ mod tests {
            "alice".to_string(),
            Coin {
                amount: Uint128::new(1_000_000_000_001),
-                denom: MIX_DENOM.base.to_string(),
+                denom: DENOM.to_string(),
            },
            &env,
            &mut deps.storage,
@@ -642,7 +642,7 @@ mod tests {
            "alice".to_string(),
            Coin {
                amount: Uint128::new(500_000_000_000),
-                denom: MIX_DENOM.base.to_string(),
+                denom: DENOM.to_string(),
            },
            &env,
            &mut deps.storage,
@@ -658,7 +658,7 @@ mod tests {
            "alice".to_string(),
            Coin {
                amount: Uint128::new(500_000_000_001),
-                denom: MIX_DENOM.base.to_string(),
+                denom: DENOM.to_string(),
            },
            &env,
            &mut deps.storage,
@@ -4,8 +4,7 @@ x-network: &NETWORK
  BECH32_PREFIX: nymt
  DENOM: nymt
  STAKE_DENOM: nyxt
-  WASMD_VERSION: v0.26.0
-  WASMD_COMMIT_HASH: dc5ef6fe84f0a5e3b0894692a18cc48fb5b00adf
+  WASMD_VERSION: v0.27.0

 services:
  genesis_validator:
@@ -7,6 +7,6 @@ RUN ./setup.sh

 FROM ubuntu:20.04
 COPY --from=go_builder /go/wasmd/build/nymd /root/nymd
-COPY --from=go_builder /go/wasmd/build/libwasmvm.so /root/libwasmvm.so
+COPY --from=go_builder /go/wasmd/build/libwasmvm*.so /root
 COPY init_and_start.sh .
 ENTRYPOINT ["./init_and_start.sh"]
@@ -1,8 +1,11 @@
 #!/bin/sh

+set -ue
+
 git clone https://github.com/CosmWasm/wasmd.git
 cd wasmd
 git checkout "${WASMD_VERSION}"
+WASMD_COMMIT_HASH=$(git rev-parse HEAD)
 mkdir build
 go build \
    -o build/nymd -mod=readonly -tags "netgo,ledger" \
@@ -14,5 +17,4 @@ go build \
    -X github.com/CosmWasm/wasmd/app.Bech32Prefix=${BECH32_PREFIX} \
    -X 'github.com/cosmos/cosmos-sdk/version.BuildTags=netgo,ledger'" \
    -trimpath ./cmd/wasmd
-WASMVM_SO=$(ldd build/nymd | grep libwasmvm.so | awk '{ print $3 }')
-cp "${WASMVM_SO}" build/
+find .. -type f -name 'libwasm*.so' -exec cp {} build \;
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
durch	3f9bfb4bb4	Put circulating supply back as Option	2022-06-15 00:03:13 +02:00
Mark Sinclair	e6a00ad8d4	Merge pull request #1363 from nymtech/feature/reorder-delegation-table-columns reorder delegation table columns	2022-06-14 18:40:14 +01:00
fmtabbara	815416bb41	allow sign in with enter key + create key listener hook	2022-06-14 17:21:07 +01:00
fmtabbara	f6f0e68fac	reorder delegation table columns	2022-06-14 16:52:45 +01:00
Mark Sinclair	70b23063c8	Update changelog and increment wallet version number for next release	2022-06-14 16:47:21 +01:00
Jędrzej Stuczyński	25a9fc85d2	Chore/lock file cleanup (#1360 ) * Removed redundant lock files + updated cw3 and cw4 cw-storage-plus addresses #1313 * Removed redundant lock files for clients addresses #1314, #1315, #1316	2022-06-14 16:34:17 +01:00
Mark Sinclair	3079a9ee7e	Merge pull request #1362 from nymtech/bugfix/delegations-reward-success-message fix redeem rewards success message	2022-06-14 16:30:40 +01:00
fmtabbara	06603ec585	fix redeem rewards success message	2022-06-14 16:21:08 +01:00
dependabot[bot]	fd940c4c7c	build(deps): bump minimist from 1.2.5 to 1.2.6 in /nym-connect/webdriver (#1346 ) Bumps [minimist](https://github.com/substack/minimist) from 1.2.5 to 1.2.6. - [Release notes](https://github.com/substack/minimist/releases) - [Commits](https://github.com/substack/minimist/compare/1.2.5...1.2.6) --- updated-dependencies: - dependency-name: minimist dependency-type: indirect ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2022-06-14 15:39:10 +01:00
dependabot[bot]	a90a8926fe	build(deps): bump async from 2.6.3 to 2.6.4 in /nym-connect (#1349 ) Bumps [async](https://github.com/caolan/async) from 2.6.3 to 2.6.4. - [Release notes](https://github.com/caolan/async/releases) - [Changelog](https://github.com/caolan/async/blob/v2.6.4/CHANGELOG.md) - [Commits](https://github.com/caolan/async/compare/v2.6.3...v2.6.4) --- updated-dependencies: - dependency-name: async dependency-type: indirect ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2022-06-14 15:38:36 +01:00
dependabot[bot]	e40cb960ce	build(deps): bump ejs from 3.1.6 to 3.1.8 in /nym-connect/webdriver (#1348 ) Bumps [ejs](https://github.com/mde/ejs) from 3.1.6 to 3.1.8. - [Release notes](https://github.com/mde/ejs/releases) - [Changelog](https://github.com/mde/ejs/blob/main/CHANGELOG.md) - [Commits](https://github.com/mde/ejs/compare/v3.1.6...v3.1.8) --- updated-dependencies: - dependency-name: ejs dependency-type: indirect ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2022-06-14 15:38:30 +01:00
dependabot[bot]	0f2d01c91a	build(deps): bump async from 3.2.1 to 3.2.4 in /nym-wallet/webdriver (#1347 ) Bumps [async](https://github.com/caolan/async) from 3.2.1 to 3.2.4. - [Release notes](https://github.com/caolan/async/releases) - [Changelog](https://github.com/caolan/async/blob/master/CHANGELOG.md) - [Commits](https://github.com/caolan/async/compare/v3.2.1...v3.2.4) --- updated-dependencies: - dependency-name: async dependency-type: indirect ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2022-06-14 15:38:22 +01:00
Gala	81bbb61dac	enabling discord icon (#1319 )	2022-06-13 15:56:07 +01:00
Gala	e768d99e3d	Explorer: Moving where is displayed the delegators number (#1341 ) * moving the delegators number * changing column header and styles order * another color test	2022-06-13 15:37:48 +01:00
Mark Sinclair	987cb5d424	Bump wallet version number	2022-06-13 13:52:24 +01:00
Fouad	7f1d5e0691	Merge pull request #1352 from nymtech/feature/tx-hash-for-rewards Show transaction hash in modals when redeeming or compounding rewards	2022-06-13 12:41:44 +01:00
Mark Sinclair	6ed28b5a1d	Show transaction details in context methods and confirmation modals for redeeming/compounding rewards	2022-06-13 12:27:39 +01:00
Mark Sinclair	b48184ba13	Add return type for redeeming or compounding rewards	2022-06-13 12:26:37 +01:00
Tommy Verrall	d1499f3361	Merge pull request #1350 from nymtech/feature/bring-back-node-settings bing back node settings	2022-06-13 12:04:47 +01:00
fmtabbara	98e0e1fc4e	fix initial request for node stats	2022-06-13 11:49:18 +01:00
Mark Sinclair	bdc8fb7ae7	nym-wallet: add font files for all weights for wallet as not working in some Linux distros (#1351 )	2022-06-13 10:50:53 +01:00
fmtabbara	0b0cbe3181	bing back node settings	2022-06-13 10:22:07 +01:00
Mark Sinclair	076a651199	Fix clippy warnings in tests	2022-06-13 10:14:13 +01:00
Pierre Dommerc	b4e9ebd9cc	[wallet] style changes to match new design and layout (#1336 ) * feat(wallet): style changes to match new design * fix(wallet): style * feat(wallet): remove useless color * feat(wallet): some style changes in balance page, show entire address set a small size to avatar account set vertical alignment to start for page cards * feat(wallet): fix padding	2022-06-13 11:03:16 +02:00
Jon Häggblad	77d16d34af	changelog: added entry for nym-connect	2022-06-10 19:41:34 +02:00
Jon Häggblad	9e8868f357	Merge pull request #1338 from nymtech/feature/hrycyszynvpn	2022-06-10 16:44:16 +02:00
Jon Häggblad	64fdf5a270	Merge remote-tracking branch 'origin/develop' into feature/hrycyszynvpn	2022-06-10 16:13:21 +02:00
Jon Häggblad	c17d65380c	connect: disable keybase notfication	2022-06-10 16:12:40 +02:00
Mark Sinclair	00e234a754	Network Explorer upgrades and fixes (#1343 ) * Upgrade storybook and add mock for Tauri `api/app` * Upgrade Network Explorer to React Router 6 * Update changelog for react router 6 upgrade	2022-06-10 14:42:53 +01:00
Mark Sinclair	6ef50b93bc	Fix type in `StateParams.ts` and apply es-lint formatting	2022-06-10 14:23:07 +01:00
Jon Häggblad	437b3b6885	socks5: allow some unused methods temporarily	2022-06-10 14:39:17 +02:00
Jon Häggblad	6976be3e3a	connect: fix unused warnings	2022-06-10 14:18:58 +02:00
Jon Häggblad	dca7a9da94	connect: update readme	2022-06-10 13:55:30 +02:00
Jon Häggblad	56b1005226	connect: remove some unused stuff and tidy	2022-06-10 13:55:14 +02:00
Jon Häggblad	caa32299a9	workflow: rename support files for nym-connect	2022-06-10 12:49:34 +02:00
Drazen Urch	eff732aa2c	Introduce staking supply, contract and wallet (#1324 ) * Introduce staking supply, contract and wallet * Migration staking supply (#1327) * Staking supply to params migration * Include into migration entrypoint * StateParams merge * Add changelog * Make everyone happy	2022-06-10 12:36:35 +02:00
Tommy Verrall	68889bd362	Merge pull request #1342 from nymtech/bugfix/prevent-multiple-send-requests Bugfix: Prevent multiple send requests	2022-06-10 11:21:11 +01:00
Jon Häggblad	1b4853b5ba	workflow: update nym-connect names	2022-06-10 12:16:11 +02:00
fmtabbara	45cc531056	move setloading state	2022-06-10 11:05:06 +01:00
Jon Häggblad	8df24b8ce2	verloc: signalling for graceful shutdown (#1323 ) * common/verloc: signalling for graceful shutdown * verloc: make shutdown handler not optional * verloc: logging without explicit target * rustmt * mixnode: note about rocket * verloc: remove accidental duplicate block * verloc: pass shutdown handler as argument to connection handler	2022-06-10 11:36:48 +02:00
Elliot	e1b5407613	Fix validator docker build on other platforms (#1329 ) * Fix validator docker build on other platforms * Require build arguments in validator docker build * docker-compose.yml: Remove unused WASMD_COMMIT_HASH argument * docker-compose.yml: Update WASMD_VERSION to v0.27.0 * Update changelog for 1329	2022-06-10 10:30:48 +03:00
Jon Häggblad	34d3d520d9	Merge remote-tracking branch 'origin/develop' into feature/hrycyszynvpn	2022-06-10 00:03:06 +02:00
Jon Häggblad	9a103d5e20	wallet: fix clippy (#1339 )	2022-06-10 00:02:31 +02:00
Jon Häggblad	352111d443	wallet: add to Makefile	2022-06-09 23:30:04 +02:00
Jon Häggblad	e9b72d1c37	rustfmt	2022-06-09 23:26:04 +02:00
Jon Häggblad	6e355dc75e	connect: update tokio	2022-06-09 21:32:15 +02:00
Jon Häggblad	d07279bde0	Merge remote-tracking branch 'origin/develop' into feature/hrycyszynvpn	2022-06-09 21:26:06 +02:00
Jon Häggblad	26f0001d9b	rustfmt	2022-06-09 21:25:49 +02:00
Jon Häggblad	f3ab6a6a4c	Remove rustfmt.toml	2022-06-09 21:25:35 +02:00
Jon Häggblad	818d2585da	Search replace all instances to nym-connect	2022-06-09 21:22:27 +02:00
Jon Häggblad	5f2b9378fe	Rename directory to nym-connect	2022-06-09 21:10:01 +02:00
Jon Häggblad	5a374fe8ff	Spawn socks5 runtime in thread	2022-06-09 21:07:44 +02:00
Fouad	62baada93d	Feature/wallet delegation UI squashed (#1326 ) * Delegation UI: Update QA vars fmt re-map coin type for qa add correct bech32 address as the network-explorer-api was complaining clean up fmt Delegation components Show delegation story on paper Remove actions header from delegations list Add copy to clipboard for delegation list node ids Move tooltip Modals Extract modal styles Fix exports Rewards summary and redeem modal Factor out simple modal Delegations actions modals: delegate, delegate more, undelegate Coin mark and move logo stories Rust types React components handle currency Form field to enter and display an Identity Key Fix up build order Update README Flat buttons End adornment Currency form field Add more props Export components Add currency and mixnode fields Group stories into folders and add flow Change exports from shared packages to stop webpack bundling issues Fix logo import Add mock for tauri api in storybook that shows a console error for operations that are not mocked Delegations views and routes for wallet Delegations list show pending delegations and undelegations wip - delegations page status Add typescript type checking to storybook webpack config and more mocks for tauri Add more interstitial states and confirmation modals Copy change Move config to inside source tree Fix up `Console` typings Add wrapper around Tauri `invoke` that logs operations in development mode wip wip wip ts-rs: remove old files ts-rs: update paths to `ts-packages/types` ts-rs: remove old files ts-rs: export new types to `ts-packages/types` Add `MajorCurrencyAmount` to convert to and from TS types for various backend currency types New crate `nym-types` to provide types for frontend apps (wallet, explorer, etc) wip update type imports and fix some lint errors update packages update type imports update type imports update type imports update type imports start pulling out use of minorMajor and majorMinor update type imports update import Add missing types generated by ts-rs fix types Adding denom to account type updates Handle micro currency denoms Fix type conversion mistake Add clean target eslint: formatting Update React currency components to use `MajorCurrencyAmount` Add separators and extra props to currency components replace currency mapper with denom returning from service Adjust type while generation is broken start integrating new CurrencyFormField component update balance and vesting on client change (not only client address) Fix up conversion from cosmwasm coin to major currency for minor denoms Fix up typings and validations to remove more `Coin` usage fix conflict fix delegations form start fixing validation type update remove console log tidy up remove more unused types remove more unused types Fix `Coin` denom to be `minor` Fix up to minor_cosmos_coin Fix up send Remove `Coin` type Fix up exported types start delegation UI more UI work close actions modal on action select update label fix old delegateion form minor updates undo change to currency in stringD Fix up types Add feature flag for generating typescript Generate types behind feature flag Use custom cli tool to export `ts-rs` types `ts-rs-cli` moves files into place and fix up `Makefile` Update generations target Add missing types for generation Generate typescript types reorder imports use make generate-typescript for new types + type import updates update types Add delegate with everything Add get block to nymd client More conversions Get a big list of delegations with lots of stuff Add `avg_uptime_percent` component api updates ui updates and fixes Add delegation history and pending events Fix up addition Fix up pending delegation event types Filter pending delegation events add history and pending events set total delegations rebase fix breaking type change on delegate page Fix mixnode mapping Add back refresh and set periodic refresh upgrade to react router 6 Add logging Export new types for gas and transactions increase container size! add sendtx type update onOK to return MAjorCurrencyAmount align table items display dash if amount not availble work on delegate and undelegate Make serializable More types Fix up errors align item icon type updates Add operation to get all pending delegation/undelegation events Fix up logging Add more logging Fix undelegate error get pending delegation events remove unused import * Fix rebase errors * Integrate fees changes: - make operations available as requests (typed with any for now, needs changing) - move `FeeDetails` to `common/types` - mock `getGasFee()` * get wallet balance after transactions * fix duplicate key * use token pool selector * update wording * Created nymd internal coin * spell delegations correctly! * Additional From implementations plus a constructor * try_add * Changed client API to use the new coin type * CoinConverter trait * Made wallet compilable with the recent changes * Simplified the API by removing the generics in favour of explicit Coin type * Fixed validator api * integrate modal divider with modal component * handle undelegation of locked tokens * only return events table if there are events * Fixed up tests and clippy * Refactored missed coin-generic API methods * changelog * refresh on network or client details change * Bunch of temporary workaround to have wallet working-ish * Add claim and compound wallet endpoints, proc_macro to generate execute and simulate * CHANGELOG * Sort CHANGELOG lines * PR comments * allow sorting of pending events * fix lint errors * handle page overflow * handle reedem and vesting redeem requests * set up compound rewards * refresh locked tokens on page load * remove old delegations pages + remove settings modal + update network explorer url * update validation for hostname (prevent leading spaces) * add compound success case * display est fee until new simulations are used * fix up coin validation * tommy fixes * Show app version at bottom of nav * Show admin page when account matches account id from `.env` file `ADMIN_ADDRESS` map. Value is fetch from GH Actions secrets at build time. * Update change log Co-authored-by: tommy <tommyvez@protonmail.com> Co-authored-by: Mark Sinclair <mmsinclair@gmail.com> Co-authored-by: Jędrzej Stuczyński <jedrzej.stuczynski@gmail.com> Co-authored-by: durch <durch@users.noreply.github.com>	2022-06-09 17:05:17 +01:00
Jon Häggblad	db09870352	Remove unused deps	2022-05-23 15:52:46 +02:00
Jon Häggblad	d703e160e3	Start socks5 client in task	2022-05-23 15:49:21 +02:00
Jon Häggblad	1d6dabd0b5	Remove some tracing in socks5 client	2022-05-20 16:11:47 +02:00
Jon Häggblad	4ce68fd6f2	Merge branch 'develop' into feature/hrycyszynvpn	2022-05-20 16:07:11 +02:00
Jon Häggblad	83f6fbec5d	Remove things not needed	2022-05-20 15:42:16 +02:00
Jon Häggblad	d87479f28c	Uncomment code and try build	2022-05-18 16:06:48 +02:00
Jon Häggblad	59db03a55d	Fix build on linux	2022-05-11 11:20:20 +02:00
Jędrzej Stuczyński	5db7f7e0bc	Fixing some dependencies	2022-04-29 14:39:42 +01:00
Mark Sinclair	2422f090cc	wip: add client	2022-04-27 14:30:17 +01:00
Mark Sinclair	1362d8a3eb	Bump rust version and make dependencies match wallet	2022-04-26 17:14:10 +01:00
Mark Sinclair	40274689e3	Add pinned versions from develop	2022-04-26 14:50:48 +01:00
Mark Sinclair	3f9d6b2f1c	wip	2022-04-26 14:50:47 +01:00