feat: New command - staking

src/commands/account/view_account_summary/mod.rs

@@ -1,7 +1,7 @@
 use color_eyre::eyre::Context;
+use futures::StreamExt;
 
-use crate::common::JsonRpcClientExt;
-use crate::common::RpcQueryResponseExt;
+use crate::common::{CallResultExt, JsonRpcClientExt, RpcQueryResponseExt};
 
 #[derive(Debug, Clone, interactive_clap::InteractiveClap)]
 #[interactive_clap(input_context = crate::GlobalContext)]
@@ -27,8 +27,9 @@ impl ViewAccountSummaryContext {
 
         let on_after_getting_block_reference_callback: crate::network_view_at_block::OnAfterGettingBlockReferenceCallback = std::sync::Arc::new({
             move |network_config, block_reference| {
-                let rpc_query_response = network_config
-                    .json_rpc_client()
+                let json_rpc_client = network_config.json_rpc_client();
+
+                let rpc_query_response = json_rpc_client
                     .blocking_call_view_account(&account_id.clone(), block_reference.clone())
                     .wrap_err_with(|| {
                         format!(
@@ -38,8 +39,7 @@ impl ViewAccountSummaryContext {
                     })?;
                 let account_view = rpc_query_response.account_view()?;
 
-                let access_key_list = network_config
-                    .json_rpc_client()
+                let access_key_list = json_rpc_client
                     .blocking_call_view_access_key_list(
                         &account_id,
                         block_reference.clone(),
@@ -52,10 +52,38 @@ impl ViewAccountSummaryContext {
                     })?
                     .access_key_list_view()?;
 
+                let validators_stake = crate::common::get_validators_stake(&json_rpc_client)?;
+
+                let runtime = tokio::runtime::Builder::new_multi_thread()
+                    .enable_all()
+                    .build()?;
+                let chunk_size = 15;
+                let concurrency = 10;
+
+                let delegated_stake: std::collections::HashMap<near_primitives::types::AccountId, crate::common::NearBalance> = runtime
+                .block_on(
+                    futures::stream::iter(validators_stake
+                        .iter()
+                        .collect::<Vec<_>>()
+                        .chunks(chunk_size),
+                    )
+                    .map(|validators| async {
+                        get_delegated_stake(&json_rpc_client, block_reference, &account_id, validators).await
+                    })
+                    .buffer_unordered(concurrency)
+                    .collect::<Vec<Result<_, _>>>(),
+                )
+                .into_iter()
+                .try_fold(std::collections::HashMap::new(), |mut acc, x| {
+                    acc.extend(x?);
+                    Ok::<_, color_eyre::eyre::Error>(acc)
+                })?;
+
                 crate::common::display_account_info(
                     &rpc_query_response.block_hash,
                     &rpc_query_response.block_height,
                     &account_id,
+                    delegated_stake,
                     &account_view,
                     &access_key_list.keys,
                 );
@@ -85,3 +113,67 @@ impl ViewAccountSummary {
         )
     }
 }
+
+async fn get_delegated_stake(
+    json_rpc_client: &near_jsonrpc_client::JsonRpcClient,
+    block_reference: &near_primitives::types::BlockReference,
+    account_id: &near_primitives::types::AccountId,
+    validators: &[(&near_primitives::types::AccountId, &u128)],
+) -> color_eyre::Result<
+    std::collections::HashMap<near_primitives::types::AccountId, crate::common::NearBalance>,
+> {
+    let mut validators_stake: std::collections::HashMap<
+        near_primitives::types::AccountId,
+        crate::common::NearBalance,
+    > = std::collections::HashMap::new();
+    for (validator_id, _) in validators {
+        let validator_id = *validator_id;
+        let user_staked_balance =
+            get_user_staked_balance(json_rpc_client, block_reference, validator_id, account_id)
+                .await
+                .ok();
+        let balance = if let Some(balance) = user_staked_balance {
+            if balance == 0 {
+                continue;
+            } else {
+                balance
+            }
+        } else {
+            continue;
+        };
+        validators_stake.insert(
+            validator_id.clone(),
+            crate::common::NearBalance::from_yoctonear(balance),
+        );
+    }
+    Ok(validators_stake)
+}
+
+async fn get_user_staked_balance(
+    json_rpc_client: &near_jsonrpc_client::JsonRpcClient,
+    block_reference: &near_primitives::types::BlockReference,
+    validator_account_id: &near_primitives::types::AccountId,
+    account_id: &near_primitives::types::AccountId,
+) -> color_eyre::eyre::Result<u128> {
+    Ok(json_rpc_client
+        .call(near_jsonrpc_client::methods::query::RpcQueryRequest {
+            block_reference: block_reference.clone(),
+            request: near_primitives::views::QueryRequest::CallFunction {
+                account_id: validator_account_id.clone(),
+                method_name: "get_account_staked_balance".to_string(),
+                args: near_primitives::types::FunctionArgs::from(
+                    serde_json::json!({
+                        "account_id": account_id,
+                    })
+                    .to_string()
+                    .into_bytes(),
+                ),
+            },
+        })
+        .await
+        .wrap_err("Failed to fetch query for view method: 'get_account_staked_balance'")?
+        .call_result()?
+        .parse_result_from_json::<String>()
+        .wrap_err("Failed to parse return value of view function call for String.")?
+        .parse::<u128>()?)
+}

src/commands/mod.rs

@@ -4,6 +4,7 @@ use strum::{EnumDiscriminants, EnumIter, EnumMessage};
 pub mod account;
 mod config;
 mod contract;
+mod staking;
 mod tokens;
 mod transaction;
 
@@ -25,6 +26,11 @@ pub enum TopLevelCommand {
     ))]
     /// Use this for token actions: send or view balances of NEAR, FT, or NFT
     Tokens(self::tokens::TokensCommands),
+    #[strum_discriminants(strum(
+        message = "staking     - Manage staking: view, add and withdraw stake"
+    ))]
+    /// Use this for manage staking: view, add and withdraw stake
+    Staking(self::staking::Staking),
     #[strum_discriminants(strum(
         message = "contract    - Manage smart-contracts: deploy code, call functions"
     ))]

