Attempting to de-rot the branch

No longer exposing plain 'DENOM'

Denom registration + conversion

Generating typescript type for DecCoin

'New' API on 'send'

Further WIP work on transforming usages of MajorCurrencyAmount into DecCoin

Further replacements of MajorCurrencyAmount into DecCoin

Attempt at dec-coinifying get_all_mix_delegations

Finished purge of MajorCurrencyAmount

Display for Fee

More unification for conversion methods

Fixed up tests and made clippy happier

Minor post-merge fixes

Removed explicit Arc and RwLock from all tauri commands

Fixed conversion to display coin

More type-restrictive exported denom type

Regenerated rust => ts types

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, Denom, Tx};
+use cosmrs::{tx, AccountId, Coin as CosmosCoin, Tx};
 use prost::Message;
 use serde::{Deserialize, Serialize};
 use std::convert::{TryFrom, TryInto};
@@ -121,7 +121,7 @@ pub trait CosmWasmClient: rpc::Client {
     async fn get_balance(
         &self,
         address: &AccountId,
-        search_denom: Denom,
+        search_denom: String,
     ) -> Result<Option<Coin>, NymdError> {
         let path = Some("/cosmos.bank.v1beta1.Query/Balance".parse().unwrap());
 

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(multiplier, payer, granter) => {
-                let mut fee = auto_fee(multiplier).await?;
-                fee.payer = payer;
-                fee.granter = granter;
+            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
             }
         };

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

@@ -1,9 +1,11 @@
 // 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;
 
@@ -11,11 +13,63 @@ 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(Option<GasAdjustment>, Option<AccountId>, Option<AccountId>),
+    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,
+        }
+    }
 }
 
 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: Denom,
+        denom: String,
     ) -> 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 anouther address
+    pub proxy: Option<Addr>, // proxy address used to delegate the funds on behalf of another address
 }
 
 impl Eq for Delegation {}

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

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

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 {
-    amount: Coin,
-    block_time: Timestamp,
+    pub amount: Coin,
+    pub block_time: Timestamp,
 }
 
 impl PledgeData {
@@ -48,9 +48,9 @@ impl PledgeData {
 
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
 pub struct OriginalVestingResponse {
-    amount: Coin,
-    number_of_periods: usize,
-    period_duration: u64,
+    pub amount: Coin,
+    pub number_of_periods: usize,
+    pub period_duration: u64,
 }
 
 impl OriginalVestingResponse {

common/network-defaults/src/lib.rs

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

common/types/src/account.rs

@@ -1,4 +1,4 @@
-use crate::currency::{CurrencyDenom, MajorCurrencyAmount};
+use crate::currency::DecCoin;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
@@ -9,13 +9,16 @@ 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: CurrencyDenom,
+    pub denom: String,
 }
 
 impl Account {
-    pub fn new(contract_address: String, client_address: String, denom: CurrencyDenom) -> Self {
+    pub fn new(contract_address: String, client_address: String, denom: String) -> Self {
         Account {
             contract_address,
             client_address,
@@ -53,6 +56,15 @@ pub struct AccountEntry {
 )]
 #[derive(Serialize, Deserialize)]
 pub struct Balance {
-    pub amount: MajorCurrencyAmount,
+    pub amount: DecCoin,
     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,22 +1,26 @@
 use crate::error::TypesError;
-use cosmrs::Denom as CosmosDenom;
-use cosmwasm_std::Coin as CosmWasmCoin;
+use config::defaults::all::Network;
+use config::defaults::{DenomDetails, DenomDetailsOwned};
+use cosmwasm_std::Fraction;
 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, CosmosCoin};
+use validator_client::nymd::Coin;
+
+#[cfg(feature = "generate-ts")]
+use ts_rs::{Dependency, TS};
 
 #[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 = "UPPERCASE"))]
+#[cfg_attr(feature = "generate-ts", ts(rename_all = "lowercase"))]
 #[derive(
     Display,
     Serialize,
@@ -29,9 +33,8 @@ use validator_client::nymd::{Coin, CosmosCoin};
     Eq,
     JsonSchema,
 )]
-#[serde(rename_all = "UPPERCASE")]
-#[strum(serialize_all = "UPPERCASE")]
-// TODO: this shouldn't be an enum...
+#[serde(rename_all = "lowercase")]
+#[strum(serialize_all = "lowercase")]
 pub enum CurrencyDenom {
     #[strum(ascii_case_insensitive)]
     Nym,
@@ -43,448 +46,470 @@ pub enum CurrencyDenom {
     Nyxt,
 }
 
-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();
+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));
+                }
+            }
         }
-        match CurrencyDenom::from_str(&denom) {
-            Ok(res) => Ok(res),
-            Err(_e) => Err(TypesError::InvalidDenom(value.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))
     }
 }
 
-impl TryFrom<CosmosDenom> for CurrencyDenom {
-    type Error = TypesError;
+// 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>,
+}
 
-    fn try_from(value: CosmosDenom) -> Result<Self, Self::Error> {
-        CurrencyDenom::parse(value.as_ref())
+impl DenomUnit {
+    pub fn new(denom: Denom, exponent: u32) -> Self {
+        DenomUnit { denom, exponent }
     }
 }
 
-#[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,
+#[derive(Debug)]
+pub struct CoinMetadata {
+    pub denom_units: Vec<DenomUnit>,
+    pub base: Denom,
+    pub display: Denom,
 }
 
-// impl JsonSchema for MajorCurrencyAmount {
-//     fn schema_name() -> String {
-//         todo!()
-//     }
-//
-//     fn json_schema(gen: &mut SchemaGenerator) -> Schema {
-//         todo!()
-//     }
-// }
+impl CoinMetadata {
+    pub fn new(denom_units: Vec<DenomUnit>, base: Denom, display: Denom) -> Self {
+        CoinMetadata {
+            denom_units,
+            base,
+            display,
+        }
+    }
+
+    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 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(),
+        )
+    }
+}
+
+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,
+        )
+    }
+}
 
 // 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,
 }
 
-impl MajorCurrencyAmount {
-    pub fn new(amount: &str, denom: CurrencyDenom) -> MajorCurrencyAmount {
-        MajorCurrencyAmount {
-            amount: MajorAmountString(amount.to_string()),
-            denom,
+// 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(),
         }
     }
 
-    pub fn zero(denom: &CurrencyDenom) -> MajorCurrencyAmount {
-        MajorCurrencyAmount::new("0", denom.clone())
+    pub fn zero<S: Into<String>>(denom: S) -> Self {
+        DecCoin {
+            denom: denom.into(),
+            amount: Decimal::zero(),
+        }
     }
-    //
-    // 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 denom_to_string(&self) -> String {
-    //     self.denom.to_string()
-    // }
+    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)
+    }
 }
 
-impl Display for MajorCurrencyAmount {
+// 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 {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{} {}", self.amount.0, self.denom)
+        write!(f, "{}{}", self.amount, self.denom)
     }
 }
 
-// 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 {
+impl From<Coin> for DecCoin {
     fn from(coin: Coin) -> Self {
-        // 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..."),
-        }
+        DecCoin::new_base(coin.amount, coin.denom)
     }
 }
 
