合并异常的处理。

Cargo.toml

@@ -23,7 +23,6 @@ serde_json = "1.0.105"
 rust_decimal = { version = "1.32.0", features = ["maths"] }
 rust_decimal_macros = "1.32.0"
 
-
 [workspace]
 members=[
     "exchanges",

config.toml.sample

@@ -40,14 +40,3 @@ colo = 0
 log_level = "info"
 # 中控端口
 port = 6000
-
-# 最大价差（价差区间结束值）
-max_spread = 0.0005
-# 最小价差（价差区间开始值）
-min_spread = 0.0001
-# 取价列表的最大长度
-rl_num = 30
-# 不用设置，暂时没用
-max_position_value = 20
-# 取价坐标
-ira = 5

global/Cargo.toml

@@ -26,4 +26,3 @@ base64 = "0.13.0"
 reqwest = "0.11.22"
 uuid = { version = "1.5.0", features = ["v4"] }
 simple_excel_writer = "0.2.0"
-num-traits = "0.2.17"

standard/src/kucoin_swap.rs

@@ -346,20 +346,12 @@ impl Platform for KucoinSwap {
         match origin_side {
             "kd" => {
                 params["side"] = json!("buy");
-                // params["stop"] = json!("down");
-                // let stop_price = utils::fix_price(price * Decimal::from_str("0.095").unwrap(), self.market.tick_size);
-                // params["stopPrice"] = json!(stop_price.to_string());
-                // params["stopPriceType"] =  json!("TP"); // 止损参考价 最近一次成交价格
             }
             "pd" => {
                 params["side"] = json!("sell");
             }
             "kk" => {
                 params["side"] = json!("sell");
-                // params["stop"] = json!("up");
-                // let stop_price = utils::fix_price(price * Decimal::from_str("1.005").unwrap(), self.market.tick_size);
-                // params["stopPrice"] = json!(stop_price.to_string());
-                // params["stopPriceType"] =  json!("TP"); // 止损参考价 最近一次成交价格
             }
             "pk" => {
                 params["side"] = json!("buy");
@@ -587,9 +579,6 @@ impl Platform for KucoinSwap {
         let mut limits = HashMap::new();
         limits.extend(order_command.limits_open);
         limits.extend(order_command.limits_close);
-        if limits.len() > 3usize{
-            info!(?limits);
-        }
         for item in limits.keys() {
             let mut self_clone = self.clone();
             let limits_clone = limits.clone();

standard/src/utils.rs

@@ -1,5 +1,3 @@
-use std::ops::{Div, Mul};
-use rust_decimal::Decimal;
 use tracing::trace;
 use exchanges::proxy;
 use crate::exchange::ExchangeEnum;
@@ -48,10 +46,4 @@ pub fn symbol_out_mapper(exchange_enum: ExchangeEnum, symbol: &str) -> String {
             symbol_upper.to_string()
         }
     }
-}
-
-// 步长修复价格
-pub fn fix_price(amount: Decimal, tick_size: Decimal) -> Decimal {
-    // 思路：做除法后四舍五入，然后使用这个值乘以步长
-    amount.div(tick_size).round().mul(tick_size)
 }

strategy/Cargo.toml

@@ -20,8 +20,6 @@ standard = { path = "../standard" }
 global = { path = "../global" }
 exchanges = { path = "../exchanges" }
 reqwest = { version = "0.11.14", features = ["json"] }
-ndarray = "0.15.6"
-argmin = "0.7"
 
 futures-util = { version = "0.3.28", default-features = false, features = ["sink", "std"] }
 futures-channel = "0.3.28"

strategy/src/instant_volatility_indicator.rs

@@ -1,60 +0,0 @@
-use std::io::{Error, ErrorKind};
-use rust_decimal::{Decimal, MathematicalOps};
-use tracing::error;
-use crate::ring_buffer::RingBuffer;
-
-#[derive(Debug)]
-pub struct InstantVolatilityIndicator {
-    sampling_buffer: RingBuffer,
-    processing_buffer: RingBuffer,
-}
-
-impl InstantVolatilityIndicator {
-    pub fn new(sampling_length: usize, processing_length: usize) -> Self{
-        InstantVolatilityIndicator{
-            sampling_buffer: RingBuffer::new(sampling_length),
-            processing_buffer: RingBuffer::new(processing_length),
-        }
-    }
-
-    pub fn add_sample(&mut self, value: Decimal) {
-        self.sampling_buffer.add_value(value);
-        let processing_value = self.indicator_calculation();
-        self.processing_buffer.add_value(processing_value);
-    }
-
-    pub fn indicator_calculation(&self) -> Decimal{
-        let sampling_buffer_vec: Vec<Decimal> = self.sampling_buffer.get_buffer_vec();
-        let mut diff_buffer: Vec<Decimal> = sampling_buffer_vec.windows(2).map(|w| w[1] - w[0]).collect();
-        for item in diff_buffer.iter_mut() {
-            *item = item.powi(2i64);
-        }
-        let mut sum: Decimal = diff_buffer.iter().sum();
-        sum /= Decimal::from(sampling_buffer_vec.len());
-        sum = match sum.sqrt() {
-            None => {
-                error!("波动率计算，开方计算错误! buffer: {:?}", sampling_buffer_vec);
-                Err(Error::new(ErrorKind::Other, "波动率计算，开方计算错误!"))
-            }
-            Some(value) => {
-                Ok(value)
-            }
-        }.unwrap();
-
-        sum
-    }
-    pub fn get_process(&self) {
-        if self.sampling_buffer.is_full() {
-            return;
-        }
-        self.sampling_buffer.process();
-    }
-
-    // 获取波动率，缓存器没满不返回波动率
-    pub fn processing_calculation(&self) -> Decimal{
-        if self.processing_buffer.is_full() {
-            return self.processing_buffer.get_last_value().unwrap();
-        }
-        Decimal::ZERO
-    }
-}

strategy/src/predictor_new.rs

@@ -1,357 +0,0 @@
-
-use rust_decimal::prelude::*;
-use rust_decimal_macros::dec;
-use global::public_params;
-use crate::instant_volatility_indicator::InstantVolatilityIndicator;
-
-#[derive(Debug)]
-pub struct PredictorNew {
-    pub loop_count: i64,                                                // 统计当前预测器更新的次数,loop
-    pub market_info_list: Vec<Vec<Decimal>>,                            // TODO 这里存放的是一个市场数据汇总，后面有时间再优化,arr
-    pub mid_price_list: Vec<Decimal>,                                   // 中间价的数组,trade_mp_series
-    pub ref_mid_price_per_exchange_per_frame: Vec<Vec<Decimal>>,        // 参考交易所的中间价的数组（注意是二维的，因为参考交易所有多个）,ref_mp_series
-    pub ref_exchange_length: usize,                                     // 参考交易所数量,ref_num
-    pub data_length_max: usize,                                         // 各类数据极限长度，防止爆内存,window
-    pub alpha: Vec<Decimal>,                                            // 价格系数
-    pub gamma: Decimal,                                                 // 定价系数
-    pub avg_spread_list: Vec<Decimal>,                                  // 平均价差
-//
-    pub transaction_prices: Vec<Decimal>,                                   // 中间价记录
-    pub variance: Decimal,                                                  // 波动率
-    pub balance_value: Decimal,                                             // 持仓价值
-// 手动输入
-    pub max_spread: Decimal,                                                // 最大点差
-    pub min_spread: Decimal,                                                // 最小点差
-    pub rl_num: Decimal,                                                    // 取价坐标
-    pub ira: Decimal,                                                       // 取值坐标
-    pub max_position_value: Decimal,                                         // 最大持仓（u）
-
-    pub vol: InstantVolatilityIndicator                                     // 波动率计算类
-}
-
-/*
-    使用Builder设计模式创建价格预测器，可以有效提高代码整洁度
-    下面的单元测试有使用示例
-*/
-impl PredictorNew {
-    pub fn new(ref_exchange_length: usize, max_spread: Decimal, min_spread: Decimal, rl_num: Decimal, max_position_value: Decimal, ira: Decimal) -> Self {
-        Self {
-            loop_count: 0,
-            market_info_list: vec![],
-            mid_price_list: vec![],
-            ref_mid_price_per_exchange_per_frame: vec![],
-            ref_exchange_length,
-            data_length_max: 10,
-            alpha: vec![Decimal::new(1, 0); 100],
-            gamma: Decimal::from_f64(0.999).unwrap(),
-            avg_spread_list: vec![dec!(0); ref_exchange_length],
-            transaction_prices: Vec::new(),
-            max_spread,
-            min_spread,
-            variance: Decimal::ZERO,
-            balance_value: Decimal::ZERO,
-            rl_num,
-            ira,
-            max_position_value,
-            vol: InstantVolatilityIndicator::new(30, 15)
-        }
-    }
-
-    pub fn alpha(mut self, alpha: Vec<Decimal>) -> Self {
-        self.alpha = alpha;
-        self
-    }
-
-    pub fn gamma(mut self, gamma: Decimal) -> Self {
-        self.gamma = gamma;
-        self
-    }
-
-    // 计算任务，python里写作processer，是个错误的单词
-    fn processor(&mut self) {
-        let last_market_info = self.market_info_list.last().unwrap();
-
-        // 更新mid_price
-        let bid_price = last_market_info[public_params::BID_PRICE_INDEX];
-        let ask_price = last_market_info[public_params::ASK_PRICE_INDEX];
-        let mid_price = (bid_price + ask_price) * dec!(0.5);
-        // debug!(?last_market_info);
-        // debug!(?bid_price, ?ask_price, ?mid_price);
-        self.mid_price_list.push(mid_price.clone());
-        self.transaction_prices.push(mid_price);
-        // 更新参考ref_mid_price
-        let mut ref_mid_price_per_exchange = vec![];
-        for ref_index in 0..self.ref_exchange_length {
-            let ref_bid_price = last_market_info[public_params::LENGTH*(1+ref_index)+public_params::BID_PRICE_INDEX];
-            let ref_ask_price = last_market_info[public_params::LENGTH*(1+ref_index)+public_params::ASK_PRICE_INDEX];
-            let ref_mid_price = (ref_bid_price + ref_ask_price) * dec!(0.5);
-            // debug!(?ref_bid_price, ?ref_ask_price, ?ref_mid_price);
-            // 依照交易所次序添加到ref_mid_price_per_exchange中
-            ref_mid_price_per_exchange.push(ref_mid_price);
-        }
-        // debug!(?ref_mid_price_per_exchange);
-        let first_price = ref_mid_price_per_exchange[0].clone();
-        self.ref_mid_price_per_exchange_per_frame.push(ref_mid_price_per_exchange);
-
-        self.transaction_prices.push(first_price);
-        // 波动率更新
-        self.update_std();
-        // 价差更新
-        // (*self).update_avg_spread()
-    }
-
-    /**
-        波动率计算（根据最近成交价，EWMA波动率算法）
-    **/
-    pub fn update_std(&mut self) {
-        let gamma = self.gamma;
-        // 如果程序刚刚启动，gamma值不能太大
-        // if self.loop_count < 100 {
-        //     gamma = 0.9f64;
-        // }
-        let len = self.transaction_prices.len();
-        if len < 3usize {
-            return;
-        }
-        // info!(?self.transaction_prices);
-        let rtn: Decimal = (self.transaction_prices[len - 1] / self.transaction_prices[len - 2]).ln();
-        let result: Decimal = gamma * rtn.powi(2) + (Decimal::ONE - gamma) * self.variance;
-        self.variance = result.sqrt().unwrap();
-    }
-
-    /**
-       计算gamma值
-    **/
-    pub fn calc_gamma(&mut self, ira: Decimal, variance: &Decimal) -> Decimal {
-        self.max_spread / Decimal::TWO * self.balance_value * variance.powi(2) * ira
-    }
-
-    /**
-       计算价格偏差范围
-    **/
-    pub fn calc_deviation_range(&mut self, ira: Decimal) -> Decimal {
-        return (self.rl_num - ira) * self.max_spread + ira * self.min_spread;
-    }
-
-    /**
-       计算预定价格
-    **/
-    pub fn calc_rp(&mut self, gamma: &Decimal, std: &Decimal) -> Decimal{
-        let last_market_info = self.market_info_list.last().unwrap();
-        let ref_bid_price = last_market_info[public_params::LENGTH+public_params::BID_PRICE_INDEX];
-        let ref_ask_price = last_market_info[public_params::LENGTH+public_params::ASK_PRICE_INDEX];
-        let ref_mid_price = (ref_bid_price + ref_ask_price) * dec!(0.5);
-        ref_mid_price - self.balance_value * gamma * std * std
-    }
-
-    pub fn calc_dk(&mut self, gamma: &Decimal, std: &Decimal) -> Decimal {
-        return ((self.max_spread + self.min_spread)/Decimal::TWO * gamma - std * std * gamma * gamma) / Decimal::TWO;
-    }
-
-    pub fn calc_kappa(&mut self, gamma: &Decimal, dk: Decimal, deviation_range: Decimal) -> Decimal {
-        let e = Decimal::E.powf(dk.to_f64().unwrap()) - Decimal::ONE;
-        gamma / e / deviation_range
-    }
-
-    /**
-        计算价差
-    **/
-    pub fn calc_theta(&mut self, gamma: Decimal, kappa: Decimal, std: &Decimal) -> Decimal {
-        let a = gamma * std * std;
-        let ln = (Decimal::ONE + gamma / kappa).ln();
-        let b = Decimal::TWO / gamma * ln;
-        (a + b) / Decimal::TWO
-    }
-
-    // 更新平均价差,_update_avg_spread
-    // fn update_avg_spread(&mut self) {
-    //     let last_ref_mid_price_per_exchange = self.ref_mid_price_per_exchange_per_frame.last().unwrap();
-    //     let mid_price_last = self.mid_price_list.last().unwrap();
-    //
-    //     for ref_index in 0..self.ref_exchange_length {
-    //         let bias = last_ref_mid_price_per_exchange[ref_index] * self.alpha[ref_index] - mid_price_last;
-    //
-    //         let mut gamma = self.gamma;
-    //         // 如果程序刚刚启动，gamma值不能太大
-    //         if self.loop_count < 100 {
-    //             gamma = dec!(0.9);
-    //         }
-    //
-    //         // 检测是否初始化
-    //         if dec!(0).eq(&self.avg_spread_list[ref_index]) {
-    //             self.avg_spread_list[ref_index] = bias;
-    //         } else {
-    //             self.avg_spread_list[ref_index] = self.avg_spread_list[ref_index] * gamma + bias*(dec!(1)-gamma);
-    //         }
-    //     }
-    // }
-
-    // 长度限定
-    fn check_length(&mut self) {
-        // 市场汇总信息长度限定
-        if self.market_info_list.len() > self.data_length_max {
-            self.market_info_list.remove(0);
-        }
-        // 交易交易所的mid_price长度限定
-        if self.mid_price_list.len() > self.data_length_max {
-            self.mid_price_list.remove(0);
-        }
-        // 参考交易所的长度限定
-        if self.ref_mid_price_per_exchange_per_frame.len() > self.data_length_max {
-            self.ref_mid_price_per_exchange_per_frame.remove(0);
-        }
-        // 成交价纪录
-        if self.transaction_prices.len() > 10usize {
-            self.transaction_prices.remove(0);
-        }
-    }
-
-    // 市场信息处理器，也是python里的onTime方法
-    pub fn market_info_handler(&mut self, new_market_info: &Vec<Decimal>) {
-        // debug!(?new_market_info);
-        // 空数据不处理
-        if new_market_info.len() == 0 {
-            return;
-        }
-
-        if self.loop_count < i64::MAX {
-            self.loop_count += 1;
-        }
-        self.market_info_list.push(new_market_info.clone());
-        (*self).processor();
-        (*self).check_length();
-    }
-
-    pub fn market_update(&mut self, best_mid_price: Decimal){
-        self.vol.add_sample(best_mid_price);
-    }
-
-    // 获取预定价格, 也就是python的Get_ref函数
-    // pub fn get_ref_price(&mut self, ref_ticker_map: &BTreeMap<String, Ticker>) -> Vec<Vec<Decimal>> {
-    //     let mut ref_price_list = vec![];
-    //     let ref_exchange_names: Vec<_> = ref_ticker_map.keys().collect();
-    //     for ref_index in 0..ref_exchange_names.len() {
-    //         let ref_exchange = ref_exchange_names[ref_index];
-    //
-    //         let ticker = ref_ticker_map.get(ref_exchange).unwrap();
-    //         let bid_price = ticker.buy;
-    //         let ask_price = ticker.sell;
-    //         let mid_price = (bid_price + ask_price) / Decimal::TWO;
-    //         let ref_bid_price = mid_price * self.alpha[ref_index] - self.avg_spread_list[ref_index];
-    //         let ref_ask_price = mid_price * self.alpha[ref_index] + self.avg_spread_list[ref_index];
-    //
-    //         ref_price_list.push(vec![ref_bid_price, ref_ask_price]);
-    //     }
-    //     debug!(?ref_price_list);
-    //
-    //     return ref_price_list;
-    // }
-    pub fn get_ref_price(&mut self) -> Vec<Vec<Decimal>>{
-        let mut ref_price_list = Vec::new();
-        // let std = self.vol.processing_calculation();
-        let std = self.variance;
-        if std == Decimal::ZERO {
-            return Vec::new();
-        }
-        let ira = self.ira;
-        let dd = self.calc_deviation_range(ira.clone());
-        let gamma = self.calc_gamma(ira.clone(), &std);
-        let rp = self.calc_rp(&gamma, &std);
-        let dk = self.calc_dk(&gamma, &std);
-        let kappa = self.calc_kappa(&gamma, dk, dd);
-        let theta = self.calc_theta(gamma, kappa, &std);
-        ref_price_list.push(vec![rp + theta , rp - theta]);
-        // info!(?std, ?dd, ?gamma, ?rp, ?dk, ?kappa, ?theta, ?ref_price_list);
-
-        // let std2 = self.variance;
-        // let dd2 = self.calc_deviation_range(ira.clone());
-        // let gamma2 = self.calc_gamma(ira, &std2);
-        // let rp2 = self.calc_rp(&gamma, &std2);
-        // let dk2 = self.calc_dk(&gamma, &std2);
-        // let kappa2 = self.calc_kappa(&gamma, dk, dd);
-        // let theta2 = self.calc_theta(gamma, kappa, &std2);
-        // let x = vec![rp2 + theta2 , rp2 - theta2];
-        // info!(?std2, ?dd2, ?gamma2, ?rp2, ?dk2, ?kappa2, ?theta2, ?x);
-        ref_price_list
-    }
-}
-
-
-#[cfg(test)]
-mod tests {
-    use std::collections::BTreeMap;
-    use std::io;
-    use std::io::Write;
-    use std::str::FromStr;
-    use rust_decimal::Decimal;
-    use rust_decimal_macros::dec;
-    use standard::Ticker;
-    use crate::predictor_new::PredictorNew;
-
-    #[test]
-    fn predictor_build_test() {
-        let mut stdout = io::stdout();
-
-        let predictor1 = PredictorNew::new(2, Default::default(), Default::default(), Default::default(), Default::default(), Decimal::ONE)
-            .alpha(vec![dec!(0.99); 100])
-            .gamma(dec!(0.8));
-        writeln!(stdout, "predictor1:").unwrap();
-        writeln!(stdout, "{:?}", predictor1).unwrap();
-        writeln!(stdout, "").unwrap();
-
-        let predictor2 = PredictorNew::new(2, Default::default(), Default::default(), Default::default(), Default::default(), Decimal::ONE);
-        writeln!(stdout, "predictor2:").unwrap();
-        writeln!(stdout, "{:?}", predictor2).unwrap();
-        writeln!(stdout, "").unwrap();
-    }
-
-    #[test]
-    fn market_info_handler_test() {
-        let mut predictor = PredictorNew::new(1, Default::default(), Default::default(), Default::default(), Default::default(), Decimal::ONE);
-        let market_info_0 = vec![dec!(0.99), dec!(1.0), dec!(0.89), dec!(0.79), dec!(0.99), dec!(1.0), dec!(0.89), dec!(0.79), dec!(0.89), dec!(0.79), dec!(0.99), dec!(1.0), dec!(0.89), dec!(0.79)];
-        predictor.market_info_handler(&market_info_0);
-        let market_info_1 = vec![dec!(0.98), dec!(0.99), dec!(0.56), dec!(0.49), dec!(0.99), dec!(1.0), dec!(0.89), dec!(0.79), dec!(0.89), dec!(0.79), dec!(0.99), dec!(1.0), dec!(0.89), dec!(0.79)];
-        predictor.market_info_handler(&market_info_1);
-    }
-
-    #[test]
-    fn get_ref_price_test() {
-        let mut predictor = PredictorNew::new(1, Default::default(), Default::default(), Default::default(), Default::default(), Decimal::ONE)
-            .alpha(vec![dec!(0.99); 100])
-            .gamma(dec!(0.8));
-        predictor.balance_value = Decimal::from_str("0.5").unwrap();
-        predictor.max_spread = Decimal::from_str("0.5").unwrap();
-        predictor.min_spread = Decimal::from_str("0.01").unwrap();
-        //
-        let mut ref_ticker_map: BTreeMap<String, Ticker> = BTreeMap::new();
-        ref_ticker_map.insert("binance".to_string(), Ticker{
-            time: 0,
-            high: Default::default(),
-            low: Default::default(),
-            sell: dec!(0.93),
-            buy: dec!(0.92),
-            last: Default::default(),
-            volume: Default::default(),
-        });
-        // println!("before market info: {:?}", predictor.get_ref_price());
-
-        let mut market_info= vec![dec!(0.99), dec!(1.0), dec!(0.991), dec!(0.79), dec!(0.99), dec!(1.0), dec!(0.89), dec!(0.79), dec!(0.89), dec!(0.79), dec!(0.99), dec!(1.0), dec!(0.89), dec!(0.79)];
-        predictor.market_info_handler(&market_info);
-        println!("market info 0: {:?}", predictor.get_ref_price());
-        market_info = vec![dec!(0.98), dec!(0.99), dec!(0.981), dec!(0.49), dec!(0.99), dec!(1.0), dec!(0.89), dec!(0.79), dec!(0.89)];
-        predictor.market_info_handler(&market_info);
-        println!("market info 1: {:?}", predictor.get_ref_price());
-        market_info = vec![dec!(0.93), dec!(1.0), dec!(0.931), dec!(0.79), dec!(0.99), dec!(1.0), dec!(0.89), dec!(0.79), dec!(0.89)];
-        predictor.market_info_handler(&market_info);
-        println!("market info 2: {:?}", predictor.get_ref_price());
-        market_info = vec![dec!(0.98), dec!(0.49), dec!(0.981), dec!(0.49), dec!(0.99), dec!(1.0), dec!(0.89), dec!(0.79), dec!(0.89)];
-        predictor.market_info_handler(&market_info);
-        println!("market info 3: {:?}", predictor.get_ref_price());
-        market_info = vec![dec!(0.99), dec!(1.0), dec!(0.991), dec!(0.69), dec!(0.99), dec!(1.0), dec!(0.89), dec!(0.79), dec!(0.89)];
-        predictor.market_info_handler(&market_info);
-        println!("market info 4: {:?}", predictor.get_ref_price());
-        market_info = vec![dec!(0.98), dec!(0.969), dec!(0.981), dec!(0.49), dec!(0.99), dec!(1.0), dec!(1.0), dec!(1.0), dec!(0.89)];
-        predictor.market_info_handler(&market_info);
-        println!("market info 5: {:?}", predictor.get_ref_price());
-    }
-}

strategy/src/quant.rs

@@ -22,7 +22,7 @@ use standard::{Account, Market, Order, OrderCommand, Platform, Position, Positio
 use standard::exchange::{Exchange};
 use standard::exchange::ExchangeEnum::{BinanceSpot, BinanceSwap, BitgetSpot, BybitSwap, GateSpot, GateSwap, KucoinSwap, OkxSwap};
 
-use crate::model::{LocalPosition, OrderInfo, TokenParam, TraderMsg};
+use crate::model::{LocalPosition, OrderInfo, OriginalTradeBa, TokenParam, TraderMsg};
 use crate::predictor::Predictor;
 use crate::strategy::Strategy;
 use crate::utils;
@@ -106,6 +106,14 @@ pub struct Quant {
     // 打印限频
     pub prev_log_ready_timestamp: i64,
     pub log_ready_log_interval: i64,
+
+    // 订单流相关参数
+    pub side: String,                                       // 当前方向, [normal, long, short]
+    pub trades: Vec<OriginalTradeBa>,                       // 订单流集合
+    pub recall_time: Decimal,                               // 前置时间
+    pub recall_max_count: usize,                            // 最大回溯条数
+    pub short_volume_rate: Decimal,                         // 主动性跌比率(0.01代表1%)
+    pub long_volume_rate: Decimal,                          // 主动性涨比率(0.01代表1%)
 }
 
 impl Quant {
@@ -151,7 +159,7 @@ impl Quant {
             exit_msg: "正常退出".to_string(),
             position_check_series: Default::default(),
             stop_loss: params.stop_loss,
-            used_pct: params.used_pct,
+            used_pct: dec!(0.95),
             mode_signal: 0,
             trade_order_update_time: Utc::now().timestamp_millis(),
             on_tick_event_time: Utc::now().timestamp_millis(),
@@ -163,7 +171,7 @@ impl Quant {
             ref_name: Default::default(),
             trade_name: "".to_string(),
             ready: 0,
-            predictor: Predictor{
+            predictor: Predictor {
                 loop_count: 0,
                 market_info_list: vec![],
                 mid_price_list: vec![],
@@ -224,6 +232,12 @@ impl Quant {
             running,
             prev_log_ready_timestamp: 0,
             log_ready_log_interval: 10 * 1000,
+            side: "normal".to_string(),
+            trades: vec![],
+            recall_time: dec!(6180),
+            recall_max_count: 5000.to_usize().unwrap(),
+            short_volume_rate: dec!(0.618),
+            long_volume_rate: dec!(0.618),
         };
         for i in 0..=params.ref_exchange.len() - 1 {
             // 拼接不会消耗原字符串
@@ -689,22 +703,7 @@ impl Quant {
 
     #[instrument(skip(self, data, name), level="TRACE")]
     pub fn _update_ticker(&mut self, data: SpecialTicker, name: String) {
-        // let spread = data.buy - data.sell;
-        // if spread > self.predictor.max_spread || self.predictor.max_spread == Decimal::ZERO{
-        //     self.predictor.max_spread = spread;
-        // }
-        // if spread < self.predictor.min_spread || self.predictor.min_spread == Decimal::ZERO{
-        //     self.predictor.min_spread = spread;
-        // }
-        // // 只用第一参考交易所最佳买卖价的中间价
-        // if name == self.ref_name[0] {
-        //     self.predictor.market_update(data.mid_price.clone());
-        //     // 查看进度
-        //     self.predictor.vol.get_process();
-        // }
         self.tickers.insert(name, data);
-
-
     }
 
     #[instrument(skip(self), level="TRACE")]
@@ -747,16 +746,10 @@ impl Quant {
                 volume: Default::default(),
             });
         }
-        // let bp = self.trade_msg.market[BID_PRICE_INDEX];
-        // let ap = self.trade_msg.market[ASK_PRICE_INDEX];
-        // let mp = (bp + ap) * dec!(0.5);
-        // 更新持仓价值
-        // self.predictor.balance_value = self.trade_msg.cash * mp;
         let ref_price: Vec<Vec<Decimal>> = self.predictor.get_ref_price(&ref_tickers);
-        if ref_price.len() == 0{
-            return;
-        }
         self.trade_msg.ref_price = ref_price;
+        // 更新主动性方向
+        self.trade_msg.side = self.side.clone();
     }
 
     // 本地记录所有报单信息
@@ -1047,15 +1040,14 @@ impl Quant {
                 self.stop().await;
             }
         }
-        if self.strategy.ref_price != Decimal::ZERO {
-            // 定价异常风控
-            if self.ready == 1 && (self.strategy.ref_price - self.strategy.mp).abs() / self.strategy.mp > dec!(0.03) {
-                let exit_msg = format!("{} 定价偏离过大，怀疑定价异常，退出。", self.params.account_name);
-                warn!(exit_msg);
-                warn!(?self.strategy.ref_price, ?self.strategy.mp);
-                self.exit_msg = exit_msg;
-                self.stop().await;
-            }
+
+        // 定价异常风控
+        if self.ready == 1 && (self.strategy.ref_price - self.strategy.mp).abs() / self.strategy.mp > dec!(0.03) {
+            let exit_msg = format!("{} 定价偏离过大，怀疑定价异常，退出。", self.params.account_name);
+            warn!(exit_msg);
+            warn!(?self.strategy.ref_price, ?self.strategy.mp);
+            self.exit_msg = exit_msg;
+            self.stop().await;
         }
     }
 

strategy/src/ring_buffer.rs

@@ -1,141 +0,0 @@
-use std::collections::VecDeque;
-use rust_decimal::{Decimal};
-use tracing::info;
-
-/**
-    环形缓存器
-**/
-#[derive(Debug)]
-pub struct RingBuffer {
-    buffer: VecDeque<Decimal>,
-    length: usize
-}
-
-impl RingBuffer {
-    pub fn new(length: usize) -> Self {
-        RingBuffer {
-            buffer: VecDeque::with_capacity(length),
-            length
-        }
-    }
-
-    // 清空缓存
-    // pub fn dealloc(&mut self){
-    //     self.buffer = VecDeque::with_capacity(self.length);
-    // }
-
-    pub fn process(&self){
-        info!("行情收集进度：{} / {}", self.buffer.len(), self.length);
-    }
-
-    // 添加元素
-    pub fn add_value(&mut self, val: Decimal) {
-        if self.buffer.len() < self.length {
-            self.buffer.push_back(val);
-        } else {
-            self.buffer.pop_front();
-            self.buffer.push_back(val);
-        }
-    }
-
-    pub fn get_buffer_vec(&self) -> Vec<Decimal>{
-        let mut buffer_vec: Vec<Decimal> = Vec::with_capacity(self.buffer.len());
-        buffer_vec.extend(self.buffer.iter().clone());
-        buffer_vec
-    }
-
-    // 获取最后一个元素
-    pub fn get_last_value(&self) -> Option<Decimal> {
-        self.buffer.back().copied()
-    }
-
-    // 是否是空的
-    // pub fn is_empty(&self) -> bool {
-    //     return self.buffer.len() == 0
-    // }
-
-    // 是否已达到最大缓存长度
-    pub fn is_full(&self) -> bool {
-        self.buffer.len() == self.length
-    }
-
-    // 平均值
-    // #[warn(dead_code)]
-    // fn mean_value(&self) -> Decimal {
-    //     if self.is_full() {
-    //         let item_sum: Decimal = self.buffer.iter().sum();
-    //         return item_sum / Decimal::from_usize(self.length).unwrap();
-    //     }
-    //     Decimal::ZERO
-    // }
-    //
-    // // 获取标准差(标准差 = 方差 * 方差)
-    // fn std_dev(&self) -> Decimal {
-    //     self.variance().sqrt().unwrap()
-    // }
-    //
-    // // 获取方差
-    // fn variance(&self) -> Decimal {
-    //     let data_mean = self.mean_value();
-    //     let std_deviation = self.buffer.iter().map(|value| {
-    //         let diff = data_mean - value;
-    //         diff * diff
-    //     }).sum::<Decimal>() / Decimal::from_usize(self.length).unwrap();
-    //     std_deviation
-    // }
-
-    // 获取缓存长度
-    // pub fn len(&self) -> usize {
-    //     self.buffer.len()
-    // }
-    //
-    // // 设置最大缓存长度
-    // pub fn set_length(&mut self, new_length: usize) {
-    //     if new_length < self.length {
-    //         for _ in 0..(self.length - new_length) {
-    //             self.buffer.pop_front();
-    //         }
-    //     }
-    //     self.length = new_length;
-    // }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::collections::VecDeque;
-    use std::str::FromStr;
-    use rust_decimal::{Decimal, MathematicalOps};
-
-    #[test]
-    fn extend_test(){
-        let mut arr: VecDeque<Decimal> = VecDeque::with_capacity(6);
-        let mut extend_arr: VecDeque<Decimal> = VecDeque::with_capacity(6);
-        for i in 0..6 {
-            arr.push_back(Decimal::from(i));
-        }
-        extend_arr.extend(arr.iter().clone());
-        println!("{:?}", arr);
-        println!("{:?}", extend_arr);
-    }
-
-    #[test]
-    fn len_test() {
-        let mut arr: Vec<Decimal> = Vec::from(vec![Decimal::new(1, 0), Decimal::new(2, 0), Decimal::new(3, 0), Decimal::new(4, 0), Decimal::new(5, 0)]);
-        let mut diff_buffer: Vec<Decimal> = arr.windows(2).map(|w| w[1] - w[0]).collect();
-        for item in diff_buffer.iter_mut() {
-            *item = item.powi(2i64);
-        }
-        let len: Decimal = Decimal::from(arr.len());
-        let mut sum: Decimal = diff_buffer.iter().sum();
-        sum /= len;
-        sum = sum.sqrt().unwrap();
-        println!("{:?}", sum);
-    }
-
-    #[test]
-    fn test_calc(){
-        let dk = Decimal::from_str("0.0000000000000000007549486024").unwrap();
-        let e = Decimal::E.powd(dk);
-        println!("{:?}",e);
-    }
-}

strategy/src/strategy.rs

@@ -301,8 +301,9 @@ impl Strategy {
 
         // 参考价格
         if trader_msg.ref_price.len() == 0 {
-            info!("参考价格还未预热完成，等待预热...");
-            return false;
+            self.ref_bp = self.bp;
+            self.ref_ap = self.ap;
+            self.ref_price = self.mp;
         } else {
             self.ref_bp = trader_msg.ref_price[self.ref_index][0];
             self.ref_ap = trader_msg.ref_price[self.ref_index][1];
@@ -481,19 +482,8 @@ impl Strategy {
         let grid = self.grid;
         let mode = self.maker_mode.clone();
 
-        // let mut mp = (ref_bp + ref_ap) * dec!(0.5);
-        // let mut buy_start = ref_bp;
-        // let mut sell_start = ref_ap;
-        // let mut avoid = min(dec!(0.0005), close * dec!(0.5));
-        // let mut close_dist = vec![
-        //     buy_start ,                    // buy upper
-        //     buy_start ,                    // buy lower
-        //     sell_start ,                   // sell lower
-        //     sell_start ,                   // sell upper
-        // ];
-
         // 平仓相关
-        let mp = (ref_bp + ref_ap) * dec!(0.5);
+        let mut mp = (ref_bp + ref_ap) * dec!(0.5);
         let mut buy_start = mp;
         let mut sell_start = mp;
         let mut avoid = min(dec!(0.0005), close * dec!(0.5));
@@ -512,16 +502,14 @@ impl Strategy {
         }
         // 跟随做市模式
         else if mode == "follow".to_string() {
-            // mp = (ref_bp + ref_ap) * dec!(0.5);
-            // buy_start = mp;
-            // sell_start = mp;
-            buy_start = ref_bp;
-            sell_start = ref_ap;
+            mp = (ref_bp + ref_ap) * dec!(0.5);
+            buy_start = mp;
+            sell_start = mp;
         } else {
             error!("未知做市类型：mode={}", mode);
             panic!("未知做市类型：mode={}", mode);
         }
-        // info!(?mode, ?buy_start, ?sell_start, ?mp);
+        // debug!(?mode, ?buy_start, ?sell_start, ?mp);
 
         // 开仓相关
         avoid = min(dec!(0.001), open * dec!(0.05));
@@ -533,21 +521,9 @@ impl Strategy {
             buy_start * (Decimal::ONE + predict - open * buy_shift  - avoid),             // buy lower
             sell_start * (Decimal::ONE + predict + open * sell_shift - avoid),            // sell lower
             sell_start * (Decimal::ONE + predict + open * sell_shift + avoid),            // sell upper
-            // buy_start,
-            // buy_start,
-            // sell_start,
-            // sell_start
         ];
-        // info!(?predict, ?open,  ?buy_shift, ?sell_shift, ?avoid);
+        // debug!(?avoid, ?buy_shift, ?sell_shift, ?avoid, ?open_dist);
 
-
-        // let mut open_dist = vec![
-        //     ref_bp ,             // buy upper
-        //     ref_bp ,             // buy lower
-        //     ref_ap ,            // sell lower
-        //     ref_ap ,            // sell upper
-        // ];
-        // debug!(?open_dist);
         // 修复价格
         for open_price in &mut open_dist {
             *open_price = utils::fix_price(*open_price, self.tick_size);
@@ -557,8 +533,6 @@ impl Strategy {
         }
         self.open_dist = open_dist.clone();
         self.close_dist = close_dist.clone();
-        // info!(?open_dist);
-        // info!(?close_dist);
         // debug!(?open_dist);
         // debug!(?close_dist);
     }
@@ -992,22 +966,9 @@ impl Strategy {
                         price.to_string(),
                         order_client_id.clone()
                     ];
+
                     command.limits_close.insert(order_client_id, order.clone());
 
-                    // 定价止损平仓单
-                    // let mut price_limit = self.pos.long_avg * Decimal::from_str("0.995").unwrap();
-                    // price_limit = utils::fix_price(price_limit, self.tick_size);
-                    //
-                    // let order_client_limit_id = utils::generate_client_id(Some(self.broker_id.clone()));
-                    // let order_limit = vec![
-                    //     self.pos.long_pos.to_string(),
-                    //     "pd".to_string(),
-                    //     price_limit.to_string(),
-                    //     order_client_limit_id.clone()
-                    // ];
-                    //
-                    // command.limits_close.insert(order_client_limit_id, order_limit.clone());
-                    // info!(?command);
                     // debug!(?command);
                 }
             }
@@ -1028,20 +989,6 @@ impl Strategy {
 
                     command.limits_close.insert(order_client_id, order.clone());
 
-                    // 定价止损平仓单
-                    // let mut price_limit = self.pos.short_avg * Decimal::from_str("1.005").unwrap();
-                    // price_limit = utils::fix_price(price_limit, self.tick_size);
-                    //
-                    // let order_client_limit_id = utils::generate_client_id(Some(self.broker_id.clone()));
-                    // let order_limit = vec![
-                    //     self.pos.short_pos.to_string(),
-                    //     "pk".to_string(),
-                    //     price_limit.to_string(),
-                    //     order_client_limit_id.clone()
-                    // ];
-                    //
-                    // command.limits_close.insert(order_client_limit_id, order_limit.clone());
-                    // info!(?command);
                     // debug!(?command);
                 }
             }
@@ -1257,6 +1204,8 @@ impl Strategy {
         if self.is_ready {
             return;
         }
+
+        info!("预热中");
     }
 
     // 在满足条件后，返回非空command，否则返回一个空的command。原文的onTime。

strategy/src/utils.rs

@@ -1,7 +1,7 @@
 use std::ops::{Div, Mul};
 use chrono::Utc;
 use rand::Rng;
-use rust_decimal::{Decimal};
+use rust_decimal::Decimal;
 use tracing::error;
 use global::public_params;