Support cloid in bulk_modify

src/exchange/mod.rs

@@ -11,7 +11,7 @@ pub use builder::*;
 pub use cancel::{ClientCancelRequest, ClientCancelRequestCloid};
 pub use exchange_client::*;
 pub use exchange_responses::*;
-pub use modify::{ClientModifyRequest, ModifyRequest};
+pub use modify::{ClientModifyRequest, ModifyRequest, OidOrCloid};
 pub use order::{
     ClientLimit, ClientOrder, ClientOrderRequest, ClientTrigger, MarketCloseParams,
     MarketOrderParams, Order,

src/exchange/modify.rs

@@ -1,14 +1,71 @@
+use crate::helpers::{hex_string_to_uuid, uuid_to_hex_string};
+
 use super::{order::OrderRequest, ClientOrderRequest};
-use serde::{Deserialize, Serialize};
+use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
+use uuid::Uuid;
+
+#[derive(Debug, Clone)]
+pub enum OidOrCloid {
+    Oid(u64),
+    Cloid(Uuid),
+}
+
+impl Serialize for OidOrCloid {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            OidOrCloid::Oid(oid) => serializer.serialize_u64(*oid),
+            // UUID rendered as compact hex (no dashes)
+            OidOrCloid::Cloid(cloid) => serializer.serialize_str(&uuid_to_hex_string(*cloid)),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for OidOrCloid {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct V;
+
+        impl<'de> de::Visitor<'de> for V {
+            type Value = OidOrCloid;
+
+            fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+                f.write_str("a u64 or a 32-character hex UUID string")
+            }
+
+            fn visit_u64<E>(self, n: u64) -> Result<Self::Value, E>
+            where
+                E: de::Error,
+            {
+                Ok(OidOrCloid::Oid(n))
+            }
+
+            fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
+            where
+                E: de::Error,
+            {
+                hex_string_to_uuid(s)
+                    .map(OidOrCloid::Cloid)
+                    .map_err(E::custom)
+            }
+        }
+
+        deserializer.deserialize_any(V)
+    }
+}
 
 #[derive(Debug)]
 pub struct ClientModifyRequest {
-    pub oid: u64,
+    pub oid: OidOrCloid,
     pub order: ClientOrderRequest,
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct ModifyRequest {
-    pub oid: u64,
+    pub oid: OidOrCloid,
     pub order: OrderRequest,
 }

src/helpers.rs

@@ -52,6 +52,18 @@ pub(crate) fn uuid_to_hex_string(uuid: Uuid) -> String {
     format!("0x{}", hex_string)
 }
 
+pub(crate) fn hex_string_to_uuid(hex_string: &str) -> Result<Uuid> {
+    if let Some(hex_string) = hex_string.strip_prefix("0x") {
+        Ok(Uuid::from_u128(
+            u128::from_str_radix(hex_string, 16).unwrap(),
+        ))
+    } else {
+        Err(Error::JsonParse(format!(
+            "Invalid hex string: {hex_string}"
+        )))
+    }
+}
+
 pub(crate) fn generate_random_key() -> Result<[u8; 32]> {
     let mut arr = [0u8; 32];
     thread_rng()

src/ws/ws_manager.rs

@@ -282,7 +282,7 @@ impl WsManager {
             }
             Message::ActiveAssetData(active_asset_data) => {
                 serde_json::to_string(&Subscription::ActiveAssetData {
-                    user: active_asset_data.data.user.clone(),
+                    user: active_asset_data.data.user,
                     coin: active_asset_data.data.coin.clone(),
                 })
                 .map_err(|e| Error::JsonParse(e.to_string()))