-// temporary...
-impl From<MajorCurrencyAmount> for CosmosCoin {
-    fn from(c: MajorCurrencyAmount) -> CosmosCoin {
-        let c: Coin = c.into();
-        c.into()
-    }
-}
+// this conversion assumes same denomination
+impl TryFrom<DecCoin> for Coin {
+    type Error = TypesError;
 
-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()
+    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,
+        })
     }
 }
 
 #[cfg(test)]
 mod test {
     use super::*;
-    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::convert::TryFrom;
     use std::string::ToString;
 
     #[test]
-    fn json_to_major_currency_amount() {
-        let nym = json!({
-            "amount": "1",
-            "denom": "NYM"
-        });
-        let nymt = json!({
-            "amount": "1",
-            "denom": "NYMT"
-        });
+    fn dec_value_scale_down() {
+        let dec = DecCoin {
+            denom: "foo".to_string(),
+            amount: "1234007000".parse().unwrap(),
+        };
 
-        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!(
-            CurrencyDenom::from_str("nymt").unwrap(),
-            CurrencyDenom::Nymt
-        );
-        assert_eq!(CurrencyDenom::from_str("NYM").unwrap(), CurrencyDenom::Nym);
-        assert_eq!(
-            CurrencyDenom::from_str("NYMT").unwrap(),
-            CurrencyDenom::Nymt
-        );
-        assert_eq!(CurrencyDenom::from_str("NyM").unwrap(), CurrencyDenom::Nym);
-        assert_eq!(
-            CurrencyDenom::from_str("NYmt").unwrap(),
-            CurrencyDenom::Nymt
-        );
-
-        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!(
-            MajorCurrencyAmount::new("1", CurrencyDenom::Nym).to_string(),
-            "1 NYM"
+            "1234007000".parse::<Decimal>().unwrap(),
+            dec.try_scale_down_value(0).unwrap()
         );
         assert_eq!(
-            MajorCurrencyAmount::new("1", CurrencyDenom::Nymt).to_string(),
-            "1 NYMT"
+            "123400700".parse::<Decimal>().unwrap(),
+            dec.try_scale_down_value(1).unwrap()
         );
         assert_eq!(
-            MajorCurrencyAmount::new("1000000000000", CurrencyDenom::Nym).to_string(),
-            "1000000000000 NYM"
+            "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()
+        );
+
+        let dec = DecCoin {
+            denom: "foo".to_string(),
+            amount: "10000000000".parse().unwrap(),
+        };
+
+        assert_eq!(
+            "100".parse::<Decimal>().unwrap(),
+            dec.try_scale_down_value(8).unwrap()
+        );
+        assert_eq!(
+            "1".parse::<Decimal>().unwrap(),
+            dec.try_scale_down_value(10).unwrap()
+        );
+        assert_eq!(
+            "0.01".parse::<Decimal>().unwrap(),
+            dec.try_scale_down_value(12).unwrap()
         );
     }
 
     #[test]
-    fn minor_coin_to_major_currency() {
-        let cosmos_coin = CosmosCoin {
-            amount: CosmosDecimal::from(1u64),
-            denom: CosmosDenom::from_str("unym").unwrap(),
+    fn dec_value_scale_up() {
+        let dec = DecCoin {
+            denom: "foo".to_string(),
+            amount: "1234.56".parse().unwrap(),
         };
-        let c = MajorCurrencyAmount::from(cosmos_coin);
-        assert_eq!(c, MajorCurrencyAmount::new("0.000001", CurrencyDenom::Nym));
-    }
 
-    #[test]
-    fn minor_cosmwasm_coin_to_major_currency() {
-        let coin = CosmWasmCoin {
-            amount: Uint128::from(1u64),
-            denom: "unym".to_string(),
-        };
-        println!(
-            "from_atomics = {}",
-            CosmWasmDecimal::from_atomics(coin.amount, 6).unwrap()
+        assert_eq!(
+            "1234.56".parse::<Decimal>().unwrap(),
+            dec.try_scale_up_value(0).unwrap()
         );
-        let c: MajorCurrencyAmount = coin.into();
-        assert_eq!(c, MajorCurrencyAmount::new("0.000001", CurrencyDenom::Nym));
-    }
-
-    #[test]
-    fn minor_cosmwasm_coin_to_major_currency_2() {
-        let coin = CosmWasmCoin {
-            amount: Uint128::from(1_000_000u64),
-            denom: "unym".to_string(),
-        };
-        println!(
-            "from_atomics = {:?}",
-            CosmWasmDecimal::from_atomics(coin.amount, 6)
-                .unwrap()
-                .to_string()
+        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 c: MajorCurrencyAmount = coin.into();
-        assert_eq!(c, MajorCurrencyAmount::new("1", CurrencyDenom::Nym));
-    }
 
-    #[test]
-    fn major_currency_to_minor_cosmos_coin() {
-        let expected_cosmos_coin = CosmosCoin {
-            amount: CosmosDecimal::from(1u64),
-            denom: CosmosDenom::from_str("unym").unwrap(),
+        let dec = DecCoin {
+            denom: "foo".to_string(),
+            amount: "0.00000123".parse().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());
+
+        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()
+        );
     }
 
     #[test]
-    fn major_currency_to_minor_cosmos_coin_2() {
-        let expected_cosmos_coin = CosmosCoin {
-            amount: CosmosDecimal::from(1000000u64),
-            denom: CosmosDenom::from_str("unym").unwrap(),
+    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(),
         };
-        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());
+        let coin = Coin::try_from(dec.clone()).unwrap();
+        assert_eq!(dec.denom, coin.denom);
+        assert_eq!(coin.amount, 123u128);
     }
 
     #[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");
+    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());
+        }
     }
 
     #[test]
-    fn denom_to_string() {
-        let c = MajorCurrencyAmount::new("1", CurrencyDenom::Nym);
-        let denom = c.denom.to_string();
-        assert_eq!(denom, "NYM".to_string());
+    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"),
+        ];
+
+        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);
+        }
     }
 }

common/types/src/delegation.rs

@@ -1,13 +1,10 @@
-use schemars::JsonSchema;
-use serde::{Deserialize, Serialize};
-
-use log::error;
+use crate::currency::{DecCoin, RegisteredCoins};
+use crate::error::TypesError;
 use mixnet_contract_common::mixnode::DelegationEvent as ContractDelegationEvent;
 use mixnet_contract_common::mixnode::PendingUndelegate as ContractPendingUndelegate;
 use mixnet_contract_common::Delegation as MixnetContractDelegation;
-
-use crate::currency::MajorCurrencyAmount;
-use crate::error::TypesError;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
 
 #[cfg_attr(feature = "generate-ts", derive(ts_rs::TS))]
 #[cfg_attr(
@@ -18,31 +15,22 @@ use crate::error::TypesError;
 pub struct Delegation {
     pub owner: String,
     pub node_identity: String,
-    pub amount: MajorCurrencyAmount,
+    pub amount: DecCoin,
     pub block_height: u64,
     pub proxy: Option<String>, // proxy address used to delegate the funds on behalf of another address
 }
 
-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();
-
+impl Delegation {
+    pub fn from_mixnet_contract(
+        delegation: MixnetContractDelegation,
+        reg: &RegisteredCoins,
+    ) -> Result<Self, TypesError> {
         Ok(Delegation {
-            owner: owner.into_string(),
-            node_identity,
-            amount,
-            block_height,
-            proxy: proxy.map(|p| p.into_string()),
+            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()),
         })
     }
 }
