cleanup in transaction section

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.19"
+version = "0.3.20"
 edition = "2021"
 
 [dependencies]

src/action.rs

@@ -57,6 +57,8 @@ pub enum Action {
     PayoutStakers([u8; 32], [u8; 32], u32),
     SetSessionKeys([u8; 32], String),
     ValidateFrom([u8; 32], u32),
+    ChillFrom([u8; 32]),
+    UnbondFrom([u8; 32], u128),
     EventLog(String, ActionLevel, ActionTarget),
 
     NewBestBlock(u32),

src/components/validator/chill_popup.rs

@@ -0,0 +1,112 @@
+use crossterm::event::{KeyCode, KeyEvent, KeyEventKind};
+use color_eyre::Result;
+use ratatui::{
+    layout::{Alignment, Constraint, Flex, Layout, Rect}, 
+    widgets::{Block, Clear, Paragraph}, 
+    Frame
+};
+use std::sync::mpsc::Sender;
+
+use super::{Component, PartialComponent, CurrentTab};
+use crate::{
+    action::Action, 
+    config::Config, 
+    palette::StylePalette, 
+};
+
+#[derive(Debug)]
+pub struct ChillPopup {
+    is_active: bool,
+    network_tx: Option<Sender<Action>>,
+    secret_seed: [u8; 32],
+    palette: StylePalette
+}
+
+impl Default for ChillPopup {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl ChillPopup {
+    pub fn new() -> Self {
+        Self {
+            is_active: false,
+            secret_seed: [0u8; 32],
+            network_tx: None,
+            palette: StylePalette::default(),
+        }
+    }
+
+    fn submit_message(&mut self) {
+        if let Some(network_tx) = &self.network_tx { 
+            let _ = network_tx.send(Action::ChillFrom(self.secret_seed));
+        }
+    }
+}
+
+impl PartialComponent for ChillPopup {
+    fn set_active(&mut self, current_tab: CurrentTab) {
+        match current_tab {
+            CurrentTab::ChillPopup => self.is_active = true,
+            _ => self.is_active = false,
+        }
+    }
+}
+
+impl Component for ChillPopup {
+    fn register_network_handler(&mut self, tx: Sender<Action>) -> Result<()> {
+        self.network_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());
+            self.palette.with_normal_border_style(style.get("normal_border_style").copied());
+            self.palette.with_normal_title_style(style.get("normal_title_style").copied());
+            self.palette.with_popup_style(style.get("popup_style").copied());
+            self.palette.with_popup_title_style(style.get("popup_title_style").copied());
+        }
+        Ok(())
+    }
+    fn handle_key_event(&mut self, key: KeyEvent) -> Result<Option<Action>> {
+        if self.is_active && key.kind == KeyEventKind::Press {
+            match key.code {
+                KeyCode::Enter => self.submit_message(),
+                KeyCode::Esc => self.is_active = false, 
+                _ => {},
+            };
+        }
+        Ok(None)
+    }
+
+    fn update(&mut self, action: Action) -> Result<Option<Action>> {
+        match action {
+            Action::SetStashSecret(secret_seed) => self.secret_seed = secret_seed,
+            _ => {}
+        };
+        Ok(None)
+    }
+
+    fn draw(&mut self, frame: &mut Frame, area: Rect) -> Result<()> {
+        if self.is_active {
+            let (border_style, border_type) = self.palette.create_popup_style();
+            let input = Paragraph::new(" Do you want to chill stash account and stop validation?")
+                .block(Block::bordered()
+                    .border_style(border_style)
+                    .border_type(border_type)
+                    .title_style(self.palette.create_popup_title_style())
+                    .title_alignment(Alignment::Right)
+                    .title(format!("Chill stash")));
+            let v = Layout::vertical([Constraint::Max(3)]).flex(Flex::Center);
+            let h = Layout::horizontal([Constraint::Max(57)]).flex(Flex::Center);
+            let [area] = v.areas(area);
+            let [area] = h.areas(area);
+
+            frame.render_widget(Clear, area);
+            frame.render_widget(input, area);
+        }
+        Ok(())
+    }
+}

