feat(cli): add queryPowers to CLI

Author: drcpu-github

Cargo.lock

@@ -1,8 +1,21 @@
 use serde::{Deserialize, Serialize};
+use strum_macros::{EnumString, IntoStaticStr};
 
 #[repr(u8)]
-#[derive(Clone, Copy, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
+#[derive(
+    Clone,
+    Copy,
+    Debug,
+    Default,
+    EnumString,
+    Eq,
+    IntoStaticStr,
+    PartialEq,
+    serde::Deserialize,
+    serde::Serialize,
+)]
 #[serde(rename_all = "lowercase")]
+#[strum(serialize_all = "snake_case")]
 pub enum Capability {
     /// The base block mining and superblock voting capability
     #[default]

data_structures/src/capabilities.rs

@@ -30,6 +30,7 @@ pin-project-lite = "0.2"
 sentry = { version = "0.29.3", features = ["log"], optional = true }
 serde = { version = "1.0.104", features = ["derive"] }
 serde_json = "1.0.47"
+strum_macros = "0.26.4"
 tokio = { version = "1.0.1", features = ["io-util", "net", "time", "sync"] }
 tokio-util = { version = "0.7", features = ["codec"] }
 trust-dns-resolver = { version = "0.20.0" , default-features = false, features = ["tokio-runtime", "system-config"] }

node/Cargo.toml

@@ -1471,10 +1471,19 @@ impl Handler<QueryStakePowers> for ChainManager {
     type Result = <QueryStakePowers as Message>::Result;
 
     fn handle(&mut self, msg: QueryStakePowers, _ctx: &mut Self::Context) -> Self::Result {
-        self.chain_state
-            .stakes
-            .by_rank(msg.capability, self.current_epoch.unwrap())
-            .collect()
+        let mut powers = HashMap::new();
+        let current_epoch = self.current_epoch.unwrap();
+        for capability in msg.capabilities {
+            for (key, power) in self
+                .chain_state
+                .stakes
+                .by_rank(capability, current_epoch)
+            {
+                powers.entry(key).or_insert(vec![]).push(power);
+            }
+        }
+
+        powers.into_iter().collect()
     }
 }
 

node/src/actors/chain_manager/handlers.rs

@@ -19,6 +19,7 @@ use itertools::Itertools;
 use jsonrpc_core::{BoxFuture, Error, Params, Value};
 use jsonrpc_pubsub::{Subscriber, SubscriptionId};
 use serde::{Deserialize, Serialize};
+use strum_macros::IntoStaticStr;
 
 use witnet_crypto::key::KeyPath;
 use witnet_data_structures::{
@@ -2267,31 +2268,44 @@ pub async fn query_stakes(params: Result<Option<QueryStakesParams>, Error>) -> J
         .await
 }
 
-/// Format of the output of getTransaction
+/// Param for query_stakes
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq, IntoStaticStr, Serialize)]
+#[serde(rename_all = "lowercase")]
+pub enum QueryPowersParams {
+    /// To query all validators' power for a specific capability
+    Capability(Capability),
+    /// To query all powers
+    All(bool),
+}
+
+/// Format of the output of query_powers
 #[derive(Clone, Debug, PartialEq, Eq, serde::Deserialize, serde::Serialize)]
 pub struct QueryPowersRecord {
     /// Current power
-    pub power: u64,
+    pub powers: Vec<u64>,
     /// Validator's stringified pkh
     pub validator: String,
     /// Withdrawer's stringified pkh
     pub withdrawer: String,
 }
 
 /// Query the amount of nanowits staked by an address.