@@ -54,7 +42,7 @@ impl TryFrom<MixnetContractDelegation> for Delegation {
 )]
 #[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq, JsonSchema)]
 pub struct DelegationRecord {
-    pub amount: MajorCurrencyAmount,
+    pub amount: DecCoin,
     pub block_height: u64,
     pub delegated_on_iso_datetime: String,
     pub uses_vesting_contract_tokens: bool,
@@ -69,16 +57,16 @@ pub struct DelegationRecord {
 pub struct DelegationWithEverything {
     pub owner: String,
     pub node_identity: String,
-    pub amount: MajorCurrencyAmount,
-    pub total_delegation: Option<MajorCurrencyAmount>,
-    pub pledge_amount: Option<MajorCurrencyAmount>,
+    pub amount: DecCoin,
+    pub total_delegation: Option<DecCoin>,
+    pub pledge_amount: Option<DecCoin>,
     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<MajorCurrencyAmount>,
+    pub accumulated_rewards: Option<DecCoin>,
     pub pending_events: Vec<DelegationEvent>,
     pub history: Vec<DelegationRecord>,
 }
@@ -92,34 +80,7 @@ pub struct DelegationWithEverything {
 pub struct DelegationResult {
     source_address: String,
     target_address: String,
-    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),
-        })
-    }
+    amount: Option<DecCoin>,
 }
 
 #[cfg_attr(feature = "generate-ts", derive(ts_rs::TS))]
@@ -143,36 +104,34 @@ pub struct DelegationEvent {
     pub kind: DelegationEventKind,
     pub node_identity: String,
     pub address: String,
-    pub amount: Option<MajorCurrencyAmount>,
+    pub amount: Option<DecCoin>,
     pub block_height: u64,
     pub proxy: Option<String>,
 }
 
-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 {
+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 {
                 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()),
-            }),
-        }
+            },
+        })
     }
 }
 
@@ -200,30 +159,6 @@ 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",
@@ -232,6 +167,6 @@ pub fn from_contract_delegation_events(
 #[derive(Deserialize, Serialize)]
 pub struct DelegationsSummaryResponse {
     pub delegations: Vec<DelegationWithEverything>,
-    pub total_delegations: MajorCurrencyAmount,
-    pub total_rewards: MajorCurrencyAmount,
+    pub total_delegations: DecCoin,
+    pub total_rewards: DecCoin,
 }

common/types/src/error.rs

@@ -4,6 +4,7 @@ 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}")]
@@ -63,6 +64,12 @@ 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::MajorCurrencyAmount;
+use crate::currency::DecCoin;
 use serde::{Deserialize, Serialize};
 use validator_client::nymd::Fee;
 
@@ -8,10 +8,16 @@ 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<MajorCurrencyAmount>,
+    pub amount: Option<DecCoin>,
     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");
@@ -25,13 +31,12 @@ impl TS for FeeDetails {
     }
 
     fn inline() -> String {
-        "{ amount: MajorCurrencyAmount | null, fee: Fee }".into()
+        "{ amount: DecCoin | null, fee: Fee }".into()
     }
 
     fn dependencies() -> Vec<Dependency> {
         vec![
-            Dependency::from_ty::<MajorCurrencyAmount>()
-                .expect("TS was incorrectly defined on `CurrencyDenom`"),
+            Dependency::from_ty::<DecCoin>().expect("TS was incorrectly defined on `DecCoin`"),
             Dependency::from_ty::<ts_type_helpers::Fee>()
                 .expect("TS was incorrectly defined on `ts_type_helpers::Fee`"),
         ]

common/types/src/gas.rs

@@ -1,48 +1,29 @@
-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, Clone)]
+#[derive(Deserialize, Serialize, Copy, Clone, Debug)]
 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_cosmrs_gas(value: CosmrsGas, _denom_minor: &str) -> Result<Gas, TypesError> {
-        Ok(Gas {
-            gas_units: value.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) -> Gas {
+        Gas { gas_units: value }
     }
-    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)?,
-        // })
+}
+
+impl From<CosmrsGas> for Gas {
+    fn from(gas: CosmrsGas) -> Self {
+        Gas {
+            gas_units: gas.value(),
+        }
     }
 }
 
@@ -51,44 +32,29 @@ impl Gas {
     feature = "generate-ts",
     ts(export_to = "ts-packages/types/src/types/rust/GasInfo.ts")
 )]
-#[derive(Deserialize, Serialize, Debug)]
+#[derive(Deserialize, Serialize, Copy, Clone, Debug)]
 pub struct GasInfo {
     /// GasWanted is the maximum units of work we allow this tx to perform.
-    pub gas_wanted: u64,
+    pub gas_wanted: Gas,
 
     /// GasUsed is the amount of gas actually consumed.
-    pub gas_used: u64,
+    pub gas_used: Gas,
+}
 
-    /// gas units converted to fee as major coin amount
-    pub fee: MajorCurrencyAmount,
+impl From<ValidatorClientGasInfo> for GasInfo {
+    fn from(info: ValidatorClientGasInfo) -> Self {
+        GasInfo {
+            gas_wanted: info.gas_wanted.into(),
+            gas_used: info.gas_used.into(),
+        }
+    }
 }
 
 impl GasInfo {
-    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(),
-        })
+    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),
+        }
     }
 }

common/types/src/gateway.rs

@@ -1,4 +1,4 @@
-use crate::currency::MajorCurrencyAmount;
+use crate::currency::{DecCoin, RegisteredCoins};
 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: MajorCurrencyAmount,
+    pub pledge_amount: DecCoin,
     pub owner: String,
     pub block_height: u64,
     pub gateway: Gateway,
@@ -63,38 +63,15 @@ pub struct GatewayBond {
 
 impl GatewayBond {
     pub fn from_mixnet_contract_gateway_bond(
-        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();
-
+        bond: MixnetContractGatewayBond,
+        reg: &RegisteredCoins,
+    ) -> Result<GatewayBond, TypesError> {
         Ok(GatewayBond {
-            pledge_amount,
-            owner: owner.into_string(),
-            block_height,
-            gateway: gateway.into(),
-            proxy: proxy.map(|p| p.into_string()),
+            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()),
         })
     }
 }

common/types/src/mixnode.rs

@@ -1,11 +1,11 @@
-use crate::currency::MajorCurrencyAmount;
+use crate::currency::{DecCoin, RegisteredCoins};
 use crate::error::TypesError;
 use mixnet_contract_common::{
-    Coin as CosmWasmCoin, MixNode as MixnetContractMixNode,
-    MixNodeBond as MixnetContractMixNodeBond,
+    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,67 +58,39 @@ impl From<MixnetContractMixNode> for MixNode {
 )]
 #[derive(Clone, Debug, Deserialize, PartialEq, Eq, Serialize, JsonSchema)]
 pub struct MixNodeBond {
-    pub pledge_amount: MajorCurrencyAmount,
-    pub total_delegation: MajorCurrencyAmount,
+    pub pledge_amount: DecCoin,
+    pub total_delegation: DecCoin,
     pub owner: String,
     pub layer: String,
     pub block_height: u64,
     pub mix_node: MixNode,
     pub proxy: Option<String>,
-    pub accumulated_rewards: Option<MajorCurrencyAmount>,
+    pub accumulated_rewards: Option<DecCoin>,
 }
 
 impl MixNodeBond {
     pub fn from_mixnet_contract_mixnode_bond(
-        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());
-
+        bond: MixnetContractMixNodeBond,
+        reg: &RegisteredCoins,
+    ) -> Result<MixNodeBond, TypesError> {
+        let denom = bond.pledge_amount.denom.clone();
         Ok(MixNodeBond {
-            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,
+            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()?,
         })
     }
 }

