分批建仓v1

global/src/params.rs

@@ -1,7 +1,6 @@
 use std::fs::File;
 use std::io::Read;
 use rust_decimal::Decimal;
-use rust_decimal::prelude::ToPrimitive;
 use rust_decimal_macros::dec;
 use toml::from_str;
 use serde_derive::Deserialize;
@@ -46,7 +45,7 @@ pub struct Params {
     // 平滑系数 默认0.999
     pub gamma: Decimal,
     // 分批建仓功能 小资金建议1 大资金建议3 默认 1
-    pub grid: i8,
+    pub grid: Decimal,
     // 平仓难度, [easy, normal, hard]
     pub close_difficulty: String,
     // 是否启用colocation技术, 1开启，0关闭 默认0
@@ -97,7 +96,7 @@ impl Params {
             ref_pair: vec![json_value["ref_pair"].as_str().unwrap().to_string()],                           // 兼容新版本与老版本
             stop_loss: Decimal::try_from(json_value["stop_loss"].as_f64().unwrap_or_default()).unwrap(),
             hold_coin: Decimal::ZERO,
-            grid: json_value["grid"].as_i64().unwrap().to_i8().unwrap(),
+            grid: Decimal::try_from(json_value["grid"].as_f64().unwrap_or_default()).unwrap(),
             close_difficulty: json_value["close_difficulty"].as_str().unwrap().to_string(),
             colo: 0,
             interval: 100,

src/main.rs

@@ -8,6 +8,7 @@ use std::sync::Arc;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::time::Duration;
 use backtrace::Backtrace;
+use rust_decimal::Decimal;
 use tokio::sync::Mutex;
 use tracing::{error, info, warn};
 use tracing_appender_timezone::non_blocking::WorkerGuard;
@@ -129,6 +130,10 @@ async fn main() {
         _guard = log_level_init(params.log_level.clone(), params.port.clone());
     }
 
+    if params.grid < Decimal::ONE {
+        info!("分批建仓要大于0。你的值：{}。", params.grid);
+    }
+
     info!("--------------------------------程序开始执行-----------------------------");
     info!("配置读取成功：{:?}。", params);
     // 主进程控制

strategy/src/core.rs

@@ -661,15 +661,6 @@ impl Core {
                 spawn(async move {
                     platform_rest_fb.command_order(&mut orders, &mut ts).await;
                 });
-
-                // 更新账户余额
-                {
-                    let mut now_balance = (self.local_cash + self.local_coin * self.predictor.mid_price) / self.used_pct;
-                    now_balance.rescale(4);
-
-                    let mut cci = self.cci_arc.lock().await;
-                    cci.now_balance = now_balance;
-                }
             }
         }
 
@@ -681,9 +672,15 @@ impl Core {
             let mut now_price = self.strategy.mp;
             now_price.rescale(8);
 
+            let mut now_balance = (self.local_cash + self.local_coin * self.predictor.mid_price) / self.used_pct;
+            now_balance.rescale(4);
+
             let mut cci = self.cci_arc.lock().await;
             cci.unrealized_pn_l = unrealized_pn_l;
             cci.now_price = now_price;
+            cci.now_balance = now_balance;
+
+            self.predictor.on_balance(now_balance).await;
         }
     }
 
@@ -873,6 +870,7 @@ impl Core {
             return;
         }
         self.local_cash = data.balance * self.used_pct;
+        self.predictor.on_balance(self.local_cash).await;
     }
 
     // #[instrument(skip(self), level="TRACE")]
