完成1版，可运行

standard/src/binance_swap.rs

@@ -156,7 +156,9 @@ impl Platform for BinanceSwap {
                 high: Decimal::from_str(res_data_json["askPrice"].as_str().unwrap()).unwrap(),
                 low: Decimal::from_str(res_data_json["bidPrice"].as_str().unwrap()).unwrap(),
                 sell: Decimal::from_str(res_data_json["askPrice"].as_str().unwrap()).unwrap(),
+                sell_volume: Default::default(),
                 buy: Decimal::from_str(res_data_json["bidPrice"].as_str().unwrap()).unwrap(),
+                buy_volume: Default::default(),
                 last: dec!(-1),
                 volume: dec!(-1),
             };
@@ -176,7 +178,9 @@ impl Platform for BinanceSwap {
                 high: Decimal::from_str(res_data_json["askPrice"].as_str().unwrap()).unwrap(),
                 low: Decimal::from_str(res_data_json["bidPrice"].as_str().unwrap()).unwrap(),
                 sell: Decimal::from_str(res_data_json["askPrice"].as_str().unwrap()).unwrap(),
+                sell_volume: Default::default(),
                 buy: Decimal::from_str(res_data_json["bidPrice"].as_str().unwrap()).unwrap(),
+                buy_volume: Default::default(),
                 last: dec!(-1),
                 volume: dec!(-1),
             };

standard/src/bitget_swap.rs

@@ -223,7 +223,9 @@ impl Platform for BitgetSwap {
                 high: Decimal::from_str(ticker_info["high24h"].as_str().unwrap()).unwrap(),
                 low: Decimal::from_str(ticker_info["low24h"].as_str().unwrap()).unwrap(),
                 sell: Decimal::from_str(ticker_info["askPr"].as_str().unwrap()).unwrap(),
+                sell_volume: Default::default(),
                 buy: Decimal::from_str(ticker_info["bidPr"].as_str().unwrap()).unwrap(),
+                buy_volume: Default::default(),
                 last: Decimal::from_str(ticker_info["lastPr"].as_str().unwrap()).unwrap(),
                 volume: Decimal::from_str(ticker_info["quoteVolume"].as_str().unwrap()).unwrap(),
             };

standard/src/bybit_swap.rs

@@ -187,7 +187,9 @@ impl Platform for BybitSwap {
                 high: value.high_price24h,
                 low: value.low_price24h,
                 sell: value.ask1_price,
+                sell_volume: Default::default(),
                 buy: value.bid1_price,
+                buy_volume: Default::default(),
                 last: value.last_price,
                 volume: value.volume24h
             })
@@ -214,7 +216,9 @@ impl Platform for BybitSwap {
                         high: value.high_price24h,
                         low: value.low_price24h,
                         sell: value.ask1_price,
+                        sell_volume: Default::default(),
                         buy: value.bid1_price,
+                        buy_volume: Default::default(),
                         last: value.last_price,
                         volume: value.volume24h
                     };

standard/src/coinex_swap.rs

@@ -186,7 +186,9 @@ impl Platform for CoinexSwap {
                         high: Decimal::from_str(value["high"].as_str().unwrap()).unwrap(),
                         low: Decimal::from_str(value["low"].as_str().unwrap()).unwrap(),
                         sell: Decimal::from_str(value["last"].as_str().unwrap()).unwrap(),
+                        sell_volume: Default::default(),
                         buy: Decimal::from_str(value["last"].as_str().unwrap()).unwrap(),
+                        buy_volume: Default::default(),
                         last: Decimal::from_str(value["last"].as_str().unwrap()).unwrap(),
                         volume: Decimal::from_str(value["volume"].as_str().unwrap()).unwrap(),
                     };
@@ -215,7 +217,9 @@ impl Platform for CoinexSwap {
                         high: Decimal::from_str(value["high"].as_str().unwrap()).unwrap(),
                         low: Decimal::from_str(value["low"].as_str().unwrap()).unwrap(),
                         sell: Decimal::from_str(value["last"].as_str().unwrap()).unwrap(),
+                        sell_volume: Default::default(),
                         buy: Decimal::from_str(value["last"].as_str().unwrap()).unwrap(),
+                        buy_volume: Default::default(),
                         last: Decimal::from_str(value["last"].as_str().unwrap()).unwrap(),
                         volume: Decimal::from_str(value["volume"].as_str().unwrap()).unwrap(),
                     };

standard/src/gate_swap.rs

