feat: derive Serialize on UserData + UserFundings + constituents (Hathor #215)

The Hathor Rust LiveExecutor's info_bridge::msg_to_value translates
SDK WSS Message variants to serde_json::Value envelopes that downstream
callbacks consume. UserData (fills) and UserFundings need to round-trip
through serde_json so the trailing-stop + partial-TP logic in
Tick 3 of hyperliquid-dex#171 can read fill data from the bridge envelope.

Refs: SekhmetsWrath/hathor-nodes-bot#215, SekhmetsWrath/hathor-nodes-bot#171

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: HathorNodes

src/ws/message_types.rs

@@ -1,4 +1,4 @@
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 
 use crate::ws::sub_structs::*;
 
@@ -17,7 +17,7 @@ pub struct AllMids {
     pub data: AllMidsData,
 }
 
-#[derive(Deserialize, Clone, Debug)]
+#[derive(Serialize, Deserialize, Clone, Debug)]
 pub struct User {
     pub data: UserData,
 }
@@ -37,7 +37,7 @@ pub struct OrderUpdates {
     pub data: Vec<OrderUpdate>,
 }
 
-#[derive(Deserialize, Clone, Debug)]
+#[derive(Serialize, Deserialize, Clone, Debug)]
 pub struct UserFundings {
     pub data: UserFundingsData,
 }
@@ -76,3 +76,90 @@ pub struct ActiveAssetData {
 pub struct Bbo {
     pub data: BboData,
 }
+
+#[cfg(test)]
+mod tests {
+    //! Round-trip tests for the `User` and `UserFundings` WSS message
+    //! wrappers. The Hathor `InfoBridge::msg_to_value` translates these
+    //! into `serde_json::Value` envelopes for downstream callbacks; the
+    //! trailing-stop / partial-TP logic depends on the inner `fills` and
+    //! `fundings` payloads reaching the callback (Hathor #215).
+    use super::*;
+    use crate::ws::sub_structs::{TradeInfo, UserData, UserFunding, UserFundingsData};
+    use alloy::primitives::Address;
+
+    fn sample_address() -> Address {
+        "0x0000000000000000000000000000000000000001"
+            .parse()
+            .expect("static valid address")
+    }
+
+    fn sample_trade_info() -> TradeInfo {
+        TradeInfo {
+            coin: "BTC".to_string(),
+            side: "B".to_string(),
+            px: "50000.0".to_string(),
+            sz: "0.01".to_string(),
+            time: 1_700_000_000_000,
+            hash: "0xabc".to_string(),
+            start_position: "0.0".to_string(),
+            dir: "Open Long".to_string(),
+            closed_pnl: "0.0".to_string(),
+            oid: 42,
+            cloid: None,
+            crossed: true,
+            fee: "0.5".to_string(),
+            fee_token: "USDC".to_string(),
+            tid: 7,
+        }
+    }
+
+    #[test]
+    fn user_data_round_trips_with_fills() {
+        let user = User {
+            data: UserData::Fills(vec![sample_trade_info()]),
+        };
+        let value = serde_json::to_value(&user).expect("serialize User");
+
+        // Wrapper serialises as `{"data": {"fills": [...]}}` because
+        // `UserData` is an internally-tagged enum with `Fills` variant
+        // becoming `{"fills": [...]}` under serde's default enum repr.
+        let fills = value
+            .pointer("/data/fills")
+            .and_then(|v| v.as_array())
+            .expect("fills array present at /data/fills");
+        assert_eq!(fills.len(), 1, "one fill expected");
+        assert_eq!(fills[0]["coin"], "BTC");
+        assert_eq!(fills[0]["px"], "50000.0");
+        assert_eq!(fills[0]["side"], "B");
+        assert_eq!(fills[0]["oid"], 42);
+        assert_eq!(fills[0]["tid"], 7);
+    }
+
+    #[test]
+    fn user_fundings_round_trips() {
+        let fundings = UserFundings {
+            data: UserFundingsData {
+                is_snapshot: Some(true),
+                user: sample_address(),
+                fundings: vec![UserFunding {
+                    time: 1_700_000_000_000,
+                    coin: "BTC".to_string(),
+                    usdc: "1.5".to_string(),
+                    szi: "0.01".to_string(),
+                    funding_rate: "0.0001".to_string(),
+                }],
+            },
+        };
+        let value = serde_json::to_value(&fundings).expect("serialize UserFundings");
+
+        let inner = value
+            .pointer("/data/fundings")
+            .and_then(|v| v.as_array())
+            .expect("fundings array present at /data/fundings");
+        assert_eq!(inner.len(), 1);
+        assert_eq!(inner[0]["coin"], "BTC");
+        assert_eq!(inner[0]["usdc"], "1.5");
+        assert_eq!(inner[0]["fundingRate"], "0.0001");
+    }
+}

src/ws/sub_structs.rs

@@ -36,7 +36,7 @@ pub struct AllMidsData {
     pub mids: HashMap<String, String>,
 }
 
-#[derive(Deserialize, Clone, Debug)]
+#[derive(Serialize, Deserialize, Clone, Debug)]
 #[serde(rename_all = "camelCase")]
 pub struct TradeInfo {
     pub coin: String,
@@ -56,15 +56,15 @@ pub struct TradeInfo {
     pub tid: u64,
 }
 
-#[derive(Deserialize, Clone, Debug)]
+#[derive(Serialize, Deserialize, Clone, Debug)]
 #[serde(rename_all = "camelCase")]
 pub struct UserFillsData {
     pub is_snapshot: Option<bool>,
     pub user: Address,
     pub fills: Vec<TradeInfo>,
 }
 
-#[derive(Deserialize, Clone, Debug)]
+#[derive(Serialize, Deserialize, Clone, Debug)]
 #[serde(rename_all = "camelCase")]
 pub enum UserData {
     Fills(Vec<TradeInfo>),
@@ -73,7 +73,7 @@ pub enum UserData {
     NonUserCancel(Vec<NonUserCancel>),
 }
 
-#[derive(Deserialize, Clone, Debug)]
+#[derive(Serialize, Deserialize, Clone, Debug)]
 pub struct Liquidation {
     pub lid: u64,
     pub liquidator: String,
@@ -82,7 +82,7 @@ pub struct Liquidation {
     pub liquidated_account_value: String,
 }
 
-#[derive(Deserialize, Clone, Debug)]
+#[derive(Serialize, Deserialize, Clone, Debug)]
 pub struct NonUserCancel {
     pub coin: String,
     pub oid: u64,
@@ -133,15 +133,15 @@ pub struct BasicOrder {
     pub cloid: Option<String>,
 }
 
-#[derive(Deserialize, Clone, Debug)]
+#[derive(Serialize, Deserialize, Clone, Debug)]
 #[serde(rename_all = "camelCase")]
 pub struct UserFundingsData {
     pub is_snapshot: Option<bool>,
     pub user: Address,
     pub fundings: Vec<UserFunding>,
 }
 
-#[derive(Deserialize, Clone, Debug)]
+#[derive(Serialize, Deserialize, Clone, Debug)]
 #[serde(rename_all = "camelCase")]
 pub struct UserFunding {
     pub time: u64,