src/commands/staking/delegate/deposit.rs

@@ -0,0 +1,88 @@
+use std::str::FromStr;
+
+#[derive(Debug, Clone, interactive_clap::InteractiveClap)]
+#[interactive_clap(input_context = super::DelegateStakeContext)]
+#[interactive_clap(output_context = DepositContext)]
+pub struct Deposit {
+    /// Enter the attached amount to be deposited into the predecessor's internal account (example: 10NEAR or 0.5near or 10000yoctonear):
+    amount: crate::common::NearBalance,
+    #[interactive_clap(skip_default_input_arg)]
+    /// What is the signer account ID?
+    signer_account_id: crate::types::account_id::AccountId,
+    #[interactive_clap(named_arg)]
+    /// Select network
+    network_config: crate::network_for_transaction::NetworkForTransactionArgs,
+}
+
+#[derive(Clone)]
+pub struct DepositContext(crate::commands::ActionContext);
+
+impl DepositContext {
+    pub fn from_previous_context(
+        previous_context: super::DelegateStakeContext,
+        scope: &<Deposit as interactive_clap::ToInteractiveClapContextScope>::InteractiveClapContextScope,
+    ) -> color_eyre::eyre::Result<Self> {
+        let signer = scope.signer_account_id.clone();
+        let signer_id: near_primitives::types::AccountId = scope.signer_account_id.clone().into();
+        let validator_account_id = previous_context.validator_account_id.clone();
+        let amount = scope.amount.clone();
+
+        let on_after_getting_network_callback: crate::commands::OnAfterGettingNetworkCallback =
+            std::sync::Arc::new(move |_network_config| {
+                Ok(crate::commands::PrepopulatedTransaction {
+                    signer_id: signer_id.clone(),
+                    receiver_id: previous_context.validator_account_id.clone(),
+                    actions: vec![near_primitives::transaction::Action::FunctionCall(
+                        near_primitives::transaction::FunctionCallAction {
+                            method_name: "deposit".to_string(),
+                            args: serde_json::json!({}).to_string().into_bytes(),
+                            gas: crate::common::NearGas::from_str("300 TeraGas")
+                                .unwrap()
+                                .inner,
+                            deposit: amount.to_yoctonear(),
+                        },
+                    )],
+                })
+            });
+
+        let amount = scope.amount.clone();
+        let on_after_sending_transaction_callback: crate::transaction_signature_options::OnAfterSendingTransactionCallback = std::sync::Arc::new(
+                move |outcome_view, _network_config| {
+                    if let near_primitives::views::FinalExecutionStatus::SuccessValue(_) = outcome_view.status {
+                        eprintln!(
+                            "<{signer}> has successfully deposited {amount} on <{validator_account_id}>.",
+                        );
+                        }
+                    Ok(())
+                },
+            );
+        Ok(Self(crate::commands::ActionContext {
+            global_context: previous_context.global_context,
+            on_after_getting_network_callback,
+            on_before_signing_callback: std::sync::Arc::new(
+                |_prepolulated_unsinged_transaction, _network_config| Ok(()),
+            ),
+            on_before_sending_transaction_callback: std::sync::Arc::new(
+                |_signed_transaction, _network_config, _message| Ok(()),
+            ),
+            on_after_sending_transaction_callback,
+        }))
+    }
+}
+
+impl From<DepositContext> for crate::commands::ActionContext {
+    fn from(item: DepositContext) -> Self {
+        item.0
+    }
+}
+
+impl Deposit {
+    pub fn input_signer_account_id(
+        context: &super::DelegateStakeContext,
+    ) -> color_eyre::eyre::Result<Option<crate::types::account_id::AccountId>> {
+        crate::common::input_signer_account_id_from_used_account_list(
+            &context.global_context.config.credentials_home_dir,
+            "What is the signer account ID?",
+        )
+    }
+}

