nym-connect: copy changes

CHANGELOG.md

@@ -24,6 +24,7 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://
 - validator-api: Added new endpoints for coconut spending flow and communications with coconut & multisig contracts ([#1261])
 - validator-api: add `uptime`, `estimated_operator_apy`, `estimated_delegators_apy` to `/mixnodes/detailed` endpoint ([#1393])
 - network-statistics: a new mixnet service that aggregates and exposes anonymized data about mixnet services ([#1328])
+- wallet: when simulating gas costs, an automatic adjustment is being used ([#1388]).
 - mixnode: Added basic mixnode hardware reporting to the HTTP API ([#1308]).
 - validator-api: endpoint, in coconut mode, for returning the validator-api cosmos address ([#1404]).
 
@@ -64,17 +65,11 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://
 [#1329]: https://github.com/nymtech/nym/pull/1329
 [#1353]: https://github.com/nymtech/nym/pull/1353
 [#1376]: https://github.com/nymtech/nym/pull/1376
+[#1388]: https://github.com/nymtech/nym/pull/1388
 [#1393]: https://github.com/nymtech/nym/pull/1393
 [#1404]: https://github.com/nymtech/nym/pull/1404
 [#1427]: https://github.com/nymtech/nym/pull/1427
 
-## [nym-wallet-v1.0.7](https://github.com/nymtech/nym/tree/nym-wallet-v1.0.7) (2022-07-11)
-
-- wallet: dark mode
-- wallet: when simulating gas costs, an automatic adjustment is being used ([#1388]).
-
-[#1388]: https://github.com/nymtech/nym/pull/1388
-
 ## [nym-contracts-v1.0.1](https://github.com/nymtech/nym/tree/nym-contracts-v1.0.1) (2022-06-22)
 
 ### Added

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

@@ -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());
 

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

@@ -514,10 +514,10 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
         let fee = match fee {
             Fee::Manual(fee) => fee,
             Fee::Auto(multiplier) => auto_fee(multiplier).await?,
-            Fee::PayerGranterAuto(auto_feegrant) => {
-                let mut fee = auto_fee(auto_feegrant.gas_adjustment).await?;
-                fee.payer = Some(auto_feegrant.payer);
-                fee.granter = Some(auto_feegrant.granter);
+            Fee::PayerGranterAuto(multiplier, payer, granter) => {
+                let mut fee = auto_fee(multiplier).await?;
+                fee.payer = payer;
+                fee.granter = granter;
                 fee
             }
         };

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

@@ -1,11 +1,9 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::nymd::Coin;
 use crate::nymd::Gas;
 use cosmrs::{tx, AccountId};
 use serde::{Deserialize, Serialize};
-use std::fmt::{Display, Formatter};
 
 pub mod gas_price;
 
@@ -13,63 +11,11 @@ pub type GasAdjustment = f32;
 
 pub const DEFAULT_SIMULATED_GAS_MULTIPLIER: GasAdjustment = 1.3;
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct AutoFeeGrant {
-    pub gas_adjustment: Option<GasAdjustment>,
-    pub payer: AccountId,
-    pub granter: AccountId,
-}
-
-impl Display for AutoFeeGrant {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        if let Some(gas_adjustment) = self.gas_adjustment {
-            write!(f, "Feegrant in auto mode with {gas_adjustment} simulated multiplier with {} payer and {} granter", self.payer, self.granter)
-        } else {
-            write!(f, "Feegrant in auto mode with no custom simulated multiplier with {} payer and {} granter", self.payer, self.granter)
-        }
-    }
-}
-
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub enum Fee {
     Manual(#[serde(with = "sealed::TxFee")] tx::Fee),
     Auto(Option<GasAdjustment>),
-    PayerGranterAuto(AutoFeeGrant),
-}
-
-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"),
-            Fee::PayerGranterAuto(auto_feegrant) => write!(f, "{}", auto_feegrant),
-        }
-    }
-}
-
-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()),
-            _ => None,
-        }
-    }
+    PayerGranterAuto(Option<GasAdjustment>, Option<AccountId>, Option<AccountId>),
 }
 
 impl From<tx::Fee> for Fee {

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

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

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

@@ -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 {}

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

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

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

@@ -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 {

common/network-defaults/src/lib.rs

@@ -267,7 +267,7 @@ impl DenomDetails {
     }
 }
 
-#[derive(Debug, Serialize, Deserialize, Hash, Clone, PartialEq, Eq)]
+#[derive(Clone, Debug, Deserialize, Eq, Hash, PartialEq, Serialize)]
 pub struct DenomDetailsOwned {
     pub base: String,
     pub display: String,

common/types/src/account.rs

@@ -1,4 +1,4 @@
-use crate::currency::DecCoin;
+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: String,
+    pub denom: CurrencyDenom,
 }
 
 impl Account {
-    pub fn new(contract_address: String, client_address: String, denom: String) -> 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,
-        }
-    }
-}

common/types/src/currency.rs

@@ -1,26 +1,22 @@
 use crate::error::TypesError;
-use config::defaults::all::Network;
-use config::defaults::{DenomDetails, DenomDetailsOwned};
-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,
@@ -33,8 +29,9 @@ use ts_rs::{Dependency, TS};
     Eq,
     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,
@@ -46,470 +43,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, network.mix_denom().into());
-        network_coins.insert(network.stake_denom().base, 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.as_ref())
     }
 }
 
-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, Eq, 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, Eq, 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 From<DenomDetailsOwned> for CoinMetadata {
-    fn from(denom_details: DenomDetailsOwned) -> Self {
-        CoinMetadata::new(
-            vec![
-                DenomUnit::new(denom_details.base.clone(), 0),
-                DenomUnit::new(
-                    denom_details.display.clone(),
-                    denom_details.display_exponent,
-                ),
-            ],
-            denom_details.base,
-            denom_details.display,
-        )
-    }
-}
+// 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, Eq, 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());
     }
 }

common/types/src/delegation.rs

@@ -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
 }
 
-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, Eq, JsonSchema)]
 pub struct DelegationRecord {
-    pub amount: DecCoin,
+    pub amount: MajorCurrencyAmount,
     pub block_height: u64,
     pub delegated_on_iso_datetime: String,
     pub uses_vesting_contract_tokens: bool,
@@ -57,16 +69,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 uses_vesting_contract_tokens: bool,
-    pub accumulated_rewards: Option<DecCoin>,
+    pub accumulated_rewards: Option<MajorCurrencyAmount>,
     pub pending_events: Vec<DelegationEvent>,
     pub history: Vec<DelegationRecord>,
 }
@@ -80,7 +92,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))]
@@ -104,34 +143,36 @@ 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,
     pub proxy: Option<String>,
 }
 
-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())?),
-                proxy: delegation.proxy.map(|p| p.into_string()),
-            },
-            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),
+                    proxy: delegation.proxy.map(|p| p.into_string()),
+                })
+            }
+            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,
                 proxy: pending_undelegate.proxy().map(|p| p.into_string()),
-            },
-        })
+            }),
+        }
     }
 }
 
@@ -159,6 +200,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",
@@ -167,6 +232,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,
 }

common/types/src/error.rs

@@ -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}")]
@@ -64,12 +63,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 {

common/types/src/fees.rs

@@ -1,4 +1,4 @@
-use crate::currency::DecCoin;
+use crate::currency::MajorCurrencyAmount;
 use serde::{Deserialize, Serialize};
 use validator_client::nymd::Fee;
 
@@ -8,16 +8,10 @@ use ts_rs::{Dependency, TS};
 #[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>,
     pub fee: Fee,
 }
 
-impl FeeDetails {
-    pub fn new(amount: Option<DecCoin>, fee: Fee) -> Self {
-        FeeDetails { amount, fee }
-    }
-}
-
 #[cfg(feature = "generate-ts")]
 impl TS for FeeDetails {
     const EXPORT_TO: Option<&'static str> = Some("ts-packages/types/src/types/rust/FeeDetails.ts");
@@ -31,12 +25,13 @@ impl TS for FeeDetails {
     }
 
     fn inline() -> String {
-        "{ amount: DecCoin | null, fee: Fee }".into()
+        "{ amount: MajorCurrencyAmount | null, fee: Fee }".into()
     }
 
     fn dependencies() -> Vec<Dependency> {
         vec![
-            Dependency::from_ty::<DecCoin>().expect("TS was incorrectly defined on `DecCoin`"),
+            Dependency::from_ty::<MajorCurrencyAmount>()
+                .expect("TS was incorrectly defined on `CurrencyDenom`"),
             Dependency::from_ty::<ts_type_helpers::Fee>()
                 .expect("TS was incorrectly defined on `ts_type_helpers::Fee`"),
         ]

common/types/src/gas.rs

@@ -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, Debug)]
 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(),
+        })
     }
 }

common/types/src/gateway.rs

@@ -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, Eq, 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()),
         })
     }
 }

common/types/src/mixnode.rs

@@ -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, Eq, 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,
         })
     }
 }

common/types/src/transaction.rs

@@ -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(),
+            // )?,
         })
     }
 }

common/types/src/vesting.rs

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

contracts/mixnet/src/delegations/transactions.rs

@@ -1195,7 +1195,7 @@ mod tests {
 
         //    _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(),

contracts/mixnet/src/rewards/transactions.rs

@@ -1225,6 +1225,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)
@@ -1530,7 +1531,7 @@ pub mod tests {
         assert_eq!(mix_2_reward_result.lambda(), U128::from_num(0.0001f64));
         assert_eq!(mix_2_reward_result.reward().int(), 974456u128);
 
-        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());
     }

contracts/vesting/src/vesting/account/mod.rs

@@ -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,
 }
 

explorer/.env.qa

@@ -1,5 +0,0 @@
-EXPLORER_API_URL=https://qa-explorer.nymtech.net/api/v1
-VALIDATOR_API_URL=https://qa-validator.nymtech.net
-BIG_DIPPER_URL=https://qa-blocks.nymtech.net
-CURRENCY_DENOM=unymt
-CURRENCY_STAKING_DENOM=unyxt

nym-connect/src/layouts/DefaultLayout.tsx