common/types/src/transaction.rs

@@ -1,6 +1,6 @@
-use crate::currency::MajorCurrencyAmount;
+use crate::currency::DecCoin;
 use crate::error::TypesError;
-use crate::gas::GasInfo;
+use crate::gas::{Gas, GasInfo};
 use serde::{Deserialize, Serialize};
 use validator_client::nymd::cosmwasm_client::types::ExecuteResult;
 use validator_client::nymd::TxResponse;
@@ -15,31 +15,23 @@ pub struct SendTxResult {
     pub block_height: u64,
     pub code: u32,
     pub details: TransactionDetails,
-    pub gas_used: u64,
-    pub gas_wanted: u64,
+    pub gas_used: Gas,
+    pub gas_wanted: Gas,
     pub tx_hash: String,
-    // pub fee: MajorCurrencyAmount,
+    pub fee: Option<DecCoin>,
 }
 
 impl SendTxResult {
-    pub fn new(
-        t: TxResponse,
-        details: TransactionDetails,
-        _denom_minor: &str,
-    ) -> Result<SendTxResult, TypesError> {
-        Ok(SendTxResult {
+    pub fn new(t: TxResponse, details: TransactionDetails, fee: Option<DecCoin>) -> SendTxResult {
+        SendTxResult {
             block_height: t.height.value(),
             code: t.tx_result.code.value(),
             details,
-            gas_used: t.tx_result.gas_used.value(),
-            gas_wanted: t.tx_result.gas_wanted.value(),
+            gas_used: t.tx_result.gas_used.into(),
+            gas_wanted: t.tx_result.gas_wanted.into(),
             tx_hash: t.hash.to_string(),
-            // 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(),
-            // )?,
-        })
+            fee,
+        }
     }
 }
 
@@ -50,11 +42,21 @@ impl SendTxResult {
 )]
 #[derive(Deserialize, Serialize, Debug)]
 pub struct TransactionDetails {
-    pub amount: MajorCurrencyAmount,
+    pub amount: DecCoin,
     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",
@@ -66,18 +68,16 @@ pub struct TransactionExecuteResult {
     pub data_json: String,
     pub transaction_hash: String,
     pub gas_info: GasInfo,
-    pub fee: MajorCurrencyAmount,
+    pub fee: Option<DecCoin>,
 }
 
 impl TransactionExecuteResult {
     pub fn from_execute_result(
         value: ExecuteResult,
-        denom_minor: &str,
+        fee: Option<DecCoin>,
     ) -> 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,
+            gas_info: value.gas_info.into(),
             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,30 +97,24 @@ pub struct RpcTransactionResponse {
     pub tx_result_json: String,
     pub block_height: u64,
     pub transaction_hash: String,
-    pub gas_info: GasInfo,
-    // pub fee: MajorCurrencyAmount,
+    pub gas_used: Gas,
+    pub gas_wanted: Gas,
+    pub fee: Option<DecCoin>,
 }
 
 impl RpcTransactionResponse {
     pub fn from_tx_response(
-        value: &TxResponse,
-        denom_minor: &str,
+        t: &TxResponse,
+        fee: Option<DecCoin>,
     ) -> Result<RpcTransactionResponse, TypesError> {
         Ok(RpcTransactionResponse {
-            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(),
-            // )?,
+            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,
         })
     }
 }

common/types/src/vesting.rs

@@ -1,10 +1,10 @@
-use crate::currency::MajorCurrencyAmount;
+use crate::currency::{DecCoin, RegisteredCoins};
 use crate::error::TypesError;
 use serde::{Deserialize, Serialize};
-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;
+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;
 
 #[cfg_attr(feature = "generate-ts", derive(ts_rs::TS))]
 #[cfg_attr(
@@ -13,25 +13,19 @@ use vesting_contract_common::PledgeData as VestingPledgeData;
 )]
 #[derive(Serialize, Deserialize, Debug)]
 pub struct PledgeData {
-    pub amount: MajorCurrencyAmount,
+    pub amount: DecCoin,
     pub block_time: u64,
 }
 
-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()
+    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(),
+        })
     }
 }
 
@@ -42,20 +36,20 @@ impl PledgeData {
 )]
 #[derive(Serialize, Deserialize, Debug)]
 pub struct OriginalVestingResponse {
-    amount: MajorCurrencyAmount,
+    amount: DecCoin,
     number_of_periods: usize,
     period_duration: u64,
 }
 
-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(),
+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,
         })
     }
 }
@@ -71,24 +65,20 @@ pub struct VestingAccountInfo {
     staking_address: Option<String>,
     start_time: u64,
     periods: Vec<VestingPeriod>,
-    amount: MajorCurrencyAmount,
+    amount: DecCoin,
 }
 
-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 {
+impl VestingAccountInfo {
+    pub fn from_vesting_contract(
+        account: ContractVestingAccount,
+        reg: &RegisteredCoins,
+    ) -> Result<Self, TypesError> {
+        Ok(VestingAccountInfo {
             owner_address: account.owner_address().to_string(),
             staking_address: account.staking_address().map(|a| a.to_string()),
             start_time: account.start_time().seconds(),
-            periods,
-            amount,
+            periods: account.periods().into_iter().map(Into::into).collect(),
+            amount: reg.attempt_convert_to_display_dec_coin(account.coin.into())?,
         })
     }
 }
@@ -104,8 +94,8 @@ pub struct VestingPeriod {
     period_seconds: u64,
 }
 
-impl From<VestingVestingPeriod> for VestingPeriod {
-    fn from(period: VestingVestingPeriod) -> Self {
+impl From<ContractVestingPeriod> for VestingPeriod {
+    fn from(period: ContractVestingPeriod) -> 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,7 +1225,6 @@ 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)
@@ -1531,7 +1530,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 {
-    owner_address: Addr,
-    staking_address: Option<Addr>,
-    start_time: Timestamp,
-    periods: Vec<VestingPeriod>,
-    coin: Coin,
+    pub owner_address: Addr,
+    pub staking_address: Option<Addr>,
+    pub start_time: Timestamp,
+    pub periods: Vec<VestingPeriod>,
+    pub coin: Coin,
     storage_key: u32,
 }
 

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

@@ -1,14 +1,11 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-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};
+use serde::{Deserialize, Serialize};
+use std::fmt;
+use strum::EnumIter;
 
 #[allow(clippy::upper_case_acronyms)]
 #[cfg_attr(feature = "generate-ts", derive(ts_rs::TS))]
@@ -28,13 +25,11 @@ impl Network {
         self.to_string().to_lowercase()
     }
 
-    // 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 {
+    pub fn base_mix_denom(&self) -> &str {
         match self {
-            // 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(),
+            Network::QA => qa::MIX_DENOM.base,
+            Network::SANDBOX => sandbox::MIX_DENOM.base,
+            Network::MAINNET => mainnet::MIX_DENOM.base,
         }
     }
 

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

@@ -1,4 +1,5 @@
 use nym_types::error::TypesError;
+use nym_wallet_types::network::Network;
 use serde::{Serialize, Serializer};
 use std::io;
 use std::num::ParseIntError;
@@ -106,6 +107,10 @@ 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,9 +4,7 @@
 )]
 
 use mixnet_contract_common::{Gateway, MixNode};
