市价单检测逻辑

src/strategy.rs

@@ -21,10 +21,12 @@ pub enum StrategyState {
     },
     CancellingOrder {               // 撤单中
         order_id: String,
-        price: Decimal,
     },
     ExecutingMarketOrder {          // 执行市价单
     },
+    WaitingMarketOrder {            // 等待市价单执行完毕
+        order_id: String,
+    },
 }
 
 #[allow(dead_code)]
@@ -32,12 +34,12 @@ pub struct Strategy {
     state: StrategyState,
     order_quantity: Decimal,                        // 写死的订单数量
     filled_quantity: Decimal,                       // 成交数量
-    
+
     rest_client: Arc<Mutex<ExtendedRestClient>>,    // rest客户端
-    
+
     min_order_interval_ms: u128,                    // 最小下单间隔（毫秒）
     min_query_order_interval_ms: u128,              // 最小查单间隔（毫秒）
-    
+
     last_order_time: Instant,
     last_query_order_time: Instant,
 }
@@ -48,12 +50,12 @@ impl Strategy {
             state: StrategyState::Idle,
             order_quantity: dec!(0.0001),
             filled_quantity: Decimal::ZERO,
-            
+
             rest_client: client_am,
-            
+
             min_order_interval_ms: 200,
             min_query_order_interval_ms: 200,
-            
+
             last_order_time: Instant::now(),
             last_query_order_time: Instant::now(),
         }
@@ -71,8 +73,8 @@ impl Strategy {
                     warn!("等待限价单状态处理失败: {}", e);
                 }
             }
-            StrategyState::CancellingOrder { order_id, price } => {
-                if let Err(e) = self.handle_cancelling_order(dm, price, order_id).await {
+            StrategyState::CancellingOrder { order_id } => {
+                if let Err(e) = self.handle_cancelling_order(dm, order_id).await {
                     warn!("撤单状态处理失败: {}", e);
                 }
             }
@@ -81,6 +83,11 @@ impl Strategy {
                     warn!("市价单执行状态处理失败: {}", e);
                 }
             }
+            StrategyState::WaitingMarketOrder { order_id } => {
+                if let Err(e) = self.handle_waiting_market_order(dm, order_id).await {
+                    warn!("等待限价单状态处理失败: {}", e);
+                }
+            }
         }
 
         Ok(())
@@ -104,10 +111,10 @@ impl Strategy {
                     order_id,
                     price: dm.best_bid
                 };
-                
+
                 self.last_order_time = Instant::now();
                 self.last_query_order_time = self.last_order_time;
-                
+
                 Ok(())
             }
             Err(e) => {
@@ -152,8 +159,7 @@ impl Strategy {
         if dm.best_bid != price {
             info!("价格已变化，从 {} 到 {}，准备撤单", price, dm.best_bid);
             self.state = StrategyState::CancellingOrder {
-                order_id,
-                price,
+                order_id
             };
         }
 
@@ -164,7 +170,6 @@ impl Strategy {
     async fn handle_cancelling_order(
         &mut self,
         _dm: &DataManager,
-        _price: Decimal,
         order_id: String,
     ) -> Result<()> {
         info!("撤单中，订单ID: {}", order_id);
@@ -204,45 +209,65 @@ impl Strategy {
     ) -> Result<()> {
         info!("执行市价卖单");
 
+        // 检查是否满足下单时间间隔
+        let elapsed = self.last_order_time.elapsed().as_millis();
+        if elapsed < self.min_order_interval_ms {
+            return Ok(());
+        }
+
         // 尝试下市价单
-        let order_id = match self.place_market_sell_order(dm.best_bid, self.filled_quantity).await {
+        match self.place_market_sell_order(dm.best_bid, self.filled_quantity).await {
             Ok(id) => {
                 info!("市价卖单下单成功，订单ID: {}", id);
-                
+
                 self.last_order_time = Instant::now();
+                self.state = StrategyState::WaitingMarketOrder {
+                    order_id: id.clone(),
+                };
                 
-                id
-            }
-            Err(e) => {
-                warn!("下市价卖单失败: {}", e);
-                return Err(e);
-            }
-        };
-
-        // 下单后暂停几秒再检查
-        sleep(Duration::from_millis(3000)).await;
-
-        // 等待市价单成交（市价单通常立即成交）
-        match self.check_order_filled(&order_id).await {
-            Ok(true) => {
-                info!("市价单已成交，返回空闲状态");
-
-                self.state = StrategyState::Idle;
-                self.filled_quantity = Decimal::ZERO;
-
-                Ok(())
-            }
-            Ok(false) => {
-                warn!("市价单未成交，保持当前状态");
                 Ok(())
             }
             Err(e) => {
-                warn!("检查市价单成交状态失败: {}", e);
+                warn!("下市价卖单失败: {}", e);
                 Err(e)
             }
         }
     }
 
+   // 状态5：等待市价单成交
+    async fn handle_waiting_market_order(
+       &mut self,
+       _dm: &DataManager,
+       order_id: String,
+   ) -> Result<()> {
+       let elapsed = self.last_query_order_time.elapsed().as_millis();
+       if elapsed < self.min_query_order_interval_ms {
+           return Ok(());
+       }
+       self.last_query_order_time = Instant::now();
+
+       // 等待市价单成交（市价单通常立即成交）
+       match self.check_order_filled(&order_id).await {
+           Ok(true) => {
+               info!("市价单已成交，返回空闲状态");
+
+               self.state = StrategyState::Idle;
+               self.filled_quantity = Decimal::ZERO;
+
+               Ok(())
+           }
+           Ok(false) => {
+               self.state = StrategyState::ExecutingMarketOrder { };
+               
+               Ok(())
+           }
+           Err(e) => {
+               warn!("检查市价单成交状态失败: {}", e);
+               Err(e)
+           }
+       }
+   }
+
     // ==================== 抽象方法（待实现）====================
 
     /// 下限价买单