套利模式观察

rust-toolchain

@@ -0,0 +1 @@
+1.81.0

strategy/src/predictor.rs

@@ -347,172 +347,14 @@ impl Predictor {
         let fair_price = a1.price * b1.value / total + b1.price * a1.value / total;
         // let fair_price = (a1.price + b1.price) / Decimal::TWO;
 
-        self.fair_price_vec[index] = if self.fair_price_vec[index].is_zero() {
-            fair_price
-        } else {
-            self.fair_price_vec[index] * dec!(0.5) + fair_price * dec!(0.5)
-        };
+        self.fair_price_vec[index] = fair_price;
         self.fair_price_vec[index].rescale(self.mid_price.scale());
         self.volume_vec[index] = a1.size + b1.size;
 
         // 合成公平价格
         if !self.fair_price_vec[0].is_zero() && !self.fair_price_vec[1].is_zero() {
-            self.price_times_avg = if self.price_times_avg.is_zero() {
-                self.fair_price_vec[1] / self.fair_price_vec[0]
-            } else {
-                self.price_times_avg * dec!(0.9995) + dec!(0.0005) * self.fair_price_vec[1] / self.fair_price_vec[0]
-            };
-
-            // 进行价格归一化处理，公平所的价格有可能是带前缀的
-            // let fair_price_part0 = self.fair_price_vec[0] * dec!(0.2);
-            // let fair_price_part1 = (self.fair_price_vec[1] / self.price_times_avg) * dec!(0.8);
-            self.fair_price = self.fair_price_vec[1] / self.price_times_avg;
-            self.fair_price_time_vec.push_back(self.fair_price);
-            self.fair_price_long_time_vec.push_back(self.fair_price);
-            self.fair_price_ema_long = if self.fair_price_ema_long.is_zero() {
-                self.fair_price
-            } else {
-                self.fair_price_ema_long * dec!(0.67) + self.fair_price * dec!(0.33)
-            };
-            self.fair_price_ema_short = if self.fair_price_ema_short.is_zero() {
-                self.fair_price
-            } else {
-                self.fair_price_ema_short * dec!(0.999) + self.fair_price * dec!(0.001)
-            };
-
-            if self.fair_price_time_vec.len() < 2 {
-                return;
-            }
-
-            let mut rate = Self::get_real_rate(&self.fair_price_time_vec);
-            rate.rescale(8);
-
-            // 重置开仓焦点，条件1
-            if !self.fair_rate_focus_open.is_zero() {
-                if self.fair_rate_focus_open > Decimal::ZERO && self.spread_ema_1000 < Decimal::ZERO {
-                    self.fair_rate_focus_open = Decimal::ZERO;
-                }
-
-                if self.fair_rate_focus_open < Decimal::ZERO && self.spread_ema_1000 > Decimal::ZERO {
-                    self.fair_rate_focus_open = Decimal::ZERO;
-                }
-            }
-            // 重置开仓焦点，条件2
-            if !self.fair_rate_focus_open.is_zero() && !self.inventory.is_zero() {
-                self.fair_rate_focus_open = Decimal::ZERO;
-            }
-            // 重置开仓焦点，条件3
-            if !self.mid_price_focus_open.is_zero() {
-                let focus_rate = (self.mid_price - self.mid_price_focus_open) / self.mid_price_focus_open;
-
-                if self.fair_rate_focus_open > Decimal::ZERO && focus_rate < Decimal::NEGATIVE_ONE * self.params.open_activate / dec!(3) {
-                    self.fair_rate_focus_open = Decimal::ZERO;
-                }
-
-                if self.fair_rate_focus_open < Decimal::ZERO && focus_rate > self.params.open_activate / dec!(3) {
-                    self.fair_rate_focus_open = Decimal::ZERO;
-                }
-            }
-            // 更新程序关注的开仓焦点
-            if self.fair_rate_focus_open.is_zero() && self.inventory.is_zero() {
-                // 只有有强度的rate才有资格被称为针，并且差价够大，
-                if rate.abs() > self.params.open_activate && self.spread.abs() > self.params.min_spread {
-                    // 向上涨，并且fair下穿mid，视为观测阶段开始
-                    if rate > Decimal::ZERO && self.spread < Decimal::ZERO {
-                        self.fair_rate_focus_open = rate;
-                        self.mid_price_focus_open = self.mid_price;
-                    }
-
-                    // 向下跌，并且fair上穿mid，视为观测阶段开始
-                    if rate < Decimal::ZERO && self.spread > Decimal::ZERO {
-                        self.fair_rate_focus_open = rate;
-                        self.mid_price_focus_open = self.mid_price;
-                    }
-                }
-            }
-
-            // ============================ 平仓逻辑处理 =======================
-            // close_rate：
-            //  大于0：当前价格在均线之上
-            //  小于0：当前价格在均线之下
-            let close_rate = rate.clone();
-            // 重置平仓焦点，条件1
-            if !self.fair_rate_focus_close.is_zero() && self.inventory.is_zero() {
-                self.fair_rate_focus_close = Decimal::ZERO;
-            }
-            // 重置平仓焦点，条件2
-            if !self.fair_rate_focus_close.is_zero() && self.fair_rate_focus_close > dec!(-0.1) {
-                let focus_rate = (self.mid_price - self.fair_price_focus_close) / self.fair_price_focus_close;
-
-                if self.fair_rate_focus_close > Decimal::ZERO && focus_rate < Decimal::NEGATIVE_ONE * self.params.close_activate / Decimal::TWO {
-                    self.fair_rate_focus_close = Decimal::ZERO;
-                }
-
-                if self.fair_rate_focus_close < Decimal::ZERO && focus_rate > self.params.close_activate / Decimal::TWO {
-                    self.fair_rate_focus_close = Decimal::ZERO;
-                }
-            }
-            // 更新程序关注的平仓焦点
-            let close_activate = self.params.open_activate;
-            if self.fair_rate_focus_close.is_zero() && !self.inventory.is_zero() && close_rate.abs() > close_activate {
-                // 多单平仓逻辑
-                if self.inventory > Decimal::ZERO && close_rate > Decimal::ZERO {
-                    if self.profit_point > Decimal::ZERO {
-                        self.fair_rate_focus_close = close_rate;
-                        self.fair_price_focus_close = self.mid_price;
-                    } else if self.t_diff.is_zero() {
-                        self.fair_rate_focus_close = close_rate;
-                        self.fair_price_focus_close = self.mid_price;
-                    }
-                }
-
-                // 空单平仓逻辑
-                if self.inventory < Decimal::ZERO && close_rate < Decimal::ZERO {
-                    if self.profit_point > Decimal::ZERO {
-                        self.fair_rate_focus_close = close_rate;
-                        self.fair_price_focus_close = self.fair_price;
-                    } else if self.t_diff.is_zero() {
-                        self.fair_rate_focus_close = close_rate;
-                        self.fair_price_focus_close = self.fair_price;
-                    }
-                }
-            }
-
-            // ============================ 平仓特殊逻辑处理1 =======================
-            // if self.fair_rate_focus_close.is_zero() && !self.inventory.is_zero() && self.profit_point < dec!(-0.01) {
-            //     self.fair_rate_focus_close = dec!(-0.11);
-            //     self.fair_price_focus_close = self.mid_price;
-            //
-            //     // let prev_open_activate = self.params.open_activate;
-            //     // self.params.open_activate = self.params.open_activate * dec!(1.5);
-            //
-            //     info!("----------------------------------------");
-            //     // info!("止损，参数调整：{} -> {}", prev_open_activate, self.params.open_activate);
-            //     info!("硬止损, 在价格{}处，成本价{}，价值={}, p={}。", self.fair_price_focus_close, self.pos_avg_price, self.pos_avg_price*self.pos_amount, self.profit_point);
-            //     info!("----------------------------------------");
-            // }
-            // ============================ 平仓特殊逻辑处理2 =======================
-            if self.fair_rate_focus_close.is_zero() && !self.inventory.is_zero() && self.profit_point_vec.len() > 1 {
-                let prev_profit_point = self.profit_point_vec[self.profit_point_vec.len() - 2];
-                let profit_point = self.profit_point_vec[self.profit_point_vec.len() - 1];
-
-                if (prev_profit_point >= Decimal::ZERO && profit_point < Decimal::ZERO) || (prev_profit_point > Decimal::ZERO && profit_point <= Decimal::ZERO) {
-                    self.fair_rate_focus_close = dec!(-0.12);
-                    self.fair_price_focus_close = self.mid_price;
-
-                    info!("----------------------------------------");
-                    info!("止损逻辑2, 在价格{}处，成本价{}，价值={}, p={}。", self.fair_price_focus_close, self.pos_avg_price, self.pos_avg_price*self.pos_amount, self.profit_point);
-                    info!("----------------------------------------");
-                }
-            }
+            self.fair_price = self.fair_price_vec[1];
         }
-
-        // // 判断价格是否回归
-        // if !self.is_regressed && self.inventory > Decimal::ZERO && self.spread_sma_1000 < max(self.spread_sma, self.spread_sma_2000) {
-        //     self.is_regressed = true
-        // } else if !self.is_regressed && self.inventory < Decimal::ZERO && self.spread_sma_1000 > min(self.spread_sma, self.spread_sma_2000) {
-        //     self.is_regressed = true
-        // }
     }
 
     pub fn update_spread(&mut self) {
@@ -546,45 +388,22 @@ impl Predictor {
             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));
+        let is_open_long = self.inventory.is_zero();
+        let is_open_short = self.inventory.is_zero();
+        let is_close_long = self.inventory > Decimal::ZERO;
+        let is_close_short = self.inventory < Decimal::ZERO;
 
         self.bid_delta = dec!(-2);
         self.ask_delta = dec!(-2);
 
         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;
         } 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;
         }
     }

strategy/src/strategy.rs

@@ -1095,7 +1095,7 @@ impl Strategy {
 
         self._cancel_open(&mut command, local_orders, predictor);   // 撤单命令处理
         self._post_close(&mut command, local_orders, predictor);    // 平仓单命令处理
-        self._post_open(&mut command, local_orders, predictor);     // 限价单命令处理
+        // self._post_open(&mut command, local_orders, predictor);     // 限价单命令处理
         self._check_local_orders(&mut command, local_orders);       // 固定时间检查超时订单
         self._update_in_cancel(&mut command, local_orders);         // 更新撤单队列，是一个filter
         self._check_request_limit(&mut command);                    // 限制频率，移除不合规则之订单，是一个filter