Add Bbo subscription type to ws_client

src/bin/order_and_modify_and_cancel.rs

@@ -0,0 +1,90 @@
+use ethers::signers::LocalWallet;
+use log::info;
+
+use hyperliquid_rust_sdk::{
+    BaseUrl, ClientCancelRequest, ClientLimit, ClientModifyRequest, ClientOrder, ClientOrderRequest, ExchangeClient, ExchangeDataStatus, ExchangeResponseStatus
+};
+use std::{thread::sleep, time::Duration};
+
+#[tokio::main]
+async fn main() {
+    env_logger::init();
+    // Key was randomly generated for testing and shouldn't be used with any real funds
+    let wallet: LocalWallet = "e908f86dbb4d55ac876378565aafeabc187f6690f046459397b17d9b9a19688e"
+        .parse()
+        .unwrap();
+
+    let exchange_client = ExchangeClient::new(None, wallet, Some(BaseUrl::Testnet), None, None)
+        .await
+        .unwrap();
+
+    let order = ClientOrderRequest {
+        asset: "ETH".to_string(),
+        is_buy: true,
+        reduce_only: false,
+        limit_px: 1800.0,
+        sz: 0.01,
+        cloid: None,
+        order_type: ClientOrder::Limit(ClientLimit {
+            tif: "Gtc".to_string(),
+        }),
+    };
+
+    let response = exchange_client.order(order, None).await.unwrap();
+    info!("Order placed: {response:?}");
+
+    let response = match response {
+        ExchangeResponseStatus::Ok(exchange_response) => exchange_response,
+        ExchangeResponseStatus::Err(e) => panic!("error with exchange response: {e}"),
+    };
+    let status = response.data.unwrap().statuses[0].clone();
+    let oid = match status {
+        ExchangeDataStatus::Filled(order) => order.oid,
+        ExchangeDataStatus::Resting(order) => order.oid,
+        _ => panic!("Error: {status:?}"),
+    };
+
+    sleep(Duration::from_secs(5));
+    // Shift the order by 1 dollar
+    let modify = ClientModifyRequest {
+        oid: oid.into(),
+        order:
+            ClientOrderRequest {
+                asset: "ETH".to_string(),
+                is_buy: true,
+                reduce_only: false,
+                limit_px: 1801.0,
+                sz: 0.01,
+                cloid: None,
+                order_type: ClientOrder::Limit(ClientLimit {
+                    tif: "Gtc".to_string(),
+                }),
+            },
+    };
+
+    let modify_response = exchange_client.modify(modify, None).await.unwrap();
+    info!("Order potentially modified: {modify_response:?}");
+    // This response will return an error if order was filled (since you can't modify a filled order), otherwise it will modify the order
+    let modify_response = match modify_response {
+        ExchangeResponseStatus::Ok(exchange_response) => exchange_response,
+        ExchangeResponseStatus::Err(e) => panic!("error with exchange response: {e}"),
+    };
+    let status = modify_response.data.unwrap().statuses[0].clone();
+    let oid = match status {
+        ExchangeDataStatus::Filled(order) => order.oid,
+        ExchangeDataStatus::Resting(order) => order.oid,
+        _ => panic!("Error: {status:?}"),
+    };
+
+    // So you can see the order before it's cancelled
+    sleep(Duration::from_secs(10));
+
+    let cancel = ClientCancelRequest {
+        asset: "ETH".to_string(),
+        oid,
+    };
+
+    // This response will return an error if order was filled (since you can't cancel a filled order), otherwise it will cancel the order
+    let response = exchange_client.cancel(cancel, None).await.unwrap();
+    info!("Order potentially cancelled: {response:?}");
+}

src/bin/order_and_modify_and_cancel_cloid.rs

