own stash identification fix

Signed-off-by: Uncle Stretch <uncle.stretch@ghostchain.io>

Cargo.toml

@@ -2,7 +2,7 @@
 name = "ghost-eye"
 authors = ["str3tch <stretch@ghostchain.io>"]
 description = "Application for interacting with Casper/Ghost nodes that are exposing RPC only to the localhost"
-version = "0.3.27"
+version = "0.3.34"
 edition = "2021"
 
 [dependencies]

src/action.rs

@@ -115,7 +115,7 @@ pub enum Action {
     SetStashSecret([u8; 32]),
     SetChoosenValidator([u8; 32], u32, u32),
     SetSlashingSpansLength(usize, [u8; 32]),
-    SetUnlockingIsEmpty(bool),
+    SetUnlockingIsEmpty(bool, [u8; 32]),
 
     BestBlockInformation(H256, u32),
     FinalizedBlockInformation(H256, u32),
@@ -132,7 +132,7 @@ pub enum Action {
     SetValidatorEraReward(u32, u128),
     SetValidatorEraClaimed(u32, bool),
     SetValidatorEraSlash(u32, u128),
-    SetValidatorEraUnlocking(u32, u128),
+    SetValidatorEraUnlocking(u32, u128, [u8; 32]),
     SetIsBonded(bool),
     SetStakedAmountRatio(u128, u128, [u8; 32]),
     SetStakedRatio(u128, u128, [u8; 32]),

src/components/nominator/current_validator_details.rs

@@ -81,7 +81,7 @@ impl CurrentValidatorDetails {
         self.is_nomination_disabled = is_disabled;
         match maybe_commission {
             Some(commission) => {
-                self.commission = commission as f64 / 1_000_000_000.0;
+                self.commission = commission as f64 / 10_000_000.0;
                 self.is_active_validator = true;
             },
             None => {

src/components/nominator/current_validators.rs

@@ -34,6 +34,7 @@ pub struct CurrentValidators {
     table_state: TableState,
     individual: Vec<EraRewardPoints>,
     known_validators: std::collections::HashMap<[u8; 32], String>,
+    active_validators: std::collections::HashSet<String>,
     total_points: u32,
     era_index: u32,
     my_stash_id: Option<[u8; 32]>,
@@ -57,6 +58,7 @@ impl CurrentValidators {
             table_state: TableState::new(),
             individual: Default::default(),
             known_validators: Default::default(),
+            active_validators: Default::default(),
             total_points: 0,
             era_index: 0,
             my_stash_id: None,
@@ -268,7 +270,14 @@ impl Component for CurrentValidators {
 
                     }
 
-                    if self.my_stash_id.is_some() && index == 0 {
+                    let mut current_validator_is_my_stash = false;
+                    if index == 0 {
+                        if let Some(account_id) = self.my_stash_id {
+                            current_validator_is_my_stash = account_id == info.account_id;
+                        }
+                    };
+
+                    if current_validator_is_my_stash {
                         let name = self.known_validators
                             .get(&info.account_id)
                             .cloned()

src/components/validator/bond_popup.rs

@@ -60,7 +60,13 @@ impl BondPopup {
 
     fn submit_message(&mut self) {
         if let Some(network_tx) = &self.network_tx { 
-            match self.amount.value().parse::<f64>() {
+            let str_amount = self.amount.value();
+            let str_amount = if str_amount.starts_with('.') {
+                &format!("0{}", str_amount)[..]
+            } else {
+                str_amount
+            };
+            match str_amount.parse::<f64>() {
                 Ok(value) => {
                     let amount = (value * 1_000_000_000_000_000_000.0) as u128;
                     let _ = if self.is_bonded {

src/components/validator/history.rs

@@ -64,17 +64,19 @@ impl History {
 
     fn payout_by_era_index(&mut self) {
         if let Some(index) = self.table_state.selected() {
+            let length = self.rewards.len() as u32;
             let era_index = self.rewards
                 .keys()
                 .nth(index)
+                .map(|i| length - i - 1)
                 .expect("BTreeMap of rewards is indexed; qed");
             let is_claimed = self.rewards
-                .get(era_index)
+                .get(&era_index)
                 .map(|x| x.is_claimed)
                 .expect("BTreeMap of rewards is indexed; qed");
             if let Some(action_tx) = &self.action_tx {
                 let _ = action_tx.send(
-                    Action::PayoutValidatorPopup(*era_index, is_claimed));
+                    Action::PayoutValidatorPopup(era_index, is_claimed));
             }
         }
     }
@@ -242,6 +244,7 @@ impl Component for History {
         let table = Table::new(
             self.rewards
                 .iter()
+                .rev()
                 .map(|(key, value)| {
                     let mut era_index_text = Text::from(key.to_string()).alignment(Alignment::Left);
                     let mut slash_text = Text::from(self.prepare_u128(value.slash)).alignment(Alignment::Center);

src/components/validator/mod.rs

@@ -52,7 +52,6 @@ use withdraw_popup::WithdrawPopup;
 #[derive(Debug, Copy, Clone, PartialEq)]
 pub enum CurrentTab {
     Nothing,
-    StashInfo,
     ListenAddresses,
     NominatorsByValidator,
     History,
@@ -118,15 +117,13 @@ impl Validator {
             CurrentTab::Withdrawals => self.current_tab = CurrentTab::History,
             CurrentTab::History => self.current_tab = CurrentTab::NominatorsByValidator,
             CurrentTab::NominatorsByValidator => self.current_tab = CurrentTab::ListenAddresses,
-            CurrentTab::ListenAddresses => self.current_tab = CurrentTab::StashInfo,
             _ => {}
         }
     }
 
     fn move_right(&mut self) {
         match self.current_tab {
-            CurrentTab::Nothing => self.current_tab = CurrentTab::StashInfo,
+            CurrentTab::Nothing => self.current_tab = CurrentTab::ListenAddresses,
-            CurrentTab::StashInfo => self.current_tab = CurrentTab::ListenAddresses,
             CurrentTab::ListenAddresses => self.current_tab = CurrentTab::NominatorsByValidator,
             CurrentTab::NominatorsByValidator => self.current_tab = CurrentTab::History,
             CurrentTab::History => self.current_tab = CurrentTab::Withdrawals,
@@ -267,7 +264,7 @@ impl Component for Validator {
         match action {
             Action::SetActiveScreen(Mode::Validator) => {
                 self.is_active = true;
-                self.current_tab = CurrentTab::StashInfo;
+                self.current_tab = CurrentTab::ListenAddresses;
             }
             Action::PayoutValidatorPopup(_, _) => {
                 self.previous_tab = self.current_tab;

src/components/validator/rebond_popup.rs

@@ -56,7 +56,13 @@ impl RebondPopup {
 
     fn submit_message(&mut self) {
         if let Some(network_tx) = &self.network_tx { 
-            match self.amount.value().parse::<f64>() {
+            let str_amount = self.amount.value();
+            let str_amount = if str_amount.starts_with('.') {
+                &format!("0{}", str_amount)[..]
+            } else {
+                str_amount
+            };
+            match str_amount.parse::<f64>() {
                 Ok(value) => {
                     let amount = (value * 1_000_000_000_000_000_000.0) as u128;
                     let _ = network_tx.send(Action::RebondFrom(self.secret_seed, amount));

src/components/validator/reward_details.rs

@@ -46,7 +46,7 @@ impl RewardDetails {
         match self.commission {
             Some(commission) => {
                 if self.nominators_blocked { "blocked".to_string() }
-                else { format!("{:.2}%", commission as f64 / 1_000_000_000.0) }
+                else { format!("{:.2}%", commission as f64 / 10_000_000.0) }
             },
             None => DotSpinner::default().to_string(),
         }

src/components/validator/rotate_popup.rs

@@ -70,10 +70,10 @@ impl RotatePopup {
             (gran_key, babe_key, audi_key, slow_key)
         } else {
             (
-                String::from("not prepared"),
+                String::from("0x0000000000000000000000000000000000000000000000000000000000000000"),
-                String::from("not prepared"),
+                String::from("0x0000000000000000000000000000000000000000000000000000000000000000"),
-                String::from("not prepared"),
+                String::from("0x0000000000000000000000000000000000000000000000000000000000000000"),
-                String::from("not prepared"),
+                String::from("0x0000000000000000000000000000000000000000000000000000000000000000"),
             )
         }
     }
@@ -94,6 +94,11 @@ impl Component for RotatePopup {
         Ok(())
     }
 
+    fn register_action_handler(&mut self, tx: UnboundedSender<Action>) -> Result<()> {
+        self.action_tx = Some(tx);
+        Ok(())
+    }
+
     fn register_config_handler(&mut self, config: Config) -> Result<()> {
         if let Some(style) = config.styles.get(&crate::app::Mode::Wallet) {
             self.palette.with_normal_style(style.get("normal_style").copied());
@@ -150,7 +155,7 @@ impl Component for RotatePopup {
                     ]),
                     ],
                 [
-                    Constraint::Min(4),
+                    Constraint::Length(4),
                     Constraint::Min(0),
                 ],
             )

src/components/validator/stash_info.rs

@@ -3,16 +3,12 @@ use std::fs::File;
 use std::io::{Write, BufRead, BufReader};
 
 use color_eyre::Result;
-use crossterm::event::{KeyCode, KeyEvent};
+use ratatui::layout::Constraint;
-use ratatui::layout::{Constraint, Margin};
 use ratatui::style::{Modifier, Stylize};
 use ratatui::{
     text::Text,
     layout::{Alignment, Rect}, 
-    widgets::{
+    widgets::{Block, Cell, Row, Table}, 
-        Block, Cell, Row, Table, TableState, Scrollbar,
-        ScrollbarOrientation, ScrollbarState,
-    }, 
     Frame
 };
 
@@ -42,8 +38,6 @@ pub struct StashInfo {
     action_tx: Option<UnboundedSender<Action>>,
     network_tx: Option<Sender<Action>>,
     palette: StylePalette,
-    scroll_state: ScrollbarState,
-    table_state: TableState,
     stash_pair: Option<PairSigner<CasperConfig, Pair>>,
     stash_address: String,
     session_keys: std::collections::HashMap<String, SessionKeyInfo>,
@@ -63,8 +57,6 @@ impl StashInfo {
             is_active: false,
             action_tx: None,
             network_tx: None,
-            scroll_state: ScrollbarState::new(0),
-            table_state: TableState::new(),
             palette: StylePalette::default(),
             stash_address: String::new(),
             stash_pair: None,
@@ -81,51 +73,6 @@ impl StashInfo {
         }
     }
 
-    fn first_row(&mut self) {
-        if self.session_keys.len() > 0 {
-            self.table_state.select(Some(0));
-            self.scroll_state = self.scroll_state.position(0);
-        }
-    }
-
-    fn next_row(&mut self) {
-        let i = match self.table_state.selected() {
-            Some(i) => {
-                if i >= self.session_keys.len() - 1 {
-                    i
-                } else {
-                    i + 1
-                }
-            },
-            None => 0,
-        };
-        self.table_state.select(Some(i));
-        self.scroll_state = self.scroll_state.position(i);
-    }
-
-    fn last_row(&mut self) {
-        if self.session_keys.len() > 0 {
-            let last = self.session_keys.len() - 1;
-            self.table_state.select(Some(last));
-            self.scroll_state = self.scroll_state.position(last);
-        }
-    }
-
-    fn previous_row(&mut self) {
-        let i = match self.table_state.selected() {
-            Some(i) => {
-                if i == 0 {
-                    0
-                } else {
-                    i - 1
-                }
-            },
-            None => 0
-        };
-        self.table_state.select(Some(i));
-        self.scroll_state = self.scroll_state.position(i);
-    }
-
     fn read_or_create_stash(&mut self) -> Result<()> {
         match File::open(&self.stash_filepath) {
             Ok(file) => {
@@ -230,16 +177,7 @@ impl StashInfo {
 }
 
 impl PartialComponent for StashInfo {
-    fn set_active(&mut self, current_tab: CurrentTab) {
+    fn set_active(&mut self, _current_tab: CurrentTab) { }
-        match current_tab {
-            CurrentTab::StashInfo => self.is_active = true,
-            _ => {
-                self.is_active = false;
-                self.table_state.select(None);
-                self.scroll_state = self.scroll_state.position(0);
-            }
-        }
-    }
 }
 
 impl Component for StashInfo {
@@ -276,19 +214,6 @@ impl Component for StashInfo {
         Ok(None)
     }
 
-    fn handle_key_event(&mut self, key: KeyEvent) -> Result<Option<Action>> {
-        if self.is_active {
-            match key.code {
-                KeyCode::Up | KeyCode::Char('k') => self.previous_row(), 
-                KeyCode::Down | KeyCode::Char('j') => self.next_row(), 
-                KeyCode::Char('g') => self.first_row(),
-                KeyCode::Char('G') => self.last_row(),
-                _ => {},
-            };
-        }
-        Ok(None)
-    }
-
     fn draw(&mut self, frame: &mut Frame, area: Rect) -> Result<()> {
         let [place, _] = super::validator_session_and_listen_layout(area);
         let (border_style, border_type) = self.palette.create_border_style(self.is_active);
@@ -340,19 +265,7 @@ impl Component for StashInfo {
             .title_style(self.palette.create_title_style(false))
             .title(self.stash_address.clone()));
 
-        let scrollbar = Scrollbar::default()
+        frame.render_widget(table, place);
-            .orientation(ScrollbarOrientation::VerticalRight)
-            .begin_symbol(None)
-            .end_symbol(None)
-            .style(self.palette.create_scrollbar_style());
-
-        frame.render_stateful_widget(table, place, &mut self.table_state);
-        frame.render_stateful_widget(
-            scrollbar,
-            place.inner(Margin { vertical: 1, horizontal: 1 }),
-            &mut self.scroll_state,
-        );
-
         Ok(())
     }
 }

src/components/validator/unbond_popup.rs

@@ -56,7 +56,13 @@ impl UnbondPopup {
 
     fn submit_message(&mut self) {
         if let Some(network_tx) = &self.network_tx { 
-            match self.amount.value().parse::<f64>() {
+            let str_amount = self.amount.value();
+            let str_amount = if str_amount.starts_with('.') {
+                &format!("0{}", str_amount)[..]
+            } else {
+                str_amount
+            };
+            match str_amount.parse::<f64>() {
                 Ok(value) => {
                     if self.is_bonded {
                         let amount = (value * 1_000_000_000_000_000_000.0) as u128;

src/components/validator/validate_popup.rs

@@ -56,9 +56,15 @@ impl ValidatePopup {
 
     fn submit_message(&mut self) {
         if let Some(network_tx) = &self.network_tx { 
-            match self.amount.value().parse::<f64>() {
+            let str_amount = self.amount.value();
+            let str_amount = if str_amount.starts_with('.') {
+                &format!("0{}", str_amount)[..]
+            } else {
+                str_amount
+            };
+            match str_amount.parse::<f64>() {
                 Ok(value) => {
-                    let amount = (value * 1_000_000_000.0).round() as u32;
+                    let amount = (value * 10_000_000.0).round() as u32;
                     let _ = network_tx.send(Action::ValidateFrom(self.secret_seed, amount));
                     if let Some(action_tx) = &self.action_tx {
                         let _ = action_tx.send(Action::ClosePopup);

src/components/validator/withdraw_popup.rs

@@ -120,14 +120,15 @@ impl Component for WithdrawPopup {
 
     fn update(&mut self, action: Action) -> Result<Option<Action>> {
         match action {
+            Action::SetExistentialDeposit(existential_deposit) => self.existential_deposit = existential_deposit,
             Action::SetStashAccount(account_id) => self.stash_account = account_id,
             Action::SetStashSecret(secret_seed) => self.secret_seed = secret_seed,
             Action::SetSlashingSpansLength(length, account_id) if self.stash_account == account_id => 
                 self.slashing_spans_length = length as u32,
             Action::SetStakedAmountRatio(_, active_balance, account_id) if self.stash_account == account_id => 
                 self.active_balance = active_balance,
-            Action::SetUnlockingIsEmpty(is_empty) => self.unlocking_is_empty = is_empty,
+            Action::SetUnlockingIsEmpty(is_empty, account_id) if self.stash_account == account_id =>
-            Action::SetExistentialDeposit(existential_deposit) => self.existential_deposit = existential_deposit,
+                self.unlocking_is_empty = is_empty,
             _ => {}
         };
         Ok(None)

src/components/validator/withdrawals.rs

@@ -27,6 +27,7 @@ pub struct Withdrawals {
     scroll_state: ScrollbarState,
     table_state: TableState,
     unlockings: BTreeMap<u32, u128>, 
+    stash_account: [u8; 32],
     current_era: u32,
 }
 
@@ -47,6 +48,7 @@ impl Withdrawals {
             table_state: TableState::new(),
             palette: StylePalette::default(),
             unlockings: BTreeMap::new(),
+            stash_account: [0u8; 32],
             current_era: 0,
         }
     }
@@ -151,8 +153,9 @@ impl Component for Withdrawals {
 
     fn update(&mut self, action: Action) -> Result<Option<Action>> {
         match action {
+            Action::SetStashAccount(account_id) => self.stash_account = account_id,
             Action::SetCurrentEra(current_era) => self.current_era = current_era,
-            Action::SetValidatorEraUnlocking(era_index, unlocking) => 
+            Action::SetValidatorEraUnlocking(era_index, unlocking, account_id) if self.stash_account == account_id => 
                 self.add_new_unlocking(era_index, unlocking),
             _ => {}
         };

src/components/wallet/transfer.rs

@@ -82,7 +82,13 @@ impl Transfer {
                         let mut account_id = [0u8; 32];
                         account_id.copy_from_slice(&seed_vec);
 
-                        match self.amount.value().parse::<f64>() {
+                        let str_amount = self.amount.value();
+                        let str_amount = if str_amount.starts_with('.') {
+                            &format!("0{}", str_amount)[..]
+                        } else {
+                            str_amount
+                        };
+                        match str_amount.parse::<f64>() {
                             Ok(value) => {
                                 let amount = (value * 1_000_000_000_000_000_000.0) as u128;
                                 let _ = network_tx.send(Action::TransferBalance(

src/network/predefined_calls.rs

@@ -281,20 +281,9 @@ pub async fn get_validator_staking_results(
     api: &OnlineClient<CasperConfig>,
     account_id: &[u8; 32],
 ) -> Result<()> {
-    let (start, end) = super::raw_calls::historical::stored_range(api, None)
+    let current_era = super::raw_calls::staking::current_era(api, None).await?.unwrap_or(0);
-        .await?
+    let era_depth = super::raw_calls::staking::history_depth(api).unwrap_or(0);
-        .map(|range| {
+    for era_index in current_era.saturating_sub(era_depth)..current_era {
-            (
-                range.0
-                    .saturating_div(6) 
-                    .saturating_sub(1), 
-                range.1
-                    .saturating_div(6)
-                    .saturating_sub(1), 
-            )
-        })
-        .unwrap_or((0, 0));
-    for era_index in start..end {
         get_validator_staking_result(action_tx, api, account_id, era_index).await?;
     }
     Ok(())
@@ -435,9 +424,9 @@ pub async fn get_validators_ledger(
 
     if let Some(ledger) = maybe_ledger {
         action_tx.send(Action::SetStakedAmountRatio(ledger.total, ledger.active, *account_id))?;
-        action_tx.send(Action::SetUnlockingIsEmpty(ledger.unlocking.0.is_empty()))?;
+        action_tx.send(Action::SetUnlockingIsEmpty(ledger.unlocking.0.is_empty(), *account_id))?;
         for chunk in ledger.unlocking.0.iter() {
-            action_tx.send(Action::SetValidatorEraUnlocking(chunk.era, chunk.value))?;
+            action_tx.send(Action::SetValidatorEraUnlocking(chunk.era, chunk.value, *account_id))?;
         }
     }
 
@@ -514,11 +503,11 @@ pub async fn get_validator_prefs(
 ) -> Result<()> {
     let maybe_validator_prefs = super::raw_calls::staking::validators(api, None, account_id)
         .await?;
-    let (comission, blocked) = match maybe_validator_prefs {
+    let (commission, blocked) = match maybe_validator_prefs {
         Some(prefs) => (Some(prefs.commission.0), prefs.blocked),
         None => (None, false),
     };
-    action_tx.send(Action::SetValidatorPrefs(comission, blocked, *account_id))?;
+    action_tx.send(Action::SetValidatorPrefs(commission, blocked, *account_id))?;
     Ok(())
 }
 

src/network/raw_calls/historical.rs

@@ -1,19 +0,0 @@
-use color_eyre::Result;
-use subxt::{
-    utils::H256,
-    client::OnlineClient,
-};
-
-use crate::{
-    casper_network,
-    CasperConfig,
-};
-
-pub async fn stored_range(
-    online_client: &OnlineClient<CasperConfig>,
-    at_hash: Option<&H256>,
-) -> Result<Option<(u32, u32)>> {
-    let storage_key = casper_network::storage().historical().stored_range();
-    let maybe_stored_range = super::do_storage_call(online_client, &storage_key, at_hash).await?;
-    Ok(maybe_stored_range)
-}

src/network/raw_calls/mod.rs

@@ -12,7 +12,6 @@ pub mod staking;
 pub mod system;
 pub mod babe;
 pub mod balances;
-pub mod historical;
 
 pub async fn do_storage_call<'address, Addr>(
     online_client: &OnlineClient<CasperConfig>,

src/network/raw_calls/staking.rs

@@ -194,3 +194,11 @@ pub async fn slashing_spans(
     let maybe_slashing_spans = super::do_storage_call(online_client, &storage_key, at_hash).await?;
     Ok(maybe_slashing_spans)
 }
+
+pub fn history_depth(
+    online_client: &OnlineClient<CasperConfig>,
+) -> Result<u32> {
+    let constant_query = casper_network::constants().staking().history_depth();
+    let history_depth = super::do_constant_call(online_client, &constant_query)?;
+    Ok(history_depth)
+}