Improve handling for unstake transaction on hypercore

gemcoder21 · gemcoder21 · commit 7e9b6fdff68f · 2026-05-29T20:03:00.000Z
diff --git a/crates/gem_hypercore/src/models/user.rs b/crates/gem_hypercore/src/models/user.rs
@@ -43,6 +43,42 @@ pub struct LedgerUpdate {
     pub delta: LedgerDelta,
 }
 
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DelegatorHistoryUpdate {
+    pub time: u64,
+    pub hash: String,
+    pub delta: DelegatorHistoryDelta,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DelegatorHistoryDelta {
+    pub c_deposit: Option<DelegatorAmountDelta>,
+    pub delegate: Option<DelegatorDelegateDelta>,
+    pub withdrawal: Option<DelegatorWithdrawalDelta>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DelegatorAmountDelta {
+    pub amount: String,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DelegatorDelegateDelta {
+    pub amount: String,
+    pub is_undelegate: bool,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DelegatorWithdrawalDelta {
+    pub amount: String,
+    pub phase: String,
+}
+
 #[derive(Debug, Clone, Deserialize)]
 #[serde(tag = "type", rename_all = "camelCase", rename_all_fields = "camelCase")]
 pub enum LedgerDelta {
diff --git a/crates/gem_hypercore/src/provider/transaction_state.rs b/crates/gem_hypercore/src/provider/transaction_state.rs
@@ -39,15 +39,59 @@ impl<C: Client> HyperCoreClient<C> {
                 let fills = self.get_user_fills_by_time(&request.sender_address, start_time).await?;
                 Ok(transaction_state_mapper::map_transaction_state_order_action(fills, *nonce, request.id.clone()))
             }
-            HyperCoreActionId::Nonce(_) | HyperCoreActionId::CDeposit { .. } | HyperCoreActionId::CWithdraw { .. } | HyperCoreActionId::TokenDelegate { .. } => {
+            HyperCoreActionId::CDeposit { .. } | HyperCoreActionId::CWithdraw { .. } | HyperCoreActionId::TokenDelegate { .. } => {
+                let updates = self.get_delegator_history(&request.sender_address).await?;
+                Ok(transaction_state_mapper::map_transaction_state_staking_action(updates, action_id, request.id.clone()))
+            }
+            HyperCoreActionId::Nonce(nonce) => {
                 let updates = self
                     .get_ledger_updates(
                         &request.sender_address,
-                        action_id.nonce().saturating_sub(transaction_state_mapper::ACTION_HISTORY_QUERY_LOOKBACK_MS) as i64,
+                        nonce.saturating_sub(transaction_state_mapper::ACTION_HISTORY_QUERY_LOOKBACK_MS) as i64,
                     )
                     .await?;
                 Ok(transaction_state_mapper::map_transaction_state_action(updates, action_id, request.id.clone()))
             }
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use chrono::{TimeZone, Utc};
+    use gem_client::testkit::MockClient;
+    use primitives::{TransactionChange, TransactionState, TransactionStateRequest};
+
+    #[tokio::test]
+    async fn test_transaction_state_uses_delegator_history_for_c_withdraw() {
+        let client = HyperCoreClient::new(MockClient::new().with_post(|_, body| {
+            let payload: serde_json::Value = serde_json::from_slice(body).unwrap();
+            assert_eq!(payload["type"], "delegatorHistory");
+            Ok(
+                r#"[{"time":1780078270596,"hash":"0x7b435a1210afafef7cbd043c84b8d402064e00f7aba2cec11f0c0564cfa389da","delta":{"withdrawal":{"amount":"0.03001423","phase":"initiated"}}}]"#
+                    .as_bytes()
+                    .to_vec(),
+            )
+        }));
+        let request_id = "action:cWithdraw:3001423:1780078264489".to_string();
+        let update = client
+            .transaction_state(TransactionStateRequest {
+                id: request_id.clone(),
+                sender_address: "0x9EdcF9Ff72088DB8130C2512E5B4D3b5F34cEaF4".to_string(),
+                created_at: Utc.timestamp_millis_opt(1780078264489).unwrap(),
+                block_number: 0,
+            })
+            .await
+            .unwrap();
+
+        assert_eq!(update.state, TransactionState::Confirmed);
+        assert_eq!(
+            update.changes,
+            vec![TransactionChange::HashChange {
+                old: request_id,
+                new: "0x7b435a1210afafef7cbd043c84b8d402064e00f7aba2cec11f0c0564cfa389da".to_string(),
+            }]
+        );
+    }
+}
diff --git a/crates/gem_hypercore/src/provider/transaction_state_mapper.rs b/crates/gem_hypercore/src/provider/transaction_state_mapper.rs
@@ -1,7 +1,7 @@
 use crate::models::{
     order::{FillDirection, UserFill},
     transaction_id::HyperCoreActionId,
-    user::{LedgerDelta, LedgerUpdate},
+    user::{DelegatorHistoryDelta, DelegatorHistoryUpdate, LedgerDelta, LedgerUpdate},
 };
 use number_formatter::BigNumberFormatter;
 use primitives::{
@@ -11,6 +11,7 @@ use primitives::{
 
 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";
 
 fn perpetual_fill_type_and_direction(dir: &FillDirection) -> Option<(TransactionType, PerpetualDirection)> {
     match dir {
@@ -69,10 +70,7 @@ pub fn map_transaction_state_order(fills: Vec<UserFill>, oid: u64, request_id: S
 }
 
 pub fn map_transaction_state_order_action(fills: Vec<UserFill>, nonce: u64, request_id: String) -> TransactionUpdate {
-    match order_action_hash(&fills, nonce) {
-        Some(hash) => confirmed_hash_change(request_id, hash),
-        None => TransactionUpdate::new_state(TransactionState::Pending),
-    }
+    transaction_update_from_hash(order_action_hash(&fills, nonce), request_id)
 }
 
 pub fn order_action_hash(fills: &[UserFill], nonce: u64) -> Option<String> {
@@ -84,10 +82,11 @@ pub fn order_action_hash(fills: &[UserFill], nonce: u64) -> Option<String> {
 }
 
 pub fn map_transaction_state_action(updates: Vec<LedgerUpdate>, action_id: HyperCoreActionId, request_id: String) -> TransactionUpdate {
-    match ledger_action_hash(&updates, &action_id) {
-        Some(hash) => confirmed_hash_change(request_id, hash),
-        None => TransactionUpdate::new_state(TransactionState::Pending),
-    }
+    transaction_update_from_hash(ledger_action_hash(&updates, &action_id), request_id)
+}
+
+pub fn map_transaction_state_staking_action(updates: Vec<DelegatorHistoryUpdate>, action_id: HyperCoreActionId, request_id: String) -> TransactionUpdate {
+    transaction_update_from_hash(delegator_history_action_hash(&updates, &action_id), request_id)
 }
 
 pub fn ledger_action_hash(updates: &[LedgerUpdate], action_id: &HyperCoreActionId) -> Option<String> {
@@ -99,6 +98,15 @@ pub fn ledger_action_hash(updates: &[LedgerUpdate], action_id: &HyperCoreActionI
         .map(|(_, update)| update.hash.clone())
 }
 
+fn delegator_history_action_hash(updates: &[DelegatorHistoryUpdate], action_id: &HyperCoreActionId) -> Option<String> {
+    let nonce = action_id.nonce();
+    updates
+        .iter()
+        .filter_map(|update| delegator_history_match_delta(update, action_id, nonce).map(|delta| (delta, update)))
+        .min_by_key(|(delta, _)| *delta)
+        .map(|(_, update)| update.hash.clone())
+}
+
 fn ledger_match_delta(update: &LedgerUpdate, action_id: &HyperCoreActionId, nonce: u64) -> Option<u64> {
     match &update.delta {
         LedgerDelta::Send { nonce: update_nonce } | LedgerDelta::SpotTransfer { nonce: update_nonce } if *update_nonce == nonce => Some(0),
@@ -114,23 +122,44 @@ fn ledger_match_delta(update: &LedgerUpdate, action_id: &HyperCoreActionId, nonc
                 return None;
             }
 
-            let Ok(update_wei) = BigNumberFormatter::value_from_amount(amount, HYPERCORE_HYPE.decimals as u32) else {
-                return None;
-            };
-
-            action_history_time_delta(update.time, nonce).filter(|_| update_wei == wei.to_string())
+            action_history_time_delta(update.time, nonce).filter(|_| amount_matches_wei(amount, wei))
         }
         LedgerDelta::Send { .. } | LedgerDelta::SpotTransfer { .. } | LedgerDelta::Other => None,
     }
 }
 
+fn delegator_history_match_delta(update: &DelegatorHistoryUpdate, action_id: &HyperCoreActionId, nonce: u64) -> Option<u64> {
+    let matches_action = match (&update.delta, action_id) {
+        (DelegatorHistoryDelta { c_deposit: Some(delta), .. }, HyperCoreActionId::CDeposit { wei, .. }) => amount_matches_wei(&delta.amount, *wei),
+        (DelegatorHistoryDelta { delegate: Some(delta), .. }, HyperCoreActionId::TokenDelegate { wei, is_undelegate, .. }) => {
+            delta.is_undelegate == *is_undelegate && amount_matches_wei(&delta.amount, *wei)
+        }
+        (DelegatorHistoryDelta { withdrawal: Some(delta), .. }, HyperCoreActionId::CWithdraw { wei, .. }) => {
+            delta.phase == DELEGATOR_WITHDRAWAL_INITIATED && amount_matches_wei(&delta.amount, *wei)
+        }
+        _ => false,
+    };
+
+    if matches_action { action_history_time_delta(update.time, nonce) } else { None }
+}
+
+fn amount_matches_wei(amount: &str, wei: u64) -> bool {
+    match BigNumberFormatter::value_from_amount(amount, HYPERCORE_HYPE.decimals as u32) {
+        Ok(update_wei) => update_wei == wei.to_string(),
+        Err(_) => false,
+    }
+}
+
 fn action_history_time_delta(time: u64, nonce: u64) -> Option<u64> {
     let delta = time.checked_sub(nonce)?;
     if delta <= ACTION_HISTORY_MATCH_WINDOW_MS { Some(delta) } else { None }
 }
 
-fn confirmed_hash_change(request_id: String, hash: String) -> TransactionUpdate {
-    TransactionUpdate::new(TransactionState::Confirmed, vec![TransactionChange::HashChange { old: request_id, new: hash }])
+fn transaction_update_from_hash(hash: Option<String>, request_id: String) -> TransactionUpdate {
+    match hash {
+        Some(hash) => TransactionUpdate::new(TransactionState::Confirmed, vec![TransactionChange::HashChange { old: request_id, new: hash }]),
+        None => TransactionUpdate::new_state(TransactionState::Pending),
+    }
 }
 
 #[cfg(test)]
@@ -246,8 +275,7 @@ mod tests {
     #[test]
     fn test_map_transaction_state_action_without_matching_nonce_stays_pending() {
         let updates = serde_json::from_str(include_str!("../../testdata/user_non_funding_ledger_updates_action_hash.json")).unwrap();
-        let action_id = HyperCoreActionId::Nonce(1777960893093);
-        let update = map_transaction_state_action(updates, action_id, "action:1777960893093".to_string());
+        let update = map_transaction_state_action(updates, HyperCoreActionId::Nonce(1777960893093), "action:1777960893093".to_string());
 
         assert_eq!(update.state, TransactionState::Pending);
         assert!(update.changes.is_empty());
@@ -334,6 +362,59 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_map_transaction_state_staking_action_confirms_delegator_history_actions() {
+        let updates: Vec<DelegatorHistoryUpdate> = serde_json::from_str(include_str!("../../testdata/delegator_history_staking_actions.json")).unwrap();
+
+        for (request_id, action_id, expected_hash) in [
+            (
+                "action:cDeposit:1000000:1780081714468",
+                HyperCoreActionId::CDeposit {
+                    wei: 1_000_000,
+                    nonce: 1780081714468,
+                },
+                "0x945b910697cd885a95d5043c857c0d0201b300ec32c0a72c38243c5956c16245",
+            ),
+            (
+                "action:tokenDelegate:1000000:stake:1780081715280",
+                HyperCoreActionId::TokenDelegate {
+                    wei: 1_000_000,
+                    is_undelegate: false,
+                    nonce: 1780081715280,
+                },
+                "0x0cfde0fb239ef8630e77043c857c1502025000e0be921735b0c68c4de292d24d",
+            ),
+            (
+                "action:cWithdraw:3001423:1780078264489",
+                HyperCoreActionId::CWithdraw {
+                    wei: 3_001_423,
+                    nonce: 1780078264489,
+                },
+                "0x7b435a1210afafef7cbd043c84b8d402064e00f7aba2cec11f0c0564cfa389da",
+            ),
+            (
+                "action:tokenDelegate:3001423:unstake:1780078264488",
+                HyperCoreActionId::TokenDelegate {
+                    wei: 3_001_423,
+                    is_undelegate: true,
+                    nonce: 1780078264488,
+                },
+                "0xc24f99bd90d6d68ac3c9043c84b8c90201c000a32bd9f55c661845104fdab075",
+            ),
+        ] {
+            assert_eq!(
+                map_transaction_state_staking_action(updates.clone(), action_id, request_id.to_string()),
+                TransactionUpdate::new(
+                    TransactionState::Confirmed,
+                    vec![TransactionChange::HashChange {
+                        old: request_id.to_string(),
+                        new: expected_hash.to_string(),
+                    }]
+                )
+            );
+        }
+    }
+
     #[test]
     fn test_map_transaction_state_action_without_matching_window_stays_pending() {
         let updates = serde_json::from_str(include_str!("../../testdata/user_non_funding_ledger_updates_c_staking_transfer.json")).unwrap();
diff --git a/crates/gem_hypercore/src/rpc/client.rs b/crates/gem_hypercore/src/rpc/client.rs
@@ -9,7 +9,7 @@ use crate::models::{
     referral::Referral,
     response::ExplorerTransactionResponse,
     spot::{OrderbookResponse, SpotMeta},
-    user::{AgentSession, LedgerUpdate, UserAbstractionMode, UserFee, UserRole},
+    user::{AgentSession, DelegatorHistoryUpdate, LedgerUpdate, UserAbstractionMode, UserFee, UserRole},
 };
 use chain_traits::ChainTraits;
 use gem_client::{CONTENT_TYPE, Client, ClientExt, ContentType};
@@ -248,6 +248,14 @@ impl<C: Client> HyperCoreClient<C> {
         .await
     }
 
+    pub async fn get_delegator_history(&self, user: &str) -> Result<Vec<DelegatorHistoryUpdate>, Box<dyn Error + Send + Sync>> {
+        self.info(json!({
+            "type": "delegatorHistory",
+            "user": user
+        }))
+        .await
+    }
+
     pub async fn get_open_orders(&self, user: &str) -> Result<Vec<OpenOrder>, Box<dyn Error + Send + Sync>> {
         self.info(json!({"type": "frontendOpenOrders", "user": user})).await
     }
diff --git a/crates/gem_hypercore/testdata/delegator_history_staking_actions.json b/crates/gem_hypercore/testdata/delegator_history_staking_actions.json
@@ -0,0 +1,43 @@
+[
+  {
+    "time": 1780081714469,
+    "hash": "0x945b910697cd885a95d5043c857c0d0201b300ec32c0a72c38243c5956c16245",
+    "delta": {
+      "cDeposit": {
+        "amount": "0.01"
+      }
+    }
+  },
+  {
+    "time": 1780081715281,
+    "hash": "0x0cfde0fb239ef8630e77043c857c1502025000e0be921735b0c68c4de292d24d",
+    "delta": {
+      "delegate": {
+        "validator": "0x3e5b2598a32ebf003ad5a7254faa3d04ff41d9fe",
+        "amount": "0.01",
+        "isUndelegate": false
+      }
+    }
+  },
+  {
+    "time": 1780078270596,
+    "hash": "0x7b435a1210afafef7cbd043c84b8d402064e00f7aba2cec11f0c0564cfa389da",
+    "delta": {
+      "withdrawal": {
+        "amount": "0.03001423",
+        "phase": "initiated"
+      }
+    }
+  },
+  {
+    "time": 1780078269817,
+    "hash": "0xc24f99bd90d6d68ac3c9043c84b8c90201c000a32bd9f55c661845104fdab075",
+    "delta": {
+      "delegate": {
+        "validator": "0x000000000056f99d36b6f2e0c51fd41496bbacb8",
+        "amount": "0.03001423",
+        "isUndelegate": true
+      }
+    }
+  }
+]
