self.state == 0才挂单交易

strategy/src/predictor.rs

@@ -19,7 +19,6 @@ use crate::utils;
 #[derive(Debug, Clone)]
 pub struct Predictor {
     pub depth_vec: Vec<Depth>,                                                  // 深度队列
-    pub spread_vec: Vec<Decimal>,                                               // 价差队列
     pub record_vec: VecDeque<Record>,                                           // 蜡烛队列
 
     pub mid_price: Decimal,                                                     // 中间价
@@ -87,6 +86,9 @@ pub struct Predictor {
     pub prev_flush_state_time: Decimal,
     pub state: usize,
     pub state_matrix: Vec<Vec<Decimal>>,
+
+    pub spread: Decimal,                                                        // 当前价差
+    pub spread_ema: Decimal,                                                    // 价差的sma，默认是sma5000
 }
 
 impl Predictor {
@@ -154,7 +156,6 @@ impl Predictor {
             fair_price_vec: vec![Decimal::ZERO; 10],
 
             // 老的队列
-            spread_vec: vec![],
             profit_point_vec: vec![],
             record_vec: VecDeque::new(),
 
@@ -219,6 +220,9 @@ impl Predictor {
                 vec![dec!(0.33), dec!(0.33), dec!(0.33)],
                 vec![dec!(0.33), dec!(0.33), dec!(0.33)],
             ],
+
+            spread: Default::default(),
+            spread_ema: Default::default(),
         };
 
         predictor
@@ -235,10 +239,13 @@ impl Predictor {
         }
 
         self.update_fair_price(depth, index).await;
-        self.update_spread();
 
         self.depth_vec[index] = depth.clone();
 
+        if index == 1 {
+            self.update_spread();
+        }
+
         if self.mid_price.is_zero() {
             return;
         }
@@ -430,6 +437,14 @@ impl Predictor {
     }
 
     pub fn update_spread(&mut self) {
+        let depth = &self.depth_vec[1];
+
+        self.spread = depth.asks[0].price - depth.bids[0].price;
+        self.spread_ema = if self.spread_ema.is_zero() {
+            self.spread
+        } else {
+            self.spread_ema * dec!(0.999) + self.spread * dec!(0.001)
+        };
     }
 
     pub async fn update_delta(&mut self) {
@@ -441,29 +456,8 @@ impl Predictor {
         // 根据马尔科夫链调整挂单策略
         let now = Decimal::from(Utc::now().timestamp_millis());
         if now - self.prev_flush_state_time > dec!(60_000) {
-            // self.state_matrix = vec![
-            //     vec![dec!(0.33), dec!(0.33), dec!(0.33)],
-            //     vec![dec!(0.33), dec!(0.33), dec!(0.33)],
-            //     vec![dec!(0.33), dec!(0.33), dec!(0.33)],
-            // ];
             self.update_state_matrix().await;
 
-            self.state = 0usize;
-            let profit_list = vec![dec!(0.33), dec!(0.33), dec!(0.33)];
-
-            let mut profit_min = dec!(1);
-            let mut profit_min_index = 0usize;
-
-            for (i, p) in profit_list.iter().enumerate() {
-                if *p < profit_min {
-                    profit_min = *p;
-                    profit_min_index = i;
-                }
-            }
-
-            // 这个是后面加了动态平仓时间再使用的
-            // self.params.holding_time = Decimal::from(profit_min_index);
-            let _ = Decimal::from(profit_min_index);
             self.prev_flush_state_time = now;
         }
 
@@ -495,10 +489,12 @@ impl Predictor {
         let is_open_long = self.force_order_value < -self.params.open
             && (self.mid_price < self.prev_trade_price * dec!(0.999) || self.prev_trade_price.is_zero())
             && self.inventory < self.params.grid
+            && self.state == 0
             && self.bid_delta == dec!(-2);
         let is_open_short = self.force_order_value > self.params.open
             && (self.mid_price > self.prev_trade_price * dec!(1.001) || self.prev_trade_price.is_zero())
             && self.inventory > -self.params.grid
+            && self.state == 0
             && self.ask_delta == dec!(-2);
 
         if is_open_long {
@@ -590,9 +586,9 @@ impl Predictor {
         let last_price = self.last_price;
         let fair_price = Self::DONT_VIEW;
 
-        let spread = self.state_matrix[0][0];
-        let spread_max = self.state_matrix[1][1];
-        let spread_min = self.state_matrix[2][2];
+        let spread = self.spread;
+        let spread_max = self.spread_ema;
+        let spread_min = Self::DONT_VIEW;
 
         let optimal_ask_price = self.optimal_ask_price;
         let optimal_bid_price = self.optimal_bid_price;
@@ -600,9 +596,8 @@ impl Predictor {
         let inventory = self.inventory;
 
         let sigma_square = Decimal::from(self.state);
-        // let sigma_square = self.error_rate;
 
-        let gamma = self.pos_amount;
+        let gamma = self.params.holding_time;
         let kappa = self.balance;
 
         let flow_ratio = Decimal::ZERO;
@@ -660,7 +655,7 @@ impl Predictor {
             let response_text = response.text().await.unwrap();
             let parsed: Value = serde_json::from_str(response_text.as_str()).unwrap();
 
-            info!("state_matrix={}", parsed["state_matrix"].to_string());
+            info!("state_matrix={}", parsed.to_string());
 
             self.state_matrix = parsed["state_matrix"]
                 .as_array()
@@ -676,6 +671,7 @@ impl Predictor {
                 .collect();
 
             self.state = parsed["state"].as_i64().unwrap() as usize;
+            self.params.holding_time = Decimal::from(parsed["min_index"].as_i64().unwrap());
         } else {
             error!("状态转移链挂了：{}", response.status());
         }