字样更新

global/src/predictor_state.rs

@@ -11,7 +11,7 @@ pub struct PredictorState {
     pub bid_price: Decimal,                                                     // 买一价
     pub optimal_ask_price: Decimal,                                             // 卖出挂单价
     pub optimal_bid_price: Decimal,                                             // 买入挂单价
-    pub ref_price: Decimal,                                                     // 预定价格
+    pub ref_price: Decimal,                                                     // 公平价格
 
     pub spread: Decimal,                                                        // 市场冲击
     pub flow_ratio: Decimal,                                                    // 资金流

strategy/src/core.rs

@@ -638,7 +638,7 @@ impl Core {
 
         // ================================ 在系统已经准备就绪的情况下，更新相关参数 =========================================
         if self.mode_signal == 0 && self.ready == 1 {
-            // 更新预定价格
+            // 更新公平价格
             self.predictor.on_depth(depth, index).await;
             // 触发事件撤单逻辑
             // 更新策略时间

strategy/src/predictor.rs

@@ -50,12 +50,13 @@ pub struct Predictor {
     pub fair_price_long_time_vec: FixedTimeRangeDeque<Decimal>,                 // 公平价格队列，10ms以内的所有公平价格
     pub spread_sma_1000_time_vec: FixedTimeRangeDeque<Decimal>,                 // spread队列，10ms以内的所有spread_sma_1000
     pub fair_price_vec: Vec<Decimal>,                                           // 公平价格列表，0表示做市所，1表示参考所
-    pub fair_price: Decimal,                                                    // 预定价格
+    pub fair_price: Decimal,                                                    // 公平价格
+    pub fair_price_ema_100000: Decimal,                                         // 公平价格_ema_100000
     pub fair_rate_focus_open: Decimal,                                          // 变化幅度焦点
     pub fair_price_focus_open: Decimal,                                         // 观测焦点时的价格
     pub fair_rate_focus_close: Decimal,                                         // 变化幅度焦点
     pub fair_price_focus_close: Decimal,                                        // 观测焦点时的价格
-    pub fair_price_when_ordering: Decimal,                                      // 下单时的预定价格
+    pub fair_price_when_ordering: Decimal,                                      // 下单时的公平价格
     pub price_times_avg: Decimal,                                               // 公平所与做市所的价格倍率的平均值
     pub is_regressed: bool,                                                     // 做市所的价格是否已经回归
 
@@ -167,6 +168,7 @@ impl Predictor {
             fair_price_long_time_vec: FixedTimeRangeDeque::new(2 * 60_000_000),
             mid_price_time_vec: FixedTimeRangeDeque::new(100_000),
             fair_price: Default::default(),
+            fair_price_ema_100000: Default::default(),
             fair_rate_focus_open: Default::default(),
             fair_price_focus_open: Default::default(),
             fair_rate_focus_close: Default::default(),
@@ -318,6 +320,11 @@ impl Predictor {
             let fair_price_part0 = self.fair_price_vec[0] * dec!(0.2);
             let fair_price_part1 = (self.fair_price_vec[1] / self.price_times_avg) * dec!(0.8);
             self.fair_price = fair_price_part0 + fair_price_part1;
+            self.fair_price_ema_100000 = if self.fair_price_ema_100000.is_zero() {
+                self.fair_price
+            } else {
+                self.fair_price_ema_100000 * dec!(0.99999) + self.fair_price * dec!(0.00001)
+            };
             self.fair_price_time_vec.push_back(self.fair_price);
 
             if self.fair_price_time_vec.len() < 2 {
@@ -601,9 +608,9 @@ impl Predictor {
         let bid_price = self.bid_price;
         let last_price = self.last_price;
 
-        let spread = self.spread_sma;
-        let spread_max = self.spread_sma_2000;
-        let spread_min = self.spread_sma_1000;
+        let spread = self.mid_price;
+        let spread_max = self.fair_price;
+        let spread_min = self.fair_price_ema_100000;
         // let spread = self.price_times_avg;
         // let spread_max = self.fair_price_vec[1] / self.fair_price_vec[0];
         // let spread_min = self.fair_price / self.mid_price;