-use std::sync::Arc;
 use tauri::Menu;
-use tokio::sync::RwLock;
 
 mod config;
 mod error;
@@ -24,7 +22,7 @@ use crate::operations::simulate;
 use crate::operations::validator_api;
 use crate::operations::vesting;
 
-use crate::state::State;
+use crate::state::WalletState;
 
 #[allow(clippy::too_many_lines)]
 fn main() {
@@ -32,7 +30,7 @@ fn main() {
     setup_logging();
 
     tauri::Builder::default()
-        .manage(Arc::new(RwLock::new(State::default())))
+        .manage(WalletState::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,20 +1,15 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use std::sync::Arc;
-
-use tokio::sync::RwLock;
-
+use crate::error::BackendError;
+use crate::state::WalletState;
 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<'_, Arc<RwLock<State>>>,
+    state: tauri::State<'_, WalletState>,
 ) -> Result<ValidatorUrls, BackendError> {
     let state = state.read().await;
     let urls: Vec<ValidatorUrl> = state.get_nymd_urls(network).collect();
@@ -24,7 +19,7 @@ pub async fn get_validator_nymd_urls(
 #[tauri::command]
 pub async fn get_validator_api_urls(
     network: WalletNetwork,
-    state: tauri::State<'_, Arc<RwLock<State>>>,
+    state: tauri::State<'_, WalletState>,
 ) -> Result<ValidatorUrls, BackendError> {
     let state = state.read().await;
     let urls: Vec<ValidatorUrl> = state.get_api_urls(network).collect();
@@ -35,7 +30,7 @@ pub async fn get_validator_api_urls(
 pub async fn select_validator_nymd_url(
     url: &str,
     network: WalletNetwork,
-    state: tauri::State<'_, Arc<RwLock<State>>>,
+    state: tauri::State<'_, WalletState>,
 ) -> Result<(), BackendError> {
     log::debug!("Selecting new validator nymd_url for {network}: {url}");
     state
@@ -49,7 +44,7 @@ pub async fn select_validator_nymd_url(
 pub async fn select_validator_api_url(
     url: &str,
     network: WalletNetwork,
-    state: tauri::State<'_, Arc<RwLock<State>>>,
+    state: tauri::State<'_, WalletState>,
 ) -> Result<(), BackendError> {
     log::debug!("Selecting new validator api_url for {network}: {url}");
     state.write().await.select_validator_api_url(url, network)?;
@@ -60,7 +55,7 @@ pub async fn select_validator_api_url(
 pub async fn add_validator(
     validator: Validator,
     network: WalletNetwork,
-    state: tauri::State<'_, Arc<RwLock<State>>>,
+    state: tauri::State<'_, WalletState>,
 ) -> Result<(), BackendError> {
     log::debug!("Add validator for {network}: {validator}");
     let url = validator.try_into()?;
@@ -72,7 +67,7 @@ pub async fn add_validator(
 pub async fn remove_validator(
     validator: Validator,
     network: WalletNetwork,
-    state: tauri::State<'_, Arc<RwLock<State>>>,
+    state: tauri::State<'_, WalletState>,
 ) -> Result<(), BackendError> {
     log::debug!("Remove validator for {network}: {validator}");
     let url = validator.try_into()?;
@@ -83,7 +78,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<'_, Arc<RwLock<State>>>,
+    state: tauri::State<'_, WalletState>,
 ) -> 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,8 +1,7 @@
 use crate::config::{Config, CUSTOM_SIMULATED_GAS_MULTIPLIER};
 use crate::error::BackendError;
 use crate::network_config;
-use crate::nymd_client;
-use crate::state::{State, WalletAccountIds};
+use crate::state::{WalletAccountIds, WalletState};
 use crate::wallet_storage::{self, DEFAULT_LOGIN_ID};
 use bip39::{Language, Mnemonic};
 use config::defaults::all::Network;
@@ -10,15 +9,11 @@ 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};
@@ -26,33 +21,30 @@ use validator_client::{nymd::SigningNymdClient, Client};
 #[tauri::command]
 pub async fn connect_with_mnemonic(
     mnemonic: String,
-    state: tauri::State<'_, Arc<RwLock<State>>>,
+    state: tauri::State<'_, WalletState>,
 ) -> 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<'_, 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
+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?
     {
-        Ok(Some(coin)) => {
-            let amount = MajorCurrencyAmount::from(coin);
-            let printable_balance = amount.to_string();
-            Ok(Balance {
-                amount,
-                printable_balance,
-            })
+        Some(coin) => {
+            let amount = guard.attempt_convert_to_display_dec_coin(coin)?;
+            Ok(Balance::new(amount))
         }
-        Ok(None) => Err(BackendError::NoBalance(
-            nymd_client!(state).address().to_string(),
-        )),
-        Err(e) => Err(BackendError::from(e)),
+        None => Err(BackendError::NoBalance(address.to_string())),
     }
 }
 
@@ -68,7 +60,7 @@ pub fn validate_mnemonic(mnemonic: &str) -> bool {
 
 #[tauri::command]
 pub async fn switch_network(
-    state: tauri::State<'_, Arc<RwLock<State>>>,
+    state: tauri::State<'_, WalletState>,
     network: WalletNetwork,
 ) -> Result<Account, BackendError> {
     let account = {
@@ -79,7 +71,7 @@ pub async fn switch_network(
         Account::new(
             client.nymd.mixnet_contract_address().to_string(),
             client.nymd.address().to_string(),
-            denom.try_into()?,
+            denom.into(),
         )
     };
 
@@ -90,7 +82,7 @@ pub async fn switch_network(
 }
 
 #[tauri::command]
-pub async fn logout(state: tauri::State<'_, Arc<RwLock<State>>>) -> Result<(), BackendError> {
+pub async fn logout(state: tauri::State<'_, WalletState>) -> Result<(), BackendError> {
     state.write().await.logout();
     Ok(())
 }
@@ -102,7 +94,7 @@ fn random_mnemonic() -> Mnemonic {
 
 async fn _connect_with_mnemonic(
     mnemonic: Mnemonic,
-    state: tauri::State<'_, Arc<RwLock<State>>>,
+    state: tauri::State<'_, WalletState>,
 ) -> Result<Account, BackendError> {
     {
         let mut w_state = state.write().await;
@@ -162,7 +154,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().try_into()?,
+            default_network.base_mix_denom().to_owned(),
         )),
         None => Err(BackendError::NetworkNotSupported(
             config::defaults::DEFAULT_NETWORK,
@@ -178,6 +170,7 @@ 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
@@ -328,7 +321,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<'_, Arc<RwLock<State>>>,
+    state: tauri::State<'_, WalletState>,
 ) -> Result<Account, BackendError> {
     log::info!("Signing in with password");
 
@@ -368,7 +361,7 @@ fn extract_first_mnemonic(
 pub async fn sign_in_with_password_and_account_id(
     account_id: &str,
     password: &str,
-    state: tauri::State<'_, Arc<RwLock<State>>>,
+    state: tauri::State<'_, WalletState>,
 ) -> Result<Account, BackendError> {
     log::info!("Signing in with password");
 
@@ -420,7 +413,7 @@ pub async fn add_account_for_password(
     mnemonic: &str,
     password: &str,
     account_id: &str,
-    state: tauri::State<'_, Arc<RwLock<State>>>,
+    state: tauri::State<'_, WalletState>,
 ) -> Result<AccountEntry, BackendError> {
     log::info!("Adding account for the current password: {account_id}");
     let mnemonic = Mnemonic::from_str(mnemonic)?;
@@ -462,7 +455,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<'_, Arc<RwLock<State>>>,
+    state: tauri::State<'_, WalletState>,
 ) -> Result<(), BackendError> {
     log::trace!("Set state with accounts:");
     let all_accounts: Vec<_> = stored_login
@@ -503,7 +496,7 @@ async fn set_state_with_all_accounts(
 pub async fn remove_account_for_password(
     password: &str,
     account_id: &str,
-    state: tauri::State<'_, Arc<RwLock<State>>>,
+    state: tauri::State<'_, WalletState>,
 ) -> Result<(), BackendError> {
     log::info!("Removing account: {account_id}");
     // Currently we only support a single, default, id in the wallet
@@ -534,7 +527,7 @@ fn derive_address(
 
 #[tauri::command]
 pub async fn list_accounts(
-    state: tauri::State<'_, Arc<RwLock<State>>>,
+    state: tauri::State<'_, WalletState>,
 ) -> Result<Vec<AccountEntry>, BackendError> {
     log::trace!("Listing accounts");
     let state = state.read().await;

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

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

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

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

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

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

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

@@ -1,46 +1,43 @@
 use crate::error::BackendError;
-use crate::nymd_client;
-use crate::state::State;
-use nym_types::currency::MajorCurrencyAmount;
+use crate::state::WalletState;
+use nym_types::currency::DecCoin;
 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: MajorCurrencyAmount,
+    amount: DecCoin,
     memo: String,
     fee: Option<Fee>,
-    state: tauri::State<'_, Arc<RwLock<State>>>,
+    state: tauri::State<'_, WalletState>,
 ) -> Result<SendTxResult, BackendError> {
-    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();
+    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());
     log::info!(
-        ">>> Send: amount = {}, minor_amount = {:?}, from = {}, to = {}, fee = {:?}",
+        ">>> Send: display_amount = {}, base_amount = {}, from = {}, to = {}, fee = {:?}",
         amount,
-        amount2,
+        amount_base,
         from_address,
-        address.as_ref(),
+        to_address,
         fee,
     );
-    let raw_res = nymd_client!(state)
-        .send(&address, vec![amount2], memo, fee)
+    let raw_res = guard
+        .current_client()?
+        .nymd
+        .send(&to_address, vec![amount_base], memo, fee)
         .await?;
     log::info!("<<< tx hash = {}", raw_res.hash.to_string());
     let res = SendTxResult::new(
         raw_res,
-        TransactionDetails {
-            from_address,
-            to_address: address.to_string(),
-            amount,
-        },
-        denom_minor.as_ref(),
-    )?;
+        TransactionDetails::new(amount, from_address, to_address.to_string()),
+        fee_amount,
+    );
     log::trace!("<<< {:?}", res);
     Ok(res)
 }

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

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

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

@@ -3,24 +3,22 @@
 
 use crate::error::BackendError;
 use crate::operations::simulate::FeeDetails;
-use crate::simulate::detailed_fee;
-use crate::state::State;
-use nym_types::currency::MajorCurrencyAmount;
+use crate::state::WalletState;
+use nym_types::currency::DecCoin;
 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: MajorCurrencyAmount,
-    state: tauri::State<'_, Arc<RwLock<State>>>,
+    amount: DecCoin,
+    state: tauri::State<'_, WalletState>,
 ) -> 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.into()];
+    let amount = vec![amount_base.into()];
 
     let client = guard.current_client()?;
     let from_address = client.nymd.address().clone();
@@ -33,5 +31,5 @@ pub async fn simulate_send(
     };
 
     let result = client.nymd.simulate(vec![msg]).await?;
-    Ok(detailed_fee(client, result))
+    guard.create_detailed_fee(result)
 }

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

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

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

@@ -3,29 +3,15 @@
 
 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, SimulateResponse};
-use validator_client::nymd::{
-    CosmosCoin, Fee, GasAdjustable, GasAdjustment, GasPrice, SigningNymdClient,
-};
-use validator_client::Client;
+use validator_client::nymd::cosmwasm_client::types::GasInfo;
+use validator_client::nymd::{CosmosCoin, Fee, GasAdjustable, GasAdjustment, GasPrice};
 
 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 {
@@ -50,24 +36,16 @@ impl SimulateResult {
         }
     }
 
-    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> {
+    pub(crate) fn adjusted_gas(&self) -> Option<Gas> {
         self.gas_info
             .map(|gas_info| gas_info.gas_used.adjust_gas(self.gas_adjustment))
     }
 
-    fn to_fee_amount(&self) -> Option<CosmosCoin> {
+    pub(crate) fn to_fee_amount(&self) -> Option<CosmosCoin> {
         self.adjusted_gas().map(|gas| &self.gas_price * gas)
     }
 
-    fn to_fee(&self) -> Fee {
+    pub(crate) 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,24 +3,21 @@
 
 use crate::error::BackendError;
 use crate::operations::simulate::FeeDetails;
-use crate::simulate::detailed_fee;
-use crate::State;
+use crate::WalletState;
 use mixnet_contract_common::IdentityKey;
 use mixnet_contract_common::{Gateway, MixNode};
-use nym_types::currency::MajorCurrencyAmount;
-use std::sync::Arc;
-use tokio::sync::RwLock;
+use nym_types::currency::DecCoin;
 use vesting_contract_common::ExecuteMsg;
 
 #[tauri::command]
 pub async fn simulate_vesting_bond_gateway(
     gateway: Gateway,
-    pledge: MajorCurrencyAmount,
+    pledge: DecCoin,
     owner_signature: String,
-    state: tauri::State<'_, Arc<RwLock<State>>>,
+    state: tauri::State<'_, WalletState>,
 ) -> Result<FeeDetails, BackendError> {
     let guard = state.read().await;
-    let pledge = pledge.into();
+    let pledge = guard.attempt_convert_to_base_coin(pledge)?;
 
     let client = guard.current_client()?;
     let vesting_contract = client.nymd.vesting_contract_address();
@@ -30,18 +27,18 @@ pub async fn simulate_vesting_bond_gateway(
         &ExecuteMsg::BondGateway {
             gateway,
             owner_signature,
-            amount: pledge,
+            amount: pledge.into(),
         },
         vec![],
     )?;
 
     let result = client.nymd.simulate(vec![msg]).await?;
-    Ok(detailed_fee(client, result))
+    guard.create_detailed_fee(result)
 }
 
 #[tauri::command]
 pub async fn simulate_vesting_unbond_gateway(
-    state: tauri::State<'_, Arc<RwLock<State>>>,
+    state: tauri::State<'_, WalletState>,
 ) -> Result<FeeDetails, BackendError> {
     let guard = state.read().await;
 
@@ -55,18 +52,18 @@ pub async fn simulate_vesting_unbond_gateway(
     )?;
 
     let result = client.nymd.simulate(vec![msg]).await?;
-    Ok(detailed_fee(client, result))
+    guard.create_detailed_fee(result)
 }
 
 #[tauri::command]
 pub async fn simulate_vesting_bond_mixnode(
     mixnode: MixNode,
     owner_signature: String,
-    pledge: MajorCurrencyAmount,
-    state: tauri::State<'_, Arc<RwLock<State>>>,
+    pledge: DecCoin,
+    state: tauri::State<'_, WalletState>,
 ) -> Result<FeeDetails, BackendError> {
     let guard = state.read().await;
-    let pledge = pledge.into();
+    let pledge = guard.attempt_convert_to_base_coin(pledge)?;
 
     let client = guard.current_client()?;
     let vesting_contract = client.nymd.vesting_contract_address();
@@ -76,18 +73,18 @@ pub async fn simulate_vesting_bond_mixnode(
         &ExecuteMsg::BondMixnode {
             mix_node: mixnode,
             owner_signature,
-            amount: pledge,
+            amount: pledge.into(),
         },
         vec![],
     )?;
 
     let result = client.nymd.simulate(vec![msg]).await?;
-    Ok(detailed_fee(client, result))
+    guard.create_detailed_fee(result)
 }
 
 #[tauri::command]
 pub async fn simulate_vesting_unbond_mixnode(
-    state: tauri::State<'_, Arc<RwLock<State>>>,
+    state: tauri::State<'_, WalletState>,
 ) -> Result<FeeDetails, BackendError> {
     let guard = state.read().await;
 
@@ -101,13 +98,13 @@ pub async fn simulate_vesting_unbond_mixnode(
     )?;
 
     let result = client.nymd.simulate(vec![msg]).await?;
-    Ok(detailed_fee(client, result))
+    guard.create_detailed_fee(result)
 }
 
 #[tauri::command]
 pub async fn simulate_vesting_update_mixnode(
     profit_margin_percent: u8,
-    state: tauri::State<'_, Arc<RwLock<State>>>,
+    state: tauri::State<'_, WalletState>,
 ) -> Result<FeeDetails, BackendError> {
     let guard = state.read().await;
 
@@ -123,17 +120,17 @@ pub async fn simulate_vesting_update_mixnode(
     )?;
 
     let result = client.nymd.simulate(vec![msg]).await?;
-    Ok(detailed_fee(client, result))
+    guard.create_detailed_fee(result)
 }
 
 #[tauri::command]
 pub async fn simulate_vesting_delegate_to_mixnode(
     identity: &str,
-    amount: MajorCurrencyAmount,
-    state: tauri::State<'_, Arc<RwLock<State>>>,
+    amount: DecCoin,
+    state: tauri::State<'_, WalletState>,
 ) -> Result<FeeDetails, BackendError> {
     let guard = state.read().await;
-    let amount = amount.into();
+    let amount = guard.attempt_convert_to_base_coin(amount)?.into();
 
     let client = guard.current_client()?;
     let vesting_contract = client.nymd.vesting_contract_address();
@@ -148,13 +145,13 @@ pub async fn simulate_vesting_delegate_to_mixnode(
     )?;
 
     let result = client.nymd.simulate(vec![msg]).await?;
-    Ok(detailed_fee(client, result))
+    guard.create_detailed_fee(result)
 }
 
 #[tauri::command]
 pub async fn simulate_vesting_undelegate_from_mixnode(
     identity: &str,
-    state: tauri::State<'_, Arc<RwLock<State>>>,
+    state: tauri::State<'_, WalletState>,
 ) -> Result<FeeDetails, BackendError> {
     let guard = state.read().await;
 
@@ -170,16 +167,16 @@ pub async fn simulate_vesting_undelegate_from_mixnode(
     )?;
 
     let result = client.nymd.simulate(vec![msg]).await?;
-    Ok(detailed_fee(client, result))
+    guard.create_detailed_fee(result)
 }
 
 #[tauri::command]
 pub async fn simulate_withdraw_vested_coins(
-    amount: MajorCurrencyAmount,
-    state: tauri::State<'_, Arc<RwLock<State>>>,
+    amount: DecCoin,
+    state: tauri::State<'_, WalletState>,
 ) -> Result<FeeDetails, BackendError> {
     let guard = state.read().await;
-    let amount = amount.into();
+    let amount = guard.attempt_convert_to_base_coin(amount)?.into();
 
     let client = guard.current_client()?;
     let vesting_contract = client.nymd.vesting_contract_address();
@@ -191,59 +188,63 @@ pub async fn simulate_withdraw_vested_coins(
     )?;
 
     let result = client.nymd.simulate(vec![msg]).await?;
-    Ok(detailed_fee(client, result))
+    guard.create_detailed_fee(result)
 }
 
 #[tauri::command]
 pub async fn simulate_vesting_claim_operator_reward(
-    state: tauri::State<'_, Arc<RwLock<State>>>,
+    state: tauri::State<'_, WalletState>,
 ) -> Result<FeeDetails, BackendError> {
     let guard = state.read().await;
     let client = guard.current_client()?;
+
     let result = client
         .nymd
         .simulate_vesting_claim_operator_reward(None)
         .await?;
-    Ok(detailed_fee(client, result))
+    guard.create_detailed_fee(result)
 }
 
 #[tauri::command]
 pub async fn simulate_vesting_compound_operator_reward(
-    state: tauri::State<'_, Arc<RwLock<State>>>,
+    state: tauri::State<'_, WalletState>,
 ) -> Result<FeeDetails, BackendError> {
     let guard = state.read().await;
     let client = guard.current_client()?;
+
     let result = client
         .nymd
         .simulate_vesting_compound_operator_reward(None)
         .await?;
-    Ok(detailed_fee(client, result))
+    guard.create_detailed_fee(result)
 }
 
 #[tauri::command]
 pub async fn simulate_vesting_claim_delegator_reward(
     mix_identity: IdentityKey,
-    state: tauri::State<'_, Arc<RwLock<State>>>,
+    state: tauri::State<'_, WalletState>,
 ) -> 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?;
-    Ok(detailed_fee(client, result))
+    guard.create_detailed_fee(result)
 }
 
 #[tauri::command]
 pub async fn simulate_vesting_compound_delegator_reward(
     mix_identity: IdentityKey,
-    state: tauri::State<'_, Arc<RwLock<State>>>,
+    state: tauri::State<'_, WalletState>,
 ) -> 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?;
-    Ok(detailed_fee(client, result))
+    guard.create_detailed_fee(result)
 }

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

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

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

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

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

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

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

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

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

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

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

@@ -1,20 +1,22 @@
 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(|| {
@@ -28,7 +30,7 @@ static METADATA_OVERRIDES: Lazy<Vec<(Url, ValidatorMetadata)>> = Lazy::new(|| {
 
 #[tauri::command]
 pub async fn load_config_from_files(
-    state: tauri::State<'_, Arc<RwLock<State>>>,
+    state: tauri::State<'_, WalletState>,
 ) -> Result<(), BackendError> {
     state.write().await.load_config_files();
     Ok(())
@@ -36,13 +38,30 @@ pub async fn load_config_from_files(
 
 #[tauri::command]
 pub async fn save_config_to_files(
-    state: tauri::State<'_, Arc<RwLock<State>>>,
+    state: tauri::State<'_, WalletState>,
 ) -> 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 State {
+pub struct WalletStateInner {
     config: config::Config,
     signing_clients: HashMap<Network, Client<SigningNymdClient>>,
     current_network: Network,
@@ -56,6 +75,7 @@ pub struct State {
 
     /// 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 {
@@ -65,7 +85,70 @@ pub(crate) struct WalletAccountIds {
     pub addresses: HashMap<Network, CosmosAccountId>,
 }
 
-impl State {
+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()))
+    }
+
     pub fn client(&self, network: Network) -> Result<&Client<SigningNymdClient>, BackendError> {
         self.signing_clients
             .get(&network)
@@ -112,6 +195,11 @@ impl State {
         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;
     }
@@ -390,7 +478,7 @@ mod tests {
 
     #[test]
     fn adding_validators_urls_prepends() {
-        let mut state = State::default();
+        let mut state = WalletStateInner::default();
         let _api_urls = state.get_api_urls(Network::MAINNET).collect::<Vec<_>>();
 
         state.add_validator_url(

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

@@ -1,11 +1,9 @@
 use crate::error::BackendError;
 use crate::nymd_client;
-use crate::state::State;
-use nym_types::currency::MajorCurrencyAmount;
+use crate::state::WalletState;
+use nym_types::currency::DecCoin;
 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> {
@@ -25,9 +23,7 @@ pub fn get_env() -> AppEnv {
 }
 
 #[tauri::command]
-pub async fn owns_mixnode(
-    state: tauri::State<'_, Arc<RwLock<State>>>,
-) -> Result<bool, BackendError> {
+pub async fn owns_mixnode(state: tauri::State<'_, WalletState>) -> Result<bool, BackendError> {
     Ok(nymd_client!(state)
         .owns_mixnode(nymd_client!(state).address())
         .await?
@@ -35,9 +31,7 @@ pub async fn owns_mixnode(
 }
 
 #[tauri::command]
-pub async fn owns_gateway(
-    state: tauri::State<'_, Arc<RwLock<State>>>,
-) -> Result<bool, BackendError> {
+pub async fn owns_gateway(state: tauri::State<'_, WalletState>) -> Result<bool, BackendError> {
     Ok(nymd_client!(state)
         .owns_gateway(nymd_client!(state).address())
         .await?
@@ -145,13 +139,14 @@ impl Operation {
 
 #[tauri::command]
 pub async fn get_old_and_incorrect_hardcoded_fee(
-    state: tauri::State<'_, Arc<RwLock<State>>>,
+    state: tauri::State<'_, WalletState>,
     operation: Operation,
-) -> Result<MajorCurrencyAmount, BackendError> {
-    let mut approximate_fee = operation.default_fee(nymd_client!(state).gas_price());
+) -> Result<DecCoin, BackendError> {
+    let guard = state.read().await;
+    let mut approximate_fee = operation.default_fee(guard.current_client()?.nymd.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);
-    Ok(coin.into())
+    guard.attempt_convert_to_display_dec_coin(coin)
 }

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, MajorAmountString, MajorCurrencyAmount};
+use nym_types::currency::{CurrencyDenom, DecCoin};
 use nym_types::delegation::{
     Delegation, DelegationEvent, DelegationEventKind, DelegationRecord, DelegationResult,
     DelegationWithEverything, DelegationsSummaryResponse, PendingUndelegate,
@@ -59,7 +59,6 @@ fn main() {
     do_export!(AccountEntry);
     do_export!(AccountWithMnemonic);
     do_export!(Balance);
-    do_export!(CurrencyDenom);
     do_export!(Delegation);
     do_export!(DelegationEvent);
     do_export!(DelegationEventKind);
@@ -77,8 +76,8 @@ fn main() {
     do_export!(GasInfo);
     do_export!(Gateway);
     do_export!(GatewayBond);
-    do_export!(MajorAmountString);
-    do_export!(MajorCurrencyAmount);
+    do_export!(CurrencyDenom);
+    do_export!(DecCoin);
     do_export!(MixNode);
     do_export!(MixNodeBond);
     do_export!(OriginalVestingResponse);

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

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

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

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

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

@@ -1,6 +1,3 @@
-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,6 +1,3 @@
-import type { MajorCurrencyAmount } from './Currency';
+import type { DecCoin } from "./DecCoin";
 
-export interface Balance {
-  amount: MajorCurrencyAmount;
-  printable_balance: string;
-}
+export interface Balance { amount: DecCoin, printable_balance: string, }

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

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

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

@@ -1,7 +0,0 @@
-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 +1,2 @@
-export type CurrencyDenom = 'NYM' | 'NYMT' | 'NYX' | 'NYXT';
+
+export type CurrencyDenom = "nym" | "nymt" | "nyx" | "nyxt";

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,20 +1,20 @@
-import type { DelegationEvent } from './DelegationEvent';
-import type { DelegationRecord } from './DelegationRecord';
-import type { MajorCurrencyAmount } from './Currency';
+import type { DecCoin } from "./DecCoin";
+import type { DelegationEvent } from "./DelegationEvent";
+import type { DelegationRecord } from "./DelegationRecord";
 
 export interface DelegationWithEverything {
   owner: string;
   node_identity: string;
-  amount: MajorCurrencyAmount;
-  total_delegation: MajorCurrencyAmount | null;
-  pledge_amount: MajorCurrencyAmount | null;
+  amount: DecCoin;
+  total_delegation: DecCoin | null;
+  pledge_amount: DecCoin | 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: MajorCurrencyAmount | null;
+  accumulated_rewards: DecCoin | 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 { MajorCurrencyAmount } from './Currency';
+import type { DecCoin } from "./DecCoin";
 
-export type FeeDetails = { amount: MajorCurrencyAmount | null; fee: Fee };
+export type FeeDetails = { amount: DecCoin | null; fee: Fee };

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

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

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

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

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

@@ -1,6 +1,3 @@
-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,13 +1,4 @@
-import type { MajorCurrencyAmount } from './Currency';
-import type { MixNode } from './Mixnode';
+import type { DecCoin } from "./DecCoin";
+import type { MixNode } from "./Mixnode";
 
-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;
-}
+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, }

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

@@ -1 +1,2 @@
-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,5 +1,3 @@
-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,7 +1,3 @@
-import type { MajorCurrencyAmount } from './Currency';
+import type { DecCoin } from "./DecCoin";
 
-export interface OriginalVestingResponse {
-  amount: MajorCurrencyAmount;
-  number_of_periods: number;
-  period_duration: bigint;
-}
+export interface OriginalVestingResponse { amount: DecCoin, number_of_periods: number, period_duration: bigint, }

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

@@ -1,6 +1,2 @@
-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 +1,2 @@
-export type Period = 'Before' | { In: number } | 'After';
+
+export type Period = "Before" | { In: number } | "After";

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

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

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

@@ -1,3 +1,5 @@
+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 +1,2 @@
-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,4 +1,2 @@
-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,7 +1,3 @@
-import type { MajorCurrencyAmount } from './Currency';
+import type { DecCoin } from "./DecCoin";
 
-export interface TransactionDetails {
-  amount: MajorCurrencyAmount;
-  from_address: string;
-  to_address: string;
-}
+export interface TransactionDetails { amount: DecCoin, from_address: string, to_address: string, }

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

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

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

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

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

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