Address review: simplify HyperCore pending withdrawals

- Source pending from delegatorSummary instead of delegatorHistory, drop countdown
- Model staking amounts as String to avoid f64 round-trip
- Drop no-op serde rename_all and inline balance parsing

Author: DRadmir

crates/gem_hypercore/src/models/balance.rs

@@ -1,7 +1,6 @@
 use gem_evm::ethereum_address_checksum;
 use serde::{Deserialize, Serialize};
 use serde_serializers::deserialize_f64_from_str;
-use strum::{Display, EnumString};
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
@@ -35,20 +34,16 @@ pub struct Token {
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct StakeBalance {
-    #[serde(deserialize_with = "deserialize_f64_from_str")]
-    pub delegated: f64,
-    #[serde(deserialize_with = "deserialize_f64_from_str")]
-    pub undelegated: f64,
-    #[serde(deserialize_with = "deserialize_f64_from_str")]
-    pub total_pending_withdrawal: f64,
+    pub delegated: String,
+    pub undelegated: String,
+    pub total_pending_withdrawal: String,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct DelegationBalance {
     pub validator: String,
-    #[serde(deserialize_with = "deserialize_f64_from_str")]
-    pub amount: f64,
+    pub amount: String,
     pub locked_until_timestamp: u64,
 }
 
@@ -58,53 +53,6 @@ impl DelegationBalance {
     }
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct DelegatorHistoryEntry {
-    pub time: u64,
-    pub delta: DelegatorDelta,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct DelegatorDelta {
-    pub withdrawal: Option<DelegatorWithdrawal>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct DelegatorWithdrawal {
-    #[serde(deserialize_with = "deserialize_f64_from_str")]
-    pub amount: f64,
-    pub phase: WithdrawalPhase,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Display, EnumString)]
-#[serde(from = "String", into = "String")]
-pub enum WithdrawalPhase {
-    #[strum(serialize = "initiated")]
-    Initiated,
-    #[strum(serialize = "finalized")]
-    Finalized,
-    #[strum(default)]
-    Other(String),
-}
-
-impl From<String> for WithdrawalPhase {
-    fn from(value: String) -> Self {
-        match value.parse() {
-            Ok(phase) => phase,
-            Err(_) => WithdrawalPhase::Other(value),
-        }
-    }
-}
-
-impl From<WithdrawalPhase> for String {
-    fn from(value: WithdrawalPhase) -> Self {
-        value.to_string()
-    }
-}
-
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Validator {

crates/gem_hypercore/src/provider/balances_mapper.rs

@@ -47,8 +47,8 @@ pub fn map_balance_tokens(spot_balances: &Balances, spot_tokens: &[SpotToken], t
 
 pub fn map_balance_staking(balance: &StakeBalance, chain: Chain) -> Result<AssetBalance, Box<dyn Error + Sync + Send>> {
     let native_decimals = Asset::from_chain(chain).decimals as u32;
-    let available_biguint = BigNumberFormatter::value_from_amount_biguint(&balance.delegated.to_string(), native_decimals).unwrap_or_default();
-    let pending_biguint = BigNumberFormatter::value_from_amount_biguint(&balance.total_pending_withdrawal.to_string(), native_decimals).unwrap_or_default();
+    let available_biguint = BigNumberFormatter::value_from_amount_biguint(&balance.delegated, native_decimals).unwrap_or_default();
+    let pending_biguint = BigNumberFormatter::value_from_amount_biguint(&balance.total_pending_withdrawal, native_decimals).unwrap_or_default();
 
     Ok(AssetBalance::new_balance(
         chain.as_asset_id(),
@@ -138,9 +138,9 @@ mod tests {
     #[test]
     fn test_map_balance_staking() {
         let stake_balance = StakeBalance {
-            delegated: 100.0,
-            undelegated: 0.0,
-            total_pending_withdrawal: 10.0,
+            delegated: "100.0".to_string(),
+            undelegated: "0.0".to_string(),
+            total_pending_withdrawal: "10.0".to_string(),
         };
         let result = map_balance_staking(&stake_balance, Chain::HyperCore).unwrap();
 

crates/gem_hypercore/src/provider/staking.rs

@@ -1,6 +1,5 @@
 use async_trait::async_trait;
 use chain_traits::ChainStaking;
-use chrono::Utc;
 use futures::try_join;
 use std::error::Error;
 
@@ -23,7 +22,7 @@ impl<C: Client> ChainStaking for HyperCoreClient<C> {
     }
 
     async fn get_staking_delegations(&self, address: String) -> Result<Vec<DelegationBase>, Box<dyn Error + Sync + Send>> {
-        let (delegations, history) = try_join!(self.get_staking_delegations(&address), self.get_staking_history(&address))?;
-        Ok(staking_mapper::map_staking_delegations(delegations, history, Utc::now(), self.chain))
+        let (delegations, stake_balance) = try_join!(self.get_staking_delegations(&address), self.get_stake_balance(&address))?;
+        Ok(staking_mapper::map_staking_delegations(delegations, stake_balance, self.chain))
     }
 }

crates/gem_hypercore/src/provider/staking_mapper.rs

@@ -1,9 +1,7 @@
-use crate::models::balance::{DelegationBalance, DelegatorHistoryEntry, Validator, WithdrawalPhase};
-use chrono::{DateTime, Duration, Utc};
+use crate::models::balance::{DelegationBalance, StakeBalance, Validator};
 use num_bigint::BigUint;
 use number_formatter::BigNumberFormatter;
 use primitives::{Asset, Chain, DelegationBase, DelegationState, DelegationValidator};
-use std::str::FromStr;
 
 pub fn map_staking_validators(validators: Vec<Validator>, chain: Chain, apy: Option<f64>) -> Vec<DelegationValidator> {
     let calculated_apy = apy.unwrap_or_else(|| Validator::max_apr(validators.clone()));
@@ -17,14 +15,14 @@ pub fn map_staking_validators(validators: Vec<Validator>, chain: Chain, apy: Opt
     result
 }
 
-pub fn map_staking_delegations(delegations: Vec<DelegationBalance>, history: Vec<DelegatorHistoryEntry>, now: DateTime<Utc>, chain: Chain) -> Vec<DelegationBase> {
+pub fn map_staking_delegations(delegations: Vec<DelegationBalance>, stake_balance: StakeBalance, chain: Chain) -> Vec<DelegationBase> {
     let native_decimals = Asset::from_chain(chain).decimals as u32;
     let mut result: Vec<DelegationBase> = delegations
         .into_iter()
         .map(|x| DelegationBase {
             asset_id: chain.as_asset_id(),
             state: DelegationState::Active,
-            balance: parse_balance(&x.amount.to_string(), native_decimals),
+            balance: BigNumberFormatter::value_from_amount_biguint(&x.amount, native_decimals).unwrap_or_default(),
             shares: BigUint::from(0u32),
             rewards: BigUint::from(0u32),
             completion_date: None,
@@ -33,58 +31,34 @@ pub fn map_staking_delegations(delegations: Vec<DelegationBalance>, history: Vec
         })
         .collect();
 
-    result.extend(map_pending_withdrawals(history, now, chain, native_decimals));
-    result
-}
-
-fn map_pending_withdrawals(history: Vec<DelegatorHistoryEntry>, now: DateTime<Utc>, chain: Chain, native_decimals: u32) -> Vec<DelegationBase> {
-    let lock_time = chain.config().stake.as_ref().map(|stake| stake.lock_time).unwrap_or_default();
-    let lock = Duration::seconds(lock_time as i64);
-
-    history
-        .into_iter()
-        .filter_map(|entry| {
-            let withdrawal = entry.delta.withdrawal?;
-            if withdrawal.phase != WithdrawalPhase::Initiated {
-                return None;
-            }
-            let completion_date = DateTime::from_timestamp_millis(entry.time as i64)? + lock;
-            if completion_date <= now {
-                return None;
-            }
-            Some(DelegationBase {
-                asset_id: chain.as_asset_id(),
-                state: DelegationState::Pending,
-                balance: parse_balance(&withdrawal.amount.to_string(), native_decimals),
-                shares: BigUint::from(0u32),
-                rewards: BigUint::from(0u32),
-                completion_date: Some(completion_date),
-                delegation_id: format!("unstaking_{}", entry.time),
-                validator_id: DelegationValidator::SYSTEM_ID.to_string(),
-            })
-        })
-        .collect()
-}
+    let pending = BigNumberFormatter::value_from_amount_biguint(&stake_balance.total_pending_withdrawal, native_decimals).unwrap_or_default();
+    if pending > BigUint::from(0u32) {
+        result.push(DelegationBase {
+            asset_id: chain.as_asset_id(),
+            state: DelegationState::Pending,
+            balance: pending,
+            shares: BigUint::from(0u32),
+            rewards: BigUint::from(0u32),
+            completion_date: None,
+            delegation_id: DelegationValidator::SYSTEM_ID.to_string(),
+            validator_id: DelegationValidator::SYSTEM_ID.to_string(),
+        });
+    }
 
-fn parse_balance(amount: &str, native_decimals: u32) -> BigUint {
-    BigNumberFormatter::value_from_amount(amount, native_decimals)
-        .ok()
-        .and_then(|s| BigUint::from_str(&s).ok())
-        .unwrap_or_default()
+    result
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::models::balance::{DelegatorDelta, DelegatorWithdrawal, ValidatorStats};
+    use crate::models::balance::ValidatorStats;
     use primitives::{Chain, DelegationState};
 
-    fn withdrawal_entry(time: u64, amount: f64, phase: WithdrawalPhase) -> DelegatorHistoryEntry {
-        DelegatorHistoryEntry {
-            time,
-            delta: DelegatorDelta {
-                withdrawal: Some(DelegatorWithdrawal { amount, phase }),
-            },
+    fn stake_balance(total_pending_withdrawal: &str) -> StakeBalance {
+        StakeBalance {
+            delegated: "0".to_string(),
+            undelegated: "0".to_string(),
+            total_pending_withdrawal: total_pending_withdrawal.to_string(),
         }
     }
 
@@ -105,7 +79,7 @@ mod tests {
         assert_eq!(result[0].chain, Chain::HyperCore);
         assert!(result[0].is_active);
         assert_eq!(result[0].commission, 5.0);
-        assert_eq!(result[0].apr, 15.0); // max_apr * 100
+        assert_eq!(result[0].apr, 15.0);
 
         let system = &result[1];
         assert_eq!(system.id, DelegationValidator::SYSTEM_ID);
@@ -125,15 +99,15 @@ mod tests {
 
         let result = map_staking_validators(validators, Chain::HyperCore, Some(10.0));
         assert_eq!(result.len(), 2);
-        assert_eq!(result[0].apr, 10.0); // Uses provided APY
+        assert_eq!(result[0].apr, 10.0);
         assert_eq!(result[1].id, DelegationValidator::SYSTEM_ID);
     }
 
     #[test]
     fn test_map_staking_delegations() {
         let delegations: Vec<DelegationBalance> = serde_json::from_str(include_str!("../../testdata/staking_delegations.json")).unwrap();
 
-        let result = map_staking_delegations(delegations, vec![], Utc::now(), Chain::HyperCore);
+        let result = map_staking_delegations(delegations, stake_balance("0"), Chain::HyperCore);
 
         assert_eq!(result.len(), 2);
 
@@ -153,27 +127,21 @@ mod tests {
     }
 
     #[test]
-    fn test_map_staking_delegations_pending_withdrawals() {
-        let now = DateTime::from_timestamp(1_780_000_000, 0).unwrap();
-        let history = vec![
-            withdrawal_entry(1_779_913_600_000, 1.5, WithdrawalPhase::Initiated),
-            withdrawal_entry(1_779_308_800_000, 2.0, WithdrawalPhase::Initiated),
-            withdrawal_entry(1_779_950_000_000, 3.0, WithdrawalPhase::Finalized),
-            DelegatorHistoryEntry {
-                time: 1_779_950_000_001,
-                delta: DelegatorDelta { withdrawal: None },
-            },
-        ];
-
-        let result = map_staking_delegations(vec![], history, now, Chain::HyperCore);
+    fn test_map_staking_delegations_pending_withdrawal() {
+        let result = map_staking_delegations(vec![], stake_balance("0.015"), Chain::HyperCore);
 
         assert_eq!(result.len(), 1);
         let pending = &result[0];
         assert!(matches!(pending.state, DelegationState::Pending));
         assert_eq!(pending.validator_id, DelegationValidator::SYSTEM_ID);
-        assert_eq!(pending.balance.to_string(), "150000000");
-        assert_eq!(pending.delegation_id, "unstaking_1779913600000");
-        assert_eq!(pending.completion_date, Some(now + Duration::seconds(518_400)));
-        assert!(pending.completion_date.unwrap() > now);
+        assert_eq!(pending.balance.to_string(), "1500000");
+        assert!(pending.completion_date.is_none());
+    }
+
+    #[test]
+    fn test_map_staking_delegations_no_pending_withdrawal() {
+        let result = map_staking_delegations(vec![], stake_balance("0"), Chain::HyperCore);
+
+        assert!(result.is_empty());
     }
 }

crates/gem_hypercore/src/rpc/client.rs

@@ -1,5 +1,5 @@
 use crate::models::{
-    balance::{Balances, DelegationBalance, DelegatorHistoryEntry, StakeBalance, Validator},
+    balance::{Balances, DelegationBalance, StakeBalance, Validator},
     candlestick::Candlestick,
     metadata::HypercoreMetadataResponse,
     order::{OpenOrder, UserFill},
@@ -115,10 +115,6 @@ impl<C: Client> HyperCoreClient<C> {
         self.info(json!({"type": "delegations", "user": user})).await
     }
 
-    pub async fn get_staking_history(&self, user: &str) -> Result<Vec<DelegatorHistoryEntry>, Box<dyn Error + Send + Sync>> {
-        self.info(json!({"type": "delegatorHistory", "user": user})).await
-    }
-
     pub async fn get_staking_apy(&self) -> Result<f64, Box<dyn Error + Send + Sync>> {
         let validators = self.get_validators().await?;
         Ok(Validator::max_apr(validators))