Show unlock date for pending unstaking (#421)

* Add unlock date for pending Hyperliquid unstaking

Derive pending unstaking rows from delegatorHistory so each withdrawal carries its own unlock date, replacing the single aggregate row that had no date.

Align iOS/Android staking UI: hide zero APR, sort delegations by numeric balance, reorder stake info card, and move the list countdown to the detail screen only.

* Reuse existing delegator history instead of duplicate request

Drop the duplicate get_staking_history method and parallel history models; map pending unstaking from the existing get_delegator_history / DelegatorHistoryUpdate, sharing the DELEGATOR_WITHDRAWAL_INITIATED phase constant.

Author: DRadmir

android/features/earn/delegation/viewmodels/src/main/kotlin/com/gemwallet/android/features/earn/delegation/viewmodels/DelegationViewModel.kt

@@ -77,7 +77,7 @@ class DelegationViewModel @Inject constructor(
             .getValidatorUrl(getCurrentBlockExplorer.getCurrentBlockExplorer(chain), delegation.validator.id)
         listOfNotNull(
             DelegationProperty.Name(delegation.validator.name, validatorUrl),
-            DelegationProperty.Apr(delegation.validator),
+            delegation.validator.takeIf { it.apr != 0.0 }?.let { DelegationProperty.Apr(it) },
             DelegationProperty.TransactionStatus(delegation.base.state, delegation.validator.isActive),
             delegation.base.state
                 .takeIf {

android/features/earn/stake/presents/src/main/kotlin/com/gemwallet/android/features/stake/presents/StakeScene.kt

@@ -41,7 +41,6 @@ import com.gemwallet.android.ui.components.list_head.CenteredListHead
 import com.gemwallet.android.ui.components.list_head.HeaderIcon
 import com.gemwallet.android.ui.components.list_item.DelegationItem
 import com.gemwallet.android.ui.components.list_item.SubheaderItem
-import com.gemwallet.android.ui.components.list_item.availableIn
 import com.gemwallet.android.ui.components.list_item.energyItem
 import com.gemwallet.android.ui.components.list_item.property.PropertyItem
 import com.gemwallet.android.ui.components.list_item.property.itemsPositioned
@@ -129,7 +128,6 @@ fun StakeScene(
                         DelegationItem(
                             assetInfo = assetInfo,
                             delegation = item,
-                            completedAt = availableIn(item),
                             listPosition = ListPosition.getPosition(index, delegations.size),
                             onClick = { onDelegation(item) }
                         )
@@ -150,9 +148,9 @@ private fun LazyListScope.stakeInfoSection(assetInfo: AssetInfo) {
     val minAmountValue = Config().getStakeConfig(assetInfo.asset.chain.string).minAmount.toLong()
     val iconUrl = assetInfo.id().getIconUrl()
     val rows = listOfNotNull(
-        minAmountValue.takeIf { it > 0 }?.let { StakeInfoRow.MinAmount(it, assetInfo.asset.chain) },
         StakeInfoRow.Apr(assetInfo.stakeApr ?: 0.0, iconUrl),
         assetInfo.lockTime?.let { StakeInfoRow.LockTime(it, iconUrl) },
+        minAmountValue.takeIf { it > 0 }?.let { StakeInfoRow.MinAmount(it, assetInfo.asset.chain) },
     )
     itemsPositioned(rows) { position, row ->
         when (row) {

android/ui/src/main/kotlin/com/gemwallet/android/ui/components/list_item/DelegationItem.kt

@@ -1,7 +1,6 @@
 package com.gemwallet.android.ui.components.list_item
 
 import androidx.compose.foundation.clickable
-import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.runtime.Composable
@@ -29,7 +28,6 @@ import com.wallet.core.primitives.DelegationState.Pending
 fun DelegationItem(
     assetInfo: AssetInfo,
     delegation: Delegation,
-    completedAt: String,
     listPosition: ListPosition,
     onClick: () -> Unit
 ) {
@@ -46,21 +44,7 @@ fun DelegationItem(
             ListItemTitleText(text = delegation.validator.name)
         },
         subtitle = {
-            val stateColor = delegation.base.state.color()
-            val stateText = delegation.stateText()
-            Column {
-                ListItemSupportText(stateText, color = stateColor)
-                when (delegation.base.state) {
-                    Pending,
-                    Activating,
-                    Deactivating -> completedAt.takeIf { it.isNotEmpty() && it != "0" }?.let {
-                        ListItemSupportText(it)
-                    }
-                    Active,
-                    Inactive,
-                    AwaitingWithdrawal -> Unit
-                }
-            }
+            ListItemSupportText(delegation.stateText(), color = delegation.base.state.color())
         },
         trailing = {
             val balance = DelegationBalanceInfoUIModel(

core/crates/gem_hypercore/src/provider/staking.rs

@@ -1,5 +1,6 @@
 use async_trait::async_trait;
 use chain_traits::ChainStaking;
+use chrono::Utc;
 use futures::try_join;
 use std::error::Error;
 
@@ -22,7 +23,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, 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))
+        let (delegations, history) = try_join!(self.get_staking_delegations(&address), self.get_delegator_history(&address))?;
+        Ok(staking_mapper::map_staking_delegations(delegations, history, Utc::now(), self.chain))
     }
 }

core/crates/gem_hypercore/src/provider/staking_mapper.rs

@@ -1,4 +1,7 @@
-use crate::models::balance::{DelegationBalance, StakeBalance, Validator};
+use crate::models::balance::{DelegationBalance, Validator};
+use crate::models::user::DelegatorHistoryUpdate;
+use crate::provider::transaction_state_mapper::DELEGATOR_WITHDRAWAL_INITIATED;
+use chrono::{DateTime, Duration, Utc};
 use num_bigint::BigUint;
 use number_formatter::BigNumberFormatter;
 use primitives::{Asset, Chain, DelegationBase, DelegationState, DelegationValidator};
@@ -15,7 +18,7 @@ pub fn map_staking_validators(validators: Vec<Validator>, chain: Chain, apy: Opt
     result
 }
 
-pub fn map_staking_delegations(delegations: Vec<DelegationBalance>, stake_balance: StakeBalance, chain: Chain) -> Vec<DelegationBase> {
+pub fn map_staking_delegations(delegations: Vec<DelegationBalance>, history: Vec<DelegatorHistoryUpdate>, now: DateTime<Utc>, chain: Chain) -> Vec<DelegationBase> {
     let native_decimals = Asset::from_chain(chain).decimals as u32;
     let mut result: Vec<DelegationBase> = delegations
         .into_iter()
@@ -31,34 +34,57 @@ pub fn map_staking_delegations(delegations: Vec<DelegationBalance>, stake_balanc
         })
         .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(),
-        });
-    }
-
+    result.extend(map_pending_withdrawals(history, now, chain, native_decimals));
     result
 }
 
+fn map_pending_withdrawals(history: Vec<DelegatorHistoryUpdate>, now: DateTime<Utc>, chain: Chain, native_decimals: u32) -> Vec<DelegationBase> {
+    let lock = Duration::seconds(chain.config().stake.as_ref().map(|stake| stake.lock_time).unwrap_or_default() as i64);
+
+    history
+        .into_iter()
+        .filter_map(|entry| {
+            let withdrawal = entry.delta.withdrawal?;
+            if withdrawal.phase != DELEGATOR_WITHDRAWAL_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: BigNumberFormatter::value_from_amount_biguint(&withdrawal.amount, native_decimals).unwrap_or_default(),
+                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()
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::models::balance::ValidatorStats;
+    use crate::models::user::{DelegatorHistoryDelta, DelegatorWithdrawalDelta};
     use primitives::{Chain, DelegationState};
 
-    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(),
+    fn withdrawal_entry(time: u64, amount: &str, phase: &str) -> DelegatorHistoryUpdate {
+        DelegatorHistoryUpdate {
+            time,
+            hash: "0x0".to_string(),
+            delta: DelegatorHistoryDelta {
+                c_deposit: None,
+                delegate: None,
+                withdrawal: Some(DelegatorWithdrawalDelta {
+                    amount: amount.to_string(),
+                    phase: phase.to_string(),
+                }),
+            },
         }
     }
 
@@ -107,7 +133,7 @@ mod tests {
     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, stake_balance("0"), Chain::HyperCore);
+        let result = map_staking_delegations(delegations, vec![], Utc::now(), Chain::HyperCore);
 
         assert_eq!(result.len(), 2);
 
@@ -127,21 +153,33 @@ mod tests {
     }
 
     #[test]
-    fn test_map_staking_delegations_pending_withdrawal() {
-        let result = map_staking_delegations(vec![], stake_balance("0.015"), Chain::HyperCore);
+    fn test_map_staking_delegations_pending_withdrawals() {
+        let now = DateTime::from_timestamp(1_780_000_000, 0).unwrap();
+        let at = |days: i64| (now - Duration::days(days)).timestamp_millis() as u64;
+        let history = vec![
+            withdrawal_entry(at(1), "1.5", "initiated"),
+            withdrawal_entry(at(8), "2.0", "initiated"),
+            withdrawal_entry(at(1), "3.0", "finalized"),
+            DelegatorHistoryUpdate {
+                time: at(0),
+                hash: "0x0".to_string(),
+                delta: DelegatorHistoryDelta {
+                    c_deposit: None,
+                    delegate: None,
+                    withdrawal: None,
+                },
+            },
+        ];
+
+        let result = map_staking_delegations(vec![], history, now, Chain::HyperCore);
 
         assert_eq!(result.len(), 1);
         let pending = &result[0];
         assert_eq!(pending.state, DelegationState::Pending);
         assert_eq!(pending.validator_id, DelegationValidator::SYSTEM_ID);
-        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());
+        assert_eq!(pending.balance.to_string(), "150000000");
+        assert_eq!(pending.delegation_id, format!("unstaking_{}", at(1)));
+        assert_eq!(pending.completion_date, Some(now + Duration::days(6)));
+        assert!(pending.completion_date.unwrap() > now);
     }
 }

core/crates/gem_hypercore/src/provider/transaction_state_mapper.rs

@@ -13,7 +13,7 @@ use crate::perpetual_formatter::usdc_value;
 
 pub const ACTION_HISTORY_QUERY_LOOKBACK_MS: u64 = 5_000;
 const ACTION_HISTORY_MATCH_WINDOW_MS: u64 = 5 * 60 * 1_000;
-const DELEGATOR_WITHDRAWAL_INITIATED: &str = "initiated";
+pub(crate) const DELEGATOR_WITHDRAWAL_INITIATED: &str = "initiated";
 
 fn perpetual_fill_type_and_direction(dir: &FillDirection) -> Option<(TransactionType, PerpetualDirection)> {
     match dir {

ios/Packages/Store/Sources/Requests/DelegationsRequest.swift

@@ -1,5 +1,6 @@
 // Copyright (c). Gem Wallet. All rights reserved.
 
+internal import BigInt
 import Foundation
 import GRDB
 import Primitives
@@ -23,9 +24,9 @@ public struct DelegationsRequest: DatabaseQueryable {
             .filter(StakeDelegationRecord.Columns.assetId == assetId.identifier)
             .joining(required: StakeDelegationRecord.validator
                 .filter(StakeValidatorRecord.Columns.providerType == providerType.rawValue))
-            .order(StakeDelegationRecord.Columns.balance.desc)
             .asRequest(of: StakeDelegationInfo.self)
             .fetchAll(db)
             .compactMap { $0.mapToDelegation() }
+            .sorted { $0.base.balanceValue > $1.base.balanceValue }
     }
 }