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

Store all clients and discard mnemonic

Browse Source
This commit is contained in:
Bogdan-Ștefan Neacșu
2022-01-17 17:21:05 +02:00
parent ac5539a0fa
commit 35c044c340
5 changed files with 89 additions and 61 deletions
Download Patch File Download Diff File Expand all files Collapse all files
nym-wallet/src-tauri/src/config/mod.rs
-8
View File
@@ -24,9 +24,6 @@ pub struct Config {
pub struct Base {
/// Information on all the networks that the wallet connects to.
networks: SupportedNetworks,
/// Mnemonic (currently of the network monitor) used for rewarding
mnemonic: String,
}
impl Default for Base {
@@ -34,7 +31,6 @@ impl Default for Base {
let networks = Network::iter().map(|network| network.into()).collect();
Base {
networks: SupportedNetworks::new(networks),
mnemonic: String::default(),
}
}
}
@@ -112,8 +108,4 @@ impl Config {
.parse()
.expect("stored vesting contract address is not a valid account address")
}
pub fn get_mnemonic(&self) -> &str {
&self.base.mnemonic
}
}
nym-wallet/src-tauri/src/network.rs
+6
View File
@@ -15,6 +15,12 @@ pub enum Network {
SANDBOX,
}
impl Default for Network {
fn default() -> Self {
Network::SANDBOX
}
}
impl Into<ConfigNetwork> for Network {
fn into(self) -> ConfigNetwork {
match self {
nym-wallet/src-tauri/src/operations/mixnet/account.rs
+57 -42
View File
@@ -3,11 +3,13 @@ use crate::error::BackendError;
use crate::network::Network;
use crate::nymd_client;
use crate::state::State;
use bip39::{Language, Mnemonic};
use serde::{Deserialize, Serialize};
use std::convert::{TryFrom, TryInto};
use std::str::FromStr;
use std::sync::Arc;
use strum::IntoEnumIterator;
use tokio::sync::RwLock;
#[cfg_attr(test, derive(ts_rs::TS))]
@@ -16,7 +18,6 @@ pub struct Account {
contract_address: String,
client_address: String,
denom: Denom,
mnemonic: Option<String>,
}
#[cfg_attr(test, derive(ts_rs::TS))]
@@ -32,12 +33,7 @@ pub async fn connect_with_mnemonic(
state: tauri::State<'_, Arc<RwLock<State>>>,
) -> Result<Account, BackendError> {
let mnemonic = Mnemonic::from_str(&mnemonic)?;
_connect_with_mnemonic(
mnemonic,
Network::try_from(config::defaults::default_network())?,
state,
)
.await
_connect_with_mnemonic(mnemonic, state).await
}
#[tauri::command]
@@ -70,9 +66,8 @@ pub async fn create_new_account(
state: tauri::State<'_, Arc<RwLock<State>>>,
) -> Result<Account, BackendError> {
let rand_mnemonic = random_mnemonic();
let mut client = connect_with_mnemonic(rand_mnemonic.to_string(), state).await?;
client.mnemonic = Some(rand_mnemonic.to_string());
Ok(client)
let account = connect_with_mnemonic(rand_mnemonic.to_string(), state).await?;
Ok(account)
}
#[tauri::command]
@@ -80,11 +75,25 @@ pub async fn switch_network(
state: tauri::State<'_, Arc<RwLock<State>>>,
network: Network,
) -> Result<Account, BackendError> {
let mnemonic = {
let account = {
let r_state = state.read().await;
Mnemonic::from_str(r_state.config().get_mnemonic())?
let client = r_state.client(network)?;
let contract_address = client.nymd.mixnet_contract_address()?.to_string();
let client_address = client.nymd.address().to_string();
let denom = client.nymd.denom()?;
Account {
contract_address,
client_address,
denom: denom.try_into()?,
}
};
_connect_with_mnemonic(mnemonic, network, state).await
let mut w_state = state.write().await;
w_state.set_network(network);
Ok(account)
}
fn random_mnemonic() -> Mnemonic {
@@ -94,38 +103,44 @@ fn random_mnemonic() -> Mnemonic {
async fn _connect_with_mnemonic(
mnemonic: Mnemonic,
network: Network,
state: tauri::State<'_, Arc<RwLock<State>>>,
) -> Result<Account, BackendError> {
let client = {
let config = state.read().await.config();
match validator_client::Client::new_signing(
validator_client::Config::new(
config.get_nymd_validator_url(network),
config.get_validator_api_url(network),
Some(config.get_mixnet_contract_address(network)),
Some(config.get_vesting_contract_address(network)),
),
mnemonic,
) {
Ok(client) => client,
Err(e) => panic!("{}", e),
let default_network = Network::try_from(config::defaults::default_network())?;
let mut default_account = None;
for network in Network::iter() {
let client = {
let config = state.read().await.config();
match validator_client::Client::new_signing(
validator_client::Config::new(
config.get_nymd_validator_url(network),
config.get_validator_api_url(network),
Some(config.get_mixnet_contract_address(network)),
Some(config.get_vesting_contract_address(network)),
),
mnemonic.clone(),
) {
Ok(client) => client,
Err(e) => panic!("{}", e),
}
};
if network == default_network {
let contract_address = client.nymd.mixnet_contract_address()?.to_string();
let client_address = client.nymd.address().to_string();
let denom = client.nymd.denom()?;
default_account = Some(Account {
contract_address,
client_address,
denom: denom.try_into()?,
});
}
};
let contract_address = client.nymd.mixnet_contract_address()?.to_string();
let client_address = client.nymd.address().to_string();
let denom = client.nymd.denom()?;
let mut w_state = state.write().await;
w_state.add_client(network, client);
}
let account = Account {
contract_address,
client_address,
denom: denom.try_into()?,
mnemonic: None,
};
let mut w_state = state.write().await;
w_state.set_client(client);
Ok(account)
default_account.ok_or(BackendError::NetworkNotSupported(
config::defaults::default_network(),
))
}
nym-wallet/src-tauri/src/operations/mixnet/bond.rs
+2 -2
View File
@@ -66,7 +66,7 @@ pub async fn mixnode_bond_details(
state: tauri::State<'_, Arc<RwLock<State>>>,
) -> Result<Option<MixNodeBond>, BackendError> {
let guard = state.read().await;
let client = guard.client()?;
let client = guard.current_client()?;
let bond = client.nymd.owns_mixnode(client.nymd.address()).await?;
Ok(bond)
}
@@ -76,7 +76,7 @@ pub async fn gateway_bond_details(
state: tauri::State<'_, Arc<RwLock<State>>>,
) -> Result<Option<GatewayBond>, BackendError> {
let guard = state.read().await;
let client = guard.client()?;
let client = guard.current_client()?;
let bond = client.nymd.owns_gateway(client.nymd.address()).await?;
Ok(bond)
}
nym-wallet/src-tauri/src/state.rs
+24 -9
View File
@@ -1,19 +1,30 @@
use crate::config::Config;
use crate::error::BackendError;
use crate::network::Network;
use validator_client::nymd::SigningNymdClient;
use validator_client::Client;
use std::collections::HashMap;
#[derive(Default)]
pub struct State {
config: Config,
signing_client: Option<Client<SigningNymdClient>>,
signing_clients: HashMap<Network, Client<SigningNymdClient>>,
current_network: Network,
}
impl State {
pub fn client(&self) -> Result<&Client<SigningNymdClient>, BackendError> {
pub fn client(&self, network: Network) -> Result<&Client<SigningNymdClient>, BackendError> {
self
.signing_client
.as_ref()
.signing_clients
.get(&network)
.ok_or(BackendError::ClientNotInitialized)
}
pub fn current_client(&self) -> Result<&Client<SigningNymdClient>, BackendError> {
self
.signing_clients
.get(&self.current_network)
.ok_or(BackendError::ClientNotInitialized)
}
@@ -21,28 +32,32 @@ impl State {
self.config.clone()
}
pub fn set_client(&mut self, signing_client: Client<SigningNymdClient>) {
self.signing_client = Some(signing_client)
pub fn add_client(&mut self, network: Network, client: Client<SigningNymdClient>) {
self.signing_clients.insert(network, client);
}
pub fn set_network(&mut self, network: Network) {
self.current_network = network;
}
}
#[macro_export]
macro_rules! client {
($state:ident) => {
$state.read().await.client()?
$state.read().await.current_client()?
};
}
#[macro_export]
macro_rules! nymd_client {
($state:ident) => {
$state.read().await.client()?.nymd
$state.read().await.current_client()?.nymd
};
}
#[macro_export]
macro_rules! api_client {
($state:ident) => {
$state.read().await.client()?.validator_api
$state.read().await.current_client()?.validator_api
};
}