参考两个所，看看情况

global/src/params.rs

@@ -98,8 +98,12 @@ impl Params {
             close: Decimal::try_from(json_value["close"].as_f64().unwrap_or_default()).unwrap(),
             second_observation_time: Decimal::try_from(json_value["second_observation_time"].as_f64().unwrap()).unwrap(),
             lever_rate: Decimal::try_from(json_value["lever_rate"].as_f64().unwrap_or_default()).unwrap(),
-            ref_exchange: vec![json_value["ref_exchange"].as_str().unwrap().to_string()],                   // 兼容新版本与老版本
-            ref_pair: vec![json_value["ref_pair"].as_str().unwrap().to_string()],                           // 兼容新版本与老版本
+            ref_exchange: json_value["ref_exchange"].as_array().unwrap().into_iter()
+                .filter_map(|v| v.as_str().map(|s| s.to_string()))
+                .collect(),
+            ref_pair: json_value["ref_pair"].as_array().unwrap().into_iter()
+                .filter_map(|v| v.as_str().map(|s| s.to_string()))
+                .collect(),                           // 兼容新版本与老版本
             stop_loss: Decimal::try_from(json_value["stop_loss"].as_f64().unwrap_or_default()).unwrap(),
             // 接下来是写死的参数
             close_activate: Decimal::ZERO,

src/core_libs.rs

@@ -36,22 +36,28 @@ pub async fn init(params: Params,
                                    error_sender.clone(),
                                    running.clone(),
                                    cci_arc.clone()).await;
-    let ref_name = core_obj.ref_name[0].clone();
-    let trade_name = core_obj.trade_name.clone();
 
     info!("core初始化……");
     core_obj.before_trade().await;
     let core_arc = Arc::new(Mutex::new(core_obj));
 
     // 参考交易所
-    exchange_disguise::run_reference_exchange(ws_running.clone(),
-                                              params.ref_exchange.get(0).unwrap().clone(),
-                                              core_arc.clone(),
-                                              ref_name,
-                                              params.ref_pair.clone(),
-                                              params.colo != 0i8,
-                                              exchange_params.clone()).await;
+    let ref_names = core_arc.lock().await.ref_name.clone();
+    for (ref_index, ref_name) in ref_names.iter().enumerate() {
+        let ref_exchange = params.ref_exchange.get(ref_index).unwrap();
+        let ref_symbol = params.ref_pair.get(ref_index).unwrap();
+
+        exchange_disguise::run_reference_exchange(ws_running.clone(),
+                                                  core_arc.clone(),
+                                                  ref_index,
+                                                  ref_name.clone(),
+                                                  ref_exchange.clone(),
+                                                  vec![ref_symbol.clone()],
+                                                  params.colo != 0i8,
+                                                  exchange_params.clone()).await;
+    }
     // 交易交易所
+    let trade_name = core_arc.lock().await.trade_name.clone();
     exchange_disguise::run_transactional_exchange(ws_running.clone(),
                                                   params.exchange,
                                                   core_arc.clone(),

strategy/src/binance_usdt_swap.rs

@@ -11,6 +11,7 @@ use crate::core::Core;
 use exchanges::binance_swap_ws::{BinanceSwapLogin, BinanceSwapSubscribeType, BinanceSwapWs, BinanceSwapWsType};
 use standard::exchange::ExchangeEnum;
 use standard::exchange_struct_handler::ExchangeStructHandler;
+use crate::bybit_usdt_swap::reference_bybit_swap_run;
 use crate::exchange_disguise::{on_depth, on_trade};
 use crate::model::OrderInfo;
 
@@ -19,7 +20,9 @@ pub(crate) async fn reference_binance_swap_run(is_shutdown_arc: Arc<AtomicBool>,
                                                core_arc: Arc<Mutex<Core>>,
                                                name: String,
                                                symbols: Vec<String>,
-                                               is_colo: bool) {
+                                               is_colo: bool,
+                                               ref_index: usize
+) {
     tokio::spawn(async move {
         //创建读写通道
         let (write_tx, write_rx) = futures_channel::mpsc::unbounded::<Message>();
@@ -42,7 +45,7 @@ pub(crate) async fn reference_binance_swap_run(is_shutdown_arc: Arc<AtomicBool>,
 
             async move {
                 // 使用克隆后的 Arc，避免 move 语义
-                on_data(core_arc_cc, &mul, &rs, &data).await
+                on_data(core_arc_cc, &mul, &rs, &data, ref_index).await
             }
         };
 
@@ -60,6 +63,9 @@ pub(crate) async fn binance_swap_run(is_shutdown_arc: Arc<AtomicBool>,
                                      symbols: Vec<String>,
                                      is_colo: bool,
                                      exchange_params: BTreeMap<String, String>) {
+    // 参考
+    reference_bybit_swap_run(is_shutdown_arc.clone(), core_arc.clone(), name.clone(), symbols.clone(), is_colo, 233).await;
+
     tokio::spawn(async move {
         //创建读写通道
         let (write_tx, write_rx) = futures_channel::mpsc::unbounded::<Message>();
@@ -69,7 +75,6 @@ pub(crate) async fn binance_swap_run(is_shutdown_arc: Arc<AtomicBool>,
             BinanceSwapSubscribeType::PrPosition,
             BinanceSwapSubscribeType::PrAccount,
             BinanceSwapSubscribeType::PrBalance,
-            BinanceSwapSubscribeType::PuAggTrade
         ]);
 
         // 读取数据
@@ -85,7 +90,7 @@ pub(crate) async fn binance_swap_run(is_shutdown_arc: Arc<AtomicBool>,
 
             async move {
                 // 使用克隆后的 Arc，避免 move 语义
-                on_data(core_arc_cc, &mul, &rs, &data).await
+                on_data(core_arc_cc, &mul, &rs, &data, 233).await
             }
         };
 
@@ -96,7 +101,7 @@ pub(crate) async fn binance_swap_run(is_shutdown_arc: Arc<AtomicBool>,
     });
 }
 
-async fn on_data(core_arc: Arc<Mutex<Core>>, multiplier: &Decimal, run_symbol: &String, response: &ResponseData) {
+async fn on_data(core_arc: Arc<Mutex<Core>>, multiplier: &Decimal, run_symbol: &String, response: &ResponseData, ref_index: usize) {
     let mut trace_stack = TraceStack::new(response.time, response.ins);
     trace_stack.on_after_span_line();
 
@@ -112,7 +117,7 @@ async fn on_data(core_arc: Arc<Mutex<Core>>, multiplier: &Decimal, run_symbol: &
             for trade in trades.iter_mut() {
                 let core_arc_clone = core_arc.clone();
 
-                on_trade(core_arc_clone, &response.label, &mut trace_stack, &trade, 1).await;
+                on_trade(core_arc_clone, &response.label, &mut trace_stack, &trade, ref_index).await;
             }
         }
         "bookTicker" => {
@@ -121,7 +126,7 @@ async fn on_data(core_arc: Arc<Mutex<Core>>, multiplier: &Decimal, run_symbol: &
             let depth = ExchangeStructHandler::book_ticker_handle(ExchangeEnum::BinanceSwap, response, multiplier);
             trace_stack.on_after_format();
 
-            on_depth(core_arc, &response.label, &mut trace_stack, &depth, 1).await;
+            on_depth(core_arc, &response.label, &mut trace_stack, &depth, ref_index).await;
         }
         "ACCOUNT_UPDATE" => {
             let account = ExchangeStructHandler::account_info_handle(ExchangeEnum::BinanceSwap, response, run_symbol);

strategy/src/bitget_usdt_swap.rs

@@ -20,15 +20,17 @@ pub async fn reference_bitget_swap_run(is_shutdown_arc: Arc<AtomicBool>,
                                        core_arc: Arc<Mutex<Core>>,
                                        name: String,
                                        symbols: Vec<String>,
-                                       is_colo: bool) {
+                                       is_colo: bool,
+                                       ref_index: usize
+) {
     spawn(async move {
         // 开启公共频道
         let (write_tx, write_rx) = futures_channel::mpsc::unbounded::<Message>();
         let mut ws = BitgetSwapWs::new_label(name, is_colo, None, BitgetSwapWsType::Public);
         ws.set_subscribe(vec![
             BitgetSwapSubscribeType::PuBooks1,
-            // BitgetSwapSubscribeType::PuKline("1".to_string()),
             BitgetSwapSubscribeType::PuTrade,
+            // BitgetSwapSubscribeType::PuKline("1".to_string()),
         ]);
 
 
@@ -58,7 +60,7 @@ pub async fn reference_bitget_swap_run(is_shutdown_arc: Arc<AtomicBool>,
                 let mut depth_asks = depth_asks.lock().await;
                 let mut depth_bids = depth_bids.lock().await;
                 // 使用克隆后的 Arc，避免 move 语义
-                on_public_data(core_arc_cc, &mul, &data, &mut depth_asks, &mut depth_bids).await
+                on_public_data(core_arc_cc, &mul, &data, &mut depth_asks, &mut depth_bids, ref_index).await
             }
         };
 
@@ -76,7 +78,7 @@ pub(crate) async fn bitget_swap_run(is_shutdown_arc: Arc<AtomicBool>,
                                     symbols: Vec<String>,
                                     is_colo: bool,
                                     exchange_params: BTreeMap<String, String>) {
-    reference_bitget_swap_run(is_shutdown_arc.clone(), core_arc.clone(), name.clone(), symbols.clone(), is_colo).await;
+    reference_bitget_swap_run(is_shutdown_arc.clone(), core_arc.clone(), name.clone(), symbols.clone(), is_colo, 233).await;
 
     spawn(async move {
         let (write_tx, write_rx) = futures_channel::mpsc::unbounded();
@@ -170,7 +172,7 @@ async fn on_private_data(core_arc_clone: Arc<Mutex<Core>>, ct_val: &Decimal, run
     }
 }
 
-async fn on_public_data(core_arc: Arc<Mutex<Core>>, mul: &Decimal, response: &ResponseData, depth_asks: &mut Vec<OrderBook>, depth_bids: &mut Vec<OrderBook>) {
+async fn on_public_data(core_arc: Arc<Mutex<Core>>, mul: &Decimal, response: &ResponseData, depth_asks: &mut Vec<OrderBook>, depth_bids: &mut Vec<OrderBook>, ref_index: usize) {
     let mut trace_stack = TraceStack::new(response.time, response.ins);
     trace_stack.on_after_span_line();
 
@@ -201,12 +203,12 @@ async fn on_public_data(core_arc: Arc<Mutex<Core>>, mul: &Decimal, response: &Re
                 };
 
                 trace_stack.on_after_format();
-                on_depth(core_arc, &response.label, &mut trace_stack, &result_depth, 0).await;
+                on_depth(core_arc, &response.label, &mut trace_stack, &result_depth, ref_index).await;
             }
             // 全量
             else {
                 trace_stack.on_after_format();
-                on_depth(core_arc, &response.label, &mut trace_stack, &depth, 0).await;
+                on_depth(core_arc, &response.label, &mut trace_stack, &depth, ref_index).await;
 
                 depth_asks.clear();
                 depth_asks.append(&mut depth.asks);
@@ -223,7 +225,7 @@ async fn on_public_data(core_arc: Arc<Mutex<Core>>, mul: &Decimal, response: &Re
             for trade in trades.iter_mut() {
                 let core_arc_clone = core_arc.clone();
 
-                on_trade(core_arc_clone, &response.label, &mut trace_stack, &trade, 0).await;
+                on_trade(core_arc_clone, &response.label, &mut trace_stack, &trade, ref_index).await;
             }
         }
         "tickers" => {

strategy/src/bybit_usdt_swap.rs

@@ -21,7 +21,9 @@ pub(crate) async fn reference_bybit_swap_run(is_shutdown_arc: Arc<AtomicBool>,
                                              core_arc: Arc<Mutex<Core>>,
                                              name: String,
                                              symbols: Vec<String>,
-                                             is_colo: bool) {
+                                             is_colo: bool,
+                                             ref_index: usize
+) {
     spawn(async move {
         //创建读写通道
         let (write_tx, write_rx) = futures_channel::mpsc::unbounded::<Message>();
@@ -29,7 +31,7 @@ pub(crate) async fn reference_bybit_swap_run(is_shutdown_arc: Arc<AtomicBool>,
         ws.set_subscribe(vec![
             BybitSwapSubscribeType::PuTrade,
             BybitSwapSubscribeType::PuOrderBook1,
-            BybitSwapSubscribeType::PuKline("1".to_string()),
+            // BybitSwapSubscribeType::PuKline("1".to_string()),
             // BybitSwapSubscribeType::PuTickers
         ]);
 
@@ -59,7 +61,7 @@ pub(crate) async fn reference_bybit_swap_run(is_shutdown_arc: Arc<AtomicBool>,
                 let mut depth_asks = depth_asks.lock().await;
                 let mut depth_bids = depth_bids.lock().await;
                 // 使用克隆后的 Arc，避免 move 语义
-                on_public_data(core_arc_cc, &mul, &data, &mut depth_asks, &mut depth_bids).await
+                on_public_data(core_arc_cc, &mul, &data, &mut depth_asks, &mut depth_bids, ref_index).await
             }
         };
 
@@ -78,11 +80,7 @@ pub(crate) async fn bybit_swap_run(is_shutdown_arc: Arc<AtomicBool>,
                                    is_colo: bool,
                                    exchange_params: BTreeMap<String, String>) {
     // 参考
-    let name_c = name.clone();
-    let symbols_c = symbols.clone();
-    let is_shutdown_arc_c = is_shutdown_arc.clone();
-    let core_arc_c = core_arc.clone();
-    reference_bybit_swap_run(is_shutdown_arc_c, core_arc_c, name_c, symbols_c, is_colo).await;
+    reference_bybit_swap_run(is_shutdown_arc.clone(), core_arc.clone(), name.clone(), symbols.clone(), is_colo, 233).await;
 
     // 交易
     spawn(async move {
@@ -120,7 +118,7 @@ pub(crate) async fn bybit_swap_run(is_shutdown_arc: Arc<AtomicBool>,
     });
 }
 
-async fn on_public_data(core_arc: Arc<Mutex<Core>>, mul: &Decimal, response: &ResponseData, depth_asks: &mut Vec<OrderBook>, depth_bids: &mut Vec<OrderBook>) {
+async fn on_public_data(core_arc: Arc<Mutex<Core>>, mul: &Decimal, response: &ResponseData, depth_asks: &mut Vec<OrderBook>, depth_bids: &mut Vec<OrderBook>, ref_index: usize) {
     let mut trace_stack = TraceStack::new(response.time, response.ins);
     trace_stack.on_after_span_line();
 
@@ -153,13 +151,13 @@ async fn on_public_data(core_arc: Arc<Mutex<Core>>, mul: &Decimal, response: &Re
                 };
 
                 trace_stack.on_after_format();
-                on_depth(core_arc.clone(), &response.label, &mut trace_stack, &result_depth, 0).await;
+                on_depth(core_arc.clone(), &response.label, &mut trace_stack, &result_depth, ref_index).await;
                 // on_depth(core_arc, &response.label, &mut trace_stack, &result_depth, 1).await;
             }
             // 全量
             else {
                 trace_stack.on_after_format();
-                on_depth(core_arc.clone(), &response.label, &mut trace_stack, &depth, 0).await;
+                on_depth(core_arc.clone(), &response.label, &mut trace_stack, &depth, ref_index).await;
                 // on_depth(core_arc, &response.label, &mut trace_stack, &depth, 1).await;
 
                 depth_asks.clear();
@@ -175,7 +173,7 @@ async fn on_public_data(core_arc: Arc<Mutex<Core>>, mul: &Decimal, response: &Re
             trace_stack.on_after_format();
 
             for trade in trades.iter_mut() {
-                on_trade(core_arc.clone(), &response.label, &mut trace_stack, &trade, 0).await;
+                on_trade(core_arc.clone(), &response.label, &mut trace_stack, &trade, ref_index).await;
                 // on_trade(core_arc.clone(), &response.label, &mut trace_stack, &trade, 1).await;
             }
         }

strategy/src/exchange_disguise.rs

@@ -24,7 +24,7 @@ pub async fn run_transactional_exchange(is_shutdown_arc :Arc<AtomicBool>,
             binance_swap_run(is_shutdown_arc, core_arc, name, symbols, is_colo, exchange_params).await;
         },
         "gate_usdt_swap" => {
-            gate_swap_run(is_shutdown_arc, true, core_arc, name, symbols, is_colo, exchange_params).await;
+            gate_swap_run(is_shutdown_arc, true, core_arc, name, symbols, is_colo, exchange_params, 233).await;
         }
         // "kucoin_usdt_swap" => {
         //     kucoin_swap_run(is_shutdown_arc, true, core_arc, name, symbols, is_colo, exchange_params).await;
@@ -56,21 +56,22 @@ pub async fn run_transactional_exchange(is_shutdown_arc :Arc<AtomicBool>,
 
 // 参考交易所启动
 pub async fn run_reference_exchange(is_shutdown_arc: Arc<AtomicBool>,
-                                    exchange_name: String,
                                     core_arc: Arc<Mutex<Core>>,
+                                    ref_index: usize,
                                     name: String,
+                                    exchange_name: String,
                                     symbols: Vec<String>,
                                     is_colo: bool,
                                     exchange_params: BTreeMap<String, String>) {
     match exchange_name.as_str() {
         "binance_usdt_swap" => {
-            reference_binance_swap_run(is_shutdown_arc, core_arc, name, symbols, is_colo).await;
+            reference_binance_swap_run(is_shutdown_arc, core_arc, name, symbols, is_colo, ref_index).await;
         },
         // "binance_spot" => {
         //     reference_binance_spot_run(is_shutdown_arc, core_arc, name, symbols, is_colo, exchange_params).await;
         // },
         "gate_usdt_swap" => {
-            gate_swap_run(is_shutdown_arc, false, core_arc, name, symbols, is_colo, exchange_params).await;
+            gate_swap_run(is_shutdown_arc, false, core_arc, name, symbols, is_colo, exchange_params, ref_index).await;
         },
         // "okex_usdt_swap" => {
         //     okex_swap_run(is_shutdown_arc, false, core_arc, name, symbols, is_colo, exchange_params).await;
@@ -85,10 +86,10 @@ pub async fn run_reference_exchange(is_shutdown_arc: Arc<AtomicBool>,
         //     bitget_spot_run(is_shutdown_arc, false, core_arc, name, symbols, is_colo, exchange_params).await;
         // },
         "bitget_usdt_swap" => {
-            reference_bitget_swap_run(is_shutdown_arc, core_arc, name, symbols, is_colo).await;
+            reference_bitget_swap_run(is_shutdown_arc, core_arc, name, symbols, is_colo, ref_index).await;
         }
         "bybit_usdt_swap" => {
-            reference_bybit_swap_run(is_shutdown_arc,  core_arc, name, symbols, is_colo).await;
+            reference_bybit_swap_run(is_shutdown_arc,  core_arc, name, symbols, is_colo, ref_index).await;
         },
         "coinex_usdt_swap" => {
             coinex_swap_run(is_shutdown_arc,false, core_arc, name, symbols, is_colo, exchange_params).await;

strategy/src/gate_usdt_swap.rs

@@ -22,7 +22,9 @@ pub async fn gate_swap_run(is_shutdown_arc: Arc<AtomicBool>,
                            name: String,
                            symbols: Vec<String>,
                            is_colo: bool,
-                           exchange_params: BTreeMap<String, String>) {
+                           exchange_params: BTreeMap<String, String>,
+                           ref_index: usize
+) {
     let (write_tx, write_rx) = futures_channel::mpsc::unbounded();
 
     let mut gate_exc = GateSwapRest::new(is_colo, exchange_params.clone());
@@ -81,6 +83,7 @@ pub async fn gate_swap_run(is_shutdown_arc: Arc<AtomicBool>,
                         &mul,
                         &rs,
                         &data,
+                        ref_index,
                 ).await
             }
         };
@@ -94,7 +97,9 @@ pub async fn gate_swap_run(is_shutdown_arc: Arc<AtomicBool>,
 async fn on_data(core_arc: Arc<Mutex<Core>>,
                  multiplier: &Decimal,
                  run_symbol: &String,
-                 response: &ResponseData) {
+                 response: &ResponseData,
+                 ref_index: usize
+) {
     let mut trace_stack = TraceStack::new(response.time, response.ins);
     trace_stack.on_after_span_line();
 
@@ -111,7 +116,7 @@ async fn on_data(core_arc: Arc<Mutex<Core>>,
             let depth = ExchangeStructHandler::book_ticker_handle(ExchangeEnum::GateSwap, response, multiplier);
             trace_stack.on_after_format();
 
-            on_depth(core_arc, &response.label, &mut trace_stack, &depth, 0).await;
+            on_depth(core_arc, &response.label, &mut trace_stack, &depth, ref_index).await;
         }
         "futures.trades" => {
             trace_stack.set_source("gate_usdt_swap.trades".to_string());
@@ -121,7 +126,7 @@ async fn on_data(core_arc: Arc<Mutex<Core>>,
             for trade in trades.iter_mut() {
                 let core_arc_clone = core_arc.clone();
 
-                on_trade(core_arc_clone, &response.label, &mut trace_stack, &trade, 1).await;
+                on_trade(core_arc_clone, &response.label, &mut trace_stack, &trade, ref_index).await;
             }
         }
         "futures.balances" => {

strategy/src/predictor.rs

@@ -53,7 +53,8 @@ pub struct Predictor {
     pub mid_price_time_vec: FixedTimeRangeDeque<Decimal>,                       // 中间价格队列，
     pub fair_price_time_vec: FixedTimeRangeDeque<Decimal>,                      // 公平价格队列，
     pub fair_price_long_time_vec: FixedTimeRangeDeque<Decimal>,                 //
-    pub fair_price_vec: Vec<Decimal>,                                           // 公平价格列表，0表示做市所，1表示参考所
+    pub fair_price_vec: Vec<Decimal>,                                           // 公平价格列表，233表示做市所，其它表示参考所
+    pub price_times_avg_vec: Vec<Decimal>,                                      // 公平所与做市所的价格倍率的平均值
     pub fair_price: Decimal,                                                    // 公平价格
     pub fair_price_ema_short: Decimal,                                          // 公平价格_ema
     pub fair_price_ema_long: Decimal,                                           // 公平价格_ema
@@ -62,7 +63,6 @@ pub struct Predictor {
     pub fair_rate_focus_close: Decimal,                                         // 变化幅度焦点
     pub fair_price_focus_close: Decimal,                                        // 观测焦点时的价格
     pub fair_price_when_ordering: Decimal,                                      // 下单时的公平价格
-    pub price_times_avg: Decimal,                                               // 公平所与做市所的价格倍率的平均值
 
     pub is_ready: bool,                                                         // 是否已准备好
 
@@ -138,9 +138,9 @@ impl Predictor {
 
         let predictor = Self {
             // 接针版本
-            depth_vec: vec![Depth::new(); 10],
-            fair_price_vec: vec![Decimal::ZERO; 10],
-            volume_vec: vec![Decimal::ZERO; 10],
+            depth_vec: vec![Depth::new(); params.ref_exchange.len()],
+            fair_price_vec: vec![Decimal::ZERO; params.ref_exchange.len()],
+            volume_vec: vec![Decimal::ZERO; params.ref_exchange.len()],
 
             // 老的队列
             spread_vec: vec![],
@@ -177,7 +177,7 @@ impl Predictor {
             fair_price_focus_close: Default::default(),
             fair_price_when_ordering: Default::default(),
 
-            price_times_avg: Default::default(),
+            price_times_avg_vec: Default::default(),
 
             is_ready: false,
             prev_trade_time: Utc::now().timestamp_micros(),
@@ -207,7 +207,7 @@ impl Predictor {
         self.last_update_time = depth.time;
         self.last_index = Decimal::from(index);
 
-        if index == 0 {
+        if index == 233 {
             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;
@@ -357,16 +357,16 @@ impl Predictor {
 
         // 合成公平价格
         if !self.fair_price_vec[0].is_zero() && !self.fair_price_vec[1].is_zero() {
-            self.price_times_avg = if self.price_times_avg.is_zero() {
+            self.price_times_avg_vec[index] = if self.price_times_avg_vec[index].is_zero() {
                 self.fair_price_vec[1] / self.fair_price_vec[0]
             } else {
-                self.price_times_avg * dec!(0.9995) + dec!(0.0005) * self.fair_price_vec[1] / self.fair_price_vec[0]
+                self.price_times_avg_vec[index] * dec!(0.9995) + dec!(0.0005) * self.fair_price_vec[1] / self.fair_price_vec[0]
             };
 
             // 进行价格归一化处理，公平所的价格有可能是带前缀的
             // 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 = self.fair_price_vec[1] / self.price_times_avg;
+            self.fair_price = self.fair_price_vec[1] / self.price_times_avg_vec[index];
             self.fair_price_time_vec.push_back(self.fair_price);
             self.fair_price_long_time_vec.push_back(self.fair_price);
             self.fair_price_ema_long = if self.fair_price_ema_long.is_zero() {
@@ -682,9 +682,9 @@ impl Predictor {
         let last_price = self.last_price;
         let fair_price = self.fair_price;
 
-        let spread = self.profit_point;
-        let spread_max = self.profit_point_ema;
-        let spread_min = Self::DONT_VIEW;
+        let spread = self.mid_price;
+        let spread_max = self.fair_price_vec[1];
+        let spread_min = self.fair_price_vec[0];
         // 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;