改用深度变化来确认市场冲击

strategy/src/avellaneda_stoikov.rs

@@ -53,7 +53,7 @@ impl AvellanedaStoikov {
     // 时间窗口大小（微秒）
     const MAX_TIME_RANGE_MICROS: i64 = 3 * 60_000_000;
     const TRADE_LONG_RANGE_MICROS: i64 = 3 * 60_000_000;
-    const SPREAD_RANGE_MICROS: i64 = 6 * 60_000_000;
+    const SPREAD_RANGE_MICROS: i64 = 15 * 60_000_000;
     const TRADE_SHORT_RANGE_MICROS: i64 = 60_000_000;
     // const ONE_MILLION: Decimal = dec!(1_000_000);
     // const TWENTY_THOUSAND: Decimal = dec!(20_000);
@@ -103,60 +103,49 @@ impl AvellanedaStoikov {
         avellaneda_stoikov
     }
 
-    // 更新最大市场冲击
-    pub fn update_spread_max(&mut self) {
-        self.spread_max = if let Some(&max_value) = self.spread_vec.deque.iter().max() {
-            max_value
-        } else {
-            Decimal::NEGATIVE_ONE
-        };
-    }
-
-    // 更新最小市场冲击
-    pub fn update_spread_min(&mut self) {
-        self.spread_min = if let Some(&min_value) = self.spread_vec.deque.iter().min() {
-            min_value
-        } else {
-            Decimal::NEGATIVE_ONE
-        };
-    }
+    // // 更新最大市场冲击
+    // pub fn update_spread_max(&mut self) {
+    //     self.spread_max = if let Some(&max_value) = self.spread_vec.deque.iter().max() {
+    //         max_value
+    //     } else {
+    //         Decimal::NEGATIVE_ONE
+    //     };
+    // }
+    //
+    // // 更新最小市场冲击
+    // pub fn update_spread_min(&mut self) {
+    //     self.spread_min = if let Some(&min_value) = self.spread_vec.deque.iter().min() {
+    //         min_value
+    //     } else {
+    //         Decimal::NEGATIVE_ONE
+    //     };
+    // }
 
     pub fn update_spread(&mut self) {
-        if self.trade_long_vec.len() > 0 {
-            //
-            let last_trade = self.trade_long_vec.get(self.trade_long_vec.len() - 1).unwrap();
-            let last_trade_price = last_trade.price;
-            let last_trade_time = last_trade.time;
-
-            let mut first_trade_price = last_trade.price;
-            for trade in self.trade_long_vec.deque.iter().rev() {
-                if last_trade_time - trade.time > Decimal::TEN {
-                    break;
-                }
-
-                first_trade_price = trade.price;
-            }
-
-            self.spread = (last_trade_price - first_trade_price).abs();
-            if self.spread > Decimal::ZERO {
-                self.spread_vec.push_back(self.spread);
-            }
+        let prev_depth_0 = &self.depth_vec[0];
+        if prev_depth_0.time.is_zero() {
+            return;
+        }
 
-            self.update_spread_max();
-            self.update_spread_min();
+        let prev_mid_price = (prev_depth_0.asks[0].price + prev_depth_0.bids[0].price) / Decimal::TWO;
+        let now = (prev_mid_price - self.mid_price).abs();
+        if !now.is_zero() {
+            self.spread = now * dec!(0.01) + self.spread * dec!(0.99)
         }
     }
 
     pub async fn on_depth(&mut self, depth: &Depth, index: usize) {
-        self.depth_vec[index] = depth.clone();
         self.update_fair_price(depth, index).await;
 
-        if index == 0 || self.mid_price.is_zero() {
+        if index == 0 {
             self.ask_price = depth.asks[0].price;
             self.bid_price = depth.bids[0].price;
             self.mid_price = (self.ask_price + self.bid_price) / Decimal::TWO;
+
+            self.update_spread();
         }
 
+        self.depth_vec[index] = depth.clone();
         self.processor().await;
     }
 
@@ -165,7 +154,6 @@ impl AvellanedaStoikov {
         self.trade_short_vec.push_back(trade.clone());
 
         self.last_price = trade.price;
-        self.update_spread();
         self.processor().await;
     }
 
@@ -227,7 +215,7 @@ impl AvellanedaStoikov {
     }
 
     pub fn update_sigma_square(&mut self) {
-        self.sigma_square = self.spread_max * dec!(0.3);
+        self.sigma_square = self.spread;
         self.sigma_square.rescale(10);
     }
 
@@ -251,7 +239,7 @@ impl AvellanedaStoikov {
 
     pub fn update_delta(&mut self) {
         if self.gamma != Decimal::ZERO {
-            let pos_edge = self.sigma_square * self.inventory.abs() * self.t_diff;
+            // let pos_edge = self.sigma_square * self.inventory.abs() * self.t_diff;
 
             self.base_delta = self.sigma_square;
 
@@ -259,11 +247,9 @@ impl AvellanedaStoikov {
             self.ask_delta = self.base_delta;
 
             if self.inventory > Decimal::ZERO {
-                self.bid_delta += pos_edge * Decimal::TEN;
                 self.ask_delta = Decimal::NEGATIVE_ONE;
             } else if self.inventory < Decimal::ZERO {
                 self.bid_delta = Decimal::NEGATIVE_ONE;
-                self.ask_delta += pos_edge * Decimal::TEN;
             }
         }
     }

strategy/src/strategy.rs

@@ -951,7 +951,7 @@ impl Strategy {
         // let one_hand_long_value = dec!(0.99) * (self.max_long_value / self.grid);
         // let one_hand_short_value = dec!(0.99) * (self.max_short_value / self.grid);
         // 挂多单
-        if self.post_side >= 0 && buy_value == Decimal::ZERO && predictor.optimal_bid_price < predictor.mid_price {
+        if self.post_side >= 0 && buy_value == Decimal::ZERO && predictor.optimal_bid_price < predictor.mid_price && predictor.inventory <= Decimal::ZERO {
             let mut target_buy_price = predictor.optimal_bid_price;
             // target_buy_price = utils::clip(target_buy_price, self.bp * dec!(0.97), self.ap * dec!(1.0005));
             target_buy_price = utils::fix_price(target_buy_price, self.tick_size);
@@ -991,7 +991,7 @@ impl Strategy {
             }
         }
         // 挂空单
-        if self.post_side <= 0 && sell_value == Decimal::ZERO && predictor.optimal_ask_price > predictor.mid_price {
+        if self.post_side <= 0 && sell_value == Decimal::ZERO && predictor.optimal_ask_price > predictor.mid_price && predictor.inventory >= Decimal::ZERO {
             let mut target_sell_price = predictor.optimal_ask_price;
             // target_sell_price = utils::clip(target_sell_price, self.bp * dec!(0.9995), self.ap * dec!(1.03));
             // 取消大小限制
@@ -1110,7 +1110,7 @@ impl Strategy {
         self.fix_price(predictor);
 
         self._cancel_open(&mut command, local_orders);              // 撤单命令处理
-        self._post_open(&mut command, local_orders, predictor);     // 限价单命令处理
+        // self._post_open(&mut command, local_orders, predictor);     // 限价单命令处理
         self._check_local_orders(&mut command, local_orders);       // 固定时间检查超时订单
         self._update_in_cancel(&mut command, local_orders);         // 更新撤单队列，是一个filter
         self._check_request_limit(&mut command);                    // 限制频率，移除不合规则之订单，是一个filter