diff --git a/nym-wallet/src-tauri/src/main.rs b/nym-wallet/src-tauri/src/main.rs
index a8efcf1bf8..8258595e90 100644
--- a/nym-wallet/src-tauri/src/main.rs
+++ b/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,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,
diff --git a/nym-wallet/src-tauri/src/network_config.rs b/nym-wallet/src-tauri/src/network_config.rs
index 2a621922d5..43e872b717 100644
--- a/nym-wallet/src-tauri/src/network_config.rs
+++ b/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;
diff --git a/nym-wallet/src-tauri/src/operations/mixnet/account.rs b/nym-wallet/src-tauri/src/operations/mixnet/account.rs
index 1f92ad17b0..51a9186943 100644
--- a/nym-wallet/src-tauri/src/operations/mixnet/account.rs
+++ b/nym-wallet/src-tauri/src/operations/mixnet/account.rs
@@ -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;
diff --git a/nym-wallet/src-tauri/src/operations/mixnet/admin.rs b/nym-wallet/src-tauri/src/operations/mixnet/admin.rs
index abfa3a48b5..faced61bce 100644
--- a/nym-wallet/src-tauri/src/operations/mixnet/admin.rs
+++ b/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!(
diff --git a/nym-wallet/src-tauri/src/operations/mixnet/bond.rs b/nym-wallet/src-tauri/src/operations/mixnet/bond.rs
index ea1c8b8bee..c9b38ca102 100644
--- a/nym-wallet/src-tauri/src/operations/mixnet/bond.rs
+++ b/nym-wallet/src-tauri/src/operations/mixnet/bond.rs
@@ -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;
diff --git a/nym-wallet/src-tauri/src/operations/mixnet/delegate.rs b/nym-wallet/src-tauri/src/operations/mixnet/delegate.rs
index 7bc81283bd..d0d101584a 100644
--- a/nym-wallet/src-tauri/src/operations/mixnet/delegate.rs
+++ b/nym-wallet/src-tauri/src/operations/mixnet/delegate.rs
@@ -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");
 
diff --git a/nym-wallet/src-tauri/src/operations/mixnet/epoch.rs b/nym-wallet/src-tauri/src/operations/mixnet/epoch.rs
index 5203e5bc62..2ca8fe0c05 100644
--- a/nym-wallet/src-tauri/src/operations/mixnet/epoch.rs
+++ b/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?;
diff --git a/nym-wallet/src-tauri/src/operations/mixnet/rewards.rs b/nym-wallet/src-tauri/src/operations/mixnet/rewards.rs
index adc4612a34..61e729e75a 100644
--- a/nym-wallet/src-tauri/src/operations/mixnet/rewards.rs
+++ b/nym-wallet/src-tauri/src/operations/mixnet/rewards.rs
@@ -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)
diff --git a/nym-wallet/src-tauri/src/operations/mixnet/send.rs b/nym-wallet/src-tauri/src/operations/mixnet/send.rs
index 4938135371..0e4cbdd6a3 100644
--- a/nym-wallet/src-tauri/src/operations/mixnet/send.rs
+++ b/nym-wallet/src-tauri/src/operations/mixnet/send.rs
@@ -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())?;
diff --git a/nym-wallet/src-tauri/src/operations/simulate/admin.rs b/nym-wallet/src-tauri/src/operations/simulate/admin.rs
index 18afef484b..93535f2e42 100644
--- a/nym-wallet/src-tauri/src/operations/simulate/admin.rs
+++ b/nym-wallet/src-tauri/src/operations/simulate/admin.rs
@@ -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()?;
diff --git a/nym-wallet/src-tauri/src/operations/simulate/cosmos.rs b/nym-wallet/src-tauri/src/operations/simulate/cosmos.rs
index 616e29adbf..0da48e1dc5 100644
--- a/nym-wallet/src-tauri/src/operations/simulate/cosmos.rs
+++ b/nym-wallet/src-tauri/src/operations/simulate/cosmos.rs
@@ -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())?;
diff --git a/nym-wallet/src-tauri/src/operations/simulate/mixnet.rs b/nym-wallet/src-tauri/src/operations/simulate/mixnet.rs
index f7e8003e6f..f5790f8380 100644
--- a/nym-wallet/src-tauri/src/operations/simulate/mixnet.rs
+++ b/nym-wallet/src-tauri/src/operations/simulate/mixnet.rs
@@ -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()?;
diff --git a/nym-wallet/src-tauri/src/operations/simulate/vesting.rs b/nym-wallet/src-tauri/src/operations/simulate/vesting.rs
index e2799172ab..a92c8b8cbb 100644
--- a/nym-wallet/src-tauri/src/operations/simulate/vesting.rs
+++ b/nym-wallet/src-tauri/src/operations/simulate/vesting.rs
@@ -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()?;
diff --git a/nym-wallet/src-tauri/src/operations/validator_api/status.rs b/nym-wallet/src-tauri/src/operations/validator_api/status.rs
index 721c39bf82..7ff60d3e6b 100644
--- a/nym-wallet/src-tauri/src/operations/validator_api/status.rs
+++ b/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)
diff --git a/nym-wallet/src-tauri/src/operations/vesting/bond.rs b/nym-wallet/src-tauri/src/operations/vesting/bond.rs
index f624c9d36a..c567e4e908 100644
--- a/nym-wallet/src-tauri/src/operations/vesting/bond.rs
+++ b/nym-wallet/src-tauri/src/operations/vesting/bond.rs
@@ -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());
diff --git a/nym-wallet/src-tauri/src/operations/vesting/delegate.rs b/nym-wallet/src-tauri/src/operations/vesting/delegate.rs
index c2d9b31e7c..9ddde467a8 100644
--- a/nym-wallet/src-tauri/src/operations/vesting/delegate.rs
+++ b/nym-wallet/src-tauri/src/operations/vesting/delegate.rs
@@ -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());
diff --git a/nym-wallet/src-tauri/src/operations/vesting/queries.rs b/nym-wallet/src-tauri/src/operations/vesting/queries.rs
index 9117d5c86d..7d0d726a1c 100644
--- a/nym-wallet/src-tauri/src/operations/vesting/queries.rs
+++ b/nym-wallet/src-tauri/src/operations/vesting/queries.rs
@@ -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;
diff --git a/nym-wallet/src-tauri/src/operations/vesting/rewards.rs b/nym-wallet/src-tauri/src/operations/vesting/rewards.rs
index e6b27fa78f..13cee7bbbd 100644
--- a/nym-wallet/src-tauri/src/operations/vesting/rewards.rs
+++ b/nym-wallet/src-tauri/src/operations/vesting/rewards.rs
@@ -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)
diff --git a/nym-wallet/src-tauri/src/state.rs b/nym-wallet/src-tauri/src/state.rs
index c84bc1e511..114abe1a24 100644
--- a/nym-wallet/src-tauri/src/state.rs
+++ b/nym-wallet/src-tauri/src/state.rs
@@ -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(
diff --git a/nym-wallet/src-tauri/src/utils.rs b/nym-wallet/src-tauri/src/utils.rs
index beab7e4f50..40e61a317b 100644
--- a/nym-wallet/src-tauri/src/utils.rs
+++ b/nym-wallet/src-tauri/src/utils.rs
@@ -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;