chore(json_rpc): simplify QueryStakesFilter

Author: guidiaz

node/src/actors/chain_manager/handlers.rs

@@ -20,7 +20,7 @@ use witnet_data_structures::{
     get_protocol_version,
     proto::versioning::ProtocolVersion,
     refresh_protocol_version,
-    staking::{errors::StakesError, prelude::StakeKey},
+    staking::{errors::StakesError, prelude::StakeKey, stakes::QueryStakesKey},
     transaction::{
         DRTransaction, StakeTransaction, Transaction, UnstakeTransaction, VTTransaction,
     },
@@ -1734,7 +1734,7 @@ impl Handler<GetBalance2> for ChainManager {
                         })
                         .add_utxo_value(vto.value, vto.time_lock as i64 > now);
                 }
-                let stakes = self.chain_state.stakes.query_stakes(QueryStakesFilter::All);
+                let stakes = self.chain_state.stakes.query_stakes(QueryStakesKey::All);
                 if let Ok(stakes) = stakes {
                     stakes.iter().for_each(|entry| {
                         balances
@@ -1757,21 +1757,22 @@ impl Handler<GetBalance2> for ChainManager {
                 NodeBalance2::Many(balances)
             }
             GetBalance2::Address(pkh) => {
+                let pkh = try_do_magic_into_pkh(pkh.clone()).map_err(|e| {
+                    log::warn!(
+                        "Failed to convert {:?} into a valid public key hash: {e}",
+                        pkh
+                    );
+                    e
+                })?;
                 let mut balance = transaction_factory::get_utxos_balance(
                     &self.chain_state.unspent_outputs_pool,
-                    try_do_magic_into_pkh(pkh.clone()).map_err(|e| {
-                        log::warn!(
-                            "Failed to convert {:?} into a valid public key hash: {e}",
-                            pkh
-                        );
-                        e
-                    })?,
+                    pkh,
                     now,
                 );
                 let stakes = self
                     .chain_state
                     .stakes
-                    .query_stakes(QueryStakesFilter::Withdrawer(pkh));
+                    .query_stakes(QueryStakesKey::Validator(pkh));
                 if let Ok(stakes) = stakes {
                     balance.add_staked(stakes.iter().fold(0u64, |staked: u64, entry| {
                         staked.saturating_add(entry.value.coins.nanowits())

node/src/actors/messages.rs

@@ -359,21 +359,11 @@ impl Message for QueryStakePowers {
 /// Stake key for quering stakes
 #[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
 #[derive(Default)]
-pub enum QueryStakesFilter {
+pub struct QueryStakesFilter {
     /// To search by the validator public key hash
-    Validator(MagicEither<String, PublicKeyHash>),
+    pub validator: Option<MagicEither<String, PublicKeyHash>>,
     /// To search by the withdrawer public key hash
-    Withdrawer(MagicEither<String, PublicKeyHash>),
-    /// To search by validator and withdrawer public key hashes
-    Key(
-        (
-            MagicEither<String, PublicKeyHash>,
-            MagicEither<String, PublicKeyHash>,
-        ),
-    ),
-    /// To query all stake entries
-    #[default]
-    All,
+    pub withdrawer: Option<MagicEither<String, PublicKeyHash>>,
 }
 
 
@@ -411,19 +401,23 @@ where
 {
     type Error = PublicKeyHashParseError;
 
-    fn try_from(query: QueryStakesFilter) -> Result<Self, Self::Error> {
-        Ok(match query {
-            QueryStakesFilter::Key(key) => QueryStakesKey::Key(StakeKey {
-                validator: try_do_magic_into_pkh(key.0)?.into(),
-                withdrawer: try_do_magic_into_pkh(key.1)?.into(),
-            }),
-            QueryStakesFilter::Validator(v) => {
-                QueryStakesKey::Validator(try_do_magic_into_pkh(v)?.into())
-            }
-            QueryStakesFilter::Withdrawer(w) => {
-                QueryStakesKey::Withdrawer(try_do_magic_into_pkh(w)?.into())
-            }
-            QueryStakesFilter::All => QueryStakesKey::All,
+    fn try_from(filter: QueryStakesFilter) -> Result<Self, Self::Error> {
+        Ok(match (filter.validator, filter.withdrawer) {
+            (Some(validator), Some(withdrawer)) => {
+                QueryStakesKey::Key(StakeKey {
+                    validator: try_do_magic_into_pkh(validator)?.into(),
+                    withdrawer: try_do_magic_into_pkh(withdrawer)?.into(),
+                })
+            }, 
+            (Some(validator), None) => {
+                QueryStakesKey::Validator(try_do_magic_into_pkh(validator)?.into())
+            },
+            (None, Some(withdrawer)) => {
+                QueryStakesKey::Withdrawer(try_do_magic_into_pkh(withdrawer)?.into())
+            },
+            (None, None) => {
+                QueryStakesKey::All
+            },
         })
     }
 }

src/cli/node/json_rpc_client.rs

@@ -1955,25 +1955,28 @@ pub fn query_stakes(
     long: bool,
 ) -> Result<(), failure::Error> {
     let mut stream = start_client(addr)?;
-    let params = match (validator, withdrawer) {
-        (Some(validator), Some(withdrawer)) => QueryStakes {
-            filter: QueryStakesFilter::Key((
-                MagicEither::Left(validator),
-                MagicEither::Left(withdrawer),
-            )),
-            limits: QueryStakesLimits::default(),
-        },
-        (Some(validator), _) => QueryStakes {
-            filter: QueryStakesFilter::Validator(MagicEither::Left(validator)),
-            limits: QueryStakesLimits::default(),
-        },
-        (_, Some(withdrawer)) => QueryStakes {
-            filter: QueryStakesFilter::Withdrawer(MagicEither::Left(withdrawer)),
-            limits: QueryStakesLimits::default(),
+    let params = QueryStakes {
+        filter: match (validator, withdrawer) {
+            (Some(validator), Some(withdrawer)) => QueryStakesFilter {
+                validator: Some(MagicEither::Left(validator)),
+                withdrawer: Some(MagicEither::Left(withdrawer)),
+            },
+            (Some(validator), None) => QueryStakesFilter {
+                validator: Some(MagicEither::Left(validator)),
+                withdrawer: None,
+            },
+            (None, Some(withdrawer)) => QueryStakesFilter {
+                validator: None,
+                withdrawer: Some(MagicEither::Left(withdrawer)),
+            },
+            (None, None) => QueryStakesFilter {
+                validator: None,
+                withdrawer: None,
+            },
         },
-        (None, None) => QueryStakes::default(),
+        limits: QueryStakesLimits::default(),
     };
-
+    
     let response = send_request(
         &mut stream,
         &format!(