@@ -0,0 +1,71 @@
+use ethers::signers::LocalWallet;
+use log::info;
+
+use hyperliquid_rust_sdk::{
+    BaseUrl, ClientCancelRequestCloid, ClientLimit, ClientModifyId, ClientModifyRequest, ClientOrder, ClientOrderRequest, ExchangeClient
+};
+use std::{thread::sleep, time::Duration};
+use uuid::Uuid;
+
+#[tokio::main]
+async fn main() {
+    env_logger::init();
+    // Key was randomly generated for testing and shouldn't be used with any real funds
+    let wallet: LocalWallet = "e908f86dbb4d55ac876378565aafeabc187f6690f046459397b17d9b9a19688e"
+        .parse()
+        .unwrap();
+
+    let exchange_client = ExchangeClient::new(None, wallet, Some(BaseUrl::Testnet), None, None)
+        .await
+        .unwrap();
+
+    // Order and Modify and Cancel with cloid
+    let cloid = Uuid::new_v4();
+    let order = ClientOrderRequest {
+        asset: "ETH".to_string(),
+        is_buy: true,
+        reduce_only: false,
+        limit_px: 1800.0,
+        sz: 0.01,
+        cloid: Some(cloid),
+        order_type: ClientOrder::Limit(ClientLimit {
+            tif: "Gtc".to_string(),
+        }),
+    };
+
+    let response = exchange_client.order(order, None).await.unwrap();
+    info!("Order placed: {response:?}");
+
+    sleep(Duration::from_secs(5));
+
+    // Shift the order by 1 dollar
+    let modify = ClientModifyRequest {
+        oid: ClientModifyId::Cloid(cloid),
+        order: ClientOrderRequest {
+            asset: "ETH".to_string(),
+            is_buy: true,
+            reduce_only: false,
+            limit_px: 1801.0,
+            sz: 0.01,
+            cloid: Some(cloid),
+            order_type: ClientOrder::Limit(ClientLimit {
+                tif: "Gtc".to_string(),
+            }),
+        },
+    };
+
+    let response = exchange_client.modify(modify, None).await.unwrap();
+    info!("Order potentially modified: {response:?}");
+
+    // So you can see the order before it's cancelled
+    sleep(Duration::from_secs(10));
+
+    let cancel = ClientCancelRequestCloid {
+        asset: "ETH".to_string(),
+        cloid,
+    };
+
+    // This response will return an error if order was filled (since you can't cancel a filled order), otherwise it will cancel the order
+    let response = exchange_client.cancel_by_cloid(cancel, None).await.unwrap();
+    info!("Order potentially cancelled: {response:?}");
+}

src/bin/ws_bbo.rs

@@ -0,0 +1,30 @@
+use hyperliquid_rust_sdk::{BaseUrl, InfoClient, Message, Subscription};
+use log::info;
+use tokio::{
+    spawn,
+    sync::mpsc::unbounded_channel,
+    time::{sleep, Duration},
+};
+
+#[tokio::main]
+async fn main() {
+    env_logger::init();
+    let mut info_client = InfoClient::new(None, Some(BaseUrl::Testnet)).await.unwrap();
+    let coin = "BTC".to_string();
+
+    let (sender, mut receiver) = unbounded_channel();
+    let subscription_id = info_client
+        .subscribe(Subscription::Bbo { coin }, sender)
+        .await
+        .unwrap();
+
+    spawn(async move {
+        sleep(Duration::from_secs(30)).await;
+        info!("Unsubscribing from bbo");
+        info_client.unsubscribe(subscription_id).await.unwrap()
+    });
+
+    while let Some(Message::Bbo(bbo)) = receiver.recv().await {
+        info!("Received bbo: {bbo:?}");
+    }
+}

src/exchange/exchange_client.rs