@@ -1560,6 +1558,7 @@ impl Core {
         // 初始化调度器
         self.local_cash = start_cash;
         self.local_coin = start_coin;
+        self.predictor.on_balance(self.local_cash).await;
 
         // 买入平台币
         if self.exchange.contains("spot") { // 现货

strategy/src/predictor.rs

@@ -49,15 +49,19 @@ pub struct Predictor {
     pub fair_price: Decimal,                                                    // 公平价格
     pub fair_price_ema_short: Decimal,                                          // 公平价格_ema
     pub fair_price_ema_long: Decimal,                                           // 公平价格_ema
-    pub mid_rate_focus_open: Decimal,                                          // 变化幅度焦点
+    pub mid_rate_focus_open: Decimal,                                           // 变化幅度焦点
     pub mid_price_focus_open: Decimal,                                          // 观测焦点时的价格
-    pub mid_rate_focus_close: Decimal,                                         // 变化幅度焦点
+    pub mid_rate_focus_close: Decimal,                                          // 变化幅度焦点
     pub fair_price_focus_close: Decimal,                                        // 观测焦点时的价格
     pub fair_price_when_ordering: Decimal,                                      // 下单时的公平价格
     pub price_times_avg: Decimal,                                               // 公平所与做市所的价格倍率的平均值
 
     pub is_ready: bool,                                                         // 是否已准备好
 
+    pub balance: Decimal,                                                       // 当前资金
+    pub one_grid_order_value: Decimal,                                          // 每一网格下单价值
+    pub prev_trade_force_order_value: Decimal,                                        // 上次下单时的爆仓价值ln
+
     pub prev_trade_time: i64,                                                   // 上次交易时间，也就是t
     pub t_diff: Decimal,                                                        // (T-t)
 
@@ -164,6 +168,9 @@ impl Predictor {
             price_times_avg: Default::default(),
 
             is_ready: false,
+            balance: Default::default(),
+            one_grid_order_value: Default::default(),
+            prev_trade_force_order_value: Default::default(),
             prev_trade_time: Utc::now().timestamp_micros(),
             t_diff: Default::default(),
             level: Default::default(),
@@ -205,7 +212,7 @@ impl Predictor {
         if self.mid_price.is_zero() {
             return;
         }
-        self.processor().await;
+        self.processor(false).await;
     }
 
     pub async fn on_trade(&mut self, trade: &Trade, _index: usize) {
@@ -252,7 +259,14 @@ impl Predictor {
 
     pub async fn on_record(&mut self, _record: &Record) {}
 
-    pub async fn on_inventory(&mut self, pos_amount: &Decimal, pos_avg_price: &Decimal, min_amount_value: &Decimal) {
+    pub async fn on_balance(&mut self, balance: Decimal) {
+        self.balance = balance;
+        if self.inventory.is_zero() {
+            self.one_grid_order_value = self.balance / self.params.grid;
+        }
+    }
+
+    pub async fn on_inventory(&mut self, pos_amount: &Decimal, pos_avg_price: &Decimal, _min_amount_value: &Decimal) {
         if self.mid_price.is_zero() {
             return;
         }
@@ -260,7 +274,7 @@ impl Predictor {
         let prev_inventory = self.inventory;
         self.pos_amount = pos_amount.clone();
         self.pos_avg_price = pos_avg_price.clone();
-        self.inventory = (pos_amount / (min_amount_value / self.mid_price)).trunc();
+        self.inventory = (pos_amount / (self.one_grid_order_value / self.mid_price)).round();
         // 小于1但不为0的情况，需要平完
         if self.inventory.is_zero() && !pos_amount.is_zero() {
             self.inventory = if pos_amount > &Decimal::ZERO {
@@ -270,26 +284,24 @@ impl Predictor {
             };
         }
 
-        if prev_inventory != self.inventory && prev_inventory.is_zero() {
+        // 用于计算加仓
+        if self.inventory.abs() > prev_inventory.abs() {
             self.prev_trade_time = Utc::now().timestamp_micros();
+            self.prev_trade_force_order_value = self.force_order_value;
             self.force_order_value = Decimal::ZERO;
         }
 
-        // 重置fair数据，用于重新计算幅度
-        if prev_inventory != self.inventory {
-        }
-
-        // 重置资金流计算
+        // 重置一些计算
         if prev_inventory != self.inventory && self.inventory.is_zero() {
             self.profit_point_vec.clear();
             self.profit_point = Decimal::ZERO;
             self.profit_point_ema = Decimal::ZERO;
 
-            self.money_flow = Decimal::ZERO;
+            self.prev_trade_force_order_value = Decimal::ZERO;
         }
 
         self.update_level().await;
-        self.processor().await;
+        self.processor(true).await;
     }
 
     pub fn get_real_rate(price_vec: &FixedTimeRangeDeque<Decimal>) -> (Decimal, Decimal, Decimal) {
@@ -367,8 +379,14 @@ impl Predictor {
         }
 
         // 可能是接针
-        let is_open_long = self.force_order_value < -self.params.open && self.inventory.is_zero();
-        let is_open_short = self.force_order_value > self.params.open && self.inventory.is_zero();
+        let is_open_long = self.force_order_value < -self.params.open
+            && self.inventory < self.params.grid
+            && self.inventory >= Decimal::ZERO
+            && self.force_order_value < self.prev_trade_force_order_value;
+        let is_open_short = self.force_order_value > self.params.open
+            && self.inventory > -self.params.grid
+            && self.inventory <= Decimal::ZERO
+            && self.force_order_value > self.prev_trade_force_order_value;
 
         let (is_close_long, is_close_short) = match self.params.close_difficulty.as_str() {
             "easy" => {
@@ -464,7 +482,7 @@ impl Predictor {
     }
 
     // #[instrument(skip(self), level="TRACE")]
-    async fn processor(&mut self) {
+    async fn processor(&mut self, is_hard_update: bool) {
         self.check_ready();
         if !self.is_ready {
             return;
@@ -499,16 +517,16 @@ impl Predictor {
 
         let inventory = self.inventory;
 
-        let sigma_square = self.money_flow;
+        let sigma_square = self.balance;
         // let sigma_square = self.error_rate;
 
         let gamma = self.force_order_value;
-        let kappa = Decimal::ZERO;
+        let kappa = self.inventory;
 
         let flow_ratio = Decimal::ZERO;
 
         let need_append = now - self.prev_insert_time > dec!(500);
-        if !need_append {
+        if !need_append && !is_hard_update {
             return;
         }
 

strategy/src/strategy.rs

@@ -937,7 +937,7 @@ impl Strategy {
 
     // 开单指令生成逻辑
     // #[instrument(skip(self, command), level="TRACE")]
-    pub fn _post_open(&mut self, command: &mut OrderCommand, local_orders: &HashMap<String, OrderInfo>, predictor: &mut Predictor) {
+    pub fn _post_open(&mut self, command: &mut OrderCommand, predictor: &mut Predictor) {
         // 开仓逻辑检测，主要是检测整点开仓逻辑
         if !self.check_allow_post_open() {
             return;
@@ -951,48 +951,15 @@ impl Strategy {
         // 报单时间更新
         self.post_open_time = self.local_time;
 
-        // 获取当前挂单价值
-        let mut buy_price_list: Vec<Decimal> = vec![];
-        let mut sell_price_list: Vec<Decimal> = vec![];
-        let mut buy_value = Decimal::ZERO;
-        let mut sell_value = Decimal::ZERO;
-        for client_id in local_orders.keys() {
-            let order = local_orders.get(client_id).unwrap();
-            if order.side == "kd".to_string() {
-                buy_price_list.push(order.price);
-                buy_value += order.amount * order.price;
-            }
-
-            if order.side == "kk".to_string() {
-                sell_price_list.push(order.price);
-                sell_value += order.amount * order.price;
-            }
-        }
-
-        // 计算可开价值
-        let long_free_value = self.max_long_value - self.long_hold_value - buy_value;
-        let short_free_value = self.max_short_value - self.short_hold_value - sell_value;
-        // debug!(?long_free_value, ?short_free_value);
-        // // 现货要特殊处理
-        // if self.exchange.contains("spot") {
-        //     let coin_value = self.coin * self.mp * self.lever_rate * self.adjust_lever_rate;
-        //     let cash_value = self.cash * self.lever_rate * self.adjust_lever_rate;
-        //
-        //     long_free_value = min(cash_value, self.max_long_value) - buy_value;
-        //     short_free_value = min(coin_value, self.max_short_value) - sell_value;
-        // }
-        // 一手开单价值计算
-        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 self.post_side >= 0 && predictor.inventory < predictor.params.grid && 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);
             let amount = if predictor.inventory < Decimal::ZERO {
                 predictor.pos_amount.abs()
             } else {
-                let value = min(one_hand_long_value, long_free_value);
+                let value = predictor.one_grid_order_value;
                 utils::fix_amount(value / self.mp, self.step_size)
             };
 
@@ -1017,7 +984,7 @@ impl Strategy {
             }
         }
         // 挂空单
-        if self.post_side <= 0 && sell_value == Decimal::ZERO && predictor.inventory.is_zero() && predictor.ask_delta != dec!(-2) {
+        if self.post_side <= 0 && predictor.inventory > -predictor.params.grid && 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));
             // 取消大小限制
@@ -1025,7 +992,7 @@ impl Strategy {
             let amount = if predictor.inventory > Decimal::ZERO {
                 predictor.pos_amount.abs()
             } else {
-                let value = min(one_hand_short_value, short_free_value);
+                let value = predictor.one_grid_order_value;
                 utils::fix_amount(value / self.mp, self.step_size)
             };
 
@@ -1095,7 +1062,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, 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