wallet: additional backend logic for selecting validators

nym-wallet/src-tauri/src/config/mod.rs

@@ -48,7 +48,8 @@ pub struct NetworkConfig {
   selected_nymd_url: Option<Url>,
   selected_api_url: Option<Url>,
 
-  // Additional user provided validators
+  // Additional user provided validators.
+  // It is an option for the purpuse of file serialization.
   validator_urls: Option<Vec<ValidatorUrl>>,
 }
 
@@ -260,11 +261,11 @@ impl Config {
   }
 
   pub fn add_validator_url(&mut self, url: ValidatorUrl, network: WalletNetwork) {
-    if let Some(net) = self.networks.get_mut(&network.as_key()) {
-      if let Some(ref mut urls) = net.validator_urls {
+    if let Some(network_config) = self.networks.get_mut(&network.as_key()) {
+      if let Some(ref mut urls) = network_config.validator_urls {
         urls.push(url);
       } else {
-        net.validator_urls = Some(vec![url]);
+        network_config.validator_urls = Some(vec![url]);
       }
     } else {
       self.networks.insert(
@@ -277,9 +278,13 @@ impl Config {
     }
   }
 
-  #[allow(unused)]
-  pub fn remove_validator_url(&mut self, _url: ValidatorUrl, _network: WalletNetwork) {
-    todo!();
+  pub fn remove_validator_url(&mut self, url: ValidatorUrl, network: WalletNetwork) {
+    if let Some(network_config) = self.networks.get_mut(&network.as_key()) {
+      if let Some(ref mut urls) = network_config.validator_urls {
+        // Removes duplicates too if there are any
+        urls.retain(|existing_url| existing_url != &url);
+      }
+    }
   }
 }
 

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

@@ -71,6 +71,8 @@ fn main() {
       network_config::select_validator_api_url,
       network_config::select_validator_nymd_url,
       network_config::update_validator_urls,
+      state::load_config_from_files,
+      state::save_config_to_files,
       utils::major_to_minor,
       utils::minor_to_major,
       utils::outdated_get_approximate_fee,

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

@@ -6,7 +6,7 @@ use crate::network::Network as WalletNetwork;
 use crate::state::State;
 
 use serde::{Deserialize, Serialize};
-use std::sync::Arc;
+use std::{fmt, sync::Arc};
 use tokio::sync::RwLock;
 
 #[cfg_attr(test, derive(ts_rs::TS))]
@@ -18,12 +18,24 @@ pub struct ValidatorUrls {
 
 #[cfg_attr(test, derive(ts_rs::TS))]
 #[cfg_attr(test, ts(export, export_to = "../src/types/rust/validatorurls.ts"))]
-#[derive(Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize)]
 pub struct Validator {
   pub nymd_url: String,
   pub api_url: Option<String>,
 }
 
+impl fmt::Display for Validator {
+  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    let nymd_url = format!("nymd_url: {}", self.nymd_url);
+    let api_url = self
+      .api_url
+      .as_ref()
+      .map(|api_url| format!(", api_url: {}", api_url))
+      .unwrap_or_default();
+    write!(f, "{nymd_url}{api_url}")
+  }
+}
+
 #[tauri::command]
 pub async fn get_validator_nymd_urls(
   network: WalletNetwork,
@@ -56,6 +68,7 @@ pub async fn select_validator_nymd_url(
   network: WalletNetwork,
   state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<(), BackendError> {
+  log::debug!("Selecting new validator nymd_url for {network}: {url}");
   state
     .write()
     .await
@@ -69,6 +82,7 @@ pub async fn select_validator_api_url(
   network: WalletNetwork,
   state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<(), BackendError> {
+  log::debug!("Selecting new validator api_url for {network}: {url}");
   state.write().await.select_validator_api_url(url, network)?;
   Ok(())
 }
@@ -79,6 +93,7 @@ pub async fn add_validator(
   network: WalletNetwork,
   state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<(), BackendError> {
+  log::debug!("Add validator for {network}: {validator}");
   let url = validator.try_into()?;
   state.write().await.add_validator_url(url, network);
   Ok(())
@@ -90,6 +105,7 @@ pub async fn remove_validator(
   network: WalletNetwork,
   state: tauri::State<'_, Arc<RwLock<State>>>,
 ) -> Result<(), BackendError> {
+  log::debug!("Remove validator for {network}: {validator}");
   let url = validator.try_into()?;
   state.write().await.remove_validator_url(url, network);
   Ok(())

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

@@ -7,11 +7,28 @@ use validator_client::nymd::SigningNymdClient;
 use validator_client::Client;
 
 use itertools::Itertools;
+use tokio::sync::RwLock;
 use url::Url;
 
 use std::collections::HashMap;
+use std::sync::Arc;
 use std::time::Duration;
 
+#[tauri::command]
+pub async fn load_config_from_files(
+  state: tauri::State<'_, Arc<RwLock<State>>>,
+) -> Result<(), BackendError> {
+  state.write().await.load_config_files();
+  Ok(())
+}
+
+#[tauri::command]
+pub async fn save_config_to_files(
+  state: tauri::State<'_, Arc<RwLock<State>>>,
+) -> Result<(), BackendError> {
+  state.read().await.save_config_files()
+}
+
 #[derive(Default)]
 pub struct State {
   config: Config,
@@ -30,6 +47,16 @@ impl State {
       .ok_or(BackendError::ClientNotInitialized)
   }
 
+  pub fn client_mut(
+    &mut self,
+    network: Network,
+  ) -> Result<&mut Client<SigningNymdClient>, BackendError> {
+    self
+      .signing_clients
+      .get_mut(&network)
+      .ok_or(BackendError::ClientNotInitialized)
+  }
+
   pub fn current_client(&self) -> Result<&Client<SigningNymdClient>, BackendError> {
     self
       .signing_clients
@@ -37,6 +64,14 @@ impl State {
       .ok_or(BackendError::ClientNotInitialized)
   }
 
+  #[allow(unused)]
+  pub fn current_client_mut(&mut self) -> Result<&mut Client<SigningNymdClient>, BackendError> {
+    self
+      .signing_clients
+      .get_mut(&self.current_network)
+      .ok_or(BackendError::ClientNotInitialized)
+  }
+
   pub fn config(&self) -> &Config {
     &self.config
   }
@@ -124,32 +159,34 @@ impl State {
     Ok(())
   }
 
-  #[allow(unused)]
   pub fn select_validator_nymd_url(
     &mut self,
     url: &str,
     network: Network,
   ) -> Result<(), BackendError> {
     self.config.select_validator_nymd_url(url.parse()?, network);
+    if let Ok(client) = self.client_mut(network) {
+      client.change_nymd(url.parse()?)?;
+    }
     Ok(())
   }
 
-  #[allow(unused)]
   pub fn select_validator_api_url(
     &mut self,
     url: &str,
     network: Network,
   ) -> Result<(), BackendError> {
     self.config.select_validator_api_url(url.parse()?, network);
+    if let Ok(client) = self.client_mut(network) {
+      client.change_validator_api(url.parse()?);
+    }
     Ok(())
   }
 
-  #[allow(unused)]
   pub fn add_validator_url(&mut self, url: ValidatorUrl, network: Network) {
     self.config.add_validator_url(url, network);
   }
 
-  #[allow(unused)]
   pub fn remove_validator_url(&mut self, url: ValidatorUrl, network: Network) {
     self.config.remove_validator_url(url, network)
   }