v4.0.4: 用价差挂单

strategy/src/predictor.rs

@@ -4,12 +4,10 @@ use std::sync::Arc;
 use chrono::{Utc};
 use futures_channel::mpsc::UnboundedSender;
 use futures_util::StreamExt;
-use reqwest::{Client};
 use rust_decimal::prelude::*;
 use rust_decimal_macros::dec;
-use serde_json::{json, Value};
 use tokio::sync::{Mutex};
-use tracing::{error, info};
+use tracing::{info};
 use global::cci::CentralControlInfo;
 use global::fixed_time_range_deque::FixedTimeRangeDeque;
 use global::params::Params;
@@ -19,8 +17,8 @@ use crate::utils;
 #[derive(Debug, Clone)]
 pub struct Predictor {
     pub depth_vec: Vec<Depth>,                                                  // 深度队列
-    pub spread_vec: Vec<Decimal>,                                               // 价差队列
     pub record_vec: VecDeque<Record>,                                           // 蜡烛队列
+    pub spread_vec: FixedTimeRangeDeque<Decimal>,                               // 价差队列
     pub trade_price_long_vec: FixedTimeRangeDeque<Decimal>,
     pub trade_233_vec: FixedTimeRangeDeque<Trade>,
     pub trade_0_vec: FixedTimeRangeDeque<Trade>,
@@ -127,13 +125,13 @@ impl Predictor {
             fair_price_vec: vec![Decimal::ZERO; params.ref_exchange.len()],
             price_avg_times_vec: vec![Decimal::ZERO; params.ref_exchange.len()],
             price_avg_times_long_vec: vec![Decimal::ZERO; params.ref_exchange.len()],
-            spread_vec: vec![Decimal::ZERO; params.ref_exchange.len()],
 
             record_vec: VecDeque::new(),
 
             trade_price_long_vec: FixedTimeRangeDeque::new(Self::TRADE_LONG_RANGE_MICROS),
             trade_233_vec: FixedTimeRangeDeque::new(Self::TRADE_SHORT_RANGE_MICROS),
             trade_0_vec: FixedTimeRangeDeque::new(Self::TRADE_SHORT_RANGE_MICROS),
+            spread_vec: FixedTimeRangeDeque::new(Self::TRADE_LONG_RANGE_MICROS),
             mid_price: Default::default(),
             fair_price: Default::default(),
             ask_price: Default::default(),
@@ -293,8 +291,7 @@ impl Predictor {
             }
             let price_avg_times_short = self.price_avg_times_vec[i];
 
-            self.spread_vec[i] = price_avg_times_short - price_avg_times_long;
-            self.signal = self.signal +  self.spread_vec[i];
+            self.signal = self.signal + price_avg_times_short - price_avg_times_long;
         }
         // self.signal = self.signal / self.params.min_spread;
         // self.signal.rescale(0);
@@ -306,6 +303,15 @@ impl Predictor {
             .count();
         if fair_price_count != 0 {
             self.fair_price = fair_price_sum / Decimal::from(fair_price_count);
+            self.spread_vec.push_back(((self.fair_price - self.mid_price) / self.mid_price).abs());
+            let max_abs_value = self.spread_vec.deque.iter().max().unwrap().clone();
+
+            let prev_open = self.params.open.clone();
+            self.params.open = max(max(self.params.min_open, dec!(0.0006)), max_abs_value / Decimal::ONE_HUNDRED);
+
+            if self.params.open != prev_open {
+                info!("open: {} -> {}", prev_open, self.params.open);
+            }
         }
     }
 
@@ -314,16 +320,6 @@ impl Predictor {
             return;
         }
 
-        let now = Decimal::from(Utc::now().timestamp_millis());
-
-        if now - self.prev_update_open_params_time > dec!(60_000)
-            || self.prev_balance != self.balance {
-            self.update_open_params().await;
-
-            self.prev_balance = self.balance;
-            self.prev_update_open_params_time = now;
-        }
-
         for fair_price in &self.fair_price_vec {
             if fair_price.is_zero() {
                 return;
@@ -410,23 +406,23 @@ impl Predictor {
         let total_amount_0: Decimal = self.trade_233_vec.deque.iter().map(|trade| trade.value).sum();
         let total_amount_1: Decimal = self.trade_0_vec.deque.iter().map(|trade| trade.value).sum();
 
-        let spread = if self.trade_price_long_vec.len() > 1 {
-            let front = self.trade_price_long_vec.deque.front().unwrap();
-            let back = self.trade_price_long_vec.deque.back().unwrap();
-
-            (back / front) - Decimal::ONE
-        } else {
-            Decimal::ZERO
-        };
+        let spread = Self::DONT_VIEW;
         let spread_min = (self.fair_price - self.mid_price) / self.mid_price;
-        let spread_max = Self::DONT_VIEW;
+        let spread_max = self.params.open;
         // let spread = self.price_times_avg;
         // let spread_max = self.fair_price_vec[1] / self.fair_price_vec[0];
         // let spread_min = self.fair_price / self.mid_price;
 
         let inventory = self.inventory;
 
-        let sigma_square = self.params.open;
+        let sigma_square = if self.trade_price_long_vec.len() > 1 {
+            let front = self.trade_price_long_vec.deque.front().unwrap();
+            let back = self.trade_price_long_vec.deque.back().unwrap();
+
+            (back / front) - Decimal::ONE
+        } else {
+            Decimal::ZERO
+        };
 
         let gamma = self.balance;
         let kappa = if total_amount_0 + total_amount_1 == Decimal::ZERO {
@@ -471,72 +467,4 @@ impl Predictor {
     pub fn get_ref_price(&mut self, _ref_ticker_map: &BTreeMap<String, Ticker>) -> Vec<Vec<Decimal>> {
         vec![]
     }
-
-    pub async fn update_open_params(&mut self) {
-        let url = "http://is.skyfffire.com:18888/ia/get_indicator";
-        let symbol = self.params.pair.to_lowercase();
-        let exchange = self.params.exchange.to_lowercase();
-
-        let params = json!({
-            "indicator": "msv",
-            "query": {
-                "exchange": exchange,
-                "symbol": symbol,
-                "minute_time_range": "10",
-                "mills_back": "37"
-            }
-        });
-
-        // 创建 HTTP 客户端
-        let client = Client::new();
-
-        // 发送 GET 请求
-        let response_rst = client.post(url)
-            .json(&params)
-            .send()
-            .await;
-
-        match response_rst {
-            Ok(response) => {
-                // 错误处理
-                if response.status().is_success() {
-                    let response_text = response.text().await.unwrap();
-                    let parsed: Value = serde_json::from_str(response_text.as_str()).unwrap();
-                    let msv = parsed["data"]["msv"].clone();
-
-                    let msv_decimals: Vec<Decimal> = msv.as_array()
-                        .unwrap()  // 确保 parsed 是一个数组
-                        .iter()
-                        .filter_map(|item| {
-                            // 尝试提取第二个值并转换为 Decimal
-                            if let Some(value) = item.get(1) {
-                                value.as_str().unwrap_or("0").parse::<Decimal>().ok()
-                            } else {
-                                None
-                            }
-                        })
-                        .collect();
-
-                    let max_abs_value = msv_decimals.iter()
-                        .map(|&value| value.abs())  // 获取每个数的绝对值
-                        .fold(Decimal::new(0, 0), |a, b| a.max(b)); // 计算最大值
-
-                    let prev_open = self.params.open.clone();
-
-                    self.params.open = if max_abs_value.is_zero() {
-                        panic!("十分钟内毫无波动的行情，停机。")
-                    } else {
-                        max(max(self.params.min_open, dec!(0.0004)), max_abs_value / Decimal::ONE_HUNDRED)
-                    };
-
-                    if self.params.open != prev_open {
-                        info!("open: {} -> {}", prev_open, self.params.open);
-                    }
-                } else {
-                    error!("自动参数挂了：{}", response.status());
-                }
-            }
-            Err(_) => {}
-        }
-    }
 }