@@ -169,7 +169,9 @@ impl Platform for GateSwap {
                         high: Decimal::from_str(value["high_24h"].as_str().unwrap()).unwrap(),
                         low: Decimal::from_str(value["low_24h"].as_str().unwrap()).unwrap(),
                         sell: Decimal::from_str(value["lowest_ask"].as_str().unwrap()).unwrap(),
+                        sell_volume: Default::default(),
                         buy: Decimal::from_str(value["highest_bid"].as_str().unwrap()).unwrap(),
+                        buy_volume: Default::default(),
                         last: Decimal::from_str(value["last"].as_str().unwrap()).unwrap(),
                         volume: Decimal::from_str(value["volume_24h"].as_str().unwrap()).unwrap(),
                     };
@@ -199,7 +201,9 @@ impl Platform for GateSwap {
                         high: Decimal::from_str(value["high_24h"].as_str().unwrap()).unwrap(),
                         low: Decimal::from_str(value["low_24h"].as_str().unwrap()).unwrap(),
                         sell: Decimal::from_str(value["lowest_ask"].as_str().unwrap()).unwrap(),
+                        sell_volume: Default::default(),
                         buy: Decimal::from_str(value["highest_bid"].as_str().unwrap()).unwrap(),
+                        buy_volume: Default::default(),
                         last: Decimal::from_str(value["last"].as_str().unwrap()).unwrap(),
                         volume: Decimal::from_str(value["volume_24h"].as_str().unwrap()).unwrap(),
                     };

standard/src/gate_swap_handle.rs

