1. 检查订单和检查仓位之间留500ms空隙，留给交易所撮合

2. 每次退出至少检查5次订单、仓位(每次检查间隔1秒)
3. 保留每次清退时的原始数据

standard/src/bitget_swap.rs

@@ -416,8 +416,8 @@ impl Platform for BitgetSwap {
 
     async fn cancel_orders_all(&mut self) -> Result<Vec<Order>, Error> {
         let response = self.request.get_pending_orders().await;
-        info!(?response);
         if response.code == 200 {
+            info!("{}", response.data.to_string());
             let mut result = vec![];
 
             if !response.data["entrustedList"].is_null() {

standard/src/bybit_swap.rs

@@ -10,7 +10,7 @@ use serde_json::{from_value, json, Value};
 use rust_decimal::prelude::FromPrimitive;
 use serde::{Deserialize, Serialize};
 use tokio::time::Instant;
-use tracing::{error, trace};
+use tracing::{error, info, trace};
 use exchanges::bybit_swap_rest::BybitSwapRest;
 use crate::{Platform, ExchangeEnum, Account, Position, Ticker, Market, Order, OrderCommand, PositionModeEnum};
 use global::trace_stack::TraceStack;
@@ -163,6 +163,7 @@ impl Platform for BybitSwap {
         let ct_val = self.market.ct_val;
         let res_data = self.request.get_positions("".to_string(), symbol_array[1].to_string().to_uppercase()).await;
         if res_data.code == 200 {
+            info!("{}", res_data.data.to_string());
             let result = res_data.data["list"].as_array().unwrap().iter().map(|item| { format_position_item(item, ct_val) }).collect();
             Ok(result)
         } else {
@@ -463,6 +464,7 @@ impl Platform for BybitSwap {
         let symbol = self.symbol_uppercase.clone();
         let res_data = self.request.cancel_orders(symbol).await;
         if res_data.code == 200 {
+            info!("{}", res_data.data.to_string());
             let res_arr: Vec<Value> = from_value(res_data.data).unwrap();
             let result = res_arr.iter().map(|item| format_cancel_order_item(item.clone())).collect();
             Ok(result)
@@ -475,6 +477,7 @@ impl Platform for BybitSwap {
         let symbol = self.symbol_uppercase.clone();
         let res_data = self.request.cancel_orders(symbol).await;
         if res_data.code == 200 {
+            info!("{}", res_data.data.to_string());
             let res_arr: Vec<Value> = from_value(res_data.data["list"].clone()).unwrap();
             let result = res_arr.iter().map(|item| format_cancel_order_item(item.clone())).collect();
             Ok(result)

standard/src/coinex_swap.rs

@@ -160,6 +160,7 @@ impl Platform for CoinexSwap {
     async fn get_positions(&mut self) -> Result<Vec<Position>, Error> {
         let res_data = self.request.get_user_position().await;
         if res_data.code == 200 {
+            info!("{}", res_data.data.to_string());
             let res_data_json = res_data.data.as_array().unwrap();
             let result = res_data_json.iter().map(|item| { format_position_item(item, Decimal::ONE) }).collect();
             Ok(result)
@@ -527,6 +528,7 @@ impl Platform for CoinexSwap {
         let symbol = self.symbol.replace("_", "").to_uppercase();
         let res_data = self.request.cancel_order_all(symbol).await;
         if res_data.code == 200 {
+            info!("{}", res_data.data.to_string());
             let result = vec![];
             Ok(result)
         } else {

standard/src/gate_swap.rs

@@ -143,6 +143,7 @@ impl Platform for GateSwap {
         let symbol_array: Vec<&str> = self.symbol.split("_").collect();
         let res_data = self.request.get_user_position(symbol_array[1].to_string().to_lowercase()).await;
         if res_data.code == 200 {
+            info!("{}", res_data.data.to_string());
             let res_data_json = res_data.data.as_array().unwrap();
             let result = res_data_json.iter().map(|item| { format_position_item(item, Decimal::ONE) }).collect();
             Ok(result)
@@ -437,6 +438,7 @@ impl Platform for GateSwap {
         let ct_val = self.market.ct_val;
         let res_data = self.request.cancel_orders(symbol_array[1].to_string().to_lowercase(), self.symbol.to_string()).await;
         if res_data.code == 200 {
+            info!("{}", res_data.data.to_string());
             let res_data_json = res_data.data.as_array().unwrap();
             let result = res_data_json.iter().map(|item| format_order_item(item.clone(), ct_val)).collect();
             Ok(result)
@@ -450,6 +452,7 @@ impl Platform for GateSwap {
         let ct_val = self.market.ct_val;
         let orders_res_data = self.request.get_orders(symbol_array[1].to_string().to_lowercase(), "open".to_string()).await;
         if orders_res_data.code == 200 {
+            info!("{}", orders_res_data.data.to_string());
             let mut result = vec![];
             let orders_res_data_json = orders_res_data.data.as_array().unwrap();
             for order in orders_res_data_json {

standard/src/kucoin_swap.rs

@@ -135,6 +135,7 @@ impl Platform for KucoinSwap {
         let symbol_array: Vec<&str> = symbol_mapper.split("_").collect();
         let res_data = self.request.get_positions(symbol_array[1].to_string()).await;
         if res_data.code == 200 {
+            info!("{}", res_data.data.to_string());
             let res_data_json = res_data.data.as_array().unwrap();
             let mut result = Vec::new();
             for item in res_data_json.iter() {
@@ -453,6 +454,7 @@ impl Platform for KucoinSwap {
         let symbol_format = format!("{}M", utils::format_symbol(symbol_mapper.clone(), ""));
         let res_data = self.request.cancel_orders(symbol_format).await;
         if res_data.code == 200 {
+            info!("{}", res_data.data.to_string());
             let res_data_json = res_data.data;
             let cancel_ids = res_data_json["cancelledOrderIds"].as_array().unwrap();
             let result = cancel_ids.iter().map(|item|
@@ -477,6 +479,7 @@ impl Platform for KucoinSwap {
     async fn cancel_orders_all(&mut self) -> Result<Vec<Order>, Error> {
         let res_data = self.request.cancel_order_all().await;
         if res_data.code == 200 {
+            info!("{}", res_data.data.to_string());
             let res_data_json = res_data.data;
             let cancel_ids = res_data_json["cancelledOrderIds"].as_array().unwrap();
             let result = cancel_ids.iter().map(|item|

strategy/src/core.rs

@@ -1154,7 +1154,7 @@ impl Core {
     }
 
     // #[instrument(skip(self, target_hold_coin), level="TRACE")]
-    pub async fn check_position(&mut self, target_hold_coin: Decimal) -> bool {
+    pub async fn check_position(&mut self, target_hold_coin: Decimal, is_first_clear: bool) -> bool {
         info!("------------------------------------------------------------------------------------------------------------");
         info!("步骤一：检查挂单：");
         let mut is_order_clear = false;
@@ -1188,6 +1188,11 @@ impl Core {
         info!("挂单检查完毕。");
         info!("");
 
+        // 如果不是第一次检查，留500ms给交易所撮合
+        if !is_first_clear {
+            sleep(Duration::from_millis(500)).await;
+        }
+
         info!("步骤二：检查仓位：");
         let is_position_clear;
         if self.exchange.contains("spot") { // 现货
@@ -1576,18 +1581,36 @@ impl Core {
 
     pub async fn clear_position_and_orders(&mut self, target_hold_coin: Decimal) {
         let mut clear_count = 1;
-        while !self.check_position(target_hold_coin).await {
-            sleep(Duration::from_secs(1)).await;
+        let mut total_clear_count = 1;
+
+        loop {
+            let is_clear = self.check_position(target_hold_coin, clear_count <= 1).await;
+            // 如果5次中间有一次没清理干净，则重新清理
+            if !is_clear {
+                clear_count = 1
+            }
 
-            if clear_count >= 3600 {
-                info!("清理次数达到上限：{}次，不再执行清理。", clear_count);
+            // 如果连续5次都检查到清理干净，则表明大概率是清理干净了的
+            if clear_count >= 5 {
+                info!("连续{}次清理完成。", clear_count);
+                info!("");
+                break
+            }
+
+            // 最大次数判定
+            if total_clear_count >= 500 {
+                info!("清理次数达到上限：{}次，不再执行清理。", total_clear_count);
                 info!("");
                 break
             }
 
             clear_count += 1;
+            total_clear_count += 1;
             info!("清理指令发送完毕，启动第{}次检查。", clear_count);
             info!("");
+
+            // 每次清理间隔1s
+            sleep(Duration::from_secs(1)).await;
         }
     }
 }