@@ -514,7 +514,7 @@ impl ExchangeClient {
         let mut transformed_modifies = Vec::new();
         for modify in modifies.into_iter() {
             transformed_modifies.push(ModifyRequest {
-                oid: modify.oid,
+                oid: modify.oid.into(),
                 order: modify.order.convert(&self.coin_to_asset)?,
             });
         }

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, ClientModifyId};
 pub use order::{
     ClientLimit, ClientOrder, ClientOrderRequest, ClientTrigger, MarketCloseParams,
     MarketOrderParams, Order,

src/exchange/modify.rs

@@ -1,14 +1,51 @@
+use crate::helpers::uuid_to_hex_string;
+
 use super::{order::OrderRequest, ClientOrderRequest};
 use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+#[derive(Debug, Clone)]
+pub enum ClientModifyId {
+    Oid(u64),
+    Cloid(Uuid),
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(untagged)]
+pub enum SerializedClientId {
+    U64(u64),
+    Str(String),
+}
+
+impl From<u64> for ClientModifyId {
+    fn from(oid: u64) -> Self {
+        ClientModifyId::Oid(oid)
+    }
+}
+
+impl From<Uuid> for ClientModifyId {
+    fn from(cloid: Uuid) -> Self {
+        ClientModifyId::Cloid(cloid)
+    }
+}
+
+impl From<ClientModifyId> for SerializedClientId {
+    fn from(client_id: ClientModifyId) -> Self {
+        match client_id {
+            ClientModifyId::Oid(oid) => SerializedClientId::U64(oid),
+            ClientModifyId::Cloid(cloid) => SerializedClientId::Str(uuid_to_hex_string(cloid)),
+        }
+    }
+}
 
 #[derive(Debug)]
 pub struct ClientModifyRequest {
-    pub oid: u64,
+    pub oid: ClientModifyId,
     pub order: ClientOrderRequest,
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct ModifyRequest {
-    pub oid: u64,
+    pub oid: SerializedClientId,
     pub order: OrderRequest,
 }

src/ws/message_types.rs

@@ -60,3 +60,8 @@ pub struct WebData2 {
 pub struct ActiveAssetCtx {
     pub data: ActiveAssetCtxData,
 }
+
+#[derive(Deserialize, Clone, Debug)]
+pub struct Bbo {
+    pub data: BboData,
+}

src/ws/sub_structs.rs

@@ -11,6 +11,7 @@ pub struct Trade {
     pub time: u64,
     pub hash: String,
     pub tid: u64,
+    pub users: (String, String), // (buyer, seller)
 }
 
 #[derive(Deserialize, Clone, Debug)]
@@ -321,3 +322,11 @@ pub struct SpotAssetCtx {
     pub shared: SharedAssetCtx,
     pub circulating_supply: String,
 }
+
+#[derive(Deserialize, Clone, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct BboData {
+    pub coin: String,
+    pub time: u64,
+    pub bbo: Vec<Option<BookLevel>>
+}

src/ws/ws_manager.rs

@@ -1,6 +1,6 @@
 use crate::{
     prelude::*,
-    ws::message_types::{AllMids, Candle, L2Book, OrderUpdates, Trades, User},
+    ws::message_types::{AllMids, Candle, L2Book, OrderUpdates, Trades, User, Bbo},
     ActiveAssetCtx, Error, Notification, UserFills, UserFundings, UserNonFundingLedgerUpdates,
     WebData2,
 };
@@ -62,6 +62,7 @@ pub enum Subscription {
     UserFundings { user: H160 },
     UserNonFundingLedgerUpdates { user: H160 },
     ActiveAssetCtx { coin: String },
+    Bbo { coin: String },
 }
 
 #[derive(Deserialize, Clone, Debug)]
@@ -83,6 +84,7 @@ pub enum Message {
     Notification(Notification),
     WebData2(WebData2),
     ActiveAssetCtx(ActiveAssetCtx),
+    Bbo(Bbo),
     Pong,
 }
 
@@ -267,6 +269,10 @@ impl WsManager {
                 })
                 .map_err(|e| Error::JsonParse(e.to_string()))
             }
+            Message::Bbo(bbo) => {
+                serde_json::to_string(&Subscription::Bbo { coin: bbo.data.coin.clone() })
+                .map_err(|e| Error::JsonParse(e.to_string()))
+            },
             Message::SubscriptionResponse | Message::Pong => Ok(String::default()),
             Message::NoData => Ok("".to_string()),
             Message::HyperliquidError(err) => Ok(format!("hyperliquid error: {err:?}")),