@@ -22,11 +22,14 @@ export const DefaultLayout: React.FC<{
   };
   return (
     <AppWindowFrame>
-      <Typography fontWeight="700" fontSize="14px" textAlign="center">
-        Connect, your privacy will be 100% protected thanks to the Nym Mixnet
+      <Typography fontWeight="400" fontSize="12px" textAlign="center" sx={{ opacity: 0.6 }}>
+        This is experimental software. <br />
+        Do not rely on it for strong anonymity (yet).
       </Typography>
-      <Typography fontWeight="700" fontSize="14px" textAlign="center" color="#60D6EF" pt={2}>
-        You are not protected now
+      <Typography fontWeight="700" fontSize="14px" textAlign="center" pt={2}>
+        Connect to the
+        <br />
+        Nym mixnet for privacy.
       </Typography>
       <ServiceProviderSelector services={services} onChange={handleServiceProviderChange} />
       <ConnectionButton

nym-wallet/Cargo.lock

@@ -3056,7 +3056,7 @@ dependencies = [
 
 [[package]]
 name = "nym_wallet"
-version = "1.0.7"
+version = "1.0.6"
 dependencies = [
  "aes-gcm",
  "argon2 0.3.4",

nym-wallet/nym-wallet-types/src/network.rs

@@ -1,12 +1,15 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use config::defaults::all::Network as ConfigNetwork;
-use config::defaults::{mainnet, qa, sandbox};
+use cosmrs::Denom;
 use serde::{Deserialize, Serialize};
 use std::fmt;
+use std::str::FromStr;
 use strum::EnumIter;
 
+use config::defaults::all::Network as ConfigNetwork;
+use config::defaults::{mainnet, qa, sandbox};
+
 #[allow(clippy::upper_case_acronyms)]
 #[cfg_attr(feature = "generate-ts", derive(ts_rs::TS))]
 #[cfg_attr(
@@ -25,11 +28,13 @@ impl Network {
         self.to_string().to_lowercase()
     }
 
-    pub fn base_mix_denom(&self) -> &str {
+    // this should be returning just a `&str`, but don't want to cause too many conflicts just yet...
+    pub fn base_mix_denom(&self) -> Denom {
         match self {
-            Network::QA => qa::MIX_DENOM.base,
-            Network::SANDBOX => sandbox::MIX_DENOM.base,
-            Network::MAINNET => mainnet::MIX_DENOM.base,
+            // network defaults should be correctly formatted
+            Network::QA => Denom::from_str(qa::MIX_DENOM.base).unwrap(),
+            Network::SANDBOX => Denom::from_str(sandbox::MIX_DENOM.base).unwrap(),
+            Network::MAINNET => Denom::from_str(mainnet::MIX_DENOM.base).unwrap(),
         }
     }
 

nym-wallet/src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nym_wallet"
-version = "1.0.7"
+version = "1.0.6"
 description = "Nym Native Wallet"
 authors = ["Nym Technologies SA"]
 license = ""

nym-wallet/src-tauri/src/error.rs

@@ -1,5 +1,4 @@
 use nym_types::error::TypesError;
-use nym_wallet_types::network::Network;
 use serde::{Serialize, Serializer};
 use std::io;
 use std::num::ParseIntError;
@@ -107,10 +106,6 @@ pub enum BackendError {
     FailedToDeriveAddress,
     #[error("{0}")]
     ValueParseError(#[from] ParseIntError),
-    #[error("The provided coin has an unknown denomination - {0}")]
-    UnknownCoinDenom(String),
-    #[error("Network {network} doesn't have any associated registered coin denoms")]
-    NoCoinsRegistered { network: Network },
 }
 
 impl Serialize for BackendError {

nym-wallet/src-tauri/src/main.rs

@@ -4,7 +4,9 @@
 )]
 
 use mixnet_contract_common::{Gateway, MixNode};
+use std::sync::Arc;
 use tauri::Menu;
+use tokio::sync::RwLock;
 
 mod config;
 mod error;
@@ -22,7 +24,7 @@ use crate::operations::simulate;
 use crate::operations::validator_api;
 use crate::operations::vesting;
 
-use crate::state::WalletState;
+use crate::state::State;
 
 #[allow(clippy::too_many_lines)]
 fn main() {
@@ -30,7 +32,7 @@ fn main() {
     setup_logging();
 
     tauri::Builder::default()
-        .manage(WalletState::default())
+        .manage(Arc::new(RwLock::new(State::default())))
         .invoke_handler(tauri::generate_handler![
             mixnet::account::add_account_for_password,
             mixnet::account::archive_wallet_file,

nym-wallet/src-tauri/src/network_config.rs

@@ -1,15 +1,20 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::error::BackendError;
-use crate::state::WalletState;
+use std::sync::Arc;
+
+use tokio::sync::RwLock;
+
 use nym_wallet_types::network::Network as WalletNetwork;
 use nym_wallet_types::network_config::{Validator, ValidatorUrl, ValidatorUrls};
 
+use crate::error::BackendError;
+use crate::state::State;
+
 #[tauri::command]
 pub async fn get_validator_nymd_urls(
     network: WalletNetwork,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<ValidatorUrls, BackendError> {
     let state = state.read().await;
     let urls: Vec<ValidatorUrl> = state.get_nymd_urls(network).collect();
@@ -19,7 +24,7 @@ pub async fn get_validator_nymd_urls(
 #[tauri::command]
 pub async fn get_validator_api_urls(
     network: WalletNetwork,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<ValidatorUrls, BackendError> {
     let state = state.read().await;
     let urls: Vec<ValidatorUrl> = state.get_api_urls(network).collect();
@@ -30,7 +35,7 @@ pub async fn get_validator_api_urls(
 pub async fn select_validator_nymd_url(
     url: &str,
     network: WalletNetwork,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<(), BackendError> {
     log::debug!("Selecting new validator nymd_url for {network}: {url}");
     state
@@ -44,7 +49,7 @@ pub async fn select_validator_nymd_url(
 pub async fn select_validator_api_url(
     url: &str,
     network: WalletNetwork,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<(), BackendError> {
     log::debug!("Selecting new validator api_url for {network}: {url}");
     state.write().await.select_validator_api_url(url, network)?;
@@ -55,7 +60,7 @@ pub async fn select_validator_api_url(
 pub async fn add_validator(
     validator: Validator,
     network: WalletNetwork,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<(), BackendError> {
     log::debug!("Add validator for {network}: {validator}");
     let url = validator.try_into()?;
@@ -67,7 +72,7 @@ pub async fn add_validator(
 pub async fn remove_validator(
     validator: Validator,
     network: WalletNetwork,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<(), BackendError> {
     log::debug!("Remove validator for {network}: {validator}");
     let url = validator.try_into()?;
@@ -78,7 +83,7 @@ pub async fn remove_validator(
 // Update the list of validators by fecthing additional ones remotely. If it fails, just ignore.
 #[tauri::command]
 pub async fn update_validator_urls(
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<(), BackendError> {
     let mut w_state = state.write().await;
     let _r = w_state.fetch_updated_validator_urls().await;

nym-wallet/src-tauri/src/operations/mixnet/account.rs

@@ -1,7 +1,8 @@
 use crate::config::{Config, CUSTOM_SIMULATED_GAS_MULTIPLIER};
 use crate::error::BackendError;
 use crate::network_config;
-use crate::state::{WalletAccountIds, WalletState};
+use crate::nymd_client;
+use crate::state::{State, WalletAccountIds};
 use crate::wallet_storage::{self, DEFAULT_LOGIN_ID};
 use bip39::{Language, Mnemonic};
 use config::defaults::all::Network;
@@ -9,11 +10,15 @@ use config::defaults::COSMOS_DERIVATION_PATH;
 use cosmrs::bip32::DerivationPath;
 use itertools::Itertools;
 use nym_types::account::{Account, AccountEntry, Balance};
+use nym_types::currency::MajorCurrencyAmount;
 use nym_wallet_types::network::Network as WalletNetwork;
 use rand::seq::SliceRandom;
 use std::collections::HashMap;
+use std::convert::TryInto;
 use std::str::FromStr;
+use std::sync::Arc;
 use strum::IntoEnumIterator;
+use tokio::sync::RwLock;
 use url::Url;
 use validator_client::nymd::wallet::{AccountData, DirectSecp256k1HdWallet};
 use validator_client::{nymd::SigningNymdClient, Client};
@@ -21,30 +26,33 @@ use validator_client::{nymd::SigningNymdClient, Client};
 #[tauri::command]
 pub async fn connect_with_mnemonic(
     mnemonic: String,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<Account, BackendError> {
     let mnemonic = Mnemonic::from_str(&mnemonic)?;
     _connect_with_mnemonic(mnemonic, state).await
 }
 
 #[tauri::command]
-pub async fn get_balance(state: tauri::State<'_, WalletState>) -> Result<Balance, BackendError> {
-    let guard = state.read().await;
-    let client = guard.current_client()?;
-    let address = client.nymd.address();
-    let network = guard.current_network();
-    let base_mix_denom = network.base_mix_denom();
-
-    match client
-        .nymd
-        .get_balance(address, base_mix_denom.to_string())
-        .await?
+pub async fn get_balance(
+    state: tauri::State<'_, Arc<RwLock<State>>>,
+) -> Result<Balance, BackendError> {
+    let denom = state.read().await.current_network().base_mix_denom();
+    match nymd_client!(state)
+        .get_balance(nymd_client!(state).address(), denom)
+        .await
     {
-        Some(coin) => {
-            let amount = guard.attempt_convert_to_display_dec_coin(coin)?;
-            Ok(Balance::new(amount))
+        Ok(Some(coin)) => {
+            let amount = MajorCurrencyAmount::from(coin);
+            let printable_balance = amount.to_string();
+            Ok(Balance {
+                amount,
+                printable_balance,
+            })
         }
-        None => Err(BackendError::NoBalance(address.to_string())),
+        Ok(None) => Err(BackendError::NoBalance(
+            nymd_client!(state).address().to_string(),
+        )),
+        Err(e) => Err(BackendError::from(e)),
     }
 }
 
@@ -60,7 +68,7 @@ pub fn validate_mnemonic(mnemonic: &str) -> bool {
 
 #[tauri::command]
 pub async fn switch_network(
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
     network: WalletNetwork,
 ) -> Result<Account, BackendError> {
     let account = {
@@ -71,7 +79,7 @@ pub async fn switch_network(
         Account::new(
             client.nymd.mixnet_contract_address().to_string(),
             client.nymd.address().to_string(),
-            denom.into(),
+            denom.try_into()?,
         )
     };
 
@@ -82,7 +90,7 @@ pub async fn switch_network(
 }
 
 #[tauri::command]
-pub async fn logout(state: tauri::State<'_, WalletState>) -> Result<(), BackendError> {
+pub async fn logout(state: tauri::State<'_, Arc<RwLock<State>>>) -> Result<(), BackendError> {
     state.write().await.logout();
     Ok(())
 }
@@ -94,7 +102,7 @@ fn random_mnemonic() -> Mnemonic {
 
 async fn _connect_with_mnemonic(
     mnemonic: Mnemonic,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<Account, BackendError> {
     {
         let mut w_state = state.write().await;
@@ -154,7 +162,7 @@ async fn _connect_with_mnemonic(
         Some(client) => Ok(Account::new(
             client.nymd.mixnet_contract_address().to_string(),
             client.nymd.address().to_string(),
-            default_network.base_mix_denom().to_owned(),
+            default_network.base_mix_denom().try_into()?,
         )),
         None => Err(BackendError::NetworkNotSupported(
             config::defaults::DEFAULT_NETWORK,
@@ -170,7 +178,6 @@ async fn _connect_with_mnemonic(
         let network: WalletNetwork = client.network.clone().into();
         let mut w_state = state.write().await;
         w_state.add_client(network, client);
-        w_state.register_default_denoms(network);
     }
 
     account_for_default_network
@@ -321,7 +328,7 @@ pub fn create_password(mnemonic: &str, password: String) -> Result<(), BackendEr
 #[tauri::command]
 pub async fn sign_in_with_password(
     password: String,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<Account, BackendError> {
     log::info!("Signing in with password");
 
@@ -361,7 +368,7 @@ fn extract_first_mnemonic(
 pub async fn sign_in_with_password_and_account_id(
     account_id: &str,
     password: &str,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<Account, BackendError> {
     log::info!("Signing in with password");
 
@@ -413,7 +420,7 @@ pub async fn add_account_for_password(
     mnemonic: &str,
     password: &str,
     account_id: &str,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<AccountEntry, BackendError> {
     log::info!("Adding account for the current password: {account_id}");
     let mnemonic = Mnemonic::from_str(mnemonic)?;
@@ -455,7 +462,7 @@ pub async fn add_account_for_password(
 async fn set_state_with_all_accounts(
     stored_login: wallet_storage::StoredLogin,
     first_id_when_converting: wallet_storage::AccountId,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<(), BackendError> {
     log::trace!("Set state with accounts:");
     let all_accounts: Vec<_> = stored_login
@@ -496,7 +503,7 @@ async fn set_state_with_all_accounts(
 pub async fn remove_account_for_password(
     password: &str,
     account_id: &str,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<(), BackendError> {
     log::info!("Removing account: {account_id}");
     // Currently we only support a single, default, id in the wallet
@@ -527,7 +534,7 @@ fn derive_address(
 
 #[tauri::command]
 pub async fn list_accounts(
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<Vec<AccountEntry>, BackendError> {
     log::trace!("Listing accounts");
     let state = state.read().await;

nym-wallet/src-tauri/src/operations/mixnet/admin.rs

@@ -1,14 +1,19 @@
-use crate::error::BackendError;
-use crate::nymd_client;
-use crate::state::WalletState;
+use std::convert::TryInto;
+use std::sync::Arc;
+
+use tokio::sync::RwLock;
+
 use mixnet_contract_common::ContractStateParams;
 use nym_wallet_types::admin::TauriContractStateParams;
-use std::convert::TryInto;
 use validator_client::nymd::Fee;
 
+use crate::error::BackendError;
+use crate::nymd_client;
+use crate::state::State;
+
 #[tauri::command]
 pub async fn get_contract_settings(
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<TauriContractStateParams, BackendError> {
     log::info!(">>> Getting contract settings");
     let res = nymd_client!(state).get_contract_settings().await?.into();
@@ -20,7 +25,7 @@ pub async fn get_contract_settings(
 pub async fn update_contract_settings(
     params: TauriContractStateParams,
     fee: Option<Fee>,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<TauriContractStateParams, BackendError> {
     let mixnet_contract_settings_params: ContractStateParams = params.try_into()?;
     log::info!(

nym-wallet/src-tauri/src/operations/mixnet/bond.rs

@@ -1,56 +1,56 @@
 use crate::error::BackendError;
-use crate::state::WalletState;
+use crate::nymd_client;
+use crate::state::State;
 use crate::{Gateway, MixNode};
-use nym_types::currency::DecCoin;
+use nym_types::currency::MajorCurrencyAmount;
 use nym_types::gateway::GatewayBond;
 use nym_types::mixnode::MixNodeBond;
 use nym_types::transaction::TransactionExecuteResult;
-use validator_client::nymd::{Coin, Fee};
+use std::sync::Arc;
+use tokio::sync::RwLock;
+use validator_client::nymd::{CosmWasmCoin, Fee};
 
 #[tauri::command]
 pub async fn bond_gateway(
     gateway: Gateway,
-    pledge: DecCoin,
+    pledge: MajorCurrencyAmount,
     owner_signature: String,
     fee: Option<Fee>,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<TransactionExecuteResult, BackendError> {
-    let guard = state.read().await;
-    let pledge_base = guard.attempt_convert_to_base_coin(pledge.clone())?;
-    let fee_amount = guard.convert_tx_fee(fee.as_ref());
-
+    let denom_minor = state.read().await.current_network().base_mix_denom();
+    let pledge_minor = pledge.clone().into();
     log::info!(
-        ">>> Bond gateway: identity_key = {}, pledge_display = {}, pledge_base = {}, fee = {:?}",
-        gateway.identity_key,
+        ">>> Bond gateway: identity_key = {}, pledge = {}, pledge_minor = {}, fee = {:?}",
+        &gateway.identity_key,
         pledge,
-        pledge_base,
+        &pledge_minor,
         fee,
     );
-    let res = guard
-        .current_client()?
-        .nymd
-        .bond_gateway(gateway, owner_signature, pledge_base, fee)
+    let res = nymd_client!(state)
+        .bond_gateway(gateway, owner_signature, pledge_minor, fee)
         .await?;
     log::info!("<<< tx hash = {}", res.transaction_hash);
     log::trace!("<<< {:?}", res);
     Ok(TransactionExecuteResult::from_execute_result(
-        res, fee_amount,
+        res,
+        denom_minor.as_ref(),
     )?)
 }
 
 #[tauri::command]
 pub async fn unbond_gateway(
     fee: Option<Fee>,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<TransactionExecuteResult, BackendError> {
-    let guard = state.read().await;
-    let fee_amount = guard.convert_tx_fee(fee.as_ref());
+    let denom_minor = state.read().await.current_network().base_mix_denom();
     log::info!(">>> Unbond gateway, fee = {:?}", fee);
-    let res = guard.current_client()?.nymd.unbond_gateway(fee).await?;
+    let res = nymd_client!(state).unbond_gateway(fee).await?;
     log::info!("<<< tx hash = {}", res.transaction_hash);
     log::trace!("<<< {:?}", res);
     Ok(TransactionExecuteResult::from_execute_result(
-        res, fee_amount,
+        res,
+        denom_minor.as_ref(),
     )?)
 }
 
@@ -58,46 +58,43 @@ pub async fn unbond_gateway(
 pub async fn bond_mixnode(
     mixnode: MixNode,
     owner_signature: String,
-    pledge: DecCoin,
+    pledge: MajorCurrencyAmount,
     fee: Option<Fee>,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<TransactionExecuteResult, BackendError> {
-    let guard = state.read().await;
-    let pledge_base = guard.attempt_convert_to_base_coin(pledge.clone())?;
-    let fee_amount = guard.convert_tx_fee(fee.as_ref());
-
+    let denom_minor = state.read().await.current_network().base_mix_denom();
+    let pledge_minor = pledge.clone().into();
     log::info!(
-        ">>> Bond mixnode: identity_key = {}, pledge_display = {}, pledge_base = {}, fee = {:?}",
+        ">>> Bond mixnode: identity_key = {}, pledge = {}, pledge_minor = {}, fee = {:?}",
         mixnode.identity_key,
         pledge,
-        pledge_base,
+        pledge_minor,
         fee,
     );
-    let res = guard
-        .current_client()?
-        .nymd
-        .bond_mixnode(mixnode, owner_signature, pledge_base, fee)
+    let res = nymd_client!(state)
+        .bond_mixnode(mixnode, owner_signature, pledge_minor, fee)
         .await?;
     log::info!("<<< tx hash = {}", res.transaction_hash);
     log::trace!("<<< {:?}", res);
     Ok(TransactionExecuteResult::from_execute_result(
-        res, fee_amount,
+        res,
+        denom_minor.as_ref(),
     )?)
 }
 
 #[tauri::command]
 pub async fn unbond_mixnode(
     fee: Option<Fee>,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<TransactionExecuteResult, BackendError> {
-    let guard = state.read().await;
-    let fee_amount = guard.convert_tx_fee(fee.as_ref());
+    let denom_minor = state.read().await.current_network().base_mix_denom();
     log::info!(">>> Unbond mixnode, fee = {:?}", fee);
-    let res = guard.current_client()?.nymd.unbond_mixnode(fee).await?;
+    let res = nymd_client!(state).unbond_mixnode(fee).await?;
     log::info!("<<< tx hash = {}", res.transaction_hash);
     log::trace!("<<< {:?}", res);
     Ok(TransactionExecuteResult::from_execute_result(
-        res, fee_amount,
+        res,
+        denom_minor.as_ref(),
     )?)
 }
 
@@ -105,43 +102,34 @@ pub async fn unbond_mixnode(
 pub async fn update_mixnode(
     profit_margin_percent: u8,
     fee: Option<Fee>,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<TransactionExecuteResult, BackendError> {
-    let guard = state.read().await;
-    let fee_amount = guard.convert_tx_fee(fee.as_ref());
+    let denom_minor = state.read().await.current_network().base_mix_denom();
     log::info!(
         ">>> Update mixnode: profit_margin_percent = {}, fee {:?}",
         profit_margin_percent,
         fee,
     );
-    let res = guard
-        .current_client()?
-        .nymd
+    let res = nymd_client!(state)
         .update_mixnode_config(profit_margin_percent, fee)
         .await?;
     log::info!("<<< tx hash = {}", res.transaction_hash);
     log::trace!("<<< {:?}", res);
     Ok(TransactionExecuteResult::from_execute_result(
-        res, fee_amount,
+        res,
+        denom_minor.as_ref(),
     )?)
 }
 
 #[tauri::command]
 pub async fn mixnode_bond_details(
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<Option<MixNodeBond>, BackendError> {
     log::info!(">>> Get mixnode bond details");
     let guard = state.read().await;
     let client = guard.current_client()?;
     let bond = client.nymd.owns_mixnode(client.nymd.address()).await?;
-    let res = bond
-        .map(|bond| {
-            guard
-                .registered_coins()
-                .map(|reg| MixNodeBond::from_mixnet_contract_mixnode_bond(bond, reg))
-        })
-        .transpose()?
-        .transpose()?;
+    let res = MixNodeBond::from_mixnet_contract_mixnode_bond(bond)?;
     log::info!(
         "<<< identity_key = {:?}",
         res.as_ref().map(|r| r.mix_node.identity_key.to_string())
@@ -152,21 +140,13 @@ pub async fn mixnode_bond_details(
 
 #[tauri::command]
 pub async fn gateway_bond_details(
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<Option<GatewayBond>, BackendError> {
     log::info!(">>> Get gateway bond details");
     let guard = state.read().await;
     let client = guard.current_client()?;
     let bond = client.nymd.owns_gateway(client.nymd.address()).await?;
-    let res = bond
-        .map(|bond| {
-            guard
-                .registered_coins()
-                .map(|reg| GatewayBond::from_mixnet_contract_gateway_bond(bond, reg))
-        })
-        .transpose()?
-        .transpose()?;
-
+    let res = GatewayBond::from_mixnet_contract_gateway_bond(bond)?;
     log::info!(
         "<<< identity_key = {:?}",
         res.as_ref().map(|r| r.gateway.identity_key.to_string())
@@ -178,23 +158,17 @@ pub async fn gateway_bond_details(
 #[tauri::command]
 pub async fn get_operator_rewards(
     address: String,
-    state: tauri::State<'_, WalletState>,
-) -> Result<DecCoin, BackendError> {
+    state: tauri::State<'_, Arc<RwLock<State>>>,
+) -> Result<MajorCurrencyAmount, BackendError> {
     log::info!(">>> Get operator rewards for {}", address);
-    let guard = state.read().await;
-    let network = guard.current_network();
-    let denom = network.base_mix_denom();
-    let reward_amount = guard
-        .current_client()?
-        .nymd
-        .get_operator_rewards(address)
-        .await?;
-    let base_coin = Coin::new(reward_amount.u128(), denom);
-    let display_coin: DecCoin = guard.attempt_convert_to_display_dec_coin(base_coin.clone())?;
+    let denom = state.read().await.current_network().base_mix_denom();
+    let rewards_as_minor = nymd_client!(state).get_operator_rewards(address).await?;
+    let coin = CosmWasmCoin::new(rewards_as_minor.u128(), denom.as_ref());
+    let amount: MajorCurrencyAmount = coin.into();
     log::info!(
-        "<<< rewards_base = {}, rewards_display = {}",
-        base_coin,
-        display_coin
+        "<<< rewards_as_minor = {}, amount = {}",
+        rewards_as_minor,
+        amount
     );
-    Ok(display_coin)
+    Ok(amount)
 }

nym-wallet/src-tauri/src/operations/mixnet/delegate.rs

@@ -1,66 +1,63 @@
 use crate::error::BackendError;
-use crate::state::WalletState;
+use crate::state::State;
 use crate::vesting::delegate::{
     get_pending_vesting_delegation_events, vesting_undelegate_from_mixnode,
 };
 use crate::{api_client, nymd_client};
+use cosmwasm_std::Coin as CosmWasmCoin;
 use mixnet_contract_common::IdentityKey;
-use nym_types::currency::DecCoin;
+use nym_types::currency::{CurrencyDenom, MajorCurrencyAmount};
 use nym_types::delegation::{
-    Delegation, DelegationEvent, DelegationRecord, DelegationWithEverything,
-    DelegationsSummaryResponse,
+    from_contract_delegation_events, Delegation, DelegationEvent, DelegationRecord,
+    DelegationWithEverything, DelegationsSummaryResponse,
 };
 use nym_types::transaction::TransactionExecuteResult;
 use std::collections::HashMap;
-use validator_client::nymd::{Coin, Fee};
+use std::sync::Arc;
+use tokio::sync::RwLock;
+use validator_client::nymd::Fee;
 
 #[tauri::command]
 pub async fn get_pending_delegation_events(
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<Vec<DelegationEvent>, BackendError> {
     log::info!(">>> Get pending delegation events");
-    let guard = state.read().await;
-    let reg = guard.registered_coins()?;
-    let client = guard.current_client()?;
-
-    let events = client
-        .nymd
-        .get_pending_delegation_events(client.nymd.address().to_string(), None)
+    let events = nymd_client!(state)
+        .get_pending_delegation_events(nymd_client!(state).address().to_string(), None)
         .await?;
     log::info!("<<< {} pending delegation events", events.len());
     log::trace!("<<< pending delegation events = {:?}", events);
 
-    Ok(events
-        .into_iter()
-        .map(|event| DelegationEvent::from_mixnet_contract(event, reg))
-        .collect::<Result<_, _>>()?)
+    match from_contract_delegation_events(events) {
+        Ok(res) => Ok(res),
+        Err(e) => Err(e.into()),
+    }
 }
 
 #[tauri::command]
 pub async fn delegate_to_mixnode(
     identity: &str,
-    amount: DecCoin,
+    amount: MajorCurrencyAmount,
     fee: Option<Fee>,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<TransactionExecuteResult, BackendError> {
-    let guard = state.read().await;
-    let delegation_base = guard.attempt_convert_to_base_coin(amount.clone())?;
-    let fee_amount = guard.convert_tx_fee(fee.as_ref());
-
+    let denom_minor = state.read().await.current_network().base_mix_denom();
+    let delegation = amount.clone().into();
     log::info!(
-        ">>> Delegate to mixnode: identity_key = {}, display_amount = {}, base_amount = {}, fee = {:?}",
+        ">>> Delegate to mixnode: identity_key = {}, amount = {}, minor_amount = {}, fee = {:?}",
         identity,
         amount,
-        delegation_base,
+        delegation,
         fee,
     );
     let res = nymd_client!(state)
-        .delegate_to_mixnode(identity, delegation_base, fee)
+        .delegate_to_mixnode(identity, delegation, fee)
         .await?;
     log::info!("<<< tx hash = {}", res.transaction_hash);
     log::trace!("<<< {:?}", res);
     Ok(TransactionExecuteResult::from_execute_result(
-        res, fee_amount,
+        res,
+        denom_minor.as_ref(),
     )?)
 }
 
@@ -68,25 +65,22 @@ pub async fn delegate_to_mixnode(
 pub async fn undelegate_from_mixnode(
     identity: &str,
     fee: Option<Fee>,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<TransactionExecuteResult, BackendError> {
-    let guard = state.read().await;
-    let fee_amount = guard.convert_tx_fee(fee.as_ref());
-
+    let denom_minor = state.read().await.current_network().base_mix_denom();
     log::info!(
         ">>> Undelegate from mixnode: identity_key = {}, fee = {:?}",
         identity,
         fee
     );
-    let res = guard
-        .current_client()?
-        .nymd
+    let res = nymd_client!(state)
         .remove_mixnode_delegation(identity, fee)
         .await?;
     log::info!("<<< tx hash = {}", res.transaction_hash);
     log::trace!("<<< {:?}", res);
     Ok(TransactionExecuteResult::from_execute_result(
-        res, fee_amount,
+        res,
+        denom_minor.as_ref(),
     )?)
 }
 
@@ -96,7 +90,7 @@ pub async fn undelegate_all_from_mixnode(
     uses_vesting_contract_tokens: bool,
     fee: Option<Fee>,
     fee2: Option<Fee>,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<Vec<TransactionExecuteResult>, BackendError> {
     log::info!(
         ">>> Undelegate all from mixnode: identity_key = {}, uses_vesting_contract_tokens = {}, fee = {:?}",
@@ -116,31 +110,30 @@ pub async fn undelegate_all_from_mixnode(
 
 struct DelegationWithHistory {
     pub delegation: Delegation,
-    pub amount_sum: DecCoin,
+    pub amount_sum: MajorCurrencyAmount,
     pub history: Vec<DelegationRecord>,
     pub uses_vesting_contract_tokens: bool,
 }
 
 #[tauri::command]
 pub async fn get_all_mix_delegations(
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<Vec<DelegationWithEverything>, BackendError> {
     log::info!(">>> Get all mixnode delegations");
 
-    let guard = state.read().await;
-    let client = guard.current_client()?;
-    let reg = guard.registered_coins()?;
-
     // TODO: add endpoint to validator API to get a single mix node bond
-    let mixnodes = client.validator_api.get_mixnodes().await?;
+    let mixnodes = api_client!(state).get_mixnodes().await?;
 
-    let address = client.nymd.address();
-    let network = guard.current_network();
-    let display_mix_denom = network.display_mix_denom();
-    let base_mix_denom = network.base_mix_denom();
+    let address = nymd_client!(state).address().to_string();
+
+    let denom_minor = state.read().await.current_network().base_mix_denom();
+    let denom: CurrencyDenom = denom_minor.clone().try_into()?;
 
     log::info!("  >>> Get delegations");
-    let delegations = client.get_all_delegator_delegations(address).await?;
+    let delegations = nymd_client!(state)
+        .get_delegator_delegations_paged(address.clone(), None, None) // get all delegations, ignoring paging
+        .await?
+        .delegations;
     log::info!("  <<< {} delegations", delegations.len());
 
     // first get pending events from the mixnet contract (operations made with unlocked tokens)
@@ -159,21 +152,20 @@ pub async fn get_all_mix_delegations(
 
     let mut map: HashMap<String, DelegationWithHistory> = HashMap::new();
 
-    for pending_event in &pending_events_for_account {
+    for pending_event in pending_events_for_account.clone() {
         if delegations
             .iter()
             .any(|d| d.node_identity == pending_event.node_identity)
         {
             let amount = pending_event
                 .amount
-                .clone()
-                .unwrap_or_else(|| DecCoin::zero(display_mix_denom));
+                .unwrap_or_else(|| MajorCurrencyAmount::zero(&denom));
             let delegation = DelegationWithHistory {
                 delegation: Delegation {
                     amount: amount.clone(),
-                    node_identity: pending_event.node_identity.clone(),
-                    proxy: pending_event.proxy.clone(), // TODO: ask @MS about delegations via vesting contract => surely we'd have proxy there?
-                    owner: pending_event.address.clone(),
+                    node_identity: pending_event.node_identity,
+                    proxy: pending_event.proxy,
+                    owner: pending_event.address,
                     block_height: pending_event.block_height,
                 },
                 amount_sum: amount,
@@ -186,13 +178,11 @@ pub async fn get_all_mix_delegations(
 
     for d in delegations {
         // create record of delegation
-        let delegated_on_iso_datetime = client
-            .nymd
+        let delegated_on_iso_datetime = nymd_client!(state)
             .get_block_timestamp(Some(d.block_height as u32))
             .await?
             .to_rfc3339();
-        let amount = guard.attempt_convert_to_display_dec_coin(d.amount.clone().into())?;
-
+        let amount: MajorCurrencyAmount = d.amount.clone().into();
         let record = DelegationRecord {
             amount: amount.clone(),
             block_height: d.block_height,
@@ -203,16 +193,14 @@ pub async fn get_all_mix_delegations(
         let entry = map
             .entry(d.node_identity.clone())
             .or_insert(DelegationWithHistory {
-                delegation: Delegation::from_mixnet_contract(d, reg)?,
+                delegation: d.try_into()?,
                 history: vec![],
-                amount_sum: DecCoin::zero(display_mix_denom),
+                amount_sum: MajorCurrencyAmount::zero(&amount.denom),
                 uses_vesting_contract_tokens: false,
             });
 
-        debug_assert_eq!(entry.amount_sum.denom, amount.denom);
-
         entry.history.push(record);
-        entry.amount_sum.amount += amount.amount;
+        entry.amount_sum = entry.amount_sum.clone() + amount;
         entry.uses_vesting_contract_tokens =
             entry.uses_vesting_contract_tokens || entry.delegation.proxy.is_some();
     }
@@ -241,25 +229,25 @@ pub async fn get_all_mix_delegations(
             .iter()
             .find(|m| m.mix_node.identity_key == node_identity);
 
-        let pledge_amount = mixnode
-            .map(|m| guard.attempt_convert_to_display_dec_coin(m.pledge_amount.clone().into()))
-            .transpose()?;
+        let pledge_amount: Option<MajorCurrencyAmount> =
+            mixnode.and_then(|m| m.pledge_amount.clone().try_into().ok());
 
-        let total_delegation = mixnode
-            .map(|m| guard.attempt_convert_to_display_dec_coin(m.total_delegation.clone().into()))
-            .transpose()?;
+        let total_delegation: Option<MajorCurrencyAmount> =
+            mixnode.and_then(|m| m.total_delegation.clone().try_into().ok());
 
         let profit_margin_percent: Option<u8> = mixnode.map(|m| m.mix_node.profit_margin_percent);
 
         log::trace!("  >>> Get accumulated rewards: address = {}", address);
-        let accumulated_rewards = match client
-            .nymd
-            .get_delegator_rewards(address.to_string(), node_identity.clone(), proxy.clone())
+        let accumulated_rewards = match nymd_client!(state)
+            .get_delegator_rewards(address.clone(), node_identity.clone(), proxy.clone())
             .await
         {
             Ok(rewards) => {
-                let reward = Coin::new(rewards.u128(), base_mix_denom);
-                let amount = guard.attempt_convert_to_display_dec_coin(reward)?;
+                let reward = CosmWasmCoin {
+                    denom: denom_minor.to_string(),
+                    amount: rewards,
+                };
+                let amount = MajorCurrencyAmount::from(reward);
                 log::trace!("  <<< rewards = {}, amount = {}", rewards, amount);
                 Some(amount)
             }
@@ -350,52 +338,40 @@ pub async fn get_delegator_rewards(
     address: String,
     mix_identity: IdentityKey,
     proxy: Option<String>,
-    state: tauri::State<'_, WalletState>,
-) -> Result<DecCoin, BackendError> {
+    state: tauri::State<'_, Arc<RwLock<State>>>,
+) -> Result<MajorCurrencyAmount, BackendError> {
+    let denom_minor = state.read().await.current_network().base_mix_denom();
     log::info!(
         ">>> Get delegator rewards: mix_identity = {}, proxy = {:?}",
         mix_identity,
         proxy
     );
-    let guard = state.read().await;
-    let network = guard.current_network();
-    let denom = network.base_mix_denom();
-    let reward_amount = guard
-        .current_client()?
-        .nymd
+    let res = nymd_client!(state)
         .get_delegator_rewards(address, mix_identity, proxy)
         .await?;
-    let base_coin = Coin::new(reward_amount.u128(), denom);
-    let display_coin: DecCoin = guard.attempt_convert_to_display_dec_coin(base_coin.clone())?;
-
-    log::info!(
-        "<<< rewards_base = {}, rewards_display = {}",
-        base_coin,
-        display_coin
-    );
-    Ok(display_coin)
+    let coin = CosmWasmCoin::new(res.u128(), denom_minor.as_ref());
+    let amount = coin.into();
+    log::info!(">>> res = {}, amount = {}", res, amount);
+    Ok(amount)
 }
 
 #[tauri::command]
 pub async fn get_delegation_summary(
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<DelegationsSummaryResponse, BackendError> {
     log::info!(">>> Get delegation summary");
 
-    let guard = state.read().await;
-    let network = guard.current_network();
-    let display_mix_denom = network.display_mix_denom();
+    let denom_minor = state.read().await.current_network().base_mix_denom();
+    let denom: CurrencyDenom = denom_minor.clone().try_into()?;
 
     let delegations = get_all_mix_delegations(state.clone()).await?;
-    let mut total_delegations = DecCoin::zero(display_mix_denom);
-    let mut total_rewards = DecCoin::zero(display_mix_denom);
+    let mut total_delegations = MajorCurrencyAmount::zero(&denom);
+    let mut total_rewards = MajorCurrencyAmount::zero(&denom);
 
-    for d in &delegations {
-        debug_assert_eq!(d.amount.denom, display_mix_denom);
-        total_delegations.amount += d.amount.amount;
-        if let Some(rewards) = &d.accumulated_rewards {
-            debug_assert_eq!(rewards.denom, display_mix_denom);
-            total_rewards.amount += rewards.amount;
+    for d in delegations.clone() {
+        total_delegations = total_delegations + d.amount;
+        if let Some(rewards) = d.accumulated_rewards {
+            total_rewards = total_rewards + rewards;
         }
     }
     log::info!(
@@ -415,7 +391,7 @@ pub async fn get_delegation_summary(
 
 #[tauri::command]
 pub async fn get_all_pending_delegation_events(
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<Vec<DelegationEvent>, BackendError> {
     log::info!(">>> Get all pending delegation events");
 

nym-wallet/src-tauri/src/operations/mixnet/epoch.rs

@@ -1,11 +1,13 @@
 use crate::error::BackendError;
 use crate::nymd_client;
-use crate::state::WalletState;
+use crate::state::State;
 use nym_wallet_types::epoch::Epoch;
+use std::sync::Arc;
+use tokio::sync::RwLock;
 
 #[tauri::command]
 pub async fn get_current_epoch(
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<Epoch, BackendError> {
     log::info!(">>> Get curren epoch");
     let interval = nymd_client!(state).get_current_epoch().await?;

nym-wallet/src-tauri/src/operations/mixnet/rewards.rs

@@ -1,50 +1,48 @@
 use crate::error::BackendError;
 use crate::nymd_client;
-use crate::state::WalletState;
+use crate::state::State;
 use crate::vesting::rewards::{vesting_claim_delegator_reward, vesting_compound_delegator_reward};
 use mixnet_contract_common::IdentityKey;
 use nym_types::transaction::TransactionExecuteResult;
+use std::sync::Arc;
+use tokio::sync::RwLock;
 use validator_client::nymd::Fee;
 
 #[tauri::command]
 pub async fn claim_operator_reward(
     fee: Option<Fee>,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<TransactionExecuteResult, BackendError> {
     // TODO: handle operator bonding with vesting contract
     log::info!(">>> Claim operator reward");
-    let guard = state.read().await;
-    let fee_amount = guard.convert_tx_fee(fee.as_ref());
-    let res = guard
-        .current_client()?
-        .nymd
+    let denom_minor = state.read().await.current_network().base_mix_denom();
+    let res = nymd_client!(state)
         .execute_claim_operator_reward(fee)
         .await?;
     log::info!("<<< tx hash = {}", res.transaction_hash);
     log::trace!("<<< {:?}", res);
     Ok(TransactionExecuteResult::from_execute_result(
-        res, fee_amount,
+        res,
+        denom_minor.as_ref(),
     )?)
 }
 
 #[tauri::command]
 pub async fn compound_operator_reward(
     fee: Option<Fee>,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<TransactionExecuteResult, BackendError> {
     // TODO: handle operator bonding with vesting contract
     log::info!(">>> Compound operator reward");
-    let guard = state.read().await;
-    let fee_amount = guard.convert_tx_fee(fee.as_ref());
-    let res = guard
-        .current_client()?
-        .nymd
+    let denom_minor = state.read().await.current_network().base_mix_denom();
+    let res = nymd_client!(state)
         .execute_compound_operator_reward(fee)
         .await?;
     log::info!("<<< tx hash = {}", res.transaction_hash);
     log::trace!("<<< {:?}", res);
     Ok(TransactionExecuteResult::from_execute_result(
-        res, fee_amount,
+        res,
+        denom_minor.as_ref(),
     )?)
 }
 
@@ -52,23 +50,21 @@ pub async fn compound_operator_reward(
 pub async fn claim_delegator_reward(
     mix_identity: IdentityKey,
     fee: Option<Fee>,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<TransactionExecuteResult, BackendError> {
     log::info!(
         ">>> Claim delegator reward: identity_key = {}",
         mix_identity
     );
-    let guard = state.read().await;
-    let fee_amount = guard.convert_tx_fee(fee.as_ref());
-    let res = guard
-        .current_client()?
-        .nymd
+    let denom_minor = state.read().await.current_network().base_mix_denom();
+    let res = nymd_client!(state)
         .execute_claim_delegator_reward(mix_identity, fee)
         .await?;
     log::info!("<<< tx hash = {}", res.transaction_hash);
     log::trace!("<<< {:?}", res);
     Ok(TransactionExecuteResult::from_execute_result(
-        res, fee_amount,
+        res,
+        denom_minor.as_ref(),
     )?)
 }
 
@@ -76,23 +72,21 @@ pub async fn claim_delegator_reward(
 pub async fn compound_delegator_reward(
     mix_identity: IdentityKey,
     fee: Option<Fee>,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<TransactionExecuteResult, BackendError> {
     log::info!(
         ">>> Compound delegator reward: identity_key = {}",
         mix_identity
     );
-    let guard = state.read().await;
-    let fee_amount = guard.convert_tx_fee(fee.as_ref());
-    let res = guard
-        .current_client()?
-        .nymd
+    let denom_minor = state.read().await.current_network().base_mix_denom();
+    let res = nymd_client!(state)
         .execute_compound_delegator_reward(mix_identity, fee)
         .await?;
     log::info!("<<< tx hash = {}", res.transaction_hash);
     log::trace!("<<< {:?}", res);
     Ok(TransactionExecuteResult::from_execute_result(
-        res, fee_amount,
+        res,
+        denom_minor.as_ref(),
     )?)
 }
 
@@ -100,7 +94,7 @@ pub async fn compound_delegator_reward(
 pub async fn claim_locked_and_unlocked_delegator_reward(
     mix_identity: IdentityKey,
     fee: Option<Fee>,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<Vec<TransactionExecuteResult>, BackendError> {
     log::info!(
         ">>> Claim delegator reward (locked and unlocked): identity_key = {}",
@@ -146,7 +140,7 @@ pub async fn claim_locked_and_unlocked_delegator_reward(
 pub async fn compound_locked_and_unlocked_delegator_reward(
     mix_identity: IdentityKey,
     fee: Option<Fee>,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<Vec<TransactionExecuteResult>, BackendError> {
     log::info!(
         ">>> Compound delegator reward (locked and unlocked): identity_key = {}",

nym-wallet/src-tauri/src/operations/mixnet/send.rs

@@ -1,43 +1,46 @@
 use crate::error::BackendError;
-use crate::state::WalletState;
-use nym_types::currency::DecCoin;
+use crate::nymd_client;
+use crate::state::State;
+use nym_types::currency::MajorCurrencyAmount;
 use nym_types::transaction::{SendTxResult, TransactionDetails};
 use std::str::FromStr;
+use std::sync::Arc;
+use tokio::sync::RwLock;
 use validator_client::nymd::{AccountId, Fee};
 
 #[tauri::command]
 pub async fn send(
     address: &str,
-    amount: DecCoin,
+    amount: MajorCurrencyAmount,
     memo: String,
     fee: Option<Fee>,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<SendTxResult, BackendError> {
-    let guard = state.read().await;
-    let amount_base = guard.attempt_convert_to_base_coin(amount.clone())?;
-
-    let to_address = AccountId::from_str(address)?;
-    let from_address = guard.current_client()?.nymd.address().to_string();
-    let fee_amount = guard.convert_tx_fee(fee.as_ref());
+    let denom_minor = state.read().await.current_network().base_mix_denom();
+    let address = AccountId::from_str(address)?;
+    let from_address = nymd_client!(state).address().to_string();
+    let amount2 = amount.clone().into();
     log::info!(
-        ">>> Send: display_amount = {}, base_amount = {}, from = {}, to = {}, fee = {:?}",
+        ">>> Send: amount = {}, minor_amount = {:?}, from = {}, to = {}, fee = {:?}",
         amount,
-        amount_base,
+        amount2,
         from_address,
-        to_address,
+        address.as_ref(),
         fee,
     );
-    let raw_res = guard
-        .current_client()?
-        .nymd
-        .send(&to_address, vec![amount_base], memo, fee)
+    let raw_res = nymd_client!(state)
+        .send(&address, vec![amount2], memo, fee)
         .await?;
     log::info!("<<< tx hash = {}", raw_res.hash.to_string());
     let res = SendTxResult::new(
         raw_res,
-        TransactionDetails::new(amount, from_address, to_address.to_string()),
-        fee_amount,
-    );
+        TransactionDetails {
+            from_address,
+            to_address: address.to_string(),
+            amount,
+        },
+        denom_minor.as_ref(),
+    )?;
     log::trace!("<<< {:?}", res);
     Ok(res)
 }

nym-wallet/src-tauri/src/operations/simulate/admin.rs

@@ -3,14 +3,17 @@
 
 use crate::error::BackendError;
 use crate::operations::simulate::FeeDetails;
-use crate::WalletState;
+use crate::simulate::detailed_fee;
+use crate::State;
 use mixnet_contract_common::{ContractStateParams, ExecuteMsg};
 use nym_wallet_types::admin::TauriContractStateParams;
+use std::sync::Arc;
+use tokio::sync::RwLock;
 
 #[tauri::command]
 pub async fn simulate_update_contract_settings(
     params: TauriContractStateParams,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<FeeDetails, BackendError> {
     let guard = state.read().await;
     let mixnet_contract_settings_params: ContractStateParams = params.try_into()?;
@@ -25,5 +28,5 @@ pub async fn simulate_update_contract_settings(
     )?;
 
     let result = client.nymd.simulate(vec![msg]).await?;
-    guard.create_detailed_fee(result)
+    Ok(detailed_fee(client, result))
 }

nym-wallet/src-tauri/src/operations/simulate/cosmos.rs

@@ -3,22 +3,24 @@
 
 use crate::error::BackendError;
 use crate::operations::simulate::FeeDetails;
-use crate::state::WalletState;
-use nym_types::currency::DecCoin;
+use crate::simulate::detailed_fee;
+use crate::state::State;
+use nym_types::currency::MajorCurrencyAmount;
 use std::str::FromStr;
+use std::sync::Arc;
+use tokio::sync::RwLock;
 use validator_client::nymd::{AccountId, MsgSend};
 
 #[tauri::command]
 pub async fn simulate_send(
     address: &str,
-    amount: DecCoin,
-    state: tauri::State<'_, WalletState>,
+    amount: MajorCurrencyAmount,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<FeeDetails, BackendError> {
     let guard = state.read().await;
-    let amount_base = guard.attempt_convert_to_base_coin(amount.clone())?;
 
     let to_address = AccountId::from_str(address)?;
-    let amount = vec![amount_base.into()];
+    let amount = vec![amount.into()];
 
     let client = guard.current_client()?;
     let from_address = client.nymd.address().clone();
@@ -31,5 +33,5 @@ pub async fn simulate_send(
     };
 
     let result = client.nymd.simulate(vec![msg]).await?;
-    guard.create_detailed_fee(result)
+    Ok(detailed_fee(client, result))
 }

nym-wallet/src-tauri/src/operations/simulate/mixnet.rs

@@ -3,20 +3,23 @@
 
 use crate::error::BackendError;
 use crate::operations::simulate::FeeDetails;
-use crate::WalletState;
+use crate::simulate::detailed_fee;
+use crate::State;
 use mixnet_contract_common::IdentityKey;
 use mixnet_contract_common::{ExecuteMsg, Gateway, MixNode};
-use nym_types::currency::DecCoin;
+use nym_types::currency::MajorCurrencyAmount;
+use std::sync::Arc;
+use tokio::sync::RwLock;
 
 #[tauri::command]
 pub async fn simulate_bond_gateway(
     gateway: Gateway,
-    pledge: DecCoin,
+    pledge: MajorCurrencyAmount,
     owner_signature: String,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<FeeDetails, BackendError> {
     let guard = state.read().await;
-    let pledge = guard.attempt_convert_to_base_coin(pledge)?;
+    let pledge = pledge.into();
 
     let client = guard.current_client()?;
     let mixnet_contract = client.nymd.mixnet_contract_address();
@@ -32,12 +35,12 @@ pub async fn simulate_bond_gateway(
     )?;
 
     let result = client.nymd.simulate(vec![msg]).await?;
-    guard.create_detailed_fee(result)
+    Ok(detailed_fee(client, result))
 }
 
 #[tauri::command]
 pub async fn simulate_unbond_gateway(
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<FeeDetails, BackendError> {
     let guard = state.read().await;
     let client = guard.current_client()?;
@@ -50,18 +53,18 @@ pub async fn simulate_unbond_gateway(
     )?;
 
     let result = client.nymd.simulate(vec![msg]).await?;
-    guard.create_detailed_fee(result)
+    Ok(detailed_fee(client, result))
 }
 
 #[tauri::command]
 pub async fn simulate_bond_mixnode(
     mixnode: MixNode,
     owner_signature: String,
-    pledge: DecCoin,
-    state: tauri::State<'_, WalletState>,
+    pledge: MajorCurrencyAmount,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<FeeDetails, BackendError> {
     let guard = state.read().await;
-    let pledge = guard.attempt_convert_to_base_coin(pledge)?;
+    let pledge = pledge.into();
 
     let client = guard.current_client()?;
     let mixnet_contract = client.nymd.mixnet_contract_address();
@@ -76,12 +79,12 @@ pub async fn simulate_bond_mixnode(
     )?;
 
     let result = client.nymd.simulate(vec![msg]).await?;
-    guard.create_detailed_fee(result)
+    Ok(detailed_fee(client, result))
 }
 
 #[tauri::command]
 pub async fn simulate_unbond_mixnode(
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<FeeDetails, BackendError> {
     let guard = state.read().await;
     let client = guard.current_client()?;
@@ -94,13 +97,13 @@ pub async fn simulate_unbond_mixnode(
     )?;
 
     let result = client.nymd.simulate(vec![msg]).await?;
-    guard.create_detailed_fee(result)
+    Ok(detailed_fee(client, result))
 }
 
 #[tauri::command]
 pub async fn simulate_update_mixnode(
     profit_margin_percent: u8,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<FeeDetails, BackendError> {
     let guard = state.read().await;
     let client = guard.current_client()?;
@@ -115,17 +118,17 @@ pub async fn simulate_update_mixnode(
     )?;
 
     let result = client.nymd.simulate(vec![msg]).await?;
-    guard.create_detailed_fee(result)
+    Ok(detailed_fee(client, result))
 }
 
 #[tauri::command]
 pub async fn simulate_delegate_to_mixnode(
     identity: &str,
-    amount: DecCoin,
-    state: tauri::State<'_, WalletState>,
+    amount: MajorCurrencyAmount,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<FeeDetails, BackendError> {
     let guard = state.read().await;
-    let delegation = guard.attempt_convert_to_base_coin(amount)?;
+    let delegation = amount.into();
 
     let client = guard.current_client()?;
     let mixnet_contract = client.nymd.mixnet_contract_address();
@@ -139,14 +142,15 @@ pub async fn simulate_delegate_to_mixnode(
     )?;
 
     let result = client.nymd.simulate(vec![msg]).await?;
-    guard.create_detailed_fee(result)
+    Ok(detailed_fee(client, result))
 }
 
 #[tauri::command]
 pub async fn simulate_undelegate_from_mixnode(
     identity: &str,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<FeeDetails, BackendError> {
+    println!("Called");
     let guard = state.read().await;
     let client = guard.current_client()?;
     let mixnet_contract = client.nymd.mixnet_contract_address();
@@ -160,57 +164,53 @@ pub async fn simulate_undelegate_from_mixnode(
     )?;
 
     let result = client.nymd.simulate(vec![msg]).await?;
-    guard.create_detailed_fee(result)
+    Ok(detailed_fee(client, result))
 }
 
 #[tauri::command]
 pub async fn simulate_claim_operator_reward(
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<FeeDetails, BackendError> {
     let guard = state.read().await;
     let client = guard.current_client()?;
-
     let result = client.nymd.simulate_claim_operator_reward(None).await?;
-    guard.create_detailed_fee(result)
+    Ok(detailed_fee(client, result))
 }
 
 #[tauri::command]
 pub async fn simulate_compound_operator_reward(
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<FeeDetails, BackendError> {
     let guard = state.read().await;
     let client = guard.current_client()?;
-
     let result = client.nymd.simulate_compound_operator_reward(None).await?;
-    guard.create_detailed_fee(result)
+    Ok(detailed_fee(client, result))
 }
 
 #[tauri::command]
 pub async fn simulate_claim_delegator_reward(
     mix_identity: IdentityKey,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<FeeDetails, BackendError> {
     let guard = state.read().await;
     let client = guard.current_client()?;
-
     let result = client
         .nymd
         .simulate_claim_delegator_reward(mix_identity, None)
         .await?;
-    guard.create_detailed_fee(result)
+    Ok(detailed_fee(client, result))
 }
 
 #[tauri::command]
 pub async fn simulate_compound_delegator_reward(
     mix_identity: IdentityKey,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<FeeDetails, BackendError> {
     let guard = state.read().await;
     let client = guard.current_client()?;
-
     let result = client
         .nymd
         .simulate_compound_delegator_reward(mix_identity, None)
         .await?;
-    guard.create_detailed_fee(result)
+    Ok(detailed_fee(client, result))
 }

nym-wallet/src-tauri/src/operations/simulate/mod.rs

@@ -3,15 +3,29 @@
 
 use cosmrs::tx;
 use cosmrs::tx::Gas;
+use nym_types::currency::MajorCurrencyAmount;
 use nym_types::fees::FeeDetails;
-use validator_client::nymd::cosmwasm_client::types::GasInfo;
-use validator_client::nymd::{CosmosCoin, Fee, GasAdjustable, GasAdjustment, GasPrice};
+use validator_client::nymd::cosmwasm_client::types::{GasInfo, SimulateResponse};
+use validator_client::nymd::{
+    CosmosCoin, Fee, GasAdjustable, GasAdjustment, GasPrice, SigningNymdClient,
+};
+use validator_client::Client;
 
 pub mod admin;
 pub mod cosmos;
 pub mod mixnet;
 pub mod vesting;
 
+pub(crate) fn detailed_fee(
+    client: &Client<SigningNymdClient>,
+    simulate_response: SimulateResponse,
+) -> FeeDetails {
+    let gas_price = client.nymd.gas_price().clone();
+    let gas_adjustment = client.nymd.gas_adjustment();
+
+    SimulateResult::new(simulate_response.gas_info, gas_price, gas_adjustment).detailed_fee()
+}
+
 // technically we could have also exposed a result: Option<AbciResult> field from the SimulateResponse,
 // but in the context of the wallet it's really irrelevant and useless for the time being
 pub(crate) struct SimulateResult {
@@ -36,16 +50,24 @@ impl SimulateResult {
         }
     }
 
-    pub(crate) fn adjusted_gas(&self) -> Option<Gas> {
+    pub fn detailed_fee(&self) -> FeeDetails {
+        let amount = self.to_fee_amount().map(MajorCurrencyAmount::from);
+        FeeDetails {
+            amount,
+            fee: self.to_fee(),
+        }
+    }
+
+    fn adjusted_gas(&self) -> Option<Gas> {
         self.gas_info
             .map(|gas_info| gas_info.gas_used.adjust_gas(self.gas_adjustment))
     }
 
-    pub(crate) fn to_fee_amount(&self) -> Option<CosmosCoin> {
+    fn to_fee_amount(&self) -> Option<CosmosCoin> {
         self.adjusted_gas().map(|gas| &self.gas_price * gas)
     }
 
-    pub(crate) fn to_fee(&self) -> Fee {
+    fn to_fee(&self) -> Fee {
         self.adjusted_gas()
             .map(|gas| {
                 let fee_amount = &self.gas_price * gas;

nym-wallet/src-tauri/src/operations/simulate/vesting.rs

@@ -3,21 +3,24 @@
 
 use crate::error::BackendError;
 use crate::operations::simulate::FeeDetails;
-use crate::WalletState;
+use crate::simulate::detailed_fee;
+use crate::State;
 use mixnet_contract_common::IdentityKey;
 use mixnet_contract_common::{Gateway, MixNode};
-use nym_types::currency::DecCoin;
+use nym_types::currency::MajorCurrencyAmount;
+use std::sync::Arc;
+use tokio::sync::RwLock;
 use vesting_contract_common::ExecuteMsg;
 
 #[tauri::command]
 pub async fn simulate_vesting_bond_gateway(
     gateway: Gateway,
-    pledge: DecCoin,
+    pledge: MajorCurrencyAmount,
     owner_signature: String,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<FeeDetails, BackendError> {
     let guard = state.read().await;
-    let pledge = guard.attempt_convert_to_base_coin(pledge)?;
+    let pledge = pledge.into();
 
     let client = guard.current_client()?;
     let vesting_contract = client.nymd.vesting_contract_address();
@@ -27,18 +30,18 @@ pub async fn simulate_vesting_bond_gateway(
         &ExecuteMsg::BondGateway {
             gateway,
             owner_signature,
-            amount: pledge.into(),
+            amount: pledge,
         },
         vec![],
     )?;
 
     let result = client.nymd.simulate(vec![msg]).await?;
-    guard.create_detailed_fee(result)
+    Ok(detailed_fee(client, result))
 }
 
 #[tauri::command]
 pub async fn simulate_vesting_unbond_gateway(
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<FeeDetails, BackendError> {
     let guard = state.read().await;
 
@@ -52,18 +55,18 @@ pub async fn simulate_vesting_unbond_gateway(
     )?;
 
     let result = client.nymd.simulate(vec![msg]).await?;
-    guard.create_detailed_fee(result)
+    Ok(detailed_fee(client, result))
 }
 
 #[tauri::command]
 pub async fn simulate_vesting_bond_mixnode(
     mixnode: MixNode,
     owner_signature: String,
-    pledge: DecCoin,
-    state: tauri::State<'_, WalletState>,
+    pledge: MajorCurrencyAmount,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<FeeDetails, BackendError> {
     let guard = state.read().await;
-    let pledge = guard.attempt_convert_to_base_coin(pledge)?;
+    let pledge = pledge.into();
 
     let client = guard.current_client()?;
     let vesting_contract = client.nymd.vesting_contract_address();
@@ -73,18 +76,18 @@ pub async fn simulate_vesting_bond_mixnode(
         &ExecuteMsg::BondMixnode {
             mix_node: mixnode,
             owner_signature,
-            amount: pledge.into(),
+            amount: pledge,
         },
         vec![],
     )?;
 
     let result = client.nymd.simulate(vec![msg]).await?;
-    guard.create_detailed_fee(result)
+    Ok(detailed_fee(client, result))
 }
 
 #[tauri::command]
 pub async fn simulate_vesting_unbond_mixnode(
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<FeeDetails, BackendError> {
     let guard = state.read().await;
 
@@ -98,13 +101,13 @@ pub async fn simulate_vesting_unbond_mixnode(
     )?;
 
     let result = client.nymd.simulate(vec![msg]).await?;
-    guard.create_detailed_fee(result)
+    Ok(detailed_fee(client, result))
 }
 
 #[tauri::command]
 pub async fn simulate_vesting_update_mixnode(
     profit_margin_percent: u8,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<FeeDetails, BackendError> {
     let guard = state.read().await;
 
@@ -120,17 +123,17 @@ pub async fn simulate_vesting_update_mixnode(
     )?;
 
     let result = client.nymd.simulate(vec![msg]).await?;
-    guard.create_detailed_fee(result)
+    Ok(detailed_fee(client, result))
 }
 
 #[tauri::command]
 pub async fn simulate_vesting_delegate_to_mixnode(
     identity: &str,
-    amount: DecCoin,
-    state: tauri::State<'_, WalletState>,
+    amount: MajorCurrencyAmount,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<FeeDetails, BackendError> {
     let guard = state.read().await;
-    let amount = guard.attempt_convert_to_base_coin(amount)?.into();
+    let amount = amount.into();
 
     let client = guard.current_client()?;
     let vesting_contract = client.nymd.vesting_contract_address();
@@ -145,13 +148,13 @@ pub async fn simulate_vesting_delegate_to_mixnode(
     )?;
 
     let result = client.nymd.simulate(vec![msg]).await?;
-    guard.create_detailed_fee(result)
+    Ok(detailed_fee(client, result))
 }
 
 #[tauri::command]
 pub async fn simulate_vesting_undelegate_from_mixnode(
     identity: &str,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<FeeDetails, BackendError> {
     let guard = state.read().await;
 
@@ -167,16 +170,16 @@ pub async fn simulate_vesting_undelegate_from_mixnode(
     )?;
 
     let result = client.nymd.simulate(vec![msg]).await?;
-    guard.create_detailed_fee(result)
+    Ok(detailed_fee(client, result))
 }
 
 #[tauri::command]
 pub async fn simulate_withdraw_vested_coins(
-    amount: DecCoin,
-    state: tauri::State<'_, WalletState>,
+    amount: MajorCurrencyAmount,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<FeeDetails, BackendError> {
     let guard = state.read().await;
-    let amount = guard.attempt_convert_to_base_coin(amount)?.into();
+    let amount = amount.into();
 
     let client = guard.current_client()?;
     let vesting_contract = client.nymd.vesting_contract_address();
@@ -188,63 +191,59 @@ pub async fn simulate_withdraw_vested_coins(
     )?;
 
     let result = client.nymd.simulate(vec![msg]).await?;
-    guard.create_detailed_fee(result)
+    Ok(detailed_fee(client, result))
 }
 
 #[tauri::command]
 pub async fn simulate_vesting_claim_operator_reward(
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<FeeDetails, BackendError> {
     let guard = state.read().await;
     let client = guard.current_client()?;
-
     let result = client
         .nymd
         .simulate_vesting_claim_operator_reward(None)
         .await?;
-    guard.create_detailed_fee(result)
+    Ok(detailed_fee(client, result))
 }
 
 #[tauri::command]
 pub async fn simulate_vesting_compound_operator_reward(
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<FeeDetails, BackendError> {
     let guard = state.read().await;
     let client = guard.current_client()?;
-
     let result = client
         .nymd
         .simulate_vesting_compound_operator_reward(None)
         .await?;
-    guard.create_detailed_fee(result)
+    Ok(detailed_fee(client, result))
 }
 
 #[tauri::command]
 pub async fn simulate_vesting_claim_delegator_reward(
     mix_identity: IdentityKey,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<FeeDetails, BackendError> {
     let guard = state.read().await;
     let client = guard.current_client()?;
-
     let result = client
         .nymd
         .simulate_vesting_claim_delegator_reward(mix_identity, None)
         .await?;
-    guard.create_detailed_fee(result)
+    Ok(detailed_fee(client, result))
 }
 
 #[tauri::command]
 pub async fn simulate_vesting_compound_delegator_reward(
     mix_identity: IdentityKey,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<FeeDetails, BackendError> {
     let guard = state.read().await;
     let client = guard.current_client()?;
-
     let result = client
         .nymd
         .simulate_vesting_compound_delegator_reward(mix_identity, None)
         .await?;
-    guard.create_detailed_fee(result)
+    Ok(detailed_fee(client, result))
 }

nym-wallet/src-tauri/src/operations/validator_api/status.rs

@@ -3,7 +3,9 @@
 
 use crate::api_client;
 use crate::error::BackendError;
-use crate::state::WalletState;
+use crate::state::State;
+use std::sync::Arc;
+use tokio::sync::RwLock;
 use validator_client::models::{
     CoreNodeStatusResponse, InclusionProbabilityResponse, MixnodeStatusResponse,
     RewardEstimationResponse, StakeSaturationResponse,
@@ -13,7 +15,7 @@ use validator_client::models::{
 pub async fn mixnode_core_node_status(
     identity: &str,
     since: Option<i64>,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<CoreNodeStatusResponse, BackendError> {
     Ok(api_client!(state)
         .get_mixnode_core_status_count(identity, since)
@@ -24,7 +26,7 @@ pub async fn mixnode_core_node_status(
 pub async fn gateway_core_node_status(
     identity: &str,
     since: Option<i64>,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<CoreNodeStatusResponse, BackendError> {
     Ok(api_client!(state)
         .get_gateway_core_status_count(identity, since)
@@ -34,7 +36,7 @@ pub async fn gateway_core_node_status(
 #[tauri::command]
 pub async fn mixnode_status(
     identity: &str,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<MixnodeStatusResponse, BackendError> {
     Ok(api_client!(state).get_mixnode_status(identity).await?)
 }
@@ -42,7 +44,7 @@ pub async fn mixnode_status(
 #[tauri::command]
 pub async fn mixnode_reward_estimation(
     identity: &str,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<RewardEstimationResponse, BackendError> {
     Ok(api_client!(state)
         .get_mixnode_reward_estimation(identity)
@@ -52,7 +54,7 @@ pub async fn mixnode_reward_estimation(
 #[tauri::command]
 pub async fn mixnode_stake_saturation(
     identity: &str,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<StakeSaturationResponse, BackendError> {
     Ok(api_client!(state)
         .get_mixnode_stake_saturation(identity)
@@ -62,7 +64,7 @@ pub async fn mixnode_stake_saturation(
 #[tauri::command]
 pub async fn mixnode_inclusion_probability(
     identity: &str,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<InclusionProbabilityResponse, BackendError> {
     Ok(api_client!(state)
         .get_mixnode_inclusion_probability(identity)

nym-wallet/src-tauri/src/operations/vesting/bond.rs

@@ -1,50 +1,48 @@
 use crate::error::BackendError;
 use crate::nymd_client;
-use crate::state::WalletState;
+use crate::state::State;
 use crate::{Gateway, MixNode};
 
-use nym_types::currency::DecCoin;
+use nym_types::currency::MajorCurrencyAmount;
 use nym_types::transaction::TransactionExecuteResult;
+use std::sync::Arc;
+use tokio::sync::RwLock;
 use validator_client::nymd::{Fee, VestingSigningClient};
 
 #[tauri::command]
 pub async fn vesting_bond_gateway(
     gateway: Gateway,
-    pledge: DecCoin,
+    pledge: MajorCurrencyAmount,
     owner_signature: String,
     fee: Option<Fee>,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<TransactionExecuteResult, BackendError> {
-    let guard = state.read().await;
-    let pledge_base = guard.attempt_convert_to_base_coin(pledge.clone())?;
-    let fee_amount = guard.convert_tx_fee(fee.as_ref());
-
+    let denom_minor = state.read().await.current_network().base_mix_denom();
+    let pledge_minor = pledge.clone().into();
     log::info!(
-        ">>> Bond gateway with locked tokens: identity_key = {}, pledge_display = {}, pledge_base = {}, fee = {:?}",
-        gateway.identity_key,
-        pledge,
-        pledge_base,
-        fee,
-    );
-    let res = guard
-        .current_client()?
-        .nymd
-        .vesting_bond_gateway(gateway, &owner_signature, pledge_base, fee)
+    ">>> Bond gateway with locked tokens: identity_key = {}, pledge = {}, pledge_minor = {}, fee = {:?}",
+    gateway.identity_key,
+    pledge,
+    pledge_minor,
+    fee,
+  );
+    let res = nymd_client!(state)
+        .vesting_bond_gateway(gateway, &owner_signature, pledge_minor, fee)
         .await?;
     log::info!("<<< tx hash = {}", res.transaction_hash);
     log::trace!("<<< {:?}", res);
     Ok(TransactionExecuteResult::from_execute_result(
-        res, fee_amount,
+        res,
+        denom_minor.as_ref(),
     )?)
 }
 
 #[tauri::command]
 pub async fn vesting_unbond_gateway(
     fee: Option<Fee>,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<TransactionExecuteResult, BackendError> {
-    let guard = state.read().await;
-    let fee_amount = guard.convert_tx_fee(fee.as_ref());
+    let denom_minor = state.read().await.current_network().base_mix_denom();
     log::info!(
         ">>> Unbond gateway bonded with locked tokens, fee = {:?}",
         fee
@@ -53,7 +51,8 @@ pub async fn vesting_unbond_gateway(
     log::info!("<<< tx hash = {}", res.transaction_hash);
     log::trace!("<<< {:?}", res);
     Ok(TransactionExecuteResult::from_execute_result(
-        res, fee_amount,
+        res,
+        denom_minor.as_ref(),
     )?)
 }
 
@@ -61,81 +60,71 @@ pub async fn vesting_unbond_gateway(
 pub async fn vesting_bond_mixnode(
     mixnode: MixNode,
     owner_signature: String,
-    pledge: DecCoin,
+    pledge: MajorCurrencyAmount,
     fee: Option<Fee>,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<TransactionExecuteResult, BackendError> {
-    let guard = state.read().await;
-    let pledge_base = guard.attempt_convert_to_base_coin(pledge.clone())?;
-    let fee_amount = guard.convert_tx_fee(fee.as_ref());
-
+    let denom_minor = state.read().await.current_network().base_mix_denom();
+    let pledge_minor = pledge.clone().into();
     log::info!(
-    ">>> Bond mixnode with locked tokens: identity_key = {}, pledge_display = {}, pledge_base = {}, fee = {:?}",
+    ">>> Bond mixnode with locked tokens: identity_key = {}, pledge = {}, pledge_minor = {}, fee = {:?}",
     mixnode.identity_key,
     pledge,
-    pledge_base,
+    pledge_minor,
     fee
   );
-    let res = guard
-        .current_client()?
-        .nymd
-        .vesting_bond_mixnode(mixnode, &owner_signature, pledge_base, fee)
+    let res = nymd_client!(state)
+        .vesting_bond_mixnode(mixnode, &owner_signature, pledge_minor, fee)
         .await?;
     log::info!("<<< tx hash = {}", res.transaction_hash);
     log::trace!("<<< {:?}", res);
     Ok(TransactionExecuteResult::from_execute_result(
-        res, fee_amount,
+        res,
+        denom_minor.as_ref(),
     )?)
 }
 
 #[tauri::command]
 pub async fn vesting_unbond_mixnode(
     fee: Option<Fee>,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<TransactionExecuteResult, BackendError> {
-    let guard = state.read().await;
-    let fee_amount = guard.convert_tx_fee(fee.as_ref());
+    let denom_minor = state.read().await.current_network().base_mix_denom();
     log::info!(
         ">>> Unbond mixnode bonded with locked tokens, fee = {:?}",
         fee
     );
-    let res = guard
-        .current_client()?
-        .nymd
-        .vesting_unbond_mixnode(fee)
-        .await?;
+    let res = nymd_client!(state).vesting_unbond_mixnode(fee).await?;
     log::info!("<<< tx hash = {}", res.transaction_hash);
     log::trace!("<<< {:?}", res);
     Ok(TransactionExecuteResult::from_execute_result(
-        res, fee_amount,
+        res,
+        denom_minor.as_ref(),
     )?)
 }
 
 #[tauri::command]
 pub async fn withdraw_vested_coins(
-    amount: DecCoin,
+    amount: MajorCurrencyAmount,
     fee: Option<Fee>,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<TransactionExecuteResult, BackendError> {
-    let guard = state.read().await;
-    let amount_base = guard.attempt_convert_to_base_coin(amount.clone())?;
-    let fee_amount = guard.convert_tx_fee(fee.as_ref());
-
+    let denom_minor = state.read().await.current_network().base_mix_denom();
+    let amount_minor = amount.clone().into();
     log::info!(
-        ">>> Withdraw vested liquid coins: amount_base = {}, amount_base = {}, fee = {:?}",
+        ">>> Withdraw vested liquid coins: amount = {}, amount_minor = {}, fee = {:?}",
         amount,
-        amount_base,
+        amount_minor,
         fee
     );
-    let res = guard
-        .current_client()?
-        .nymd
-        .withdraw_vested_coins(amount_base, fee)
+    let res = nymd_client!(state)
+        .withdraw_vested_coins(amount_minor, fee)
         .await?;
     log::info!("<<< tx hash = {}", res.transaction_hash);
     log::trace!("<<< {:?}", res);
     Ok(TransactionExecuteResult::from_execute_result(
-        res, fee_amount,
+        res,
+        denom_minor.as_ref(),
     )?)
 }
 
@@ -143,23 +132,21 @@ pub async fn withdraw_vested_coins(
 pub async fn vesting_update_mixnode(
     profit_margin_percent: u8,
     fee: Option<Fee>,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<TransactionExecuteResult, BackendError> {
-    let guard = state.read().await;
-    let fee_amount = guard.convert_tx_fee(fee.as_ref());
+    let denom_minor = state.read().await.current_network().base_mix_denom();
     log::info!(
         ">>> Update mixnode bonded with locked tokens: profit_margin_percent = {}, fee = {:?}",
         profit_margin_percent,
         fee,
     );
-    let res = guard
-        .current_client()?
-        .nymd
+    let res = nymd_client!(state)
         .vesting_update_mixnode_config(profit_margin_percent, fee)
         .await?;
     log::info!("<<< tx hash = {}", res.transaction_hash);
     log::trace!("<<< {:?}", res);
     Ok(TransactionExecuteResult::from_execute_result(
-        res, fee_amount,
+        res,
+        denom_minor.as_ref(),
     )?)
 }

nym-wallet/src-tauri/src/operations/vesting/delegate.rs

@@ -1,18 +1,23 @@
-use crate::error::BackendError;
-use crate::state::WalletState;
-use nym_types::currency::DecCoin;
-use nym_types::delegation::DelegationEvent;
+use std::sync::Arc;
+
+use tokio::sync::RwLock;
+
+use nym_types::currency::MajorCurrencyAmount;
+use nym_types::delegation::{from_contract_delegation_events, DelegationEvent};
 use nym_types::transaction::TransactionExecuteResult;
 use validator_client::nymd::{Fee, VestingSigningClient};
 
+use crate::error::BackendError;
+use crate::nymd_client;
+use crate::state::State;
+
 #[tauri::command]
 pub async fn get_pending_vesting_delegation_events(
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<Vec<DelegationEvent>, BackendError> {
     log::info!(">>> Get pending delegations from vesting contract");
 
     let guard = state.read().await;
-    let reg = guard.registered_coins()?;
     let client = &guard.current_client()?.nymd;
     let vesting_contract = client.vesting_contract_address();
 
@@ -26,39 +31,36 @@ pub async fn get_pending_vesting_delegation_events(
     log::info!("<<< {} events", events.len());
     log::trace!("<<< {:?}", events);
 
-    Ok(events
-        .into_iter()
-        .map(|event| DelegationEvent::from_mixnet_contract(event, reg))
-        .collect::<Result<_, _>>()?)
+    match from_contract_delegation_events(events) {
+        Ok(res) => Ok(res),
+        Err(e) => Err(e.into()),
+    }
 }
 
 #[tauri::command]
 pub async fn vesting_delegate_to_mixnode(
     identity: &str,
-    amount: DecCoin,
+    amount: MajorCurrencyAmount,
     fee: Option<Fee>,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<TransactionExecuteResult, BackendError> {
-    let guard = state.read().await;
-    let delegation = guard.attempt_convert_to_base_coin(amount.clone())?;
-    let fee_amount = guard.convert_tx_fee(fee.as_ref());
-
+    let denom_minor = state.read().await.current_network().base_mix_denom();
+    let delegation = amount.clone().into();
     log::info!(
-    ">>> Delegate to mixnode with locked tokens: identity_key = {}, amount_display = {}, amount_base = {}, fee = {:?}",
+    ">>> Delegate to mixnode with locked tokens: identity_key = {}, amount = {}, minor_amount = {}, fee = {:?}",
     identity,
     amount,
     delegation,
     fee
   );
-    let res = guard
-        .current_client()?
-        .nymd
+    let res = nymd_client!(state)
         .vesting_delegate_to_mixnode(identity, delegation, fee)
         .await?;
     log::info!("<<< tx hash = {}", res.transaction_hash);
     log::trace!("<<< {:?}", res);
     Ok(TransactionExecuteResult::from_execute_result(
-        res, fee_amount,
+        res,
+        denom_minor.as_ref(),
     )?)
 }
 
@@ -66,23 +68,21 @@ pub async fn vesting_delegate_to_mixnode(
 pub async fn vesting_undelegate_from_mixnode(
     identity: &str,
     fee: Option<Fee>,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<TransactionExecuteResult, BackendError> {
-    let guard = state.read().await;
-    let fee_amount = guard.convert_tx_fee(fee.as_ref());
+    let denom_minor = state.read().await.current_network().base_mix_denom();
     log::info!(
         ">>> Undelegate from mixnode delegated with locked tokens: identity_key = {}, fee = {:?}",
         identity,
         fee,
     );
-    let res = guard
-        .current_client()?
-        .nymd
+    let res = nymd_client!(state)
         .vesting_undelegate_from_mixnode(identity, fee)
         .await?;
     log::info!("<<< tx hash = {}", res.transaction_hash);
     log::trace!("<<< {:?}", res);
     Ok(TransactionExecuteResult::from_execute_result(
-        res, fee_amount,
+        res,
+        denom_minor.as_ref(),
     )?)
 }

nym-wallet/src-tauri/src/operations/vesting/queries.rs

@@ -1,106 +1,92 @@
-use crate::error::BackendError;
-use crate::nymd_client;
-use crate::state::WalletState;
+use std::sync::Arc;
+
 use cosmwasm_std::Timestamp;
-use nym_types::currency::DecCoin;
+use tokio::sync::RwLock;
+
+use nym_types::currency::MajorCurrencyAmount;
 use nym_types::vesting::VestingAccountInfo;
 use nym_types::vesting::{OriginalVestingResponse, PledgeData};
 use validator_client::nymd::VestingQueryClient;
 use vesting_contract_common::Period;
 
+use crate::error::BackendError;
+use crate::nymd_client;
+use crate::state::State;
+
 #[tauri::command]
 pub async fn locked_coins(
     block_time: Option<u64>,
-    state: tauri::State<'_, WalletState>,
-) -> Result<DecCoin, BackendError> {
+    state: tauri::State<'_, Arc<RwLock<State>>>,
+) -> Result<MajorCurrencyAmount, BackendError> {
     log::info!(">>> Query locked coins");
-    let guard = state.read().await;
-    let client = guard.current_client()?;
-
-    let res = client
-        .nymd
+    let res = nymd_client!(state)
         .locked_coins(
-            client.nymd.address().as_ref(),
+            nymd_client!(state).address().as_ref(),
             block_time.map(Timestamp::from_seconds),
         )
-        .await?;
-    let display = guard.attempt_convert_to_display_dec_coin(res)?;
-    log::info!("<<< locked coins = {}", display);
-    Ok(display)
+        .await?
+        .into();
+    log::info!("<<< locked coins = {}", res);
+    Ok(res)
 }
 
 #[tauri::command]
 pub async fn spendable_coins(
     block_time: Option<u64>,
-    state: tauri::State<'_, WalletState>,
-) -> Result<DecCoin, BackendError> {
+    state: tauri::State<'_, Arc<RwLock<State>>>,
+) -> Result<MajorCurrencyAmount, BackendError> {
     log::info!(">>> Query spendable coins");
-    let guard = state.read().await;
-    let client = guard.current_client()?;
-
-    let res = client
-        .nymd
+    let res = nymd_client!(state)
         .spendable_coins(
-            client.nymd.address().as_ref(),
+            nymd_client!(state).address().as_ref(),
             block_time.map(Timestamp::from_seconds),
         )
-        .await?;
-
-    let display = guard.attempt_convert_to_display_dec_coin(res)?;
-    log::info!("<<< spendable coins = {}", display);
-    Ok(display)
+        .await?
+        .into();
+    log::info!("<<< spendable coins = {}", res);
+    Ok(res)
 }
 
 #[tauri::command]
 pub async fn vested_coins(
     vesting_account_address: &str,
     block_time: Option<u64>,
-    state: tauri::State<'_, WalletState>,
-) -> Result<DecCoin, BackendError> {
+    state: tauri::State<'_, Arc<RwLock<State>>>,
+) -> Result<MajorCurrencyAmount, BackendError> {
     log::info!(">>> Query vested coins");
-    let guard = state.read().await;
-
-    let res = guard
-        .current_client()?
-        .nymd
+    let res = nymd_client!(state)
         .vested_coins(
             vesting_account_address,
             block_time.map(Timestamp::from_seconds),
         )
-        .await?;
-
-    let display = guard.attempt_convert_to_display_dec_coin(res)?;
-    log::info!("<<< vested coins = {}", display);
-    Ok(display)
+        .await?
+        .into();
+    log::info!("<<< vested coins = {}", res);
+    Ok(res)
 }
 
 #[tauri::command]
 pub async fn vesting_coins(
     vesting_account_address: &str,
     block_time: Option<u64>,
-    state: tauri::State<'_, WalletState>,
-) -> Result<DecCoin, BackendError> {
+    state: tauri::State<'_, Arc<RwLock<State>>>,
+) -> Result<MajorCurrencyAmount, BackendError> {
     log::info!(">>> Query vesting coins");
-    let guard = state.read().await;
-
-    let res = guard
-        .current_client()?
-        .nymd
+    let res = nymd_client!(state)
         .vesting_coins(
             vesting_account_address,
             block_time.map(Timestamp::from_seconds),
         )
-        .await?;
-
-    let display = guard.attempt_convert_to_display_dec_coin(res)?;
-    log::info!("<<< vesting coins = {}", display);
-    Ok(display)
+        .await?
+        .into();
+    log::info!("<<< vesting coins = {}", res);
+    Ok(res)
 }
 
 #[tauri::command]
 pub async fn vesting_start_time(
     vesting_account_address: &str,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<u64, BackendError> {
     log::info!(">>> Query vesting start time");
     let res = nymd_client!(state)
@@ -114,7 +100,7 @@ pub async fn vesting_start_time(
 #[tauri::command]
 pub async fn vesting_end_time(
     vesting_account_address: &str,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<u64, BackendError> {
     log::info!(">>> Query vesting end time");
     let res = nymd_client!(state)
@@ -128,19 +114,13 @@ pub async fn vesting_end_time(
 #[tauri::command]
 pub async fn original_vesting(
     vesting_account_address: &str,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<OriginalVestingResponse, BackendError> {
     log::info!(">>> Query original vesting");
-    let guard = state.read().await;
-    let reg = guard.registered_coins()?;
-
-    let res = guard
-        .current_client()?
-        .nymd
+    let res = nymd_client!(state)
         .original_vesting(vesting_account_address)
-        .await?;
-
-    let res = OriginalVestingResponse::from_vesting_contract(res, reg)?;
+        .await?
+        .try_into()?;
     log::info!("<<< {:?}", res);
     Ok(res)
 }
@@ -149,23 +129,18 @@ pub async fn original_vesting(
 pub async fn delegated_free(
     vesting_account_address: &str,
     block_time: Option<u64>,
-    state: tauri::State<'_, WalletState>,
-) -> Result<DecCoin, BackendError> {
+    state: tauri::State<'_, Arc<RwLock<State>>>,
+) -> Result<MajorCurrencyAmount, BackendError> {
     log::info!(">>> Query delegated free");
-    let guard = state.read().await;
-
-    let res = guard
-        .current_client()?
-        .nymd
+    let res = nymd_client!(state)
         .delegated_free(
             vesting_account_address,
             block_time.map(Timestamp::from_seconds),
         )
-        .await?;
-
-    let display = guard.attempt_convert_to_display_dec_coin(res)?;
-    log::info!("<<< delegated free = {}", display);
-    Ok(display)
+        .await?
+        .into();
+    log::info!("<<< delegated free = {}", res);
+    Ok(res)
 }
 
 /// Returns the total amount of delegated tokens that have vested
@@ -173,42 +148,30 @@ pub async fn delegated_free(
 pub async fn delegated_vesting(
     block_time: Option<u64>,
     vesting_account_address: &str,
-    state: tauri::State<'_, WalletState>,
-) -> Result<DecCoin, BackendError> {
+    state: tauri::State<'_, Arc<RwLock<State>>>,
+) -> Result<MajorCurrencyAmount, BackendError> {
     log::info!(">>> Query delegated vesting");
-    let guard = state.read().await;
-
-    let res = guard
-        .current_client()?
-        .nymd
+    let res = nymd_client!(state)
         .delegated_vesting(
             vesting_account_address,
             block_time.map(Timestamp::from_seconds),
         )
-        .await?;
-
-    let display = guard.attempt_convert_to_display_dec_coin(res)?;
-    log::info!("<<< delegated_vesting = {}", display);
-    Ok(display)
+        .await?
+        .into();
+    log::info!("<<< delegated_vesting = {}", res);
+    Ok(res)
 }
 
 #[tauri::command]
 pub async fn vesting_get_mixnode_pledge(
     address: &str,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<Option<PledgeData>, BackendError> {
     log::info!(">>> Query vesting get mixnode pledge");
-    let guard = state.read().await;
-    let reg = guard.registered_coins()?;
-
-    let res = guard
-        .current_client()?
-        .nymd
+    let res = nymd_client!(state)
         .get_mixnode_pledge(address)
         .await?
-        .map(|pledge| PledgeData::from_vesting_contract(pledge, reg))
-        .transpose()?;
-
+        .and_then(PledgeData::and_then);
     log::info!("<<< {:?}", res);
     Ok(res)
 }
@@ -216,20 +179,13 @@ pub async fn vesting_get_mixnode_pledge(
 #[tauri::command]
 pub async fn vesting_get_gateway_pledge(
     address: &str,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<Option<PledgeData>, BackendError> {
     log::info!(">>> Query vesting get gateway pledge");
-    let guard = state.read().await;
-    let reg = guard.registered_coins()?;
-
-    let res = guard
-        .current_client()?
-        .nymd
+    let res = nymd_client!(state)
         .get_gateway_pledge(address)
         .await?
-        .map(|pledge| PledgeData::from_vesting_contract(pledge, reg))
-        .transpose()?;
-
+        .and_then(PledgeData::and_then);
     log::info!("<<< {:?}", res);
     Ok(res)
 }
@@ -237,7 +193,7 @@ pub async fn vesting_get_gateway_pledge(
 #[tauri::command]
 pub async fn get_current_vesting_period(
     address: &str,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<Period, BackendError> {
     log::info!(">>> Query current vesting period");
     let res = nymd_client!(state)
@@ -250,15 +206,10 @@ pub async fn get_current_vesting_period(
 #[tauri::command]
 pub async fn get_account_info(
     address: &str,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<VestingAccountInfo, BackendError> {
     log::info!(">>> Query account info");
-    let guard = state.read().await;
-    let res = guard.registered_coins()?;
-
-    let vesting_account = guard.current_client()?.nymd.get_account(address).await?;
-    let res = VestingAccountInfo::from_vesting_contract(vesting_account, res)?;
-
+    let res = nymd_client!(state).get_account(address).await?.try_into()?;
     log::info!("<<< {:?}", res);
     Ok(res)
 }

nym-wallet/src-tauri/src/operations/vesting/rewards.rs

@@ -1,46 +1,44 @@
 use crate::error::BackendError;
-use crate::state::WalletState;
+use crate::nymd_client;
+use crate::state::State;
 use mixnet_contract_common::IdentityKey;
 use nym_types::transaction::TransactionExecuteResult;
+use std::sync::Arc;
+use tokio::sync::RwLock;
 use validator_client::nymd::Fee;
 
 #[tauri::command]
 pub async fn vesting_claim_operator_reward(
-    fee: Option<Fee>,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<TransactionExecuteResult, BackendError> {
     log::info!(">>> Vesting account: claim operator reward");
-    let guard = state.read().await;
-    let fee_amount = guard.convert_tx_fee(fee.as_ref());
-    let res = guard
-        .current_client()?
-        .nymd
+    let denom_minor = state.read().await.current_network().base_mix_denom();
+    let res = nymd_client!(state)
         .execute_vesting_claim_operator_reward(None)
         .await?;
     log::info!("<<< tx hash = {}", res.transaction_hash);
     log::trace!("<<< {:?}", res);
     Ok(TransactionExecuteResult::from_execute_result(
-        res, fee_amount,
+        res,
+        denom_minor.as_ref(),
     )?)
 }
 
 #[tauri::command]
 pub async fn vesting_compound_operator_reward(
     fee: Option<Fee>,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<TransactionExecuteResult, BackendError> {
     log::info!(">>> Vesting account: compound operator reward");
-    let guard = state.read().await;
-    let fee_amount = guard.convert_tx_fee(fee.as_ref());
-    let res = guard
-        .current_client()?
-        .nymd
+    let denom_minor = state.read().await.current_network().base_mix_denom();
+    let res = nymd_client!(state)
         .execute_vesting_compound_operator_reward(fee)
         .await?;
     log::info!("<<< tx hash = {}", res.transaction_hash);
     log::trace!("<<< {:?}", res);
     Ok(TransactionExecuteResult::from_execute_result(
-        res, fee_amount,
+        res,
+        denom_minor.as_ref(),
     )?)
 }
 
@@ -48,23 +46,21 @@ pub async fn vesting_compound_operator_reward(
 pub async fn vesting_claim_delegator_reward(
     mix_identity: IdentityKey,
     fee: Option<Fee>,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<TransactionExecuteResult, BackendError> {
     log::info!(
         ">>> Vesting account: claim delegator reward: identity_key = {}",
         mix_identity
     );
-    let guard = state.read().await;
-    let fee_amount = guard.convert_tx_fee(fee.as_ref());
-    let res = guard
-        .current_client()?
-        .nymd
+    let denom_minor = state.read().await.current_network().base_mix_denom();
+    let res = nymd_client!(state)
         .execute_vesting_claim_delegator_reward(mix_identity, fee)
         .await?;
     log::info!("<<< tx hash = {}", res.transaction_hash);
     log::trace!("<<< {:?}", res);
     Ok(TransactionExecuteResult::from_execute_result(
-        res, fee_amount,
+        res,
+        denom_minor.as_ref(),
     )?)
 }
 
@@ -72,22 +68,20 @@ pub async fn vesting_claim_delegator_reward(
 pub async fn vesting_compound_delegator_reward(
     mix_identity: IdentityKey,
     fee: Option<Fee>,
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<TransactionExecuteResult, BackendError> {
     log::info!(
         ">>> Vesting account: compound delegator reward: identity_key = {}",
         mix_identity
     );
-    let guard = state.read().await;
-    let fee_amount = guard.convert_tx_fee(fee.as_ref());
-    let res = guard
-        .current_client()?
-        .nymd
+    let denom_minor = state.read().await.current_network().base_mix_denom();
+    let res = nymd_client!(state)
         .execute_vesting_compound_delegator_reward(mix_identity, fee)
         .await?;
     log::info!("<<< tx hash = {}", res.transaction_hash);
     log::trace!("<<< {:?}", res);
     Ok(TransactionExecuteResult::from_execute_result(
-        res, fee_amount,
+        res,
+        denom_minor.as_ref(),
     )?)
 }

nym-wallet/src-tauri/src/state.rs

@@ -1,22 +1,20 @@
 use crate::config;
 use crate::error::BackendError;
-use crate::simulate::SimulateResult;
-use itertools::Itertools;
-use log::warn;
-use nym_types::currency::{DecCoin, RegisteredCoins};
-use nym_types::fees::FeeDetails;
 use nym_wallet_types::network::Network;
 use nym_wallet_types::network_config;
+
+use strum::IntoEnumIterator;
+use validator_client::nymd::{AccountId as CosmosAccountId, SigningNymdClient};
+use validator_client::Client;
+
+use itertools::Itertools;
 use once_cell::sync::Lazy;
+use tokio::sync::RwLock;
+use url::Url;
+
 use std::collections::HashMap;
 use std::sync::Arc;
 use std::time::Duration;
-use strum::IntoEnumIterator;
-use tokio::sync::{RwLock, RwLockReadGuard, RwLockWriteGuard};
-use url::Url;
-use validator_client::nymd::cosmwasm_client::types::SimulateResponse;
-use validator_client::nymd::{AccountId as CosmosAccountId, Coin, Fee, SigningNymdClient};
-use validator_client::Client;
 
 // Some hardcoded metadata overrides
 static METADATA_OVERRIDES: Lazy<Vec<(Url, ValidatorMetadata)>> = Lazy::new(|| {
@@ -30,7 +28,7 @@ static METADATA_OVERRIDES: Lazy<Vec<(Url, ValidatorMetadata)>> = Lazy::new(|| {
 
 #[tauri::command]
 pub async fn load_config_from_files(
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<(), BackendError> {
     state.write().await.load_config_files();
     Ok(())
@@ -38,30 +36,13 @@ pub async fn load_config_from_files(
 
 #[tauri::command]
 pub async fn save_config_to_files(
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<(), BackendError> {
     state.read().await.save_config_files()
 }
 
-#[derive(Default, Clone)]
-pub struct WalletState {
-    inner: Arc<RwLock<WalletStateInner>>,
-}
-
-impl WalletState {
-    // not the best API, but those are exposed here for backwards compatibility with the existing
-    // state type assumptions so that we wouldn't need to fix it up everywhere at once
-    pub(crate) async fn read(&self) -> RwLockReadGuard<'_, WalletStateInner> {
-        self.inner.read().await
-    }
-
-    pub(crate) async fn write(&self) -> RwLockWriteGuard<'_, WalletStateInner> {
-        self.inner.write().await
-    }
-}
-
 #[derive(Default)]
-pub struct WalletStateInner {
+pub struct State {
     config: config::Config,
     signing_clients: HashMap<Network, Client<SigningNymdClient>>,
     current_network: Network,
@@ -75,7 +56,6 @@ pub struct WalletStateInner {
 
     /// We fetch (and cache) some metadata, such as names, when available
     validator_metadata: HashMap<Url, ValidatorMetadata>,
-    registered_coins: HashMap<Network, RegisteredCoins>,
 }
 
 pub(crate) struct WalletAccountIds {
@@ -85,70 +65,7 @@ pub(crate) struct WalletAccountIds {
     pub addresses: HashMap<Network, CosmosAccountId>,
 }
 
-impl WalletStateInner {
-    // note that `Coin` is ALWAYS the base coin
-    pub fn attempt_convert_to_base_coin(&self, coin: DecCoin) -> Result<Coin, BackendError> {
-        let registered_coins = self
-            .registered_coins
-            .get(&self.current_network)
-            .ok_or_else(|| BackendError::UnknownCoinDenom(coin.denom.clone()))?;
-
-        Ok(registered_coins.attempt_convert_to_base_coin(coin)?)
-    }
-
-    pub fn attempt_convert_to_display_dec_coin(&self, coin: Coin) -> Result<DecCoin, BackendError> {
-        let registered_coins = self
-            .registered_coins
-            .get(&self.current_network)
-            .ok_or_else(|| BackendError::UnknownCoinDenom(coin.denom.clone()))?;
-
-        Ok(registered_coins.attempt_convert_to_display_dec_coin(coin)?)
-    }
-
-    pub(crate) fn registered_coins(&self) -> Result<&RegisteredCoins, BackendError> {
-        self.registered_coins
-            .get(&self.current_network)
-            .ok_or(BackendError::NoCoinsRegistered {
-                network: self.current_network,
-            })
-    }
-
-    pub(crate) fn convert_tx_fee(&self, fee: Option<&Fee>) -> Option<DecCoin> {
-        let mut fee_amount = fee?.try_get_manual_amount()?;
-        if fee_amount.len() > 1 {
-            warn!(
-            "our tx fee contained more than a single denomination. using the first one for display"
-        )
-        }
-        if fee_amount.is_empty() {
-            warn!("our tx has had an unknown fee set");
-            None
-        } else {
-            self.attempt_convert_to_display_dec_coin(fee_amount.pop().unwrap())
-                .ok()
-        }
-    }
-
-    // this one is rather gnarly and I'm not 100% sure how to feel about existence of it
-    pub(crate) fn create_detailed_fee(
-        &self,
-        simulate_response: SimulateResponse,
-    ) -> Result<FeeDetails, BackendError> {
-        // this MUST succeed as we just used it before
-        let client = self.current_client()?;
-        let gas_price = client.nymd.gas_price().clone();
-        let gas_adjustment = client.nymd.gas_adjustment();
-
-        let res = SimulateResult::new(simulate_response.gas_info, gas_price, gas_adjustment);
-
-        let amount = res
-            .to_fee_amount()
-            .map(|amount| self.attempt_convert_to_display_dec_coin(amount.into()))
-            .transpose()?;
-
-        Ok(FeeDetails::new(amount, res.to_fee()))
-    }
-
+impl State {
     pub fn client(&self, network: Network) -> Result<&Client<SigningNymdClient>, BackendError> {
         self.signing_clients
             .get(&network)
@@ -195,11 +112,6 @@ impl WalletStateInner {
         self.signing_clients.insert(network, client);
     }
 
-    pub fn register_default_denoms(&mut self, network: Network) {
-        self.registered_coins
-            .insert(network, RegisteredCoins::default_denoms(network.into()));
-    }
-
     pub fn set_network(&mut self, network: Network) {
         self.current_network = network;
     }
@@ -478,7 +390,7 @@ mod tests {
 
     #[test]
     fn adding_validators_urls_prepends() {
-        let mut state = WalletStateInner::default();
+        let mut state = State::default();
         let _api_urls = state.get_api_urls(Network::MAINNET).collect::<Vec<_>>();
 
         state.add_validator_url(

nym-wallet/src-tauri/src/utils.rs

@@ -1,9 +1,11 @@
 use crate::error::BackendError;
 use crate::nymd_client;
-use crate::state::WalletState;
-use nym_types::currency::DecCoin;
+use crate::state::State;
+use nym_types::currency::MajorCurrencyAmount;
 use nym_wallet_types::app::AppEnv;
 use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+use tokio::sync::RwLock;
 use validator_client::nymd::{tx, Coin, CosmosCoin, Gas, GasPrice};
 
 fn get_env_as_option(key: &str) -> Option<String> {
@@ -23,7 +25,9 @@ pub fn get_env() -> AppEnv {
 }
 
 #[tauri::command]
-pub async fn owns_mixnode(state: tauri::State<'_, WalletState>) -> Result<bool, BackendError> {
+pub async fn owns_mixnode(
+    state: tauri::State<'_, Arc<RwLock<State>>>,
+) -> Result<bool, BackendError> {
     Ok(nymd_client!(state)
         .owns_mixnode(nymd_client!(state).address())
         .await?
@@ -31,7 +35,9 @@ pub async fn owns_mixnode(state: tauri::State<'_, WalletState>) -> Result<bool,
 }
 
 #[tauri::command]
-pub async fn owns_gateway(state: tauri::State<'_, WalletState>) -> Result<bool, BackendError> {
+pub async fn owns_gateway(
+    state: tauri::State<'_, Arc<RwLock<State>>>,
+) -> Result<bool, BackendError> {
     Ok(nymd_client!(state)
         .owns_gateway(nymd_client!(state).address())
         .await?
@@ -139,14 +145,13 @@ impl Operation {
 
 #[tauri::command]
 pub async fn get_old_and_incorrect_hardcoded_fee(
-    state: tauri::State<'_, WalletState>,
+    state: tauri::State<'_, Arc<RwLock<State>>>,
     operation: Operation,
-) -> Result<DecCoin, BackendError> {
-    let guard = state.read().await;
-    let mut approximate_fee = operation.default_fee(guard.current_client()?.nymd.gas_price());
+) -> Result<MajorCurrencyAmount, BackendError> {
+    let mut approximate_fee = operation.default_fee(nymd_client!(state).gas_price());
     // on all our chains it should only ever contain a single type of currency
     assert_eq!(approximate_fee.amount.len(), 1);
     let coin: Coin = approximate_fee.amount.pop().unwrap().into();
     log::info!("hardcoded fee for {:?} is {:?}", operation, coin);
-    guard.attempt_convert_to_display_dec_coin(coin)
+    Ok(coin.into())
 }

nym-wallet/src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "package": {
     "productName": "nym-wallet",
-    "version": "1.0.7"
+    "version": "1.0.6"
   },
   "build": {
     "distDir": "../dist",

tools/ts-rs-cli/src/main.rs

@@ -4,7 +4,7 @@ use walkdir::WalkDir;
 
 use mixnet_contract_common::mixnode::RewardedSetNodeStatus;
 use nym_types::account::{Account, AccountEntry, AccountWithMnemonic, Balance};
-use nym_types::currency::{CurrencyDenom, DecCoin};
+use nym_types::currency::{CurrencyDenom, MajorAmountString, MajorCurrencyAmount};
 use nym_types::delegation::{
     Delegation, DelegationEvent, DelegationEventKind, DelegationRecord, DelegationResult,
     DelegationWithEverything, DelegationsSummaryResponse, PendingUndelegate,
@@ -59,6 +59,7 @@ fn main() {
     do_export!(AccountEntry);
     do_export!(AccountWithMnemonic);
     do_export!(Balance);
+    do_export!(CurrencyDenom);
     do_export!(Delegation);
     do_export!(DelegationEvent);
     do_export!(DelegationEventKind);
@@ -76,8 +77,8 @@ fn main() {
     do_export!(GasInfo);
     do_export!(Gateway);
     do_export!(GatewayBond);
-    do_export!(CurrencyDenom);
-    do_export!(DecCoin);
+    do_export!(MajorAmountString);
+    do_export!(MajorCurrencyAmount);
     do_export!(MixNode);
     do_export!(MixNodeBond);
     do_export!(OriginalVestingResponse);

ts-packages/types/src/types/rust/Account.ts

@@ -1,2 +1,7 @@
+import type { CurrencyDenom } from './CurrencyDenom';
 
-export interface Account { contract_address: string, client_address: string, denom: string, }
+export interface Account {
+  contract_address: string;
+  client_address: string;
+  denom: CurrencyDenom;
+}

ts-packages/types/src/types/rust/AccountEntry.ts

@@ -1,2 +1,4 @@
-
-export interface AccountEntry { id: string, address: string, }
+export interface AccountEntry {
+  id: string;
+  address: string;
+}

ts-packages/types/src/types/rust/AccountWithMnemonic.ts

@@ -1,3 +1,6 @@
-import type { Account } from "./Account";
+import type { Account } from './Account';
 
-export interface AccountWithMnemonic { account: Account, mnemonic: string, }
+export interface AccountWithMnemonic {
+  account: Account;
+  mnemonic: string;
+}

ts-packages/types/src/types/rust/Balance.ts

@@ -1,3 +1,6 @@
-import type { DecCoin } from "./DecCoin";
+import type { MajorCurrencyAmount } from './Currency';
 
-export interface Balance { amount: DecCoin, printable_balance: string, }
+export interface Balance {
+  amount: MajorCurrencyAmount;
+  printable_balance: string;
+}

ts-packages/types/src/types/rust/CoreNodeStatusResponse.ts

@@ -1,2 +1,4 @@
-
-export interface CoreNodeStatusResponse { identity: string, count: number, }
+export interface CoreNodeStatusResponse {
+  identity: string;
+  count: number;
+}

ts-packages/types/src/types/rust/Currency.ts

@@ -0,0 +1,7 @@
+import type { CurrencyDenom } from './CurrencyDenom';
+import type { MajorAmountString } from './CurrencyStringMajorAmount';
+
+export interface MajorCurrencyAmount {
+  amount: MajorAmountString;
+  denom: CurrencyDenom;
+}

ts-packages/types/src/types/rust/CurrencyDenom.ts

@@ -1,2 +1 @@
-
-export type CurrencyDenom = "nym" | "nymt" | "nyx" | "nyxt";
+export type CurrencyDenom = 'NYM' | 'NYMT' | 'NYX' | 'NYXT';

ts-packages/types/src/types/rust/CurrencyStringMajorAmount.ts

@@ -0,0 +1 @@
+export type MajorAmountString = string;

ts-packages/types/src/types/rust/DecCoin.ts

@@ -1,3 +0,0 @@
-import type { CurrencyDenom } from "./CurrencyDenom";
-
-export type DecCoin = { denom: CurrencyDenom, amount: string };

ts-packages/types/src/types/rust/Delegation.ts

@@ -1,3 +1,9 @@
-import type { DecCoin } from "./DecCoin";
+import type { MajorCurrencyAmount } from './Currency';
 
-export interface Delegation { owner: string, node_identity: string, amount: DecCoin, block_height: bigint, proxy: string | null, }
+export interface Delegation {
+  owner: string;
+  node_identity: string;
+  amount: MajorCurrencyAmount;
+  block_height: bigint;
+  proxy: string | null;
+}

ts-packages/types/src/types/rust/DelegationEvent.ts

@@ -1,11 +1,11 @@
-import type { DecCoin } from "./DecCoin";
-import type { DelegationEventKind } from "./DelegationEventKind";
+import type { DelegationEventKind } from './DelegationEventKind';
+import type { MajorCurrencyAmount } from './Currency';
 
 export interface DelegationEvent {
   kind: DelegationEventKind;
   node_identity: string;
   address: string;
-  amount: DecCoin | null;
+  amount: MajorCurrencyAmount | null;
   block_height: bigint;
   proxy: string | null;
 }

ts-packages/types/src/types/rust/DelegationEventKind.ts

@@ -1,2 +1 @@
-
-export type DelegationEventKind = "Delegate" | "Undelegate";
+export type DelegationEventKind = 'Delegate' | 'Undelegate';

ts-packages/types/src/types/rust/DelegationRecord.ts

@@ -1,7 +1,7 @@
-import type { DecCoin } from "./DecCoin";
+import type { MajorCurrencyAmount } from './Currency';
 
 export interface DelegationRecord {
-  amount: DecCoin;
+  amount: MajorCurrencyAmount;
   block_height: bigint;
   delegated_on_iso_datetime: string;
   uses_vesting_contract_tokens: boolean;

ts-packages/types/src/types/rust/DelegationResult.ts

@@ -1,3 +1,7 @@
-import type { DecCoin } from "./DecCoin";
+import type { MajorCurrencyAmount } from './Currency';
 
-export interface DelegationResult { source_address: string, target_address: string, amount: DecCoin | null, }
+export interface DelegationResult {
+  source_address: string;
+  target_address: string;
+  amount: MajorCurrencyAmount | null;
+}

ts-packages/types/src/types/rust/DelegationSummaryResponse.ts

@@ -1,4 +1,8 @@
-import type { DecCoin } from "./DecCoin";
-import type { DelegationWithEverything } from "./DelegationWithEverything";
+import type { DelegationWithEverything } from './DelegationWithEverything';
+import type { MajorCurrencyAmount } from './Currency';
 
-export interface DelegationsSummaryResponse { delegations: Array<DelegationWithEverything>, total_delegations: DecCoin, total_rewards: DecCoin, }
+export interface DelegationsSummaryResponse {
+  delegations: Array<DelegationWithEverything>;
+  total_delegations: MajorCurrencyAmount;
+  total_rewards: MajorCurrencyAmount;
+}

ts-packages/types/src/types/rust/DelegationWithEverything.ts

@@ -1,20 +1,20 @@
-import type { DecCoin } from "./DecCoin";
-import type { DelegationEvent } from "./DelegationEvent";
-import type { DelegationRecord } from "./DelegationRecord";
+import type { DelegationEvent } from './DelegationEvent';
+import type { DelegationRecord } from './DelegationRecord';
+import type { MajorCurrencyAmount } from './Currency';
 
 export interface DelegationWithEverything {
   owner: string;
   node_identity: string;
-  amount: DecCoin;
-  total_delegation: DecCoin | null;
-  pledge_amount: DecCoin | null;
+  amount: MajorCurrencyAmount;
+  total_delegation: MajorCurrencyAmount | null;
+  pledge_amount: MajorCurrencyAmount | null;
   block_height: bigint;
   delegated_on_iso_datetime: string;
   profit_margin_percent: number | null;
   avg_uptime_percent: number | null;
   stake_saturation: number | null;
   uses_vesting_contract_tokens: boolean;
-  accumulated_rewards: DecCoin | null;
+  accumulated_rewards: MajorCurrencyAmount | null;
   pending_events: Array<DelegationEvent>;
   history: Array<DelegationRecord>;
 }

ts-packages/types/src/types/rust/FeeDetails.ts

@@ -1,4 +1,4 @@
 import type { Fee } from './Fee';
-import type { DecCoin } from "./DecCoin";
+import type { MajorCurrencyAmount } from './Currency';
 
-export type FeeDetails = { amount: DecCoin | null; fee: Fee };
+export type FeeDetails = { amount: MajorCurrencyAmount | null; fee: Fee };

ts-packages/types/src/types/rust/GasInfo.ts

@@ -1,3 +1,7 @@
-import type { Gas } from "./Gas";
+import type { MajorCurrencyAmount } from './Currency';
 
-export interface GasInfo { gas_wanted: Gas, gas_used: Gas, }
+export interface GasInfo {
+  gas_wanted: bigint;
+  gas_used: bigint;
+  fee: MajorCurrencyAmount;
+}

ts-packages/types/src/types/rust/GatewayBond.ts

@@ -1,4 +1,10 @@
-import type { DecCoin } from "./DecCoin";
-import type { Gateway } from "./Gateway";
+import type { Gateway } from './Gateway';
+import type { MajorCurrencyAmount } from './Currency';
 
-export interface GatewayBond { pledge_amount: DecCoin, owner: string, block_height: bigint, gateway: Gateway, proxy: string | null, }
+export interface GatewayBond {
+  pledge_amount: MajorCurrencyAmount;
+  owner: string;
+  block_height: bigint;
+  gateway: Gateway;
+  proxy: string | null;
+}

ts-packages/types/src/types/rust/InclusionProbabilityResponse.ts

@@ -1,3 +1,6 @@
-import type { SelectionChance } from "./SelectionChance";
+import type { SelectionChance } from './SelectionChance';
 
-export interface InclusionProbabilityResponse { in_active: SelectionChance, in_reserve: SelectionChance, }
+export interface InclusionProbabilityResponse {
+  in_active: SelectionChance;
+  in_reserve: SelectionChance;
+}

ts-packages/types/src/types/rust/MixNodeBond.ts

@@ -1,4 +1,13 @@
-import type { DecCoin } from "./DecCoin";
-import type { MixNode } from "./Mixnode";
+import type { MajorCurrencyAmount } from './Currency';
+import type { MixNode } from './Mixnode';
 
-export interface MixNodeBond { pledge_amount: DecCoin, total_delegation: DecCoin, owner: string, layer: string, block_height: bigint, mix_node: MixNode, proxy: string | null, accumulated_rewards: DecCoin | null, }
+export interface MixNodeBond {
+  pledge_amount: MajorCurrencyAmount;
+  total_delegation: MajorCurrencyAmount;
+  owner: string;
+  layer: string;
+  block_height: bigint;
+  mix_node: MixNode;
+  proxy: string | null;
+  accumulated_rewards: MajorCurrencyAmount | null;
+}

ts-packages/types/src/types/rust/MixnodeStatus.ts

@@ -1,2 +1 @@
-
-export type MixnodeStatus = "active" | "standby" | "inactive" | "not_found";
+export type MixnodeStatus = 'active' | 'standby' | 'inactive' | 'not_found';

ts-packages/types/src/types/rust/MixnodeStatusResponse.ts

@@ -1,3 +1,5 @@
-import type { MixnodeStatus } from "./MixnodeStatus";
+import type { MixnodeStatus } from './MixnodeStatus';
 
-export interface MixnodeStatusResponse { status: MixnodeStatus, }
+export interface MixnodeStatusResponse {
+  status: MixnodeStatus;
+}

ts-packages/types/src/types/rust/OriginalVestingResponse.ts

@@ -1,3 +1,7 @@
-import type { DecCoin } from "./DecCoin";
+import type { MajorCurrencyAmount } from './Currency';
 
-export interface OriginalVestingResponse { amount: DecCoin, number_of_periods: number, period_duration: bigint, }
+export interface OriginalVestingResponse {
+  amount: MajorCurrencyAmount;
+  number_of_periods: number;
+  period_duration: bigint;
+}

ts-packages/types/src/types/rust/PendingUndelegate.ts

@@ -1,2 +1,6 @@
-
-export interface PendingUndelegate { mix_identity: string, delegate: string, proxy: string | null, block_height: bigint, }
+export interface PendingUndelegate {
+  mix_identity: string;
+  delegate: string;
+  proxy: string | null;
+  block_height: bigint;
+}

ts-packages/types/src/types/rust/Period.ts

@@ -1,2 +1 @@
-
-export type Period = "Before" | { In: number } | "After";
+export type Period = 'Before' | { In: number } | 'After';

ts-packages/types/src/types/rust/PledgeData.ts

@@ -1,3 +1,6 @@
-import type { DecCoin } from "./DecCoin";
+import type { MajorCurrencyAmount } from './Currency';
 
-export interface PledgeData { amount: DecCoin, block_time: bigint, }
+export interface PledgeData {
+  amount: MajorCurrencyAmount;
+  block_time: bigint;
+}

ts-packages/types/src/types/rust/RpcTransactionResponse.ts

@@ -1,5 +1,3 @@
-import type { DecCoin } from "./DecCoin";
-import type { Gas } from "./Gas";
 import type { GasInfo } from './GasInfo';
 
 export interface RpcTransactionResponse {

ts-packages/types/src/types/rust/SelectionChance.ts

@@ -1,2 +1 @@
-
-export type SelectionChance = "VeryHigh" | "High" | "Moderate" | "Low" | "VeryLow";
+export type SelectionChance = 'VeryHigh' | 'High' | 'Moderate' | 'Low' | 'VeryLow';

ts-packages/types/src/types/rust/StakeSaturationResponse.ts

@@ -1,2 +1,4 @@
-
-export interface StakeSaturationResponse { saturation: number, as_at: bigint, }
+export interface StakeSaturationResponse {
+  saturation: number;
+  as_at: bigint;
+}

ts-packages/types/src/types/rust/TransactionDetails.ts

@@ -1,3 +1,7 @@
-import type { DecCoin } from "./DecCoin";
+import type { MajorCurrencyAmount } from './Currency';
 
-export interface TransactionDetails { amount: DecCoin, from_address: string, to_address: string, }
+export interface TransactionDetails {
+  amount: MajorCurrencyAmount;
+  from_address: string;
+  to_address: string;
+}

ts-packages/types/src/types/rust/TransactionExecuteResult.ts

@@ -1,4 +1,10 @@
-import type { DecCoin } from "./DecCoin";
-import type { GasInfo } from "./GasInfo";
+import type { GasInfo } from './GasInfo';
+import type { MajorCurrencyAmount } from './Currency';
 
-export interface TransactionExecuteResult { logs_json: string, data_json: string, transaction_hash: string, gas_info: GasInfo, fee: DecCoin | null, }
+export interface TransactionExecuteResult {
+  logs_json: string;
+  data_json: string;
+  transaction_hash: string;
+  gas_info: GasInfo;
+  fee: MajorCurrencyAmount;
+}

ts-packages/types/src/types/rust/VestingAccountInfo.ts

@@ -1,4 +1,10 @@
-import type { DecCoin } from "./DecCoin";
-import type { VestingPeriod } from "./VestingPeriod";
+import type { MajorCurrencyAmount } from './Currency';
+import type { VestingPeriod } from './VestingPeriod';
 
-export interface VestingAccountInfo { owner_address: string, staking_address: string | null, start_time: bigint, periods: Array<VestingPeriod>, amount: DecCoin, }
+export interface VestingAccountInfo {
+  owner_address: string;
+  staking_address: string | null;
+  start_time: bigint;
+  periods: Array<VestingPeriod>;
+  amount: MajorCurrencyAmount;
+}

ts-packages/types/src/types/rust/VestingPeriod.ts

@@ -1,2 +1,4 @@
-
-export interface VestingPeriod { start_time: bigint, period_seconds: bigint, }
+export interface VestingPeriod {
+  start_time: bigint;
+  period_seconds: bigint;
+}