GRIN/nym
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Removed explicit Arc and RwLock from all tauri commands

Browse Source
This commit is contained in:
Jędrzej Stuczyński
2022-06-06 17:51:45 +01:00
parent 8300daa117
commit 2bcdc4c3d0
20 changed files with 147 additions and 180 deletions
Download Patch File Download Diff File Expand all files Collapse all files
nym-wallet/src-tauri/src/main.rs
+2 -4
View File
@@ -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,14 +22,14 @@ use crate::operations::simulate;
use crate::operations::validator_api;
use crate::operations::vesting;
use crate::state::State;
use crate::state::WalletState;
fn main() {
dotenv::dotenv().ok();
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::connect_with_mnemonic,
nym-wallet/src-tauri/src/network_config.rs
+9 -14
View File
@@ -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
+12 -16
View File
@@ -1,7 +1,7 @@
use crate::config::{Config, CUSTOM_SIMULATED_GAS_MULTIPLIER};
use crate::error::BackendError;
use crate::network_config;
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;
@@ -13,9 +13,7 @@ use nym_wallet_types::network::Network as WalletNetwork;
use rand::seq::SliceRandom;
use std::collections::HashMap;
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};
@@ -23,16 +21,14 @@ 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> {
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();
@@ -64,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 = {
@@ -86,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(())
}
@@ -98,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;
@@ -319,7 +315,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");
@@ -359,7 +355,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");
@@ -406,7 +402,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)?;
@@ -448,7 +444,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
@@ -489,7 +485,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
@@ -520,7 +516,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
+7 -12
View File
@@ -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
+9 -11
View File
@@ -1,12 +1,10 @@
use crate::error::BackendError;
use crate::state::State;
use crate::state::WalletState;
use crate::{Gateway, MixNode};
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::{Coin, Fee};
#[tauri::command]
@@ -15,7 +13,7 @@ pub async fn bond_gateway(
pledge: DecCoin,
owner_signature: String,
fee: Option<Fee>,
state: tauri::State<'_, Arc<RwLock<State>>>,
state: tauri::State<'_, WalletState>,
) -> Result<TransactionExecuteResult, BackendError> {
let guard = state.read().await;
let pledge_base = guard.attempt_convert_to_base_coin(pledge.clone())?;
@@ -43,7 +41,7 @@ pub async fn bond_gateway(
#[tauri::command]
pub async fn unbond_gateway(
fee: Option<Fee>,
state: tauri::State<'_, Arc<RwLock<State>>>,
state: tauri::State<'_, WalletState>,
) -> Result<TransactionExecuteResult, BackendError> {
let guard = state.read().await;
let fee_amount = guard.convert_tx_fee(fee.as_ref());
@@ -62,7 +60,7 @@ pub async fn bond_mixnode(
owner_signature: String,
pledge: DecCoin,
fee: Option<Fee>,
state: tauri::State<'_, Arc<RwLock<State>>>,
state: tauri::State<'_, WalletState>,
) -> Result<TransactionExecuteResult, BackendError> {
let guard = state.read().await;
let pledge_base = guard.attempt_convert_to_base_coin(pledge.clone())?;
@@ -90,7 +88,7 @@ pub async fn bond_mixnode(
#[tauri::command]
pub async fn unbond_mixnode(
fee: Option<Fee>,
state: tauri::State<'_, Arc<RwLock<State>>>,
state: tauri::State<'_, WalletState>,
) -> Result<TransactionExecuteResult, BackendError> {
let guard = state.read().await;
let fee_amount = guard.convert_tx_fee(fee.as_ref());
@@ -107,7 +105,7 @@ 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 guard = state.read().await;
let fee_amount = guard.convert_tx_fee(fee.as_ref());
@@ -130,7 +128,7 @@ pub async fn update_mixnode(
#[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;
@@ -154,7 +152,7 @@ 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;
@@ -180,7 +178,7 @@ pub async fn gateway_bond_details(
#[tauri::command]
pub async fn get_operator_rewards(
address: String,
state: tauri::State<'_, Arc<RwLock<State>>>,
state: tauri::State<'_, WalletState>,
) -> Result<DecCoin, BackendError> {
log::info!(">>> Get operator rewards for {}", address);
let guard = state.read().await;
nym-wallet/src-tauri/src/operations/mixnet/delegate.rs
+8 -10
View File
@@ -1,5 +1,5 @@
use crate::error::BackendError;
use crate::state::State;
use crate::state::WalletState;
use crate::vesting::delegate::get_pending_vesting_delegation_events;
use crate::{api_client, nymd_client};
use mixnet_contract_common::IdentityKey;
@@ -10,13 +10,11 @@ use nym_types::delegation::{
};
use nym_types::transaction::TransactionExecuteResult;
use std::collections::HashMap;
use std::sync::Arc;
use tokio::sync::RwLock;
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 guard = state.read().await;
@@ -41,7 +39,7 @@ pub async fn delegate_to_mixnode(
identity: &str,
amount: DecCoin,
fee: Option<Fee>,
state: tauri::State<'_, Arc<RwLock<State>>>,
state: tauri::State<'_, WalletState>,
) -> Result<TransactionExecuteResult, BackendError> {
let guard = state.read().await;
let delegation_base = guard.attempt_convert_to_base_coin(amount.clone())?;
@@ -68,7 +66,7 @@ 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 guard = state.read().await;
let fee_amount = guard.convert_tx_fee(fee.as_ref());
@@ -98,7 +96,7 @@ struct DelegationWithHistory {
#[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");
@@ -319,7 +317,7 @@ pub async fn get_delegator_rewards(
address: String,
mix_identity: IdentityKey,
proxy: Option<String>,
state: tauri::State<'_, Arc<RwLock<State>>>,
state: tauri::State<'_, WalletState>,
) -> Result<DecCoin, BackendError> {
log::info!(
">>> Get delegator rewards: mix_identity = {}, proxy = {:?}",
@@ -347,7 +345,7 @@ pub async fn get_delegator_rewards(
#[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");
@@ -384,7 +382,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
+2 -4
View File
@@ -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
+5 -7
View File
@@ -1,15 +1,13 @@
use crate::error::BackendError;
use crate::nymd_client;
use crate::state::State;
use crate::state::WalletState;
use mixnet_contract_common::IdentityKey;
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<(), BackendError> {
nymd_client!(state)
.execute_claim_operator_reward(fee)
@@ -20,7 +18,7 @@ pub async fn claim_operator_reward(
#[tauri::command]
pub async fn compound_operator_reward(
fee: Option<Fee>,
state: tauri::State<'_, Arc<RwLock<State>>>,
state: tauri::State<'_, WalletState>,
) -> Result<(), BackendError> {
nymd_client!(state)
.execute_compound_operator_reward(fee)
@@ -32,7 +30,7 @@ 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<(), BackendError> {
nymd_client!(state)
.execute_claim_delegator_reward(mix_identity, fee)
@@ -44,7 +42,7 @@ 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<(), BackendError> {
nymd_client!(state)
.execute_compound_delegator_reward(mix_identity, fee)
nym-wallet/src-tauri/src/operations/mixnet/send.rs
+2 -4
View File
@@ -1,10 +1,8 @@
use crate::error::BackendError;
use crate::state::State;
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]
@@ -13,7 +11,7 @@ pub async fn send(
amount: DecCoin,
memo: String,
fee: Option<Fee>,
state: tauri::State<'_, Arc<RwLock<State>>>,
state: tauri::State<'_, WalletState>,
) -> Result<SendTxResult, BackendError> {
let guard = state.read().await;
let amount_base = guard.attempt_convert_to_base_coin(amount.clone())?;
nym-wallet/src-tauri/src/operations/simulate/admin.rs
+2 -4
View File
@@ -3,16 +3,14 @@
use crate::error::BackendError;
use crate::operations::simulate::{FeeDetails, SimulateResult};
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()?;
nym-wallet/src-tauri/src/operations/simulate/cosmos.rs
+2 -4
View File
@@ -3,18 +3,16 @@
use crate::error::BackendError;
use crate::operations::simulate::{FeeDetails, SimulateResult};
use crate::state::State;
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: DecCoin,
state: tauri::State<'_, Arc<RwLock<State>>>,
state: tauri::State<'_, WalletState>,
) -> Result<FeeDetails, BackendError> {
let guard = state.read().await;
let amount_base = guard.attempt_convert_to_base_coin(amount.clone())?;
nym-wallet/src-tauri/src/operations/simulate/mixnet.rs
+12 -14
View File
@@ -3,19 +3,17 @@
use crate::error::BackendError;
use crate::operations::simulate::{FeeDetails, SimulateResult};
use crate::State;
use crate::WalletState;
use mixnet_contract_common::IdentityKey;
use mixnet_contract_common::{ExecuteMsg, Gateway, MixNode};
use nym_types::currency::DecCoin;
use std::sync::Arc;
use tokio::sync::RwLock;
#[tauri::command]
pub async fn simulate_bond_gateway(
gateway: Gateway,
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 = guard.attempt_convert_to_base_coin(pledge)?;
@@ -40,7 +38,7 @@ pub async fn simulate_bond_gateway(
#[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;
@@ -63,7 +61,7 @@ pub async fn simulate_bond_mixnode(
mixnode: MixNode,
owner_signature: String,
pledge: DecCoin,
state: tauri::State<'_, Arc<RwLock<State>>>,
state: tauri::State<'_, WalletState>,
) -> Result<FeeDetails, BackendError> {
let guard = state.read().await;
let pledge = guard.attempt_convert_to_base_coin(pledge)?;
@@ -87,7 +85,7 @@ pub async fn simulate_bond_mixnode(
#[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;
@@ -108,7 +106,7 @@ pub async fn simulate_unbond_mixnode(
#[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;
@@ -132,7 +130,7 @@ pub async fn simulate_update_mixnode(
pub async fn simulate_delegate_to_mixnode(
identity: &str,
amount: DecCoin,
state: tauri::State<'_, Arc<RwLock<State>>>,
state: tauri::State<'_, WalletState>,
) -> Result<FeeDetails, BackendError> {
let guard = state.read().await;
let delegation = guard.attempt_convert_to_base_coin(amount)?;
@@ -156,7 +154,7 @@ pub async fn simulate_delegate_to_mixnode(
#[tauri::command]
pub async fn simulate_undelegate_from_mixnode(
identity: &str,
state: tauri::State<'_, Arc<RwLock<State>>>,
state: tauri::State<'_, WalletState>,
) -> Result<FeeDetails, BackendError> {
let guard = state.read().await;
@@ -178,7 +176,7 @@ pub async fn simulate_undelegate_from_mixnode(
#[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()?;
@@ -190,7 +188,7 @@ pub async fn simulate_claim_operator_reward(
#[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()?;
@@ -203,7 +201,7 @@ pub async fn simulate_compound_operator_reward(
#[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()?;
@@ -219,7 +217,7 @@ pub async fn simulate_claim_delegator_reward(
#[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()?;
nym-wallet/src-tauri/src/operations/simulate/vesting.rs
+11 -13
View File
@@ -3,12 +3,10 @@
use crate::error::BackendError;
use crate::operations::simulate::{FeeDetails, SimulateResult};
use crate::State;
use crate::WalletState;
use mixnet_contract_common::IdentityKey;
use mixnet_contract_common::{Gateway, MixNode};
use nym_types::currency::DecCoin;
use std::sync::Arc;
use tokio::sync::RwLock;
use vesting_contract_common::ExecuteMsg;
#[tauri::command]
@@ -16,7 +14,7 @@ pub async fn simulate_vesting_bond_gateway(
gateway: Gateway,
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 = guard.attempt_convert_to_base_coin(pledge)?;
@@ -41,7 +39,7 @@ pub async fn simulate_vesting_bond_gateway(
#[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;
@@ -64,7 +62,7 @@ pub async fn simulate_vesting_bond_mixnode(
mixnode: MixNode,
owner_signature: String,
pledge: DecCoin,
state: tauri::State<'_, Arc<RwLock<State>>>,
state: tauri::State<'_, WalletState>,
) -> Result<FeeDetails, BackendError> {
let guard = state.read().await;
let pledge = guard.attempt_convert_to_base_coin(pledge)?;
@@ -89,7 +87,7 @@ pub async fn simulate_vesting_bond_mixnode(
#[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;
@@ -110,7 +108,7 @@ pub async fn simulate_vesting_unbond_mixnode(
#[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;
@@ -133,7 +131,7 @@ pub async fn simulate_vesting_update_mixnode(
#[tauri::command]
pub async fn simulate_withdraw_vested_coins(
amount: DecCoin,
state: tauri::State<'_, Arc<RwLock<State>>>,
state: tauri::State<'_, WalletState>,
) -> Result<FeeDetails, BackendError> {
let guard = state.read().await;
let amount = guard.attempt_convert_to_base_coin(amount)?.into();
@@ -154,7 +152,7 @@ pub async fn simulate_withdraw_vested_coins(
#[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()?;
@@ -169,7 +167,7 @@ pub async fn simulate_vesting_claim_operator_reward(
#[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()?;
@@ -185,7 +183,7 @@ pub async fn simulate_vesting_compound_operator_reward(
#[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()?;
@@ -201,7 +199,7 @@ pub async fn simulate_vesting_claim_delegator_reward(
#[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()?;
nym-wallet/src-tauri/src/operations/validator_api/status.rs
+7 -9
View File
@@ -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
+7 -9
View File
@@ -1,12 +1,10 @@
use crate::error::BackendError;
use crate::nymd_client;
use crate::state::State;
use crate::state::WalletState;
use crate::{Gateway, MixNode};
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]
@@ -15,7 +13,7 @@ pub async fn vesting_bond_gateway(
pledge: DecCoin,
owner_signature: String,
fee: Option<Fee>,
state: tauri::State<'_, Arc<RwLock<State>>>,
state: tauri::State<'_, WalletState>,
) -> Result<TransactionExecuteResult, BackendError> {
let guard = state.read().await;
let pledge_base = guard.attempt_convert_to_base_coin(pledge.clone())?;
@@ -43,7 +41,7 @@ pub async fn vesting_bond_gateway(
#[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 guard = state.read().await;
let fee_amount = guard.convert_tx_fee(fee.as_ref());
@@ -65,7 +63,7 @@ pub async fn vesting_bond_mixnode(
owner_signature: String,
pledge: DecCoin,
fee: Option<Fee>,
state: tauri::State<'_, Arc<RwLock<State>>>,
state: tauri::State<'_, WalletState>,
) -> Result<TransactionExecuteResult, BackendError> {
let guard = state.read().await;
let pledge_base = guard.attempt_convert_to_base_coin(pledge.clone())?;
@@ -93,7 +91,7 @@ pub async fn vesting_bond_mixnode(
#[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 guard = state.read().await;
let fee_amount = guard.convert_tx_fee(fee.as_ref());
@@ -117,7 +115,7 @@ pub async fn vesting_unbond_mixnode(
pub async fn withdraw_vested_coins(
amount: DecCoin,
fee: Option<Fee>,
state: tauri::State<'_, Arc<RwLock<State>>>,
state: tauri::State<'_, WalletState>,
) -> Result<TransactionExecuteResult, BackendError> {
let guard = state.read().await;
let amount_base = guard.attempt_convert_to_base_coin(amount.clone())?;
@@ -145,7 +143,7 @@ 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 guard = state.read().await;
let fee_amount = guard.convert_tx_fee(fee.as_ref());
nym-wallet/src-tauri/src/operations/vesting/delegate.rs
+4 -6
View File
@@ -1,15 +1,13 @@
use crate::error::BackendError;
use crate::state::State;
use crate::state::WalletState;
use nym_types::currency::DecCoin;
use nym_types::delegation::DelegationEvent;
use nym_types::transaction::TransactionExecuteResult;
use std::sync::Arc;
use tokio::sync::RwLock;
use validator_client::nymd::{Fee, VestingSigningClient};
#[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");
@@ -39,7 +37,7 @@ pub async fn vesting_delegate_to_mixnode(
identity: &str,
amount: DecCoin,
fee: Option<Fee>,
state: tauri::State<'_, Arc<RwLock<State>>>,
state: tauri::State<'_, WalletState>,
) -> Result<TransactionExecuteResult, BackendError> {
let guard = state.read().await;
let delegation = guard.attempt_convert_to_base_coin(amount.clone())?;
@@ -68,7 +66,7 @@ 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 guard = state.read().await;
let fee_amount = guard.convert_tx_fee(fee.as_ref());
nym-wallet/src-tauri/src/operations/vesting/queries.rs
+14 -16
View File
@@ -1,19 +1,17 @@
use crate::error::BackendError;
use crate::nymd_client;
use crate::state::State;
use crate::state::WalletState;
use cosmwasm_std::Timestamp;
use nym_types::currency::DecCoin;
use nym_types::vesting::VestingAccountInfo;
use nym_types::vesting::{OriginalVestingResponse, PledgeData};
use std::sync::Arc;
use tokio::sync::RwLock;
use validator_client::nymd::VestingQueryClient;
use vesting_contract_common::Period;
#[tauri::command]
pub async fn locked_coins(
block_time: Option<u64>,
state: tauri::State<'_, Arc<RwLock<State>>>,
state: tauri::State<'_, WalletState>,
) -> Result<DecCoin, BackendError> {
log::info!(">>> Query locked coins");
let guard = state.read().await;
@@ -34,7 +32,7 @@ pub async fn locked_coins(
#[tauri::command]
pub async fn spendable_coins(
block_time: Option<u64>,
state: tauri::State<'_, Arc<RwLock<State>>>,
state: tauri::State<'_, WalletState>,
) -> Result<DecCoin, BackendError> {
log::info!(">>> Query spendable coins");
let guard = state.read().await;
@@ -57,7 +55,7 @@ pub async fn spendable_coins(
pub async fn vested_coins(
vesting_account_address: &str,
block_time: Option<u64>,
state: tauri::State<'_, Arc<RwLock<State>>>,
state: tauri::State<'_, WalletState>,
) -> Result<DecCoin, BackendError> {
log::info!(">>> Query vested coins");
let guard = state.read().await;
@@ -80,7 +78,7 @@ pub async fn vested_coins(
pub async fn vesting_coins(
vesting_account_address: &str,
block_time: Option<u64>,
state: tauri::State<'_, Arc<RwLock<State>>>,
state: tauri::State<'_, WalletState>,
) -> Result<DecCoin, BackendError> {
log::info!(">>> Query vesting coins");
let guard = state.read().await;
@@ -102,7 +100,7 @@ pub async fn vesting_coins(
#[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)
@@ -116,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)
@@ -130,7 +128,7 @@ 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 guard = state.read().await;
@@ -151,7 +149,7 @@ pub async fn original_vesting(
pub async fn delegated_free(
vesting_account_address: &str,
block_time: Option<u64>,
state: tauri::State<'_, Arc<RwLock<State>>>,
state: tauri::State<'_, WalletState>,
) -> Result<DecCoin, BackendError> {
log::info!(">>> Query delegated free");
let guard = state.read().await;
@@ -175,7 +173,7 @@ pub async fn delegated_free(
pub async fn delegated_vesting(
block_time: Option<u64>,
vesting_account_address: &str,
state: tauri::State<'_, Arc<RwLock<State>>>,
state: tauri::State<'_, WalletState>,
) -> Result<DecCoin, BackendError> {
log::info!(">>> Query delegated vesting");
let guard = state.read().await;
@@ -197,7 +195,7 @@ pub async fn delegated_vesting(
#[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 guard = state.read().await;
@@ -218,7 +216,7 @@ 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 guard = state.read().await;
@@ -239,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)
@@ -252,7 +250,7 @@ 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 guard = state.read().await;
nym-wallet/src-tauri/src/operations/vesting/rewards.rs
+5 -7
View File
@@ -1,14 +1,12 @@
use crate::error::BackendError;
use crate::nymd_client;
use crate::state::State;
use crate::state::WalletState;
use mixnet_contract_common::IdentityKey;
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>>>,
state: tauri::State<'_, WalletState>,
) -> Result<(), BackendError> {
nymd_client!(state)
.execute_vesting_claim_operator_reward(None)
@@ -19,7 +17,7 @@ pub async fn vesting_claim_operator_reward(
#[tauri::command]
pub async fn vesting_compound_operator_reward(
fee: Option<Fee>,
state: tauri::State<'_, Arc<RwLock<State>>>,
state: tauri::State<'_, WalletState>,
) -> Result<(), BackendError> {
nymd_client!(state)
.execute_vesting_compound_operator_reward(fee)
@@ -31,7 +29,7 @@ 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<(), BackendError> {
nymd_client!(state)
.execute_vesting_claim_delegator_reward(mix_identity, fee)
@@ -43,7 +41,7 @@ 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<(), BackendError> {
nymd_client!(state)
.execute_vesting_compound_delegator_reward(mix_identity, fee)
nym-wallet/src-tauri/src/state.rs
+23 -6
View File
@@ -12,7 +12,7 @@ use std::collections::HashMap;
use std::sync::Arc;
use std::time::Duration;
use strum::IntoEnumIterator;
use tokio::sync::RwLock;
use tokio::sync::{RwLock, RwLockReadGuard, RwLockWriteGuard};
use url::Url;
use validator_client::nymd::{AccountId as CosmosAccountId, Coin, Fee, SigningNymdClient};
use validator_client::Client;
@@ -29,7 +29,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(())
@@ -37,13 +37,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,
@@ -67,7 +84,7 @@ 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
@@ -453,7 +470,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
+4 -10
View File
@@ -1,11 +1,9 @@
use crate::error::BackendError;
use crate::nymd_client;
use crate::state::State;
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> {
@@ -24,9 +22,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?
@@ -34,9 +30,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?
@@ -144,7 +138,7 @@ 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<DecCoin, BackendError> {
let guard = state.read().await;