[feat] Implement schedule cancel (#123)

This PR implements the schedule_cancel functionality.


https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#schedule-cancel-dead-mans-switch

Author: calumrussell

src/bin/order_and_schedule_cancel.rs

@@ -0,0 +1,66 @@
+use ethers::signers::LocalWallet;
+use log::info;
+
+use hyperliquid_rust_sdk::{
+    BaseUrl, ClientLimit, 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 = "84f77cc056fb165d8081d0f218748122481dfe3d4dfa80ad9420d11f4b7faba5"
+        .parse()
+        .unwrap();
+
+    let exchange_client = ExchangeClient::new(None, wallet, Some(BaseUrl::Testnet), None, None)
+        .await
+        .unwrap();
+
+    info!("Testing Schedule Cancel Dead Man's Switch functionality...");
+
+    // First, place a test order that we can cancel later
+    let order = ClientOrderRequest {
+        asset: "ETH".to_string(),
+        is_buy: true,
+        reduce_only: false,
+        limit_px: 100.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!("Test order placed: {response:?}");
+
+    match response {
+        ExchangeResponseStatus::Ok(exchange_response) => {
+            let status = &exchange_response.data.unwrap().statuses[0];
+            match status {
+                ExchangeDataStatus::Filled(_) => info!("Order was filled"),
+                ExchangeDataStatus::Resting(_) => info!("Order is resting"),
+                _ => info!("Order status: {status:?}"),
+            }
+        }
+        ExchangeResponseStatus::Err(e) => {
+            info!("Error placing order: {e}");
+            return;
+        }
+    }
+
+    // Schedule a cancel operation 15 seconds in the future
+    // Use chrono to for UTC timestamp
+    let current_time = chrono::Utc::now().timestamp_millis() as u64;
+    let cancel_time = current_time + 15000; // 15 seconds from now
+
+    let response = exchange_client
+        .schedule_cancel(Some(cancel_time), None)
+        .await
+        .unwrap();
+    info!("schedule_cancel response: {:?}", response);
+    sleep(Duration::from_secs(20));
+}

src/exchange/actions.rs

@@ -313,6 +313,13 @@ pub struct ApproveBuilderFee {
     pub hyperliquid_chain: String,
 }
 
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct ScheduleCancel {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub time: Option<u64>,
+}
+
 impl Eip712 for ApproveBuilderFee {
     type Error = Eip712Error;
 

src/exchange/exchange_client.rs

@@ -2,8 +2,8 @@ use crate::signature::sign_typed_data;
 use crate::{
     exchange::{
         actions::{
-            ApproveAgent, ApproveBuilderFee, BulkCancel, BulkModify, BulkOrder, SetReferrer,
-            UpdateIsolatedMargin, UpdateLeverage, UsdSend,
+            ApproveAgent, ApproveBuilderFee, BulkCancel, BulkModify, BulkOrder, ScheduleCancel,
+            SetReferrer, UpdateIsolatedMargin, UpdateLeverage, UsdSend,
         },
         cancel::{CancelRequest, CancelRequestCloid},
         modify::{ClientModifyRequest, ModifyRequest},
@@ -69,6 +69,7 @@ pub enum Actions {
     SetReferrer(SetReferrer),
     ApproveBuilderFee(ApproveBuilderFee),
     EvmUserModify(EvmUserModify),
+    ScheduleCancel(ScheduleCancel),
 }
 
 impl Actions {
@@ -781,6 +782,23 @@ impl ExchangeClient {
 
         self.post(action, signature, timestamp).await
     }
+
+    pub async fn schedule_cancel(
+        &self,
+        time: Option<u64>,
+        wallet: Option<&LocalWallet>,
+    ) -> Result<ExchangeResponseStatus> {
+        let wallet = wallet.unwrap_or(&self.wallet);
+        let timestamp = next_nonce();
+
+        let action = Actions::ScheduleCancel(ScheduleCancel { time });
+        let connection_id = action.hash(timestamp, self.vault_address)?;
+        let action = serde_json::to_value(&action).map_err(|e| Error::JsonParse(e.to_string()))?;
+        let is_mainnet = self.http_client.is_mainnet();
+        let signature = sign_l1_action(wallet, connection_id, is_mainnet)?;
+
+        self.post(action, signature, timestamp).await
+    }
 }
 
 fn round_to_decimals(value: f64, decimals: u32) -> f64 {