-pub async fn query_powers(params: Result<(Capability,), Error>) -> JsonRpcResult {
-    let capability = match params {
-        Ok(x) => x.0,
-        Err(_) => Capability::Mining,
+pub async fn query_powers(params: Result<QueryPowersParams, Error>) -> JsonRpcResult {
+    // Short-circuit if parameters are wrong
+    let params = params?;
+
+    let capabilities = match params {
+        QueryPowersParams::All(_) => ALL_CAPABILITIES.to_vec(),
+        QueryPowersParams::Capability(c) => vec![c],
     };
     ChainManager::from_registry()
-        .send(QueryStakePowers { capability })
+        .send(QueryStakePowers { capabilities })
         .map(|res| match res {
             Ok(candidates) => {
                 let candidates: Vec<QueryPowersRecord> = candidates
                     .iter()
-                    .map(|(key, power)| QueryPowersRecord {
-                        power: *power,
+                    .map(|(key, powers)| QueryPowersRecord {
+                        powers: powers.clone(),
                         validator: key.validator.to_string(),
                         withdrawer: key.withdrawer.to_string(),
                     })

node/src/actors/json_rpc/api.rs

@@ -347,12 +347,12 @@ impl Message for StakeAuthorization {
 /// Message for querying stakes
 #[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize)]
 pub struct QueryStakePowers {
-    /// capability being searched for
-    pub capability: Capability,
+    /// capabilities being searched for
+    pub capabilities: Vec<Capability>,
 }
 
 impl Message for QueryStakePowers {
-    type Result = Vec<(StakeKey<PublicKeyHash>, Power)>;
+    type Result = Vec<(StakeKey<PublicKeyHash>, Vec<Power>)>;
 }
 
 /// Stake key for quering stakes

node/src/actors/messages.rs

@@ -14,7 +14,7 @@ use ansi_term::Color::{Purple, Red, White, Yellow};
 use failure::{bail, Fail};
 use itertools::Itertools;
 use num_format::{Locale, ToFormattedString};
-use prettytable::{row, Table};
+use prettytable::{row, Cell, Row, Table};
 use qrcode::render::unicode;
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
 
@@ -24,6 +24,7 @@ use witnet_crypto::{
     key::{ExtendedPK, ExtendedSK},
 };
 use witnet_data_structures::{
+    capabilities::{Capability, ALL_CAPABILITIES},
     chain::{
         priority::{PrioritiesEstimate, Priority, PriorityEstimate, TimeToBlock},
         tapi::{current_active_wips, ActiveWips},
@@ -49,7 +50,8 @@ use witnet_data_structures::{
 use witnet_node::actors::{
     chain_manager::run_dr_locally,
     json_rpc::api::{
-        AddrType, GetBlockChainParams, GetTransactionOutput, PeersResult, QueryStakesParams,
+        AddrType, GetBlockChainParams, GetTransactionOutput, PeersResult, QueryPowersParams,
+        QueryPowersRecord, QueryStakesParams,
     },
     messages::{
         AuthorizeStake, BuildDrt, BuildStakeParams, BuildStakeResponse, BuildUnstakeParams,
@@ -2009,6 +2011,74 @@ pub fn query_stakes(
     Ok(())
 }
 
+pub fn query_powers(
+    addr: SocketAddr,
+    capability: Option<String>,
+    all: bool,
+) -> Result<(), failure::Error> {
+    let mut stream = start_client(addr)?;
+    let params = if all {
+        QueryPowersParams::All(true)
+    } else {
+        match capability {
+            Some(c) => match Capability::from_str(&c) {
+                Ok(c) => QueryPowersParams::Capability(c),
+                Err(_) => QueryPowersParams::Capability(Capability::Mining),
+            },
+            None => QueryPowersParams::Capability(Capability::Mining),
+        }
+    };
+
+    let response = send_request(
+        &mut stream,
+        &format!(
+            r#"{{"jsonrpc": "2.0","method": "queryPowers", "params": {}, "id": 1}}"#,
+            serde_json::to_string(&params).unwrap()
+        ),
+    )?;
+
+    let mut powers: Vec<QueryPowersRecord> = parse_response(&response)?;
+    powers.sort_by_key(|power| Reverse(power.powers[0]));
+
+    let mut powers_table = Table::new();
+    powers_table.set_format(*prettytable::format::consts::FORMAT_NO_BORDER_LINE_SEPARATOR);
+    if all {
+        let mut header = vec![
+            Cell::new("Validator").style_spec("c"),
+            Cell::new("Withdrawer").style_spec("c"),
+        ];
+        for capability in ALL_CAPABILITIES {
+            let capability_str: &'static str = capability.into();
+            header.push(Cell::new(capability_str).style_spec("c"));
+        }
+        powers_table.set_titles(Row::new(header));
+        for power in powers.iter() {
+            let mut row = vec![
+                Cell::new(&power.validator.to_string()),
+                Cell::new(&power.withdrawer.to_string()),
+            ];
+            for p in &power.powers {
+                row.push(Cell::new(&p.to_formatted_string(&Locale::en)).style_spec("r"));
+            }
+            powers_table.add_row(Row::new(row));
+        }
+    } else {
+        let capability_str: &'static str = params.into();
+        powers_table.set_titles(row![c->"Validator", c->"Withdrawer", c->capability_str]);
+        for power in powers.iter() {
+            powers_table.add_row(row![
+                power.validator,
+                power.withdrawer,
+                r->(power.powers[0]).to_formatted_string(&Locale::en),
+            ]);
+        }
+    }
+    powers_table.printstd();
+    println!();
+
+    Ok(())
+}
+
 #[derive(Serialize, Deserialize)]
 struct SignatureWithData {
     address: String,

src/cli/node/json_rpc_client.rs

@@ -304,6 +304,11 @@ pub fn exec_cmd(
             all,
             long,
         ),
+        Command::QueryPowers {
+            node,
+            capability,
+            all,
+        } => rpc::query_powers(node.unwrap_or(default_jsonrpc), capability, all),
         Command::Unstake {
             node,
             operator,
@@ -840,6 +845,21 @@ pub enum Command {
         #[structopt(short = "l", long = "long")]
         long: bool,
     },
+
+    #[structopt(
+        name = "queryPowers",
+        alias = "powers",
+        about = "Retrieve information about powers"
+    )]
+    QueryPowers {
+        /// Socket address of the Witnet node to query
+        #[structopt(short = "n", long = "node")]
+        node: Option<SocketAddr>,
+        #[structopt(short = "c", long = "capability")]
+        capability: Option<String>,
+        #[structopt(short = "a", long = "all")]
+        all: bool,
+    },
     #[structopt(name = "unstake", about = "Create an unstake transaction")]
     Unstake {
         /// Socket address of the Witnet node to query