src/components/validator/mod.rs

@@ -25,6 +25,8 @@ mod bond_popup;
 mod payout_popup;
 mod rotate_popup;
 mod validate_popup;
+mod chill_popup;
+mod unbond_popup;
 
 use stash_details::StashDetails;
 use staking_details::StakingDetails;
@@ -40,6 +42,8 @@ use bond_popup::BondPopup;
 use payout_popup::PayoutPopup;
 use rotate_popup::RotatePopup;
 use validate_popup::ValidatePopup;
+use chill_popup::ChillPopup;
+use unbond_popup::UnbondPopup;
 
 #[derive(Debug, Copy, Clone, PartialEq)]
 pub enum CurrentTab {
@@ -55,6 +59,8 @@ pub enum CurrentTab {
     PayoutPopup,
     RotatePopup,
     ValidatePopup,
+    ChillPopup,
+    UnbondPopup,
 }
 
 pub trait PartialComponent: Component {
@@ -89,6 +95,8 @@ impl Default for Validator {
                 Box::new(PayoutPopup::default()),
                 Box::new(RotatePopup::default()),
                 Box::new(ValidatePopup::default()),
+                Box::new(ChillPopup::default()),
+                Box::new(UnbondPopup::default()),
             ],
         }
     }
@@ -150,6 +158,8 @@ impl Component for Validator {
             CurrentTab::BondPopup | 
                 CurrentTab::RotatePopup |
                 CurrentTab::ValidatePopup |
+                CurrentTab::ChillPopup |
+                CurrentTab::UnbondPopup |
                 CurrentTab::PayoutPopup => match key.code {
                 KeyCode::Esc => {
                     self.current_tab = self.previous_tab;
@@ -198,6 +208,20 @@ impl Component for Validator {
                         component.set_active(self.current_tab.clone());
                     }
                 },
+                KeyCode::Char('U') => {
+                    self.previous_tab = self.current_tab;
+                    self.current_tab = CurrentTab::UnbondPopup;
+                    for component in self.components.iter_mut() {
+                        component.set_active(self.current_tab.clone());
+                    }
+                },
+                KeyCode::Char('C') => {
+                    self.previous_tab = self.current_tab;
+                    self.current_tab = CurrentTab::ChillPopup;
+                    for component in self.components.iter_mut() {
+                        component.set_active(self.current_tab.clone());
+                    }
+                },
                 KeyCode::Char('B') => {
                     self.previous_tab = self.current_tab;
                     self.current_tab = CurrentTab::BondPopup;

src/components/validator/unbond_popup.rs

@@ -0,0 +1,181 @@
+use crossterm::event::{KeyCode, KeyEvent, KeyEventKind};
+use color_eyre::Result;
+use ratatui::{
+    layout::{Position, Alignment, Constraint, Flex, Layout, Rect}, 
+    widgets::{Block, Clear, Paragraph}, 
+    Frame
+};
+use tokio::sync::mpsc::UnboundedSender;
+use std::sync::mpsc::Sender;
+
+use super::{Component, PartialComponent, CurrentTab};
+use crate::{
+    action::Action, 
+    config::Config, 
+    palette::StylePalette, 
+    types::{ActionLevel, ActionTarget}, 
+    widgets::{Input, InputRequest},
+};
+
+#[derive(Debug)]
+pub struct UnbondPopup {
+    is_active: bool,
+    action_tx: Option<UnboundedSender<Action>>,
+    network_tx: Option<Sender<Action>>,
+    secret_seed: [u8; 32],
+    is_bonded: bool,
+    amount: Input,
+    palette: StylePalette
+}
+
+impl Default for UnbondPopup {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl UnbondPopup {
+    pub fn new() -> Self {
+        Self {
+            is_active: false,
+            secret_seed: [0u8; 32],
+            action_tx: None,
+            network_tx: None,
+            is_bonded: false,
+            amount: Input::new(String::new()),
+            palette: StylePalette::default(),
+        }
+    }
+
+    fn log_event(&mut self, message: String, level: ActionLevel) {
+        if let Some(action_tx) = &self.action_tx {
+            let _ = action_tx.send(
+                Action::EventLog(message, level, ActionTarget::ValidatorLog));
+        }
+    }
+
+    fn submit_message(&mut self) {
+        if let Some(network_tx) = &self.network_tx { 
+            match self.amount.value().parse::<f64>() {
+                Ok(value) => {
+                    if self.is_bonded {
+                        let amount = (value * 1_000_000_000_000_000_000.0) as u128;
+                        let _ = network_tx.send(Action::UnbondFrom(
+                                self.secret_seed, amount));
+                    } else {
+                        self.log_event(
+                            format!("current stash doesn't have bond yet"), 
+                            ActionLevel::Warn);
+                    }
+                    if let Some(action_tx) = &self.action_tx {
+                        let _ = action_tx.send(Action::ClosePopup);
+                    }
+                },
+                Err(err) => self.log_event(
+                    format!("invalid amount, error: {err}"), ActionLevel::Error),
+            }
+        }
+    }
+
+    fn enter_char(&mut self, new_char: char) {
+        let is_separator_needed = !self.amount.value().contains('.') && new_char == '.';
+        if new_char.is_digit(10) || is_separator_needed {
+            let _ = self.amount.handle(InputRequest::InsertChar(new_char));
+        }
+    }
+
+    fn delete_char(&mut self) {
+        let _ = self.amount.handle(InputRequest::DeletePrevChar);
+    }
+
+    fn move_cursor_right(&mut self) {
+        let _ = self.amount.handle(InputRequest::GoToNextChar);
+    }
+
+    fn move_cursor_left(&mut self) {
+        let _ = self.amount.handle(InputRequest::GoToPrevChar);
+    }
+}
+
+impl PartialComponent for UnbondPopup {
+    fn set_active(&mut self, current_tab: CurrentTab) {
+        match current_tab {
+            CurrentTab::UnbondPopup => self.is_active = true,
+            _ => {
+                self.is_active = false;
+                self.amount = Input::new(String::new());
+            }
+        };
+    }
+}
+
+impl Component for UnbondPopup {
+    fn register_network_handler(&mut self, tx: Sender<Action>) -> Result<()> {
+        self.network_tx = Some(tx);
+        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());
+            self.palette.with_normal_border_style(style.get("normal_border_style").copied());
+            self.palette.with_normal_title_style(style.get("normal_title_style").copied());
+            self.palette.with_popup_style(style.get("popup_style").copied());
+            self.palette.with_popup_title_style(style.get("popup_title_style").copied());
+        }
+        Ok(())
+    }
+    fn handle_key_event(&mut self, key: KeyEvent) -> Result<Option<Action>> {
+        if self.is_active && key.kind == KeyEventKind::Press {
+            match key.code {
+                KeyCode::Enter => self.submit_message(),
+                KeyCode::Char(to_insert) => self.enter_char(to_insert),
+                KeyCode::Backspace => self.delete_char(),
+                KeyCode::Left => self.move_cursor_left(),
+                KeyCode::Right => self.move_cursor_right(),
+                KeyCode::Esc => self.is_active = false, 
+                _ => {},
+            };
+        }
+        Ok(None)
+    }
+
+    fn update(&mut self, action: Action) -> Result<Option<Action>> {
+        match action {
+            Action::SetIsBonded(is_bonded) => self.is_bonded = is_bonded,
+            Action::SetStashSecret(secret_seed) => self.secret_seed = secret_seed,
+            _ => {}
+        };
+        Ok(None)
+    }
+
+    fn draw(&mut self, frame: &mut Frame, area: Rect) -> Result<()> {
+        if self.is_active {
+            let (border_style, border_type) = self.palette.create_popup_style();
+            let input = Paragraph::new(self.amount.value())
+                .block(Block::bordered()
+                    .border_style(border_style)
+                    .border_type(border_type)
+                    .title_style(self.palette.create_popup_title_style())
+                    .title_alignment(Alignment::Right)
+                    .title(format!("Unbond amount")));
+            let v = Layout::vertical([Constraint::Max(3)]).flex(Flex::Center);
+            let h = Layout::horizontal([Constraint::Max(50)]).flex(Flex::Center);
+            let [area] = v.areas(area);
+            let [area] = h.areas(area);
+
+            frame.render_widget(Clear, area);
+            frame.render_widget(input, area);
+            frame.set_cursor_position(Position::new(
+                    area.x + self.amount.cursor() as u16 + 1,
+                    area.y + 1
+            ));
+        }
+        Ok(())
+    }
+}

src/components/validator/withdrawals.rs

@@ -178,25 +178,21 @@ impl Component for Withdrawals {
             self.unlockings
                 .iter()
                 .map(|(key, value)| {
-                    let mut era_index_text = Text::from(key.to_string()).alignment(Alignment::Left);
                     let mut est_era_text = Text::from(self.estimate_time(*key)).alignment(Alignment::Center);
                     let mut value_text = Text::from(self.prepare_u128(*value)).alignment(Alignment::Right);
 
                     if *key > self.current_era {
-                        era_index_text = era_index_text.add_modifier(Modifier::CROSSED_OUT);
                         est_era_text = est_era_text.add_modifier(Modifier::CROSSED_OUT);
                         value_text = value_text.add_modifier(Modifier::CROSSED_OUT);
                     }
 
                     Row::new(vec![
-                        Cell::from(era_index_text),
                         Cell::from(est_era_text),
                         Cell::from(value_text),
                     ])
                 }),
             [
-                Constraint::Length(12),
-                Constraint::Length(13),
+                Constraint::Length(7),
                 Constraint::Min(0),
             ],
         )

src/network/mod.rs

@@ -349,6 +349,41 @@ impl Network {
                 }
                 Ok(())
             }
+            Action::ChillFrom(sender) => {
+                let sender_str = hex::encode(sender);
+                let maybe_nonce = self.senders.get_mut(&sender_str);
+                if let Ok(tx_progress) = predefined_txs::chill(
+                    &self.action_tx,
+                    &self.online_client_api,
+                    &sender,
+                    maybe_nonce,
+                ).await {
+                    self.transactions_to_watch.push(TxToWatch {
+                        tx_progress,
+                        sender: sender_str,
+                        target: ActionTarget::ValidatorLog,
+                    });
+                }
+                Ok(())
+            }
+            Action::UnbondFrom(sender, amount) => {
+                let sender_str = hex::encode(sender);
+                let maybe_nonce = self.senders.get_mut(&sender_str);
+                if let Ok(tx_progress) = predefined_txs::unbond(
+                    &self.action_tx,
+                    &self.online_client_api,
+                    &sender,
+                    &amount,
+                    maybe_nonce,
+                ).await {
+                    self.transactions_to_watch.push(TxToWatch {
+                        tx_progress,
+                        sender: sender_str,
+                        target: ActionTarget::ValidatorLog,
+                    });
+                }
+                Ok(())
+            }
             _ => Ok(())
         }
     }

