binance数据已加入predictor

strategy/src/binance_usdt_swap.rs

@@ -4,7 +4,7 @@ use std::sync::atomic::AtomicBool;
 use rust_decimal::Decimal;
 use tokio::sync::Mutex;
 use tokio_tungstenite::tungstenite::Message;
-use tracing::{error, info};
+use tracing::{error};
 use exchanges::response_base::ResponseData;
 use global::trace_stack::{TraceStack};
 use crate::core::Core;
@@ -152,11 +152,10 @@ async fn on_data(core_arc: Arc<Mutex<Core>>, multiplier: &Decimal, run_symbol: &
             core.update_order(order_infos, trace_stack).await;
         }
         "forceOrder" => {
-            info!("{}", response.data.to_string());
-
             let force_order = ExchangeStructHandler::force_order_handle(ExchangeEnum::BinanceSwap, &response);
 
-            info!(?force_order);
+            let mut core = core_arc.lock().await;
+            core.update_force_order(force_order).await;
         }
         _ => {
             error!("未知推送类型");

strategy/src/core.rs

@@ -18,7 +18,7 @@ use tracing::{error, info, warn};
 use global::cci::CentralControlInfo;
 use global::params::Params;
 use global::trace_stack::TraceStack;
-use standard::{Account, Depth, Market, Order, OrderCommand, Platform, Position, PositionModeEnum, Record, SpecialTicker, Ticker, Trade};
+use standard::{Account, Depth, ForceOrder, Market, Order, OrderCommand, Platform, Position, PositionModeEnum, Record, SpecialTicker, Ticker, Trade};
 use standard::exchange::{Exchange};
 use standard::exchange::ExchangeEnum::{BinanceSwap, BybitSwap, BitgetSwap, GateSwap};
 
@@ -284,6 +284,10 @@ impl Core {
         return core_obj;
     }
 
+    pub async fn update_force_order(&mut self, force_order: ForceOrder) {
+        self.predictor.on_force_order(force_order).await;
+    }
+
     // #[instrument(skip(self, data, trace_stack), level="TRACE")]
     pub async fn update_order(&mut self, data: Vec<OrderInfo>, trace_stack: TraceStack) {
         for order in data {

strategy/src/predictor.rs

@@ -11,7 +11,7 @@ use tracing::{info};
 use global::cci::CentralControlInfo;
 use global::fixed_time_range_deque::FixedTimeRangeDeque;
 use global::params::Params;
-use standard::{Depth, Record, Ticker, Trade};
+use standard::{Depth, ForceOrder, Record, Ticker, Trade};
 use crate::utils;
 
 #[derive(Debug, Clone)]
@@ -51,6 +51,8 @@ pub struct Predictor {
     pub ask_delta: Decimal,                                                     // δa
     pub bid_delta: Decimal,                                                     // δb
 
+    pub force_order_time_vec: FixedTimeRangeDeque<ForceOrder>,                  // 爆仓单队列
+
     pub mid_price_time_vec: FixedTimeRangeDeque<Decimal>,                       // 中间价格队列，
     pub mid_price_long_time_vec: FixedTimeRangeDeque<Decimal>,                  // 中间价格队列，
     pub mid_price_trend_time_vec: FixedTimeRangeDeque<Decimal>,                  // 中间价格队列，
@@ -169,6 +171,8 @@ impl Predictor {
             ask_delta: Default::default(),
             bid_delta: Default::default(),
 
+            force_order_time_vec: FixedTimeRangeDeque::new(60 * 1_000_000),
+
             fair_price_time_vec: FixedTimeRangeDeque::new((params.second_observation_time.to_f64().unwrap() * 1_000_000f64).to_i64().unwrap()),
             fair_price_long_time_vec: FixedTimeRangeDeque::new((params.second_observation_time.to_f64().unwrap() * 1_000_000f64).to_i64().unwrap() * 2),
             mid_price_time_vec: FixedTimeRangeDeque::new((params.second_observation_time.to_f64().unwrap() * 1_000_000f64).to_i64().unwrap()),
@@ -276,6 +280,20 @@ impl Predictor {
         // self.processor().await;
     }
 
+    pub async fn on_force_order(&mut self, force_order: ForceOrder) {
+        match self.force_order_time_vec.deque.iter().last() {
+            Some(last) => {
+                // 有的交易所会重复推，这样做个容错处理
+                if force_order.time != last.time && force_order.value != last.value {
+                    self.force_order_time_vec.push_back(force_order);
+                }
+            }
+            None => {
+                self.force_order_time_vec.push_back(force_order);
+            }
+        }
+    }
+
     pub async fn update_level(&mut self) {
         self.level = (Decimal::NEGATIVE_ONE + (Decimal::ONE + dec!(8) * self.inventory.abs()).sqrt().unwrap()) / Decimal::TWO;
         self.level = min(self.level, dec!(6));
@@ -737,26 +755,11 @@ impl Predictor {
 
         let inventory = self.inventory;
 
-        let sigma_square = if self.mid_price_time_vec.len() > 1 {
-            let first = self.mid_price_time_vec.deque.front().unwrap();
-            let last = self.mid_price_time_vec.deque.back().unwrap();
-
-            let mut rst = (last - first) / first;
-
-            rst.rescale(8);
-
-            rst
-        } else {
-            Decimal::ZERO
-        };
+        let sigma_square: Decimal = self.force_order_time_vec.deque.iter().map(|item| item.value).sum();
         // let sigma_square = self.error_rate;
 
         let gamma = self.trades_volume_short;
-        let kappa = if sigma_square.is_zero() {
-            Self::DONT_VIEW
-        } else {
-            (self.trades_volume_short / sigma_square.abs()).ln()
-        };
+        let kappa = Decimal::ZERO;
 
         let flow_ratio = Decimal::ZERO;