走吧，上线试试

standard/src/bitget_swap.rs

@@ -487,6 +487,11 @@ impl Platform for BitgetSwap {
         }
 
         let res_data_json = res_data.data;
+
+        if res_data_json["orderId"].is_null() {
+            return Err(Error::new(ErrorKind::Other, res_data_json.to_string()));
+        }
+
         let result = Order {
             id: res_data_json["orderId"].as_str().unwrap().to_string(),
             custom_id: res_data_json["clientOid"].as_str().unwrap().to_string(),

strategy/src/predictor.rs

@@ -39,6 +39,8 @@ pub struct Predictor {
     pub pos_amount: Decimal,                                                    // 原始持仓量
     pub pos_avg_price: Decimal,                                                 // 原始持仓价格
 
+    pub signal: Decimal,                                                        // 大于0代表此时是正向信号，小于0则相反
+
     pub money_flow: Decimal,                                                    // 资金流
 
     pub ask_delta: Decimal,                                                     // δa
@@ -168,7 +170,10 @@ impl Predictor {
             prev_trade_time: Utc::now().timestamp_micros(),
             t_diff: Default::default(),
             pos_amount: Default::default(),
+
             money_flow: Default::default(),
+            signal: Default::default(),
+
             profit_point: Default::default(),
             profit_point_ema: Default::default(),
             last_update_time: Default::default(),
@@ -325,7 +330,7 @@ impl Predictor {
         self.fair_price_std_vec[index] = self.fair_price_vec[index] / self.price_avg_times_vec[index];
 
         // 开仓信号处理
-        let mut signal = Decimal::ZERO;
+        self.signal = Decimal::ZERO;
         for (i, fair_price_std) in self.fair_price_std_vec.iter().enumerate() {
             if fair_price_std.is_zero() {
                 return;
@@ -334,54 +339,28 @@ impl Predictor {
             self.spread_vec[i] = fair_price_std - self.mid_price;
 
             if self.spread_vec[i] > self.params.min_spread {
-                signal = signal + Decimal::ONE;
+                self.signal = self.signal + Decimal::ONE;
             }
             if self.spread_vec[i] < -self.params.min_spread {
-                signal = signal - Decimal::ONE;
+                self.signal = self.signal - Decimal::ONE;
             }
         }
 
-        // 重置开仓焦点，条件1
-        if !self.fair_rate_focus_open.is_zero() && !self.inventory.is_zero() {
-            self.fair_rate_focus_open = Decimal::ZERO;
-        }
-        // 重置开仓焦点，条件2
-        if !self.fair_rate_focus_open.is_zero() && signal.abs() < Decimal::from(self.params.ref_exchange.len()) {
-            self.fair_rate_focus_open = Decimal::ZERO;
-        }
         // 更新程序关注的开仓焦点
         if self.fair_rate_focus_open.is_zero() && self.inventory.is_zero() {
             // 只有有强度的rate才有资格被称为针，并且差价够大，
-            if signal.abs() == Decimal::from(self.params.ref_exchange.len()) {
-                if signal > Decimal::ZERO {
+            if self.signal.abs() == Decimal::from(self.params.ref_exchange.len()) {
+                if self.signal > Decimal::ZERO {
                     self.fair_rate_focus_open = dec!(0.01);
                     self.mid_price_focus_open = self.mid_price;
                 }
 
-                if signal < Decimal::ZERO {
+                if self.signal < Decimal::ZERO {
                     self.fair_rate_focus_open = dec!(-0.01);
                     self.mid_price_focus_open = self.mid_price;
                 }
             }
         }
-
-        // ============================ 平仓逻辑处理 =======================
-        // 重置平仓焦点，条件1
-        if !self.fair_rate_focus_close.is_zero() && self.inventory.is_zero() {
-            self.fair_rate_focus_close = Decimal::ZERO;
-        }
-        // 更新程序关注的平仓焦点
-        if self.fair_rate_focus_close.is_zero() && !self.inventory.is_zero() {
-            if self.inventory > Decimal::ZERO {
-                self.fair_rate_focus_close = dec!(0.01);
-                self.mid_price_focus_close = self.mid_price;
-            }
-
-            if self.inventory < Decimal::ZERO {
-                self.fair_rate_focus_close = dec!(-0.01);
-                self.mid_price_focus_close = self.mid_price;
-            }
-        }
     }
 
     pub fn update_spread(&mut self) {
@@ -407,55 +386,55 @@ impl Predictor {
     }
 
     pub fn update_delta(&mut self) {
-        // -2表示不想成交
-        // -1表示市价成交(委托对手盘的价格，但不一定能市价成交)，这里再想想吧，经常委托出去没成交，明显比别人慢了
-        // 0是买一/卖一成交
-
         if self.mid_price.is_zero() {
             return;
         }
 
-        // 可能是趋势
-        // let is_open_long = self.spread_sma_1000 - self.spread_sma > self.params.open && self.fair_price > self.mid_price;
-        // let is_open_short = self.spread_sma_1000 - self.spread_sma < self.params.open * Decimal::NEGATIVE_ONE && self.fair_price < self.mid_price;
-        // 可能是接针
-        let is_open_long = self.fair_rate_focus_open > Decimal::ZERO;
-        let is_open_short = self.fair_rate_focus_open < Decimal::ZERO;
-        let is_close_long = self.inventory > Decimal::ZERO && (self.fair_rate_focus_close > Decimal::ZERO || self.fair_rate_focus_close < dec!(-0.1));
-        let is_close_short = self.inventory < Decimal::ZERO && (self.fair_rate_focus_close < Decimal::ZERO || self.fair_rate_focus_close < dec!(-0.1));
+        for fair_price in &self.fair_price_vec {
+            if fair_price.is_zero() {
+                return;
+            }
+        }
 
-        self.bid_delta = dec!(-2);
-        self.ask_delta = dec!(-2);
+        let is_close_long = self.inventory > Decimal::ZERO;
+        let is_close_short = self.inventory < Decimal::ZERO;
 
         if is_close_long {
-            // let close_rate = (self.error_rate / dec!(0.5)) * self.params.close;
-            //
-            // self.ask_delta = self.mid_price * close_rate;
-            self.ask_delta = self.mid_price * self.params.close;
+            self.ask_delta = dec!(0);
+            self.bid_delta = dec!(-2);
+
+            self.optimal_ask_price = self.mid_price + self.mid_price * self.params.close;
+            self.optimal_bid_price = Self::DONT_VIEW;
         } else if is_close_short {
-            // let close_rate = (self.error_rate / dec!(0.5)) * self.params.close;
-            //
-            // self.bid_delta = self.mid_price * close_rate;
-            self.bid_delta = self.mid_price * self.params.close;
-        } else if is_open_long {
-            // let is_open_long_market = self.spread_sma_1000 - self.spread_sma > self.params.open_market;
-            // self.bid_delta = if is_open_long_market {
-            //     dec!(-1)
-            // } else {
-            //     dec!(0)
-            // };
-
-            self.bid_delta = self.params.open * self.mid_price;
-        } else if is_open_short {
-            // let is_open_short_market = self.spread_sma_1000 - self.spread_sma < self.params.open_market * Decimal::NEGATIVE_ONE;
-            // self.ask_delta = if is_open_short_market {
-            //     dec!(-1)
-            // } else {
-            //     dec!(0)
-            // }
-
-            self.ask_delta = self.params.open * self.mid_price;
+            self.bid_delta = dec!(0);
+            self.ask_delta = dec!(-2);
+
+            self.optimal_bid_price = self.mid_price - self.mid_price * self.params.close;
+            self.optimal_ask_price = Self::DONT_VIEW;
+        } else {
+            if self.signal > Decimal::ZERO {
+                self.bid_delta = dec!(0);
+                self.ask_delta = dec!(-2);
+
+                self.optimal_bid_price = self.mid_price - self.mid_price * self.params.open;
+                self.optimal_ask_price = Self::DONT_VIEW;
+            } else if self.signal < Decimal::ZERO {
+                self.ask_delta = dec!(0);
+                self.bid_delta = dec!(-2);
+
+                self.optimal_ask_price = self.mid_price + self.mid_price * self.params.open;
+                self.optimal_bid_price = Self::DONT_VIEW;
+            } else {
+                self.bid_delta = dec!(0);
+                self.ask_delta = dec!(0);
+
+                self.optimal_bid_price = self.mid_price - self.mid_price * self.params.open;
+                self.optimal_ask_price = self.mid_price + self.mid_price * self.params.open;
+            }
         }
+
+        self.optimal_ask_price.rescale(self.mid_price.scale());
+        self.optimal_bid_price.rescale(self.mid_price.scale());
     }
 
     pub fn update_optimal_ask_and_bid(&mut self) {
@@ -543,10 +522,10 @@ impl Predictor {
         let mid_price = self.mid_price;
         let ask_price = self.fair_price_std_vec[0];
         let bid_price = self.fair_price_std_vec[1];
+        let optimal_ask_price = self.optimal_ask_price;
+        let optimal_bid_price = self.optimal_bid_price;
         let last_price = Self::DONT_VIEW;
         let fair_price = Self::DONT_VIEW;
-        let optimal_ask_price = Self::DONT_VIEW;
-        let optimal_bid_price = Self::DONT_VIEW;
 
         let spread = Self::DONT_VIEW;
         let spread_min = self.spread_vec[0];
@@ -564,7 +543,7 @@ impl Predictor {
         };
         // let sigma_square = self.error_rate;
 
-        let gamma = self.fair_rate_focus_open;
+        let gamma = self.signal;
         let kappa = self.fair_rate_focus_close;
 
         let flow_ratio = Decimal::ZERO;

strategy/src/strategy.rs

@@ -98,7 +98,6 @@ pub struct Strategy {
     pub ref_index: usize,                                           //
     pub predict: Decimal,                                           //
     pub predict_alpha: Decimal,                                     //
-    pub post_side: i64,                                             // 交易方向
     pub trade_vol_24h_w: Decimal,                                   // 24小时成交额（单位：万）
     pub grid: Decimal,                                              // 网格数量
 }
@@ -189,7 +188,6 @@ impl Strategy {
             ref_index: 0,
             predict: Default::default(),
             predict_alpha: Default::default(),
-            post_side: 0,
             trade_vol_24h_w: Default::default(),
             grid: Decimal::from(params.grid),
         };
@@ -985,7 +983,7 @@ impl Strategy {
         let one_hand_long_value = dec!(0.97) * (self.max_long_value / self.grid);
         let one_hand_short_value = dec!(0.97) * (self.max_short_value / self.grid);
         // 挂多单
-        if self.post_side >= 0 && buy_value == Decimal::ZERO && predictor.inventory.is_zero() && predictor.bid_delta != dec!(-2) {
+        if buy_value == Decimal::ZERO && predictor.inventory.is_zero() && predictor.bid_delta != dec!(-2) {
             let mut target_buy_price = predictor.optimal_bid_price;
             // target_buy_price = utils::clip(target_buy_price, self.bp * dec!(0.97), self.ap * dec!(1.0005));
             target_buy_price = utils::fix_price(target_buy_price, self.tick_size);
@@ -1016,7 +1014,7 @@ impl Strategy {
             }
         }
         // 挂空单
-        if self.post_side <= 0 && sell_value == Decimal::ZERO && predictor.inventory.is_zero() && predictor.ask_delta != dec!(-2) {
+        if sell_value == Decimal::ZERO && predictor.inventory.is_zero() && predictor.ask_delta != dec!(-2) {
             let mut target_sell_price = predictor.optimal_ask_price;
             // target_sell_price = utils::clip(target_sell_price, self.bp * dec!(0.9995), self.ap * dec!(1.03));
             // 取消大小限制