src/network/predefined_txs.rs

@@ -1,6 +1,6 @@
 use color_eyre::Result;
 use subxt::{
-    ext::sp_core::{sr25519::Pair, Pair as PairT},
+    ext::sp_core::{sr25519::Pair, Pair as PairT}, 
     tx::{PairSigner, TxProgress}, 
     OnlineClient,
 };
@@ -19,48 +19,19 @@ pub async fn transfer_balance(
     sender: &[u8; 32],
     receiver: &[u8; 32],
     amount: &u128,
-    mut maybe_nonce: Option<&mut u32>,
+    maybe_nonce: Option<&mut u32>,
 ) -> Result<TxProgress<CasperConfig, OnlineClient<CasperConfig>>> {
-    let receiver_id = subxt::utils::MultiAddress::Id(
-        subxt::utils::AccountId32::from(*receiver)
-    );
-
-    let transfer_tx = casper_network::tx()
-        .balances()
-        .transfer_allow_death(receiver_id, *amount);
-
-    let tx_params = match maybe_nonce {
-        Some(ref mut nonce) => {
-            **nonce = nonce.saturating_add(1);
-            CasperExtrinsicParamsBuilder::new()
-                .nonce(nonce.saturating_sub(1) as u64)
-                .build()
-        },
-        None => CasperExtrinsicParamsBuilder::new().build(),
-    };
-
-    let pair = Pair::from_seed(sender);
-    let signer = PairSigner::<CasperConfig, Pair>::new(pair);
-
-    match api
-        .tx()
-        .sign_and_submit_then_watch(&transfer_tx, &signer, tx_params)
-        .await {
-            Ok(tx_progress) => {
-                action_tx.send(Action::EventLog(
-                        format!("transfer transaction {} sent", tx_progress.extrinsic_hash()),
-                        ActionLevel::Info,
-                        ActionTarget::WalletLog))?;
-                Ok(tx_progress)
-            },
-            Err(err) => {
-                action_tx.send(Action::EventLog(
-                        format!("error during transfer: {err}"), 
-                        ActionLevel::Error,
-                        ActionTarget::WalletLog))?;
-                Err(err.into())
-            }
-        }
+    let receiver_id = subxt::utils::MultiAddress::Id(subxt::utils::AccountId32::from(*receiver));
+    let transfer_tx = casper_network::tx().balances().transfer_allow_death(receiver_id, *amount);
+    inner_sign_and_submit_then_watch(
+        action_tx, 
+        api, 
+        sender, 
+        maybe_nonce, 
+        Box::new(transfer_tx), 
+        "transfer", 
+        ActionTarget::WalletLog,
+    ).await
 }
 
 pub async fn bond_extra(
@@ -68,44 +39,18 @@ pub async fn bond_extra(
     api: &OnlineClient<CasperConfig>,
     sender: &[u8; 32],
     amount: &u128,
-    mut maybe_nonce: Option<&mut u32>,
+    maybe_nonce: Option<&mut u32>,
 ) -> Result<TxProgress<CasperConfig, OnlineClient<CasperConfig>>> {
-    let transfer_tx = casper_network::tx()
-        .staking()
-        .bond_extra(*amount);
-
-    let tx_params = match maybe_nonce {
-        Some(ref mut nonce) => {
-            **nonce = nonce.saturating_add(1);
-            CasperExtrinsicParamsBuilder::new()
-                .nonce(nonce.saturating_sub(1) as u64)
-                .build()
-        },
-        None => CasperExtrinsicParamsBuilder::new().build(),
-    };
-
-    let pair = Pair::from_seed(sender);
-    let signer = PairSigner::<CasperConfig, Pair>::new(pair);
-
-    match api
-        .tx()
-        .sign_and_submit_then_watch(&transfer_tx, &signer, tx_params)
-        .await {
-            Ok(tx_progress) => {
-                action_tx.send(Action::EventLog(
-                        format!("bond extra transaction {} sent", tx_progress.extrinsic_hash()),
-                        ActionLevel::Info,
-                        ActionTarget::ValidatorLog))?;
-                Ok(tx_progress)
-            },
-            Err(err) => {
-                action_tx.send(Action::EventLog(
-                        format!("error during bond extra: {err}"), 
-                        ActionLevel::Error,
-                        ActionTarget::ValidatorLog))?;
-                Err(err.into())
-            }
-        }
+    let bond_extra_tx = casper_network::tx().staking().bond_extra(*amount);
+    inner_sign_and_submit_then_watch(
+        action_tx, 
+        api, 
+        sender, 
+        maybe_nonce, 
+        Box::new(bond_extra_tx), 
+        "bond extra", 
+        ActionTarget::ValidatorLog,
+    ).await
 }
 
 pub async fn bond(
@@ -113,48 +58,20 @@ pub async fn bond(
     api: &OnlineClient<CasperConfig>,
     sender: &[u8; 32],
     amount: &u128,
-    mut maybe_nonce: Option<&mut u32>,
+    maybe_nonce: Option<&mut u32>,
 ) -> Result<TxProgress<CasperConfig, OnlineClient<CasperConfig>>> {
     // auto-stake everything by now
-    let reward_destination = 
-        casper_network::runtime_types::pallet_staking::RewardDestination::Staked;
-
-    let transfer_tx = casper_network::tx()
-        .staking()
-        .bond(*amount, reward_destination);
-
-    let tx_params = match maybe_nonce {
-        Some(ref mut nonce) => {
-            **nonce = nonce.saturating_add(1);
-            CasperExtrinsicParamsBuilder::new()
-                .nonce(nonce.saturating_sub(1) as u64)
-                .build()
-        },
-        None => CasperExtrinsicParamsBuilder::new().build(),
-    };
-
-    let pair = Pair::from_seed(sender);
-    let signer = PairSigner::<CasperConfig, Pair>::new(pair);
-
-    match api
-        .tx()
-        .sign_and_submit_then_watch(&transfer_tx, &signer, tx_params)
-        .await {
-            Ok(tx_progress) => {
-                action_tx.send(Action::EventLog(
-                        format!("bond transaction {} sent", tx_progress.extrinsic_hash()),
-                        ActionLevel::Info,
-                        ActionTarget::ValidatorLog))?;
-                Ok(tx_progress)
-            },
-            Err(err) => {
-                action_tx.send(Action::EventLog(
-                        format!("error during bond: {err}"), 
-                        ActionLevel::Error,
-                        ActionTarget::ValidatorLog))?;
-                Err(err.into())
-            }
-        }
+    let reward_destination = casper_network::runtime_types::pallet_staking::RewardDestination::Staked;
+    let bond_tx = casper_network::tx().staking().bond(*amount, reward_destination);
+    inner_sign_and_submit_then_watch(
+        action_tx, 
+        api, 
+        sender, 
+        maybe_nonce, 
+        Box::new(bond_tx), 
+        "bond", 
+        ActionTarget::ValidatorLog,
+    ).await
 }
 
 pub async fn payout_stakers(
@@ -163,45 +80,19 @@ pub async fn payout_stakers(
     sender: &[u8; 32],
     stash: &[u8; 32],
     era_index: u32,
-    mut maybe_nonce: Option<&mut u32>,
+    maybe_nonce: Option<&mut u32>,
 ) -> Result<TxProgress<CasperConfig, OnlineClient<CasperConfig>>> {
     let stash_id = subxt::utils::AccountId32::from(*stash);
-    let transfer_tx = casper_network::tx()
-        .staking()
-        .payout_stakers(stash_id, era_index);
-
-    let tx_params = match maybe_nonce {
-        Some(ref mut nonce) => {
-            **nonce = nonce.saturating_add(1);
-            CasperExtrinsicParamsBuilder::new()
-                .nonce(nonce.saturating_sub(1) as u64)
-                .build()
-        },
-        None => CasperExtrinsicParamsBuilder::new().build(),
-    };
-
-    let pair = Pair::from_seed(sender);
-    let signer = PairSigner::<CasperConfig, Pair>::new(pair);
-
-    match api
-        .tx()
-        .sign_and_submit_then_watch(&transfer_tx, &signer, tx_params)
-        .await {
-            Ok(tx_progress) => {
-                action_tx.send(Action::EventLog(
-                        format!("payout stakers {} sent", tx_progress.extrinsic_hash()),
-                        ActionLevel::Info,
-                        ActionTarget::ValidatorLog))?;
-                Ok(tx_progress)
-            },
-            Err(err) => {
-                action_tx.send(Action::EventLog(
-                        format!("error during payout stakers: {err}"), 
-                        ActionLevel::Error,
-                        ActionTarget::ValidatorLog))?;
-                Err(err.into())
-            }
-        }
+    let payout_stakers_tx = casper_network::tx().staking().payout_stakers(stash_id, era_index);
+    inner_sign_and_submit_then_watch(
+        action_tx, 
+        api, 
+        sender, 
+        maybe_nonce, 
+        Box::new(payout_stakers_tx), 
+        "payout stakers", 
+        ActionTarget::ValidatorLog,
+    ).await
 }
 
 pub async fn set_keys(
@@ -209,7 +100,7 @@ pub async fn set_keys(
     api: &OnlineClient<CasperConfig>,
     sender: &[u8; 32],
     hashed_keys_str: &String,
-    mut maybe_nonce: Option<&mut u32>,
+    maybe_nonce: Option<&mut u32>,
 ) -> Result<TxProgress<CasperConfig, OnlineClient<CasperConfig>>> {
     let (gran_key, babe_key, audi_key, slow_key) = {
         let s = hashed_keys_str.trim_start_matches("0x");
@@ -220,53 +111,24 @@ pub async fn set_keys(
             hex::decode(&s[192..256]).unwrap().as_slice().try_into().unwrap(),
         )
     };
-
     let session_keys = runtime_types::casper_runtime::opaque::SessionKeys {
         grandpa: runtime_types::sp_consensus_grandpa::app::Public(gran_key),
         babe: runtime_types::sp_consensus_babe::app::Public(babe_key),
         authority_discovery: runtime_types::sp_authority_discovery::app::Public(audi_key),
         slow_clap: runtime_types::ghost_slow_clap::sr25519::app_sr25519::Public(slow_key),
     };
-
     // it seems like there is no check for the second paramter, that's why
-    // we it can be anything.
-    // Not sure TBH
-    let transfer_tx = casper_network::tx()
-        .session()
-        .set_keys(session_keys, Vec::new());
-
-    let tx_params = match maybe_nonce {
-        Some(ref mut nonce) => {
-            **nonce = nonce.saturating_add(1);
-            CasperExtrinsicParamsBuilder::new()
-                .nonce(nonce.saturating_sub(1) as u64)
-                .build()
-        },
-        None => CasperExtrinsicParamsBuilder::new().build(),
-    };
-
-    let pair = Pair::from_seed(sender);
-    let signer = PairSigner::<CasperConfig, Pair>::new(pair);
-
-    match api
-        .tx()
-        .sign_and_submit_then_watch(&transfer_tx, &signer, tx_params)
-        .await {
-            Ok(tx_progress) => {
-                action_tx.send(Action::EventLog(
-                        format!("set keys {} sent", tx_progress.extrinsic_hash()),
-                        ActionLevel::Info,
-                        ActionTarget::ValidatorLog))?;
-                Ok(tx_progress)
-            },
-            Err(err) => {
-                action_tx.send(Action::EventLog(
-                        format!("error during set keys: {err}"), 
-                        ActionLevel::Error,
-                        ActionTarget::ValidatorLog))?;
-                Err(err.into())
-            }
-        }
+    // we it can be anything. For example empty vector.
+    let set_keys_tx = casper_network::tx().session().set_keys(session_keys, Vec::new());
+    inner_sign_and_submit_then_watch(
+        action_tx, 
+        api, 
+        sender, 
+        maybe_nonce, 
+        Box::new(set_keys_tx), 
+        "set keys", 
+        ActionTarget::ValidatorLog,
+    ).await
 }
 
 pub async fn validate(
@@ -274,17 +136,71 @@ pub async fn validate(
     api: &OnlineClient<CasperConfig>,
     sender: &[u8; 32],
     percent: u32,
-    mut maybe_nonce: Option<&mut u32>,
+    maybe_nonce: Option<&mut u32>,
 ) -> Result<TxProgress<CasperConfig, OnlineClient<CasperConfig>>> {
     let validator_prefs = casper_network::runtime_types::pallet_staking::ValidatorPrefs {
         commission: runtime_types::sp_arithmetic::per_things::Perbill(percent),
         blocked: percent >= 1_000_000_000u32,
     };
+    let validate_tx = casper_network::tx().staking().validate(validator_prefs);
+    inner_sign_and_submit_then_watch(
+        action_tx, 
+        api, 
+        sender, 
+        maybe_nonce, 
+        Box::new(validate_tx), 
+        "validate", 
+        ActionTarget::ValidatorLog,
+    ).await
+}
 
-    let transfer_tx = casper_network::tx()
-        .staking()
-        .validate(validator_prefs);
+pub async fn chill(
+    action_tx: &UnboundedSender<Action>,
+    api: &OnlineClient<CasperConfig>,
+    sender: &[u8; 32],
+    maybe_nonce: Option<&mut u32>,
+) -> Result<TxProgress<CasperConfig, OnlineClient<CasperConfig>>> {
+    let chill_tx = casper_network::tx().staking().chill();
+    inner_sign_and_submit_then_watch(
+        action_tx, 
+        api, 
+        sender, 
+        maybe_nonce, 
+        Box::new(chill_tx), 
+        "chill", 
+        ActionTarget::ValidatorLog,
+    ).await
+}
 
+pub async fn unbond(
+    action_tx: &UnboundedSender<Action>,
+    api: &OnlineClient<CasperConfig>,
+    sender: &[u8; 32],
+    amount: &u128,
+    maybe_nonce: Option<&mut u32>,
+) -> Result<TxProgress<CasperConfig, OnlineClient<CasperConfig>>> {
+    let unbond_tx = casper_network::tx().staking().unbond(*amount);
+    inner_sign_and_submit_then_watch(
+        action_tx, 
+        api, 
+        sender, 
+        maybe_nonce, 
+        Box::new(unbond_tx), 
+        "unbond", 
+        ActionTarget::ValidatorLog,
+    ).await
+}
+
+async fn inner_sign_and_submit_then_watch(
+    action_tx: &UnboundedSender<Action>,
+    api: &OnlineClient<CasperConfig>,
+    sender: &[u8; 32],
+    mut maybe_nonce: Option<&mut u32>,
+    tx_call: Box<dyn subxt::tx::Payload>,
+    tx_name: &str,
+    target: ActionTarget,
+) -> Result<TxProgress<CasperConfig, OnlineClient<CasperConfig>>> {
+    let signer = PairSigner::<CasperConfig, Pair>::new(Pair::from_seed(sender));
     let tx_params = match maybe_nonce {
         Some(ref mut nonce) => {
             **nonce = nonce.saturating_add(1);
@@ -295,25 +211,22 @@ pub async fn validate(
         None => CasperExtrinsicParamsBuilder::new().build(),
     };
 
-    let pair = Pair::from_seed(sender);
-    let signer = PairSigner::<CasperConfig, Pair>::new(pair);
-
     match api
         .tx()
-        .sign_and_submit_then_watch(&transfer_tx, &signer, tx_params)
+        .sign_and_submit_then_watch(&tx_call, &signer, tx_params)
         .await {
             Ok(tx_progress) => {
                 action_tx.send(Action::EventLog(
-                        format!("set keys {} sent", tx_progress.extrinsic_hash()),
-                        ActionLevel::Info,
-                        ActionTarget::ValidatorLog))?;
+                        format!("{tx_name} transaction {} sent", tx_progress.extrinsic_hash()), 
+                        ActionLevel::Info, 
+                        target))?;
                 Ok(tx_progress)
             },
             Err(err) => {
                 action_tx.send(Action::EventLog(
-                        format!("error during set keys: {err}"), 
-                        ActionLevel::Error,
-                        ActionTarget::ValidatorLog))?;
+                        format!("error during {tx_name} transaction: {err}"), 
+                        ActionLevel::Error, 
+                        target))?;
                 Err(err.into())
             }
         }