src/commands/staking/delegate/deposit_and_stake.rs

@@ -0,0 +1,88 @@
+use std::str::FromStr;
+
+#[derive(Debug, Clone, interactive_clap::InteractiveClap)]
+#[interactive_clap(input_context = super::DelegateStakeContext)]
+#[interactive_clap(output_context = DepositAndStakeContext)]
+pub struct DepositAndStake {
+    /// Enter the attached amount to be deposited and then staked into the predecessor's internal account (example: 10NEAR or 0.5near or 10000yoctonear):
+    amount: crate::common::NearBalance,
+    #[interactive_clap(skip_default_input_arg)]
+    /// What is the signer account ID?
+    signer_account_id: crate::types::account_id::AccountId,
+    #[interactive_clap(named_arg)]
+    /// Select network
+    network_config: crate::network_for_transaction::NetworkForTransactionArgs,
+}
+
+#[derive(Clone)]
+pub struct DepositAndStakeContext(crate::commands::ActionContext);
+
+impl DepositAndStakeContext {
+    pub fn from_previous_context(
+        previous_context: super::DelegateStakeContext,
+        scope: &<DepositAndStake as interactive_clap::ToInteractiveClapContextScope>::InteractiveClapContextScope,
+    ) -> color_eyre::eyre::Result<Self> {
+        let signer = scope.signer_account_id.clone();
+        let signer_id: near_primitives::types::AccountId = scope.signer_account_id.clone().into();
+        let validator_account_id = previous_context.validator_account_id.clone();
+        let amount = scope.amount.clone();
+
+        let on_after_getting_network_callback: crate::commands::OnAfterGettingNetworkCallback =
+            std::sync::Arc::new(move |_network_config| {
+                Ok(crate::commands::PrepopulatedTransaction {
+                    signer_id: signer_id.clone(),
+                    receiver_id: previous_context.validator_account_id.clone(),
+                    actions: vec![near_primitives::transaction::Action::FunctionCall(
+                        near_primitives::transaction::FunctionCallAction {
+                            method_name: "deposit_and_stake".to_string(),
+                            args: serde_json::json!({}).to_string().into_bytes(),
+                            gas: crate::common::NearGas::from_str("300 TeraGas")
+                                .unwrap()
+                                .inner,
+                            deposit: amount.to_yoctonear(),
+                        },
+                    )],
+                })
+            });
+
+        let amount = scope.amount.clone();
+        let on_after_sending_transaction_callback: crate::transaction_signature_options::OnAfterSendingTransactionCallback = std::sync::Arc::new(
+                move |outcome_view, _network_config| {
+                    if let near_primitives::views::FinalExecutionStatus::SuccessValue(_) = outcome_view.status {
+                        eprintln!(
+                            "<{signer}> has successfully deposited and staked {amount} on <{validator_account_id}>.",
+                        );
+                        }
+                    Ok(())
+                },
+            );
+        Ok(Self(crate::commands::ActionContext {
+            global_context: previous_context.global_context,
+            on_after_getting_network_callback,
+            on_before_signing_callback: std::sync::Arc::new(
+                |_prepolulated_unsinged_transaction, _network_config| Ok(()),
+            ),
+            on_before_sending_transaction_callback: std::sync::Arc::new(
+                |_signed_transaction, _network_config, _message| Ok(()),
+            ),
+            on_after_sending_transaction_callback,
+        }))
+    }
+}
+
+impl From<DepositAndStakeContext> for crate::commands::ActionContext {
+    fn from(item: DepositAndStakeContext) -> Self {
+        item.0
+    }
+}
+
+impl DepositAndStake {
+    pub fn input_signer_account_id(
+        context: &super::DelegateStakeContext,
+    ) -> color_eyre::eyre::Result<Option<crate::types::account_id::AccountId>> {
+        crate::common::input_signer_account_id_from_used_account_list(
+            &context.global_context.config.credentials_home_dir,
+            "What is the signer account ID?",
+        )
+    }
+}