quant->core，quant不会再出现了。

exchanges/src/binance_swap_rest.rs

@@ -385,7 +385,7 @@ impl BinanceSwapRest {
         let message = format!("{}", params_str_v);
 
         // let secret_key2 = "2b5eb11e18796d12d88f13dc27dbbd02c2cc51ff7059765ed9821957d82bb4d9";
-        // let message2 = "symbol=BTCUSDT&side=BUY&type=LIMIT&quantity=1&price=9000&timeInForce=GTC&recvWindow=5000&timestamp=1591702613943";
+        // let message2 = "symbol=BTCUSDT&side=BUY&type=LIMIT&coreity=1&price=9000&timeInForce=GTC&recvWindow=5000&timestamp=1591702613943";
         let signed_key = hmac::Key::new(hmac::HMAC_SHA256, secret_key.as_ref());
         let sign = hex::encode(hmac::sign(&signed_key, message.as_bytes()).as_ref());
 

exchanges/tests/binance_swap_test.rs

@@ -50,10 +50,10 @@ async fn ws_custom_subscribe() {
             while let Ok(Some(data)) = read_rx.try_next() {
                 // 消息被忽略
                 let mut trace_stack = TraceStack::default();
-                trace_stack.on_before_unlock_quant();
+                trace_stack.on_before_unlock_core();
                 trace_stack.on_after_network(data.time);
 
-                let delay = trace_stack.before_unlock_quant - trace_stack.after_network;
+                let delay = trace_stack.before_unlock_core - trace_stack.after_network;
                 max_delay = max(max_delay, delay);
                 info!("{}us, max={}us", delay, max_delay);
 

global/src/params.rs

@@ -29,7 +29,7 @@ pub struct Params {
     pub lever_rate: Decimal,
     // 现货底仓
     pub hold_coin: Decimal,
-    // quant的run_strategy函数，用于定期检查使用
+    // core的run_strategy函数，用于定期检查使用
     pub interval: u64,
     // 参考盘口
     pub ref_exchange: Vec<String>,

global/src/trace_stack.rs

@@ -8,9 +8,9 @@ pub struct TraceStack {
     pub before_network: i64,                // 官方数据生成时间
     pub after_network: i64,                 // 到达网络层时间
 
-    pub before_unlock_quant: i64,           // 解锁quant之前的时间
-    pub before_quant: i64,                  // quant层执行开始时间（也是通道+锁走完后的时间）
-    pub after_quant: i64,                   // quant层执行结束时间
+    pub before_unlock_core: i64,           // 解锁core之前的时间
+    pub before_core: i64,                  // core层执行开始时间（也是通道+锁走完后的时间）
+    pub after_core: i64,                   // core层执行结束时间
 
     pub before_format: i64,                 // 开始格式化时间
     pub after_format: i64,                  // 结束格式化时间
@@ -35,16 +35,16 @@ impl TraceStack {
         self.after_network = after_network;
     }
 
-    pub fn on_before_unlock_quant(&mut self) {
-        self.before_unlock_quant = Utc::now().timestamp_micros();
+    pub fn on_before_unlock_core(&mut self) {
+        self.before_unlock_core = Utc::now().timestamp_micros();
     }
 
-    pub fn on_before_quant(&mut self) {
-        self.before_quant = Utc::now().timestamp_micros();
+    pub fn on_before_core(&mut self) {
+        self.before_core = Utc::now().timestamp_micros();
     }
 
-    pub fn on_after_quant(&mut self) {
-        self.after_quant = Utc::now().timestamp_micros();
+    pub fn on_after_core(&mut self) {
+        self.after_core = Utc::now().timestamp_micros();
     }
 
     pub fn on_before_format(&mut self) {
@@ -111,20 +111,20 @@ impl fmt::Display for TraceStack {
             msg.push_str(format!("数据生成+到达rust耗时{}毫秒  ", (self.after_network - self.before_network).to_f64().unwrap() / 1000.0).as_str());
         }
 
-        if self.before_unlock_quant != 0 && self.after_network != 0 {
-            msg.push_str(format!("数据通道耗时{}微秒  ", self.before_unlock_quant - self.after_network).as_str());
+        if self.before_unlock_core != 0 && self.after_network != 0 {
+            msg.push_str(format!("数据通道耗时{}微秒  ", self.before_unlock_core - self.after_network).as_str());
         }
 
-        if self.before_quant != 0 && self.before_unlock_quant != 0 {
-            msg.push_str(format!("解锁quant{}微秒  ", self.before_quant - self.before_unlock_quant).as_str());
+        if self.before_core != 0 && self.before_unlock_core != 0 {
+            msg.push_str(format!("解锁core{}微秒  ", self.before_core - self.before_unlock_core).as_str());
         }
 
         if self.after_format != 0 && self.before_format != 0 {
             msg.push_str(format!("数据格式化耗时{}微秒  ", self.after_format - self.before_format).as_str());
         }
 
-        if self.after_quant != 0 && self.before_quant != 0 {
-            msg.push_str(format!("quant执行耗时{}微秒  ", self.after_quant - self.before_quant).as_str());
+        if self.after_core != 0 && self.before_core != 0 {
+            msg.push_str(format!("core执行耗时{}微秒  ", self.after_core - self.before_core).as_str());
         }
 
         if self.after_strategy != 0 && self.before_strategy != 0 {
@@ -132,7 +132,7 @@ impl fmt::Display for TraceStack {
         }
 
         if self.after_network != 0 && self.after_strategy != 0 {
-            msg.push_str(format!("quant走完{}微秒  ", self.after_strategy - self.after_network).as_str());
+            msg.push_str(format!("core走完{}微秒  ", self.after_strategy - self.after_network).as_str());
         }
 
         if self.before_send != 0 && self.before_send_thread != 0 {
@@ -158,9 +158,9 @@ impl Default for TraceStack {
             after_network: 0,
             before_format: 0,
             after_format: 0,
-            before_unlock_quant: 0,
-            before_quant: 0,
-            after_quant: 0,
+            before_unlock_core: 0,
+            before_core: 0,
+            after_core: 0,
             before_strategy: 0,
             after_strategy: 0,
             before_send_thread: 0,

src/quant_libs.rs → src/core_libs.rs

@@ -1,8 +1,8 @@
 
-use strategy::quant::Quant;
+use strategy::core::Core;
 use std::collections::BTreeMap;
 use std::io::Error;
-use strategy::{exchange_disguise, quant};
+use strategy::{exchange_disguise, core};
 use std::sync::Arc;
 use std::sync::atomic::{AtomicBool};
 use std::time::Duration;
@@ -18,7 +18,7 @@ use strategy::model::OrderInfo;
 pub async fn init(params: Params,
                   ws_running: Arc<AtomicBool>,
                   running: Arc<AtomicBool>,
-                  cci_arc: Arc<Mutex<CentralControlInfo>>) -> Arc<Mutex<Quant>> {
+                  cci_arc: Arc<Mutex<CentralControlInfo>>) -> Arc<Mutex<Core>> {
     // 封装
     let mut exchange_params:BTreeMap<String, String> = BTreeMap::new();
     exchange_params.insert("access_key".to_string(), params.access_key.clone());
@@ -28,24 +28,24 @@ pub async fn init(params: Params,
     let (order_sender, mut order_receiver) = mpsc::channel::<Order>(100);
     let (error_sender, mut error_receiver) = mpsc::channel::<Error>(100);
 
-    let mut quant_obj = Quant::new(params.exchange.clone(),
+    let mut core_obj = Core::new(params.exchange.clone(),
                                    params.clone(),
                                    exchange_params.clone(),
                                    order_sender.clone(),
                                    error_sender.clone(),
                                    running.clone(),
                                    cci_arc.clone()).await;
-    let ref_name = quant_obj.ref_name[0].clone();
-    let trade_name = quant_obj.trade_name.clone();
+    let ref_name = core_obj.ref_name[0].clone();
+    let trade_name = core_obj.trade_name.clone();
 
-    info!("quant初始化……");
-    quant_obj.before_trade().await;
-    let quant_arc = Arc::new(Mutex::new(quant_obj));
+    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(),
-                                              quant_arc.clone(),
+                                              core_arc.clone(),
                                               ref_name,
                                               params.ref_pair.clone(),
                                               params.colo != 0i8,
@@ -53,18 +53,18 @@ pub async fn init(params: Params,
     // 交易交易所
     exchange_disguise::run_transactional_exchange(ws_running.clone(),
                                                   params.exchange,
-                                                  quant_arc.clone(),
+                                                  core_arc.clone(),
                                                   trade_name,
                                                   vec![params.pair.clone()],
                                                   params.colo != 0i8,
                                                   exchange_params.clone()).await;
     // 启动定期触发的系统逻辑
-    quant::on_timer(quant_arc.clone());
+    core::on_timer(core_arc.clone());
     // 启动策略逻辑
-    quant::run_strategy(quant_arc.clone());
-    info!("quant初始化完成。");
+    core::run_strategy(core_arc.clone());
+    info!("core初始化完成。");
 
-    let order_handler_quant_arc = quant_arc.clone();
+    let order_handler_core_arc = core_arc.clone();
     tokio::spawn(async move {
         loop {
             tokio::time::sleep(Duration::from_millis(1)).await;
@@ -74,11 +74,11 @@ pub async fn init(params: Params,
                     // 刚下的订单有可能会成交，所以有几率触发后续订单逻辑，所以这里也是一个订单触发逻辑
                     let mut trace_stack = TraceStack::default();
                     trace_stack.on_after_network(Utc::now().timestamp_micros());
-                    trace_stack.on_before_unlock_quant();
+                    trace_stack.on_before_unlock_core();
 
                     if order.status != "NULL" {
                         trace_stack.on_before_format();
-                        let mut quant = order_handler_quant_arc.lock().await;
+                        let mut core = order_handler_core_arc.lock().await;
                         // let mut delay_time_lock_instance = delay_time_lock.lock().await;
                         let order_info = OrderInfo {
                             symbol: "".to_string(),
@@ -97,7 +97,7 @@ pub async fn init(params: Params,
                         };
                         trace_stack.on_after_format();
 
-                        quant.update_local_order(order_info.clone(), trace_stack);
+                        core.update_local_order(order_info.clone(), trace_stack);
                     }
                 },
                 None => {
@@ -107,16 +107,16 @@ pub async fn init(params: Params,
         }
     });
 
-    let _error_handler_quant_arc = quant_arc.clone();
+    let _error_handler_core_arc = core_arc.clone();
     tokio::spawn(async move {
         loop {
             tokio::time::sleep(Duration::from_millis(1)).await;
 
             match error_receiver.recv().await {
                 Some(_error) => {
-                    // let mut quant = _error_handler_quant_arc.lock().await;
+                    // let mut core = _error_handler_core_arc.lock().await;
                     // error!("main: 订单出现错误{:?}", _error);
-                    // quant.strategy._print_summary();
+                    // core.strategy._print_summary();
                 },
                 None => {
                     error!("Error channel has been closed!");
@@ -125,5 +125,5 @@ pub async fn init(params: Params,
         }
     });
 
-    return quant_arc;
+    return core_arc;
 }

src/main.rs

@@ -1,6 +1,6 @@
 mod server;
 mod control_c;
-mod quant_libs;
+mod core_libs;
 
 use std::sync::Arc;
 use std::sync::atomic::{AtomicBool, Ordering};
@@ -71,8 +71,8 @@ async fn main() {
 
     // ws退出程序
     let ws_running = Arc::new(AtomicBool::new(true));
-    // quant初始化动作
-    let quant_arc = quant_libs::init(params.clone(), ws_running.clone(), running.clone(), cci_arc.clone()).await;
+    // core初始化动作
+    let core_arc = core_libs::init(params.clone(), ws_running.clone(), running.clone(), cci_arc.clone()).await;
     // 初始化中控服务
     server::run_server(params.port.clone(), running.clone(), cci_arc.clone());
     // ctrl c退出检查程序
@@ -88,8 +88,8 @@ async fn main() {
     tokio::time::sleep(Duration::from_secs(1)).await;
 
     info!("等待清空仓位、订单（再次按control c可以立马结束）……");
-    let mut quant = quant_arc.lock().await;
-    quant.exit().await;
+    let mut core = core_arc.lock().await;
+    core.exit().await;
     info!("程序已退出！为以防万一，请再次检查仓位和订单！");
     // 等两秒，等中控反应过来
     tokio::time::sleep(Duration::from_secs(2)).await;

standard/src/binance_swap.rs

@@ -218,7 +218,7 @@ impl Platform for BinanceSwap {
                         tick_size: Decimal::from_str(&price_filter["tickSize"].as_str().unwrap()).unwrap(),
                         amount_size: Decimal::from_str(lot_size_filter["stepSize"].as_str().unwrap()).unwrap(),
                         price_precision: Decimal::from_f64(value["pricePrecision"].as_f64().unwrap()).unwrap(),
-                        amount_precision: Decimal::from_f64(value["quantityPrecision"].as_f64().unwrap()).unwrap(),
+                        amount_precision: Decimal::from_f64(value["coreityPrecision"].as_f64().unwrap()).unwrap(),
                         min_qty: Decimal::from_str(lot_size_filter["minQty"].as_str().unwrap()).unwrap(),
                         max_qty: Decimal::from_str(lot_size_filter["maxQty"].as_str().unwrap()).unwrap(),
                         min_notional: Decimal::from_str(price_filter["minPrice"].as_str().unwrap()).unwrap(),
@@ -261,7 +261,7 @@ impl Platform for BinanceSwap {
                         tick_size: Decimal::from_str(&price_filter["tickSize"].as_str().unwrap()).unwrap(),
                         amount_size: Decimal::from_str(lot_size_filter["stepSize"].as_str().unwrap()).unwrap(),
                         price_precision: Decimal::from_f64(value["pricePrecision"].as_f64().unwrap()).unwrap(),
-                        amount_precision: Decimal::from_f64(value["quantityPrecision"].as_f64().unwrap()).unwrap(),
+                        amount_precision: Decimal::from_f64(value["coreityPrecision"].as_f64().unwrap()).unwrap(),
                         min_qty: Decimal::from_str(lot_size_filter["minQty"].as_str().unwrap()).unwrap(),
                         max_qty: Decimal::from_str(lot_size_filter["maxQty"].as_str().unwrap()).unwrap(),
                         min_notional: Decimal::from_str(price_filter["minPrice"].as_str().unwrap()).unwrap(),

standard/src/bitget_spot.rs

@@ -160,7 +160,7 @@ impl Platform for BitgetSpot {
                     let base_asset = value["baseCoin"].as_str().unwrap().to_string();
                     let quote_asset = value["quoteCoin"].as_str().unwrap().to_string();
                     let price_precision = Decimal::from_str(value["pricePrecision"].as_str().unwrap()).unwrap();
-                    let amount_precision = Decimal::from_str(value["quantityPrecision"].as_str().unwrap()).unwrap();
+                    let amount_precision = Decimal::from_str(value["coreityPrecision"].as_str().unwrap()).unwrap();
                     let min_qty = Decimal::from_str(&value["minTradeAmount"].as_str().unwrap()).unwrap();
                     let max_qty = Decimal::from_str(&value["maxTradeAmount"].as_str().unwrap()).unwrap();
 
@@ -213,7 +213,7 @@ impl Platform for BitgetSpot {
                     let base_asset = value["baseCoin"].as_str().unwrap().to_string();
                     let quote_asset = value["quoteCoin"].as_str().unwrap().to_string();
                     let price_precision = Decimal::from_str(value["pricePrecision"].as_str().unwrap()).unwrap();
-                    let amount_precision = Decimal::from_str(value["quantityPrecision"].as_str().unwrap()).unwrap();
+                    let amount_precision = Decimal::from_str(value["coreityPrecision"].as_str().unwrap()).unwrap();
                     let min_qty = Decimal::from_str(&value["minTradeAmount"].as_str().unwrap()).unwrap();
                     let max_qty = Decimal::from_str(&value["maxTradeAmount"].as_str().unwrap()).unwrap();
 

standard/src/gate_swap.rs

@@ -232,7 +232,7 @@ impl Platform for GateSwap {
                     let tick_size = Decimal::from_str(value["order_price_round"].as_str().unwrap()).unwrap();
                     let min_qty = Decimal::from_str(&value["order_size_min"].to_string()).unwrap();
                     let max_qty = Decimal::from_str(&value["order_size_max"].to_string()).unwrap();
-                    let ct_val = Decimal::from_str(value["quanto_multiplier"].as_str().unwrap()).unwrap();
+                    let ct_val = Decimal::from_str(value["coreo_multiplier"].as_str().unwrap()).unwrap();
 
                     let amount_size = min_qty * ct_val;
                     let price_precision = Decimal::from_u32(tick_size.scale()).unwrap();
@@ -281,7 +281,7 @@ impl Platform for GateSwap {
                     let tick_size = Decimal::from_str(value["order_price_round"].as_str().unwrap()).unwrap();
                     let min_qty = Decimal::from_str(&value["order_size_min"].to_string()).unwrap();
                     let max_qty = Decimal::from_str(&value["order_size_max"].to_string()).unwrap();
-                    let ct_val = Decimal::from_str(value["quanto_multiplier"].as_str().unwrap()).unwrap();
+                    let ct_val = Decimal::from_str(value["coreo_multiplier"].as_str().unwrap()).unwrap();
 
                     let amount_size = min_qty * ct_val;
                     let price_precision = Decimal::from_u32(tick_size.scale()).unwrap();

strategy/src/binance_spot.rs

@@ -10,11 +10,11 @@ use exchanges::response_base::ResponseData;
 use global::trace_stack::TraceStack;
 use standard::exchange::ExchangeEnum::BinanceSpot;
 use crate::exchange_disguise::on_special_depth;
-use crate::quant::Quant;
+use crate::core::Core;
 
 // 参考 币安 现货 启动
 pub async fn reference_binance_spot_run(bool_v1 :Arc<AtomicBool>,
-                                        quant_arc: Arc<Mutex<Quant>>,
+                                        core_arc: Arc<Mutex<Core>>,
                                         name: String,
                                         symbols: Vec<String>,
                                         is_colo: bool,
@@ -31,7 +31,7 @@ pub async fn reference_binance_spot_run(bool_v1 :Arc<AtomicBool>,
 
     // 开启数据读取线程
     let write_tx_am = Arc::new(Mutex::new(write_tx));
-    let bot_arc_clone = quant_arc.clone();
+    let bot_arc_clone = core_arc.clone();
 
     spawn(async move {
         //链接
@@ -69,7 +69,7 @@ pub async fn reference_binance_spot_run(bool_v1 :Arc<AtomicBool>,
     // });
     //
     // spawn(async move {
-    //     let bot_arc_clone = Arc::clone(&quant_arc);
+    //     let bot_arc_clone = Arc::clone(&core_arc);
     //     // trade
     //     let mut max_buy = Decimal::ZERO;
     //     let mut min_sell = Decimal::ZERO;
@@ -89,14 +89,14 @@ pub async fn reference_binance_spot_run(bool_v1 :Arc<AtomicBool>,
     // });
 }
 
-async fn on_data(bot_arc_clone: Arc<Mutex<Quant>>,
+async fn on_data(bot_arc_clone: Arc<Mutex<Core>>,
                  update_flag_u: &mut Decimal,
                  _max_buy: &mut Decimal,
                  _min_sell: &mut Decimal,
                  data: ResponseData) {
     let mut trace_stack = TraceStack::default();
     trace_stack.on_after_network(data.time);
-    trace_stack.on_before_unlock_quant();
+    trace_stack.on_before_unlock_core();
 
     if data.code != "200".to_string() {
         return;
@@ -104,11 +104,11 @@ async fn on_data(bot_arc_clone: Arc<Mutex<Quant>>,
     if data.channel == "aggTrade" {
         // let trade: OriginalTradeBa = serde_json::from_str(data.data.as_str()).unwrap();
         // let str = data.label.clone();
-        // let mut quant = bot_arc_clone.lock().await;
-        // if quant.is_update.contains_key(&data.label) && *quant.is_update.get(str.as_str()).unwrap() {
+        // let mut core = bot_arc_clone.lock().await;
+        // if core.is_update.contains_key(&data.label) && *core.is_update.get(str.as_str()).unwrap() {
         //     *max_buy = Decimal::ZERO;
         //     *min_sell = Decimal::ZERO;
-        //     quant.is_update.remove(str.as_str());
+        //     core.is_update.remove(str.as_str());
         // }
         // if trade.p > *max_buy || *max_buy == Decimal::ZERO{
         //     *max_buy = trade.p
@@ -117,7 +117,7 @@ async fn on_data(bot_arc_clone: Arc<Mutex<Quant>>,
         //     *min_sell = trade.p
         // }
         // {
-        //     quant.max_buy_min_sell_cache.insert(data.label, vec![*max_buy, *min_sell]);
+        //     core.max_buy_min_sell_cache.insert(data.label, vec![*max_buy, *min_sell]);
         // }
     } else if data.channel == "bookTicker" {
         trace_stack.on_before_format();

strategy/src/binance_usdt_swap.rs

@@ -8,13 +8,13 @@ use exchanges::response_base::ResponseData;
 use global::trace_stack::TraceStack;
 use standard::exchange::ExchangeEnum::BinanceSwap;
 use crate::model::{OriginalTradeBa};
-use crate::quant::Quant;
+use crate::core::Core;
 use exchanges::binance_swap_ws::{BinanceSwapSubscribeType, BinanceSwapWs, BinanceSwapWsType};
 use crate::exchange_disguise::{on_special_depth};
 
 // 参考 币安 合约 启动
 pub(crate) async fn reference_binance_swap_run(bool_v1 :Arc<AtomicBool>,
-                                               quant_arc: Arc<Mutex<Quant>>,
+                                               core_arc: Arc<Mutex<Core>>,
                                                name: String,
                                                symbols: Vec<String>,
                                                is_colo: bool,
@@ -32,7 +32,7 @@ pub(crate) async fn reference_binance_swap_run(bool_v1 :Arc<AtomicBool>,
         ]);
 
         //读取数据
-        let bot_arc_clone = Arc::clone(&quant_arc);
+        let bot_arc_clone = Arc::clone(&core_arc);
         tokio::spawn(async move {
             // ticker
             let mut update_flag_u = Decimal::ZERO;
@@ -57,14 +57,14 @@ pub(crate) async fn reference_binance_swap_run(bool_v1 :Arc<AtomicBool>,
     });
 }
 
-async fn on_data(bot_arc_clone: Arc<Mutex<Quant>>,
+async fn on_data(bot_arc_clone: Arc<Mutex<Core>>,
                  update_flag_u: &mut Decimal,
                  _max_buy: &mut Decimal,
                  _min_sell: &mut Decimal,
                  data: ResponseData) {
     let mut trace_stack = TraceStack::default();
     trace_stack.on_after_network(data.time);
-    trace_stack.on_before_unlock_quant();
+    trace_stack.on_before_unlock_core();
 
     if data.code != "200".to_string() {
         return;
@@ -78,12 +78,12 @@ async fn on_data(bot_arc_clone: Arc<Mutex<Quant>>,
         // on_trade(trade.clone(), bot_arc_clone.clone()).await;
 
         // 原本的逻辑
-        let mut quant = bot_arc_clone.lock().await;
+        let mut core = bot_arc_clone.lock().await;
         let str = data.label.clone();
-        if quant.is_update.contains_key(&data.label) && *quant.is_update.get(str.as_str()).unwrap() {
+        if core.is_update.contains_key(&data.label) && *core.is_update.get(str.as_str()).unwrap() {
             *_max_buy = Decimal::ZERO;
             *_min_sell = Decimal::ZERO;
-            quant.is_update.remove(str.as_str());
+            core.is_update.remove(str.as_str());
         }
         if trade.p > *_max_buy || *_max_buy == Decimal::ZERO {
             *_max_buy = trade.p
@@ -91,7 +91,7 @@ async fn on_data(bot_arc_clone: Arc<Mutex<Quant>>,
         if trade.p < *_min_sell || *_min_sell == Decimal::ZERO {
             *_min_sell = trade.p
         }
-        quant.max_buy_min_sell_cache.insert(data.label, vec![*_max_buy, *_min_sell]);
+        core.max_buy_min_sell_cache.insert(data.label, vec![*_max_buy, *_min_sell]);
     } else if data.channel == "bookTicker" {
         trace_stack.on_before_format();
         // 将ticker数据转换为模拟深度

strategy/src/bitget_spot.rs

@@ -13,11 +13,11 @@ use global::trace_stack::TraceStack;
 use standard::exchange::ExchangeEnum::BitgetSpot;
 use crate::exchange_disguise::on_special_depth;
 use crate::model::{OrderInfo, OriginalTradeGa};
-use crate::quant::Quant;
+use crate::core::Core;
 
 pub async fn bitget_spot_run(bool_v1 :Arc<AtomicBool>,
                              is_trade: bool,
-                             quant_arc: Arc<Mutex<Quant>>,
+                             core_arc: Arc<Mutex<Core>>,
                              name: String,
                              symbols: Vec<String>,
                              is_colo: bool,
@@ -53,7 +53,7 @@ pub async fn bitget_spot_run(bool_v1 :Arc<AtomicBool>,
             .await.expect("链接失败(内部一个心跳线程应该已经关闭了)");
     });
     // 消费数据
-    let bot_arc_clone = quant_arc.clone();
+    let bot_arc_clone = core_arc.clone();
     spawn(async move {
         // ticker
         let mut update_flag_u = Decimal::ZERO;
@@ -74,15 +74,15 @@ pub async fn bitget_spot_run(bool_v1 :Arc<AtomicBool>,
     // 开启私有频道
     if is_trade {
         // 新增获取余额的协程
-        let account_quant_arc = quant_arc.clone();
+        let account_core_arc = core_arc.clone();
         spawn(async move {
             loop {
                 // 每30秒重新获取一次
                 sleep(Duration::from_secs(30)).await;
 
                 {
-                    let mut quant = account_quant_arc.lock().await;
-                    quant.update_equity_rest_spot().await;
+                    let mut core = account_core_arc.lock().await;
+                    core.update_equity_rest_spot().await;
                 }
             }
         });
@@ -112,9 +112,9 @@ pub async fn bitget_spot_run(bool_v1 :Arc<AtomicBool>,
         });
 
         // 消费数据
-        let bot_arc_clone = quant_arc.clone();
+        let bot_arc_clone = core_arc.clone();
         spawn(async move {
-            let ct_val = quant_arc.clone().lock().await.platform_rest.get_self_market().ct_val;
+            let ct_val = core_arc.clone().lock().await.platform_rest.get_self_market().ct_val;
 
             loop {
                 if let Some(data) = read_rx_public.next().await {
@@ -127,11 +127,11 @@ pub async fn bitget_spot_run(bool_v1 :Arc<AtomicBool>,
     }
 }
 
-async fn on_private_data(bot_arc_clone: Arc<Mutex<Quant>>, ct_val: Decimal, data: ResponseData) {
+async fn on_private_data(bot_arc_clone: Arc<Mutex<Core>>, ct_val: Decimal, data: ResponseData) {
     let mut trace_stack = TraceStack::default();
 
     trace_stack.on_after_network(data.time);
-    trace_stack.on_before_unlock_quant();
+    trace_stack.on_before_unlock_core();
 
     if data.code != "200".to_string() {
         return;
@@ -164,23 +164,23 @@ async fn on_private_data(bot_arc_clone: Arc<Mutex<Quant>>, ct_val: Decimal, data
             order_infos.push(order_info);
         }
         {
-            let mut quant = bot_arc_clone.lock().await;
-            quant.update_order(order_infos, trace_stack);
+            let mut core = bot_arc_clone.lock().await;
+            core.update_order(order_infos, trace_stack);
         }
     } else if data.channel == "account" {
         // let account = standard::handle_info::HandleSwapInfo::handle_account_info(BitgetSpot, data, run_symbol.clone());
         // {
-        //     let mut quant = bot_arc_clone.lock().await;
-        //     quant.update_equity(account);
+        //     let mut core = bot_arc_clone.lock().await;
+        //     core.update_equity(account);
         // }
     }
 }
 
-async fn on_public_data(bot_arc_clone: Arc<Mutex<Quant>>, update_flag_u: &mut Decimal, max_buy: &mut Decimal, min_sell: &mut Decimal, data: ResponseData) {
+async fn on_public_data(bot_arc_clone: Arc<Mutex<Core>>, update_flag_u: &mut Decimal, max_buy: &mut Decimal, min_sell: &mut Decimal, data: ResponseData) {
     let mut trace_stack = TraceStack::default();
 
     trace_stack.on_after_network(data.time);
-    trace_stack.on_before_unlock_quant();
+    trace_stack.on_before_unlock_core();
 
     if data.code != "200".to_string() {
         return;
@@ -193,12 +193,12 @@ async fn on_public_data(bot_arc_clone: Arc<Mutex<Quant>>, update_flag_u: &mut De
 
         on_special_depth(bot_arc_clone, update_flag_u, data.label, trace_stack, special_depth).await;
     } else if data.channel == "trade" {
-        let mut quant = bot_arc_clone.lock().await;
+        let mut core = bot_arc_clone.lock().await;
         let str = data.label.clone();
-        if quant.is_update.contains_key(&data.label) && *quant.is_update.get(str.as_str()).unwrap() {
+        if core.is_update.contains_key(&data.label) && *core.is_update.get(str.as_str()).unwrap() {
             *max_buy = Decimal::ZERO;
             *min_sell = Decimal::ZERO;
-            quant.is_update.remove(str.as_str());
+            core.is_update.remove(str.as_str());
         }
         let trades: Vec<OriginalTradeGa> = serde_json::from_str(data.data.as_str()).unwrap();
         for trade in trades {
@@ -209,7 +209,7 @@ async fn on_public_data(bot_arc_clone: Arc<Mutex<Quant>>, update_flag_u: &mut De
                 *min_sell = trade.price
             }
         }
-        quant.max_buy_min_sell_cache.insert(data.label, vec![*max_buy, *min_sell]);
+        core.max_buy_min_sell_cache.insert(data.label, vec![*max_buy, *min_sell]);
     }
 }
 

strategy/src/bybit_usdt_swap.rs

@@ -14,13 +14,13 @@ use standard::exchange::ExchangeEnum::{BybitSwap};
 use standard::handle_info::{DepthParam, format_depth, make_special_depth};
 use standard::MarketOrder;
 use crate::model::{OrderInfo, OriginalTradeBy};
-use crate::quant::Quant;
+use crate::core::Core;
 use crate::exchange_disguise::on_special_depth;
 
 // 1交易、0参考 bybit 合约 启动
 pub async fn bybit_swap_run(bool_v1: Arc<AtomicBool>,
                            is_trade: bool,
-                           _quant_arc: Arc<Mutex<Quant>>,
+                           _core_arc: Arc<Mutex<Core>>,
                            name: String,
                            symbols: Vec<String>,
                            is_colo: bool,
@@ -49,7 +49,7 @@ pub async fn bybit_swap_run(bool_v1: Arc<AtomicBool>,
                                    read_tx_public).await.expect("链接失败(内部一个心跳线程应该已经关闭了)");
     });
     // 消费数据
-    let bot_arc_clone = _quant_arc.clone();
+    let bot_arc_clone = _core_arc.clone();
     // 接收public数据
     spawn(async move {
         // ticker
@@ -98,7 +98,7 @@ pub async fn bybit_swap_run(bool_v1: Arc<AtomicBool>,
         });
 
         // 消费数据
-        let bot_arc_clone = _quant_arc.clone();
+        let bot_arc_clone = _core_arc.clone();
         // 接收private信息
         spawn(async move {
             let ct_val = bot_arc_clone.clone().lock().await.platform_rest.get_self_market().ct_val;
@@ -114,14 +114,14 @@ pub async fn bybit_swap_run(bool_v1: Arc<AtomicBool>,
         });
 
         // 定时获取仓位信息
-        let position_quant_clone = _quant_arc.clone();
+        let position_core_clone = _core_arc.clone();
         spawn(async move {
             let mut interval = time::interval(Duration::from_secs(30));
             loop {
                 interval.tick().await;
                 {
-                    let mut quant = position_quant_clone.lock().await;
-                    quant.update_position_rest_swap().await;
+                    let mut core = position_core_clone.lock().await;
+                    core.update_position_rest_swap().await;
                 }
 
             }
@@ -131,11 +131,11 @@ pub async fn bybit_swap_run(bool_v1: Arc<AtomicBool>,
 
 
 
-async fn on_private_data(bot_arc_clone: Arc<Mutex<Quant>>, ct_val: Decimal, data: ResponseData, run_symbol: String) {
+async fn on_private_data(bot_arc_clone: Arc<Mutex<Core>>, ct_val: Decimal, data: ResponseData, run_symbol: String) {
     let mut trace_stack = TraceStack::default();
 
     trace_stack.on_after_network(data.time);
-    trace_stack.on_before_unlock_quant();
+    trace_stack.on_before_unlock_core();
 
     if data.code != "200".to_string() {
         return;
@@ -143,8 +143,8 @@ async fn on_private_data(bot_arc_clone: Arc<Mutex<Quant>>, ct_val: Decimal, data
     if data.channel == "wallet" {
         let account = standard::handle_info::HandleSwapInfo::handle_account_info(BybitSwap, data, run_symbol.clone());
         {
-            let mut quant = bot_arc_clone.lock().await;
-            quant.update_equity(account).await;
+            let mut core = bot_arc_clone.lock().await;
+            core.update_equity(account).await;
         }
     } else if data.channel == "order" {
         trace_stack.on_before_format();
@@ -175,22 +175,22 @@ async fn on_private_data(bot_arc_clone: Arc<Mutex<Quant>>, ct_val: Decimal, data
         }
 
         {
-            let mut quant = bot_arc_clone.lock().await;
-            quant.update_order(order_infos, trace_stack);
+            let mut core = bot_arc_clone.lock().await;
+            core.update_order(order_infos, trace_stack);
         }
     } else if data.channel == "position" {
         let positions = standard::handle_info::HandleSwapInfo::handle_position(BybitSwap,data, ct_val.clone());
         {
-            let mut quant = bot_arc_clone.lock().await;
-            quant.update_position(positions).await;
+            let mut core = bot_arc_clone.lock().await;
+            core.update_position(positions).await;
         }
     }
 }
 
-async fn on_public_data(bot_arc_clone: Arc<Mutex<Quant>>, update_flag_u: &mut Decimal, max_buy: &mut Decimal, min_sell: &mut Decimal, data: ResponseData, depth_asks: &mut Vec<MarketOrder>, depth_bids: &mut Vec<MarketOrder>) {
+async fn on_public_data(bot_arc_clone: Arc<Mutex<Core>>, update_flag_u: &mut Decimal, max_buy: &mut Decimal, min_sell: &mut Decimal, data: ResponseData, depth_asks: &mut Vec<MarketOrder>, depth_bids: &mut Vec<MarketOrder>) {
     let mut trace_stack = TraceStack::default();
     trace_stack.on_after_network(data.time);
-    trace_stack.on_before_unlock_quant();
+    trace_stack.on_before_unlock_core();
 
     if data.code != "200".to_string() {
         return;
@@ -220,12 +220,12 @@ async fn on_public_data(bot_arc_clone: Arc<Mutex<Quant>>, update_flag_u: &mut De
 
         on_special_depth(bot_arc_clone, update_flag_u, label, trace_stack, depth).await;
     } else if data.channel == "trade" {
-        let mut quant = bot_arc_clone.lock().await;
+        let mut core = bot_arc_clone.lock().await;
         let str = data.label.clone();
-        if quant.is_update.contains_key(&data.label) && *quant.is_update.get(str.as_str()).unwrap(){
+        if core.is_update.contains_key(&data.label) && *core.is_update.get(str.as_str()).unwrap(){
             *max_buy = Decimal::ZERO;
             *min_sell = Decimal::ZERO;
-            quant.is_update.remove(str.as_str());
+            core.is_update.remove(str.as_str());
         }
         let trades: Vec<OriginalTradeBy> = serde_json::from_str(data.data.as_str()).unwrap();
         for trade in trades {
@@ -236,7 +236,7 @@ async fn on_public_data(bot_arc_clone: Arc<Mutex<Quant>>, update_flag_u: &mut De
                 *min_sell = trade.p
             }
         }
-        quant.max_buy_min_sell_cache.insert(data.label, vec![*max_buy, *min_sell]);
+        core.max_buy_min_sell_cache.insert(data.label, vec![*max_buy, *min_sell]);
     }
 }
 

strategy/src/quant.rs → strategy/src/core.rs

@@ -30,7 +30,7 @@ use crate::utils;
 use crate::utils::clip;
 
 
-pub struct Quant {
+pub struct Core {
     pub params: Params,
     // 启动时间
     pub start_time: i64,
@@ -120,17 +120,17 @@ pub struct Quant {
     pub cci_arc: Arc<Mutex<CentralControlInfo>>,            // 中控信息汇集
 }
 
-impl Quant {
+impl Core {
     pub async fn new(exchange: String,
                      params: Params,
                      exchange_params: BTreeMap<String, String>,
                      order_sender: Sender<Order>,
                      error_sender: Sender<Error>,
                      running: Arc<AtomicBool>,
-                     cci_arc: Arc<Mutex<CentralControlInfo>>) -> Quant {
+                     cci_arc: Arc<Mutex<CentralControlInfo>>) -> Core {
         let symbol = params.pair.clone();
         let pairs: Vec<&str> = params.pair.split('_').collect();
-        let mut quant_obj = Quant {
+        let mut core_obj = Core {
             params: params.clone(),
             start_time: 0,
             symbol: symbol.clone(),
@@ -259,25 +259,25 @@ impl Quant {
             let market_update_interval_key = tickers_key.clone();
             let max_buy_min_sell_cache_key = tickers_key.clone();
 
-            quant_obj.tickers.insert(tickers_key, SpecialTicker::new());
-            quant_obj.ref_name.push(ref_name_element);
-            quant_obj.depths.insert(depths_key, Default::default());
-            quant_obj.market_update_time.insert(market_update_time_key, Default::default());
-            quant_obj.market_update_interval.insert(market_update_interval_key, Default::default());
-            quant_obj.max_buy_min_sell_cache.insert(max_buy_min_sell_cache_key, vec![Decimal::ZERO, Decimal::ZERO]);
+            core_obj.tickers.insert(tickers_key, SpecialTicker::new());
+            core_obj.ref_name.push(ref_name_element);
+            core_obj.depths.insert(depths_key, Default::default());
+            core_obj.market_update_time.insert(market_update_time_key, Default::default());
+            core_obj.market_update_interval.insert(market_update_interval_key, Default::default());
+            core_obj.max_buy_min_sell_cache.insert(max_buy_min_sell_cache_key, vec![Decimal::ZERO, Decimal::ZERO]);
         }
-        let name = format!("{}{}{}", quant_obj.exchange.clone(), "@", quant_obj.symbol);
+        let name = format!("{}{}{}", core_obj.exchange.clone(), "@", core_obj.symbol);
         let market_update_time_key = name.clone();
         let market_update_interval_key = name.clone();
         let tickers_key = name.clone();
         let depths_key = name.clone();
         let max_buy_min_sell_cache_key = name.clone();
-        quant_obj.trade_name = name;
-        quant_obj.market_update_time.insert(market_update_time_key, Default::default());
-        quant_obj.market_update_interval.insert(market_update_interval_key, Default::default());
-        quant_obj.tickers.insert(tickers_key, SpecialTicker::new());
-        quant_obj.depths.insert(depths_key, Default::default());
-        quant_obj.max_buy_min_sell_cache.insert(max_buy_min_sell_cache_key, vec![Decimal::ZERO, Decimal::ZERO]);
+        core_obj.trade_name = name;
+        core_obj.market_update_time.insert(market_update_time_key, Default::default());
+        core_obj.market_update_interval.insert(market_update_interval_key, Default::default());
+        core_obj.tickers.insert(tickers_key, SpecialTicker::new());
+        core_obj.depths.insert(depths_key, Default::default());
+        core_obj.max_buy_min_sell_cache.insert(max_buy_min_sell_cache_key, vec![Decimal::ZERO, Decimal::ZERO]);
         // broker.newWs
         let mut price_alpha: Vec<Decimal> = Vec::new();
         for ref_pair_str in params.ref_pair {
@@ -290,11 +290,11 @@ impl Quant {
             }
         }
         info!("价格系数：{:?}", price_alpha);
-        quant_obj.predictor = Predictor::new(quant_obj.ref_name.len())
+        core_obj.predictor = Predictor::new(core_obj.ref_name.len())
             .alpha(price_alpha)
             .gamma(params.gamma);
 
-        return quant_obj;
+        return core_obj;
     }
 
     #[instrument(skip(self, data, trace_stack), level="TRACE")]
@@ -662,7 +662,7 @@ impl Quant {
             if self.mode_signal == 0 && self.ready == 1 && flag == 1 {
                 // 更新交易数据
                 self.update_trade_msg();
-                trace_stack.on_after_quant();
+                trace_stack.on_after_core();
                 // 触发事件撤单逻辑
                 // 更新策略时间
                 self.strategy.local_time = Utc::now().timestamp_millis();
@@ -1607,8 +1607,8 @@ impl Quant {
     }
 }
 
-#[instrument(skip(quant_arc), level="TRACE")]
-pub fn run_strategy(quant_arc: Arc<Mutex<Quant>>) -> JoinHandle<()> {
+#[instrument(skip(core_arc), level="TRACE")]
+pub fn run_strategy(core_arc: Arc<Mutex<Core>>) -> JoinHandle<()> {
     return spawn(async move {
         //定期触发策略
         info!("定时触发器启动");
@@ -1618,41 +1618,41 @@ pub fn run_strategy(quant_arc: Arc<Mutex<Quant>>) -> JoinHandle<()> {
             let start_time = Utc::now().timestamp_millis();
             let mut delay = 1u64;
             {
-                let mut quant = quant_arc.lock().await;
-                if quant.ready == 1 {
+                let mut core = core_arc.lock().await;
+                if core.ready == 1 {
                     // 更新交易信息集合
-                    quant.update_trade_msg();
-                    if quant.mode_signal != 0 {
-                        if quant.mode_signal > 1 {
-                            quant.mode_signal -= 1;
+                    core.update_trade_msg();
+                    if core.mode_signal != 0 {
+                        if core.mode_signal > 1 {
+                            core.mode_signal -= 1;
                         }
-                        if quant.mode_signal == 1 {
+                        if core.mode_signal == 1 {
                             return;
                         }
                         // 触发策略  更新策略时间
-                        quant.strategy.local_time = Utc::now().timestamp_millis();
-                        let trade_msg = quant.trade_msg.clone();
-                        let mut platform_rest_fb = quant.platform_rest.clone_box();
+                        core.strategy.local_time = Utc::now().timestamp_millis();
+                        let trade_msg = core.trade_msg.clone();
+                        let mut platform_rest_fb = core.platform_rest.clone_box();
                         // 获取信号
-                        if quant.mode_signal > 20 {
+                        if core.mode_signal > 20 {
                             // 先执行onExit
-                            let orders = quant.strategy.on_exit(&trade_msg);
+                            let orders = core.strategy.on_exit(&trade_msg);
                             if orders.is_not_empty() {
                                 info!("触发onExit");
                                 info!(?orders);
-                                quant._update_local_orders(&orders);
+                                core._update_local_orders(&orders);
                                 spawn(async move {
                                     platform_rest_fb.command_order(orders, Default::default()).await;
                                 });
                             }
                         } else {
                             // 再执行onSleep
-                            let orders = quant.strategy.on_sleep(&trade_msg);
+                            let orders = core.strategy.on_sleep(&trade_msg);
                             // 记录指令触发信息
                             if orders.is_not_empty() {
                                 info!("触发onSleep");
                                 info!(?orders);
-                                quant._update_local_orders(&orders);
+                                core._update_local_orders(&orders);
                                 spawn(async move {
                                     platform_rest_fb.command_order(orders, Default::default()).await;
                                 });
@@ -1660,12 +1660,12 @@ pub fn run_strategy(quant_arc: Arc<Mutex<Quant>>) -> JoinHandle<()> {
                         }
                     }
                 } else {
-                    quant.check_ready();
+                    core.check_ready();
                 }
                 // 计算耗时并进行休眠
                 let pass_time = (Utc::now().timestamp_millis() - start_time).to_u64().unwrap();
-                if pass_time < quant.interval {
-                    delay = quant.interval - pass_time;
+                if pass_time < core.interval {
+                    delay = core.interval - pass_time;
                 }
             }
             sleep(Duration::from_millis(delay)).await;
@@ -1674,9 +1674,9 @@ pub fn run_strategy(quant_arc: Arc<Mutex<Quant>>) -> JoinHandle<()> {
 }
 
 // 定期触发的系统逻辑
-#[instrument(skip(quant_arc), level="TRACE")]
-pub fn on_timer(quant_arc: Arc<Mutex<Quant>>) -> JoinHandle<()> {
-    let quant_arc_clone = quant_arc.clone();
+#[instrument(skip(core_arc), level="TRACE")]
+pub fn on_timer(core_arc: Arc<Mutex<Core>>) -> JoinHandle<()> {
+    let core_arc_clone = core_arc.clone();
 
     return spawn(async move {
         tokio::time::sleep(Duration::from_secs(20)).await;
@@ -1684,27 +1684,27 @@ pub fn on_timer(quant_arc: Arc<Mutex<Quant>>) -> JoinHandle<()> {
         loop {
             tokio::time::sleep(Duration::from_secs(10)).await;
 
-            let mut quant = quant_arc_clone.lock().await;
+            let mut core = core_arc_clone.lock().await;
             {
                 // 检查风控
-                quant.check_risk().await;
+                core.check_risk().await;
 
                 // 线程停止信号
-                if quant.mode_signal == 1 {
+                if core.mode_signal == 1 {
                     return;
                 }
 
                 // 计算预估成交额
-                let total_trade_value = quant.local_buy_value + quant.local_sell_value;
-                let time_diff = Decimal::from(Utc::now().timestamp_millis() - quant.start_time);
+                let total_trade_value = core.local_buy_value + core.local_sell_value;
+                let time_diff = Decimal::from(Utc::now().timestamp_millis() - core.start_time);
                 let trade_vol_24h = (total_trade_value / time_diff) * dec!(86400);
-                quant.strategy.trade_vol_24h_w = trade_vol_24h / dec!(10000);
-                quant.strategy.trade_vol_24h_w.rescale(2);
+                core.strategy.trade_vol_24h_w = trade_vol_24h / dec!(10000);
+                core.strategy.trade_vol_24h_w.rescale(2);
 
-                // TODO quant没有rest
-                // info!("Rest报单平均延迟{}ms", quant.rest.avg_delay);
-                // info!("Rest报单最高延迟{}ms", quant.rest.max_delay);
-                for (_name, _interval) in &quant.market_update_interval {
+                // TODO core没有rest
+                // info!("Rest报单平均延迟{}ms", core.rest.avg_delay);
+                // info!("Rest报单最高延迟{}ms", core.rest.max_delay);
+                for (_name, _interval) in &core.market_update_interval {
                     // debug!("WS盘口{}行情平均更新间隔{}ms。", name, interval);
                 }
             }

strategy/src/exchange_disguise.rs

@@ -13,31 +13,31 @@ use crate::gate_swap::gate_swap_run;
 use crate::kucoin_spot::kucoin_spot_run;
 use crate::kucoin_swap::kucoin_swap_run;
 use crate::okx_usdt_swap::okex_swap_run;
-use crate::quant::Quant;
+use crate::core::Core;
 
 // 交易交易所启动
 pub async fn run_transactional_exchange(bool_v1 :Arc<AtomicBool>,
                                         exchange_name: String,
-                                        quant_arc: Arc<Mutex<Quant>>,
+                                        core_arc: Arc<Mutex<Core>>,
                                         name: String,
                                         symbols: Vec<String>,
                                         is_colo: bool,
                                         exchange_params: BTreeMap<String, String>) {
     match exchange_name.as_str() {
         "gate_usdt_swap" => {
-            gate_swap_run(bool_v1, true, quant_arc, name, symbols, is_colo, exchange_params).await;
+            gate_swap_run(bool_v1, true, core_arc, name, symbols, is_colo, exchange_params).await;
         }
         "kucoin_usdt_swap" => {
-            kucoin_swap_run(bool_v1, true, quant_arc, name, symbols, is_colo, exchange_params).await;
+            kucoin_swap_run(bool_v1, true, core_arc, name, symbols, is_colo, exchange_params).await;
         },
         "okex_usdt_swap" => {
-            okex_swap_run(bool_v1,true, quant_arc, name, symbols, is_colo, exchange_params).await;
+            okex_swap_run(bool_v1,true, core_arc, name, symbols, is_colo, exchange_params).await;
         },
         "bitget_spot" => {
-            bitget_spot_run(bool_v1,true, quant_arc, name, symbols, is_colo, exchange_params).await;
+            bitget_spot_run(bool_v1,true, core_arc, name, symbols, is_colo, exchange_params).await;
         },
         "bybit_usdt_swap" => {
-            bybit_swap_run(bool_v1,true, quant_arc, name, symbols, is_colo, exchange_params).await;
+            bybit_swap_run(bool_v1,true, core_arc, name, symbols, is_colo, exchange_params).await;
         }
         _ => {
             let msg = format!("不支持的交易交易所：{}", exchange_name);
@@ -49,35 +49,35 @@ pub async fn run_transactional_exchange(bool_v1 :Arc<AtomicBool>,
 // 参考交易所启动
 pub async fn run_reference_exchange(bool_v1: Arc<AtomicBool>,
                                     exchange_name: String,
-                                    quant_arc: Arc<Mutex<Quant>>,
+                                    core_arc: Arc<Mutex<Core>>,
                                     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(bool_v1, quant_arc, name, symbols, is_colo, exchange_params).await;
+            reference_binance_swap_run(bool_v1, core_arc, name, symbols, is_colo, exchange_params).await;
         },
         "binance_spot" => {
-            reference_binance_spot_run(bool_v1, quant_arc, name, symbols, is_colo, exchange_params).await;
+            reference_binance_spot_run(bool_v1, core_arc, name, symbols, is_colo, exchange_params).await;
         },
         "gate_usdt_swap" => {
-            gate_swap_run(bool_v1, false, quant_arc, name, symbols, is_colo, exchange_params).await;
+            gate_swap_run(bool_v1, false, core_arc, name, symbols, is_colo, exchange_params).await;
         },
         "okex_usdt_swap" => {
-            okex_swap_run(bool_v1, false, quant_arc, name, symbols, is_colo, exchange_params).await;
+            okex_swap_run(bool_v1, false, core_arc, name, symbols, is_colo, exchange_params).await;
         },
         "kucoin_usdt_swap" => {
-            kucoin_swap_run(bool_v1, false, quant_arc, name, symbols, is_colo, exchange_params).await;
+            kucoin_swap_run(bool_v1, false, core_arc, name, symbols, is_colo, exchange_params).await;
         },
         "kucoin_spot" => {
-            kucoin_spot_run(bool_v1, false, quant_arc, name, symbols, is_colo, exchange_params).await;
+            kucoin_spot_run(bool_v1, false, core_arc, name, symbols, is_colo, exchange_params).await;
         },
         "bitget_spot" => {
-            bitget_spot_run(bool_v1, false, quant_arc, name, symbols, is_colo, exchange_params).await;
+            bitget_spot_run(bool_v1, false, core_arc, name, symbols, is_colo, exchange_params).await;
         },
         "bybit_usdt_swap" => {
-            bybit_swap_run(bool_v1, false, quant_arc, name, symbols, is_colo, exchange_params).await;
+            bybit_swap_run(bool_v1, false, core_arc, name, symbols, is_colo, exchange_params).await;
         },
         _ => {
             let msg = format!("不支持的参考交易所：{}", exchange_name);
@@ -86,25 +86,25 @@ pub async fn run_reference_exchange(bool_v1: Arc<AtomicBool>,
     }
 }
 
-pub async fn on_special_depth(bot_arc: Arc<Mutex<Quant>>,
+pub async fn on_special_depth(bot_arc: Arc<Mutex<Core>>,
                               update_flag_u: &mut Decimal,
                               label: String,
                               trace_stack: TraceStack,
                               special_depth: SpecialDepth) {
     if special_depth.t > *update_flag_u {
         *update_flag_u = special_depth.t;
-        let mut quant = bot_arc.lock().await;
+        let mut core = bot_arc.lock().await;
         let mut ts = trace_stack.clone();
-        ts.on_before_quant();
+        ts.on_before_core();
 
-        quant._update_ticker(special_depth.ticker, label.clone());
-        quant._update_depth(special_depth.depth.clone(), label.clone(), ts).await;
-        quant.local_depths.insert(special_depth.name, special_depth.depth);
+        core._update_ticker(special_depth.ticker, label.clone());
+        core._update_depth(special_depth.depth.clone(), label.clone(), ts).await;
+        core.local_depths.insert(special_depth.name, special_depth.depth);
     }
 }
 
 // pub async fn on_trade(trade: OriginalTradeBa,
-//                       bot_arc_clone: Arc<Mutex<Quant>>) {
+//                       bot_arc_clone: Arc<Mutex<Core>>) {
     // let mut bot = bot_arc_clone.lock().await;
     // // 1. 塞入数据到bot
     // bot.trades.push(trade.clone());

strategy/src/gate_swap.rs

@@ -13,13 +13,13 @@ use exchanges::response_base::ResponseData;
 use global::trace_stack::TraceStack;
 use standard::exchange::ExchangeEnum::GateSwap;
 use crate::model::{OrderInfo, OriginalTradeGa};
-use crate::quant::Quant;
+use crate::core::Core;
 use crate::exchange_disguise::on_special_depth;
 
 // 1交易、0参考 gate 合约 启动
 pub async fn gate_swap_run(bool_v1: Arc<AtomicBool>,
                            is_trade: bool,
-                           quant_arc: Arc<Mutex<Quant>>,
+                           core_arc: Arc<Mutex<Core>>,
                            name: String,
                            symbols: Vec<String>,
                            is_colo: bool,
@@ -71,7 +71,7 @@ pub async fn gate_swap_run(bool_v1: Arc<AtomicBool>,
     });
 
     spawn(async move {
-        let bot_arc_clone = Arc::clone(&quant_arc);
+        let bot_arc_clone = Arc::clone(&core_arc);
         let run_symbol = symbols.clone()[0].clone();
         // trade
         let mut update_flag_u = Decimal::ZERO;
@@ -93,7 +93,7 @@ pub async fn gate_swap_run(bool_v1: Arc<AtomicBool>,
     });
 }
 
-async fn on_data(bot_arc_clone: Arc<Mutex<Quant>>,
+async fn on_data(bot_arc_clone: Arc<Mutex<Core>>,
                  update_flag_u: &mut Decimal,
                  multiplier: Decimal,
                  run_symbol: String,
@@ -102,7 +102,7 @@ async fn on_data(bot_arc_clone: Arc<Mutex<Quant>>,
                  data: ResponseData) {
     let mut trace_stack = TraceStack::default();
     trace_stack.on_after_network(data.time);
-    trace_stack.on_before_unlock_quant();
+    trace_stack.on_before_unlock_core();
 
     if data.code != "200".to_string() {
         return;
@@ -118,8 +118,8 @@ async fn on_data(bot_arc_clone: Arc<Mutex<Quant>>,
     } else if data.channel == "futures.balances" {
         let account = standard::handle_info::HandleSwapInfo::handle_account_info(GateSwap, data, run_symbol.clone());
         {
-            let mut quant = bot_arc_clone.lock().await;
-            quant.update_equity(account).await;
+            let mut core = bot_arc_clone.lock().await;
+            core.update_equity(account).await;
         }
     } else if data.channel == "futures.orders" {
         trace_stack.on_before_format();
@@ -147,22 +147,22 @@ async fn on_data(bot_arc_clone: Arc<Mutex<Quant>>,
         }
 
         {
-            let mut quant = bot_arc_clone.lock().await;
-            quant.update_order(order_infos, trace_stack);
+            let mut core = bot_arc_clone.lock().await;
+            core.update_order(order_infos, trace_stack);
         }
     } else if data.channel == "futures.positions" {
         let positions = standard::handle_info::HandleSwapInfo::handle_position(GateSwap,data, multiplier.clone());
         {
-            let mut quant = bot_arc_clone.lock().await;
-            quant.update_position(positions).await;
+            let mut core = bot_arc_clone.lock().await;
+            core.update_position(positions).await;
         }
     } else if data.channel == "futures.trades" {
-        let mut quant = bot_arc_clone.lock().await;
+        let mut core = bot_arc_clone.lock().await;
         let str = data.label.clone();
-        if quant.is_update.contains_key(&data.label) && *quant.is_update.get(str.as_str()).unwrap(){
+        if core.is_update.contains_key(&data.label) && *core.is_update.get(str.as_str()).unwrap(){
             *max_buy = Decimal::ZERO;
             *min_sell = Decimal::ZERO;
-            quant.is_update.remove(str.as_str());
+            core.is_update.remove(str.as_str());
         }
         let trades: Vec<OriginalTradeGa> = serde_json::from_str(data.data.as_str()).unwrap();
         for trade in trades {
@@ -173,7 +173,7 @@ async fn on_data(bot_arc_clone: Arc<Mutex<Quant>>,
                 *min_sell = trade.price
             }
         }
-        quant.max_buy_min_sell_cache.insert(data.label, vec![*max_buy, *min_sell]);
+        core.max_buy_min_sell_cache.insert(data.label, vec![*max_buy, *min_sell]);
     }
 }
 

strategy/src/kucoin_spot.rs

@@ -10,12 +10,12 @@ use global::trace_stack::TraceStack;
 use standard::exchange::ExchangeEnum::KucoinSpot;
 use crate::exchange_disguise::on_special_depth;
 use crate::model::OriginalTradeGa;
-use crate::quant::Quant;
+use crate::core::Core;
 
 // 1交易、0参考 kucoin 现货 启动
 pub async fn kucoin_spot_run(bool_v1: Arc<AtomicBool>,
                              _is_trade: bool,
-                             quant_arc: Arc<Mutex<Quant>>,
+                             core_arc: Arc<Mutex<Core>>,
                              name: String,
                              symbols: Vec<String>,
                              is_colo: bool,
@@ -48,7 +48,7 @@ pub async fn kucoin_spot_run(bool_v1: Arc<AtomicBool>,
     //读取
     // let bool_v1_clone = Arc::clone(&bool_v1);
     tokio::spawn(async move {
-        let bot_arc_clone = Arc::clone(&quant_arc);
+        let bot_arc_clone = Arc::clone(&core_arc);
         // trade
         let mut update_flag_u = Decimal::ZERO;
         let mut max_buy = Decimal::ZERO;
@@ -70,7 +70,7 @@ pub async fn kucoin_spot_run(bool_v1: Arc<AtomicBool>,
     });
 }
 
-async fn on_kucoin_spot_data(bot_arc_clone: Arc<Mutex<Quant>>,
+async fn on_kucoin_spot_data(bot_arc_clone: Arc<Mutex<Core>>,
                              update_flag_u: &mut Decimal,
                              _multiplier: Decimal,
                              max_buy: &mut Decimal,
@@ -78,7 +78,7 @@ async fn on_kucoin_spot_data(bot_arc_clone: Arc<Mutex<Quant>>,
                              data: ResponseData) {
     let mut trace_stack = TraceStack::default();
     trace_stack.on_after_network(data.time);
-    trace_stack.on_before_unlock_quant();
+    trace_stack.on_before_unlock_core();
 
     if data.code != "200".to_string() {
         return;
@@ -99,12 +99,12 @@ async fn on_kucoin_spot_data(bot_arc_clone: Arc<Mutex<Quant>>,
 
         on_special_depth(bot_arc_clone, update_flag_u, data.label, trace_stack, special_depth).await;
     }  else if data.channel == "trade.l3match" {
-        let mut quant = bot_arc_clone.lock().await;
+        let mut core = bot_arc_clone.lock().await;
         let str = data.label.clone();
-        if quant.is_update.contains_key(&data.label) && *quant.is_update.get(str.as_str()).unwrap() {
+        if core.is_update.contains_key(&data.label) && *core.is_update.get(str.as_str()).unwrap() {
             *max_buy = Decimal::ZERO;
             *min_sell = Decimal::ZERO;
-            quant.is_update.remove(str.as_str());
+            core.is_update.remove(str.as_str());
         }
         let trade: OriginalTradeGa = serde_json::from_str(data.data.as_str()).unwrap();
         if trade.price > *max_buy || *max_buy == Decimal::ZERO {
@@ -113,13 +113,13 @@ async fn on_kucoin_spot_data(bot_arc_clone: Arc<Mutex<Quant>>,
         if trade.price < *min_sell || *min_sell == Decimal::ZERO {
             *min_sell = trade.price
         }
-        quant.max_buy_min_sell_cache.insert(data.label, vec![*max_buy, *min_sell]);
+        core.max_buy_min_sell_cache.insert(data.label, vec![*max_buy, *min_sell]);
     } else if data.channel == "availableBalance.change" {
         // 取消原有推送解析，因为推送的信息不准确
         // let account = standard::handle_info::HandleSwapInfo::handle_account_info(KucoinSwap, data, run_symbol.clone());
         // {
-        //     let mut quant = bot_arc_clone.lock().await;
-        //     quant.update_equity(account);
+        //     let mut core = bot_arc_clone.lock().await;
+        //     core.update_equity(account);
         // }
     } else if data.channel == "symbolOrderChange" {
         // trace_stack.on_before_format();
@@ -149,14 +149,14 @@ async fn on_kucoin_spot_data(bot_arc_clone: Arc<Mutex<Quant>>,
         // }
         //
         // {
-        //     let mut quant = bot_arc_clone.lock().await;
-        //     quant.update_order(order_infos, trace_stack);
+        //     let mut core = bot_arc_clone.lock().await;
+        //     core.update_order(order_infos, trace_stack);
         // }
     } else if data.channel == "position.change" {
         // let positions = standard::handle_info::HandleSwapInfo::handle_position(KucoinSwap,data, multiplier);
         // {
-        //     let mut quant = bot_arc_clone.lock().await;
-        //     quant.update_position(positions);
+        //     let mut core = bot_arc_clone.lock().await;
+        //     core.update_position(positions);
         // }
     }
 }

strategy/src/kucoin_swap.rs

@@ -17,12 +17,12 @@ use standard::exchange::ExchangeEnum::KucoinSwap;
 use crate::exchange_disguise::on_special_depth;
 
 use crate::model::{OrderInfo, OriginalTradeGa};
-use crate::quant::Quant;
+use crate::core::Core;
 
 // 1交易、0参考 kucoin 合约 启动
 pub async fn kucoin_swap_run(bool_v1 :Arc<AtomicBool>,
                              is_trade: bool,
-                             quant_arc: Arc<Mutex<Quant>>,
+                             core_arc: Arc<Mutex<Core>>,
                              name: String,
                              symbols: Vec<String>,
                              is_colo: bool,
@@ -36,15 +36,15 @@ pub async fn kucoin_swap_run(bool_v1 :Arc<AtomicBool>,
     }
 
     // 新增定期获取余额的协程
-    let account_quant_arc = quant_arc.clone();
+    let account_core_arc = core_arc.clone();
     spawn(async move {
         loop {
             // 每30秒重新获取一次
             sleep(Duration::from_secs(30)).await;
 
             {
-                let mut quant = account_quant_arc.lock().await;
-                quant.update_equity_rest_swap().await;
+                let mut core = account_core_arc.lock().await;
+                core.update_equity_rest_swap().await;
             }
         }
     });
@@ -87,7 +87,7 @@ pub async fn kucoin_swap_run(bool_v1 :Arc<AtomicBool>,
 
         // 数据处理协程
         spawn(async move {
-            let bot_arc_clone = Arc::clone(&quant_arc);
+            let bot_arc_clone = Arc::clone(&core_arc);
 
             // ticker
             let mut update_flag_u = Decimal::ZERO;
@@ -109,7 +109,7 @@ pub async fn kucoin_swap_run(bool_v1 :Arc<AtomicBool>,
     });
 }
 
-async fn on_data(bot_arc_clone: Arc<Mutex<Quant>>,
+async fn on_data(bot_arc_clone: Arc<Mutex<Core>>,
                  update_flag_u: &mut Decimal,
                  multiplier: Decimal,
                  max_buy: &mut Decimal,
@@ -117,7 +117,7 @@ async fn on_data(bot_arc_clone: Arc<Mutex<Quant>>,
                  data: ResponseData) {
     let mut trace_stack = TraceStack::default();
     trace_stack.on_after_network(data.time);
-    trace_stack.on_before_unlock_quant();
+    trace_stack.on_before_unlock_core();
 
     if data.code != "200".to_string() {
         return;
@@ -138,8 +138,8 @@ async fn on_data(bot_arc_clone: Arc<Mutex<Quant>>,
         // 取消原有推送解析，因为推送的信息不准确
         // let account = standard::handle_info::HandleSwapInfo::handle_account_info(KucoinSwap, data, run_symbol.clone());
         // {
-        //     let mut quant = bot_arc_clone.lock().await;
-        //     quant.update_equity(account);
+        //     let mut core = bot_arc_clone.lock().await;
+        //     core.update_equity(account);
         // }
     } else if data.channel == "symbolOrderChange" {
         trace_stack.on_before_format();
@@ -169,22 +169,22 @@ async fn on_data(bot_arc_clone: Arc<Mutex<Quant>>,
         }
 
         {
-            let mut quant = bot_arc_clone.lock().await;
-            quant.update_order(order_infos, trace_stack);
+            let mut core = bot_arc_clone.lock().await;
+            core.update_order(order_infos, trace_stack);
         }
     } else if data.channel == "position.change" {
         let positions = standard::handle_info::HandleSwapInfo::handle_position(KucoinSwap,data, multiplier);
         {
-            let mut quant = bot_arc_clone.lock().await;
-            quant.update_position(positions).await;
+            let mut core = bot_arc_clone.lock().await;
+            core.update_position(positions).await;
         }
     } else if data.channel == "match" {
-        let mut quant = bot_arc_clone.lock().await;
+        let mut core = bot_arc_clone.lock().await;
         let str = data.label.clone();
-        if quant.is_update.contains_key(&data.label) && *quant.is_update.get(str.as_str()).unwrap() {
+        if core.is_update.contains_key(&data.label) && *core.is_update.get(str.as_str()).unwrap() {
             *max_buy = Decimal::ZERO;
             *min_sell = Decimal::ZERO;
-            quant.is_update.remove(str.as_str());
+            core.is_update.remove(str.as_str());
         }
         let trade: OriginalTradeGa = serde_json::from_str(data.data.as_str()).unwrap();
         if trade.price > *max_buy || *max_buy == Decimal::ZERO {
@@ -193,7 +193,7 @@ async fn on_data(bot_arc_clone: Arc<Mutex<Quant>>,
         if trade.price < *min_sell || *min_sell == Decimal::ZERO {
             *min_sell = trade.price
         }
-        quant.max_buy_min_sell_cache.insert(data.label, vec![*max_buy, *min_sell]);
+        core.max_buy_min_sell_cache.insert(data.label, vec![*max_buy, *min_sell]);
     }
 }
 

strategy/src/lib.rs

@@ -1,4 +1,4 @@
-pub mod quant;
+pub mod core;
 pub mod model;
 mod strategy;
 mod predictor;

strategy/src/okx_usdt_swap.rs

@@ -10,11 +10,11 @@ use global::trace_stack::TraceStack;
 use standard::exchange::ExchangeEnum::OkxSwap;
 use crate::exchange_disguise::on_special_depth;
 use crate::model::{OrderInfo, OriginalTradeOK};
-use crate::quant::Quant;
+use crate::core::Core;
 
 pub async fn okex_swap_run(bool_v1: Arc<AtomicBool>,
                            is_trade: bool,
-                           _quant_arc: Arc<Mutex<Quant>>,
+                           _core_arc: Arc<Mutex<Core>>,
                            name: String,
                            symbols: Vec<String>,
                            is_colo: bool,
@@ -44,7 +44,7 @@ pub async fn okex_swap_run(bool_v1: Arc<AtomicBool>,
                                    read_tx_public).await.expect("链接失败(内部一个心跳线程应该已经关闭了)");
     });
     // 消费数据
-    let bot_arc_clone = _quant_arc.clone();
+    let bot_arc_clone = _core_arc.clone();
     // 接收public数据
     tokio::spawn(async move {
         // ticker
@@ -89,10 +89,10 @@ pub async fn okex_swap_run(bool_v1: Arc<AtomicBool>,
         });
 
         // 消费数据
-        let bot_arc_clone = _quant_arc.clone();
+        let bot_arc_clone = _core_arc.clone();
         // 接收private信息
         tokio::spawn(async move {
-            let ct_val = _quant_arc.clone().lock().await.platform_rest.get_self_market().ct_val;
+            let ct_val = _core_arc.clone().lock().await.platform_rest.get_self_market().ct_val;
             let run_symbol = symbols.clone()[0].clone();
             loop {
                 if let Some(private_data) = read_rx_private.next().await {
@@ -106,11 +106,11 @@ pub async fn okex_swap_run(bool_v1: Arc<AtomicBool>,
     }
 }
 
-async fn on_private_data(bot_arc_clone: Arc<Mutex<Quant>>, ct_val: Decimal, data: ResponseData, run_symbol: String) {
+async fn on_private_data(bot_arc_clone: Arc<Mutex<Core>>, ct_val: Decimal, data: ResponseData, run_symbol: String) {
     let mut trace_stack = TraceStack::default();
 
     trace_stack.on_after_network(data.time);
-    trace_stack.on_before_unlock_quant();
+    trace_stack.on_before_unlock_core();
 
     if data.code != "200".to_string() {
         return;
@@ -142,28 +142,28 @@ async fn on_private_data(bot_arc_clone: Arc<Mutex<Quant>>, ct_val: Decimal, data
             order_infos.push(order_info);
         }
         {
-            let mut quant = bot_arc_clone.lock().await;
-            quant.update_order(order_infos, trace_stack);
+            let mut core = bot_arc_clone.lock().await;
+            core.update_order(order_infos, trace_stack);
         }
     } else if data.channel == "balance_and_position" {
         let positions = standard::handle_info::HandleSwapInfo::handle_position(OkxSwap,data, ct_val);
         {
-            let mut quant = bot_arc_clone.lock().await;
-            quant.update_position(positions).await;
+            let mut core = bot_arc_clone.lock().await;
+            core.update_position(positions).await;
         }
     } else if data.channel == "account" {
         let account = standard::handle_info::HandleSwapInfo::handle_account_info(OkxSwap, data.clone(), run_symbol.clone());
         {
-            let mut quant = bot_arc_clone.lock().await;
-            quant.update_equity(account).await;
+            let mut core = bot_arc_clone.lock().await;
+            core.update_equity(account).await;
         }
     }
 }
 
-async fn on_public_data(bot_arc_clone: Arc<Mutex<Quant>>, update_flag_u: &mut Decimal, max_buy: &mut Decimal, min_sell: &mut Decimal, data: ResponseData) {
+async fn on_public_data(bot_arc_clone: Arc<Mutex<Core>>, update_flag_u: &mut Decimal, max_buy: &mut Decimal, min_sell: &mut Decimal, data: ResponseData) {
     let mut trace_stack = TraceStack::default();
     trace_stack.on_after_network(data.time);
-    trace_stack.on_before_unlock_quant();
+    trace_stack.on_before_unlock_core();
 
     if data.code != "200".to_string() {
         return;
@@ -174,12 +174,12 @@ async fn on_public_data(bot_arc_clone: Arc<Mutex<Quant>>, update_flag_u: &mut De
         trace_stack.on_after_format();
         on_special_depth(bot_arc_clone, update_flag_u, data.label, trace_stack, special_depth).await;
     } else if data.channel == "trades" {
-        let mut quant = bot_arc_clone.lock().await;
+        let mut core = bot_arc_clone.lock().await;
         let str = data.label.clone();
-        if quant.is_update.contains_key(&data.label) && *quant.is_update.get(str.as_str()).unwrap(){
+        if core.is_update.contains_key(&data.label) && *core.is_update.get(str.as_str()).unwrap(){
             *max_buy = Decimal::ZERO;
             *min_sell = Decimal::ZERO;
-            quant.is_update.remove(str.as_str());
+            core.is_update.remove(str.as_str());
         }
         let trades: Vec<OriginalTradeOK> = serde_json::from_str(data.data.as_str()).unwrap();
         for trade in trades {
@@ -190,7 +190,7 @@ async fn on_public_data(bot_arc_clone: Arc<Mutex<Quant>>, update_flag_u: &mut De
                 *min_sell = trade.px
             }
         }
-        quant.max_buy_min_sell_cache.insert(data.label, vec![*max_buy, *min_sell]);
+        core.max_buy_min_sell_cache.insert(data.label, vec![*max_buy, *min_sell]);
     } else if data.channel == "books5" {
         trace_stack.on_before_format();
         let special_depth = standard::handle_info::HandleSwapInfo::handle_special_depth(OkxSwap, data.clone());