@@ -130,6 +130,7 @@ pub fn handle_book_ticker(res_data: &ResponseData) -> SpecialDepth {
     let create_at = (*res_data).data["t"].as_i64().unwrap() * 1000;
 
     let ticker_info = SpecialTicker { sell: ap, buy: bp, mid_price: mp, t, create_at };
+    // 最佳买方的价格, 最佳买方的数量, 最佳卖方的价格, 最佳卖方的数量        
     let depth_info = vec![bp, bq, ap, aq];
 
     SpecialDepth {

standard/src/htx_swap.rs

@@ -197,7 +197,9 @@ impl Platform for HtxSwap {
             high: Decimal::from_str(ticker_info["high"].as_str().unwrap()).unwrap(),
             low: Decimal::from_str(ticker_info["low"].as_str().unwrap()).unwrap(),
             sell: Decimal::from_f64(ticker_info["bid"][0].as_f64().unwrap()).unwrap(),
+            sell_volume: Default::default(),
             buy: Decimal::from_f64(ticker_info["ask"][0].as_f64().unwrap()).unwrap(),
+            buy_volume: Default::default(),
             last: Decimal::from_str(ticker_info["close"].as_str().unwrap()).unwrap(),
             volume: Decimal::from_str(ticker_info["amount"].as_str().unwrap()).unwrap(),
         };

standard/src/kucoin_swap.rs

@@ -161,7 +161,9 @@ impl Platform for KucoinSwap {
                 high: Decimal::from_str(ticker_info["bestAskPrice"].as_str().unwrap()).unwrap(),
                 low: Decimal::from_str(ticker_info["bestBidPrice"].as_str().unwrap()).unwrap(),
                 sell: Decimal::from_str(ticker_info["bestAskPrice"].as_str().unwrap()).unwrap(),
+                sell_volume: Default::default(),
                 buy: Decimal::from_str(ticker_info["bestBidPrice"].as_str().unwrap()).unwrap(),
+                buy_volume: Default::default(),
                 last: Decimal::from_str(ticker_info["price"].as_str().unwrap()).unwrap(),
                 volume: Decimal::from_str(&ticker_info["size"].to_string()).unwrap(),
             };
@@ -184,7 +186,9 @@ impl Platform for KucoinSwap {
                 high: Decimal::from_str(ticker_info["bestAskPrice"].as_str().unwrap()).unwrap(),
                 low: Decimal::from_str(ticker_info["bestBidPrice"].as_str().unwrap()).unwrap(),
                 sell: Decimal::from_str(ticker_info["bestAskPrice"].as_str().unwrap()).unwrap(),
+                sell_volume: Default::default(),
                 buy: Decimal::from_str(ticker_info["bestBidPrice"].as_str().unwrap()).unwrap(),
+                buy_volume: Default::default(),
                 last: Decimal::from_str(ticker_info["price"].as_str().unwrap()).unwrap(),
                 volume: Decimal::from_str(&ticker_info["size"].to_string()).unwrap(),
             };

standard/src/lib.rs

@@ -321,7 +321,9 @@ pub struct Ticker {
     pub high: Decimal,
     pub low: Decimal,
     pub sell: Decimal,
+    pub sell_volume: Decimal,
     pub buy: Decimal,
+    pub buy_volume: Decimal,
     pub last: Decimal,
     pub volume: Decimal,
 }
@@ -333,7 +335,9 @@ impl Ticker {
             high: Default::default(),
             low: Default::default(),
             sell: Default::default(),
+            sell_volume: Default::default(),
             buy: Default::default(),
+            buy_volume: Default::default(),
             last: Default::default(),
             volume: Default::default(),
         }

strategy/src/core.rs

@@ -891,14 +891,21 @@ impl Core {
         // 更新 ref
         let mut ref_tickers: BTreeMap<String, Ticker> = BTreeMap::new();
         for i in &self.ref_name {
-            let bp = self.tickers.get(i).unwrap().buy;
-            let ap = self.tickers.get(i).unwrap().sell;
+            // 最佳买方的价格, 最佳买方的数量, 最佳卖方的价格, 最佳卖方的数量 
+            let bp = self.depths.get(i).unwrap().get(0).unwrap().clone();
+            let bv = self.depths.get(i).unwrap().get(1).unwrap().clone();
+            let ap = self.depths.get(i).unwrap().get(2).unwrap().clone();
+            let av = self.depths.get(i).unwrap().get(3).unwrap().clone();
+            // let bp = self.tickers.get(i).unwrap().buy;
+            // let ap = self.tickers.get(i).unwrap().sell;
             ref_tickers.insert(i.clone(), Ticker {
                 time: 0,
                 high: Default::default(),
                 low: Default::default(),
                 sell: ap,
+                sell_volume: av,
                 buy: bp,
+                buy_volume: bv,
                 last: Default::default(),
                 volume: Default::default(),
             });

strategy/src/predictor.rs

@@ -50,8 +50,8 @@ impl Predictor {
     // #[instrument(skip(self), level="TRACE")]
     fn processor(&mut self) {
         let last_market_info = self.market_info_list.last().unwrap();
-
-        // 更新mid_price
+        // [bp, bv, ap, av, max_price, min_price, bp1, bv1, ap1, av1, max_price1, min_price1......]
+        // 更新交易交易所的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);
@@ -129,7 +129,7 @@ impl Predictor {
         (*self).check_length();
     }
 
-    // 获取预定价格, 也就是python的Get_ref函数
+    // 获取预定价格, 也就是python的Get_ref函数（self.alpha[ref_index] 始终是1）
     // #[instrument(skip(self, ref_ticker_map), level="TRACE")]
     pub fn get_ref_price(&mut self, ref_ticker_map: &BTreeMap<String, Ticker>) -> Vec<Vec<Decimal>> {
         let mut ref_price_list = vec![];
@@ -140,13 +140,18 @@ impl Predictor {
             let ticker = ref_ticker_map.get(ref_exchange).unwrap();
             let bid_price = ticker.buy;
             let ask_price = ticker.sell;
-            let ref_bid_price = bid_price * self.alpha[ref_index] - self.avg_spread_list[ref_index];
-            let ref_ask_price = ask_price * self.alpha[ref_index] - self.avg_spread_list[ref_index];
-
-            ref_price_list.push(vec![ref_bid_price, ref_ask_price]);
+            let bid_volume = ticker.buy_volume;
+            let ask_volume = ticker.sell_volume;
+            // let ref_bid_price = bid_price * self.alpha[ref_index] - self.avg_spread_list[ref_index];
+            // let ref_ask_price = ask_price * self.alpha[ref_index] - self.avg_spread_list[ref_index];
+
+            let ref_bid_price = bid_price;
+            let ref_ask_price = ask_price;
+            // 买价bp（0），卖价ap（1），买量bv（2），卖量av（3）
+            ref_price_list.push(vec![ref_bid_price, ref_ask_price, bid_volume, ask_volume]);
         }
 
-        return ref_price_list;
+        ref_price_list
     }
 }
 
@@ -198,7 +203,9 @@ mod tests {
             high: Default::default(),
             low: Default::default(),
             sell: dec!(0.93),
+            sell_volume: Default::default(),
             buy: dec!(0.92),
+            buy_volume: Default::default(),
             last: Default::default(),
             volume: Default::default(),
         });

strategy/src/strategy.rs

@@ -310,7 +310,11 @@ impl Strategy {
         } else {
             self.ref_bp = ref_price[self.ref_index][0];
             self.ref_ap = ref_price[self.ref_index][1];
-            self.ref_price = (self.ref_bp + self.ref_ap) * dec!(0.5);
+            let bv = ref_price[self.ref_index][2];
+            let av = ref_price[self.ref_index][3];
+            // 微价格（加权中间价）作为基价 S = (ap*bv+bp*av)/(av+bv)
+            self.ref_price = (self.ref_ap * bv + self.ref_bp * av) / (av + bv);
+            // self.ref_price = (self.ref_bp + self.ref_ap) * dec!(0.5);
         }
         // debug!(?self.ref_bp, ?self.ref_ap, %self.ref_price);
 
@@ -475,23 +479,32 @@ impl Strategy {
     // #[instrument(skip(self), level="TRACE")]
     pub fn generate_dist(&mut self) {
         let open = self.trade_open_dist;
-        let close = self.trade_close_dist;
+        // let close = self.trade_close_dist;
         let pos_rate = vec![self.long_hold_rate, self.short_hold_rate];
         let ref_bp = self.ref_bp;
         let ref_ap = self.ref_ap;
-        let predict = self.predict;
+        // let predict = self.predict;
         let grid = self.grid;
 
         // 平仓相关
-        let mut mp = (ref_bp + ref_ap) * dec!(0.5);
+        // let mut mp = (ref_bp + ref_ap) * dec!(0.5);
+        // 使用微价格 如果微价格偏向卖价，可能表示卖压增加，价格可能走低；偏向买价，可能表示买压增加，价格可能走高。
+        let mut mp = self.ref_price;
         let mut buy_start = mp;
         let mut sell_start = mp;
-        let mut avoid = min(dec!(0.0005), close * dec!(0.5));
+        // let mut avoid = min(dec!(0.0005), close * dec!(0.5));
+        // 最终发送订单时，价格是 upper和lower的中间值，所以 + - avoid无用
+        // self.close_dist = vec![
+        //     buy_start * (Decimal::ONE + predict - close + avoid),                    // buy upper
+        //     buy_start * (Decimal::ONE + predict - close - avoid),                    // buy lower
+        //     sell_start * (Decimal::ONE + predict + close - avoid),                   // sell lower
+        //     sell_start * (Decimal::ONE + predict + close + avoid),                   // sell upper
+        // ];
         self.close_dist = vec![
-            buy_start * (Decimal::ONE + predict - close + avoid),                    // buy upper
-            buy_start * (Decimal::ONE + predict - close - avoid),                    // buy lower
-            sell_start * (Decimal::ONE + predict + close - avoid),                   // sell lower
-            sell_start * (Decimal::ONE + predict + close + avoid),                   // sell upper
+            buy_start,                    // buy upper
+            buy_start,                    // buy lower
+            sell_start,                   // sell lower
+            sell_start,                   // sell upper
         ];
         // debug!(?mp, ?buy_start, ?sell_start, ?avoid, ?close_dist);
 
@@ -512,15 +525,16 @@ impl Strategy {
         // debug!(?mode, ?buy_start, ?sell_start, ?mp);
 
         // 开仓相关
-        avoid = min(dec!(0.002), open * dec!(0.1));
-        // 持仓偏移
+        // avoid = min(dec!(0.002), open * dec!(0.1));
+        // 持仓偏移（有网格时生效）(有持多单时，开仓价格向上偏移；持空单时，开仓价格向下偏移)  grid = 1（网格数量)
         let buy_shift = Decimal::ONE + pos_rate[0] * grid;
         let sell_shift = Decimal::ONE + pos_rate[1] * grid;
+        // 最终发送订单时，价格是 upper和lower的中间值，所以 + - avoid无用
         self.open_dist = vec![
-            buy_start * (Decimal::ONE + predict - open * buy_shift  + avoid),             // buy upper
-            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 * (Decimal::ONE  - open * buy_shift),            // buy upper
+            buy_start * (Decimal::ONE  - open * buy_shift),             // buy lower
+            sell_start * (Decimal::ONE + open * sell_shift),            // sell lower
+            sell_start * (Decimal::ONE + open * sell_shift),            // sell upper
         ];
         // debug!(?avoid, ?buy_shift, ?sell_shift, ?avoid, ?open_dist);