bybit的基础功能都加入了。

derive/tests/binance_swap_export_test.rs

@@ -5,7 +5,7 @@ use derive::export_excel::ExportEnum;
 use crate::export_excel_test::test_new_export;
 
 
-const SYMBOL: &str = "RDNT_USDT";
+const SYMBOL: &str = "SUPER_USDT";
 
 // 测试获取Exchange实体
 #[tokio::test]
@@ -14,6 +14,6 @@ async fn test_get_self_exchange() {
     global::log_utils::init_log_with_trace();
 
     let mut export = test_new_export(ExportEnum::BinanceSwap).await;
-    let export_trades = export.export_trades("binance_swap", SYMBOL.to_string(), 1725003480000, 1725011269000, 1000).await;
+    let export_trades = export.export_trades("binance_swap", SYMBOL.to_string(), 1726027200000, 1726103276000, 1000).await;
     trace!(?export_trades);
 }

exchanges/src/bybit_swap_ws.rs

@@ -25,7 +25,7 @@ pub enum BybitSwapWsType {
 pub enum BybitSwapSubscribeType {
     PuOrderBook1,
     PuOrderBook50,
-    PuBlicTrade,
+    PuTrade,
     PuTickers,
     PuKline(String),
 
@@ -118,7 +118,7 @@ impl BybitSwapWs {
             if match t {
                 BybitSwapSubscribeType::PuOrderBook1 => false,
                 BybitSwapSubscribeType::PuOrderBook50 => false,
-                BybitSwapSubscribeType::PuBlicTrade => false,
+                BybitSwapSubscribeType::PuTrade => false,
                 BybitSwapSubscribeType::PuTickers => false,
                 BybitSwapSubscribeType::PuKline(_) => false,
 
@@ -144,7 +144,7 @@ impl BybitSwapWs {
             BybitSwapSubscribeType::PuOrderBook50 => {
                 format!("orderbook.50.{}", symbol)
             }
-            BybitSwapSubscribeType::PuBlicTrade => {
+            BybitSwapSubscribeType::PuTrade => {
                 format!("publicTrade.{}", symbol)
             }
             BybitSwapSubscribeType::PuTickers => {

standard/src/bybit_swap_handle.rs

@@ -6,7 +6,7 @@ use tokio::time::Instant;
 use tracing::{error};
 use exchanges::response_base::ResponseData;
 use global::trace_stack::TraceStack;
-use crate::{Account, OrderBook, Order, Position, PositionModeEnum, SpecialOrder, Depth};
+use crate::{Account, OrderBook, Order, Position, PositionModeEnum, SpecialOrder, Depth, Trade};
 
 // 处理账号信息
 pub fn handle_account_info(res_data: &ResponseData, symbol: &String) -> Account {
@@ -136,27 +136,41 @@ pub fn format_order_item(order: Value, ct_val: &Decimal) -> Order {
     rst_order
 }
 
-// 处理特殊Ticket信息
-// pub fn handle_ticker(res_data: &ResponseData) -> SpecialDepth {
-//     let ap = Decimal::from_str(res_data.data["ask1Price"].as_str().unwrap()).unwrap();
-//     let bp = Decimal::from_str(res_data.data["bid1Price"].as_str().unwrap()).unwrap();
-//     let aq = Decimal::from_str(res_data.data["ask1Size"].as_str().unwrap()).unwrap();
-//     let bq = Decimal::from_str(res_data.data["bid1Size"].as_str().unwrap()).unwrap();
-//     let mp = (bp + ap) * dec!(0.5);
-//
-//     let t = Decimal::from_i64(res_data.data["ts"].as_i64().unwrap()).unwrap();
-//     let create_at = t.to_i64().unwrap();
-//
-//     let ticker_info = SpecialTicker { sell: ap, buy: bp, mid_price: mp, t, create_at: 0 };
-//     let depth_info = vec![bp, bq, ap, aq];
-//     SpecialDepth {
-//         name: res_data.tag.clone(),
-//         depth: depth_info,
-//         ticker: ticker_info,
-//         t,
-//         create_at,
-//     }
-// }
+pub fn format_trade_items(response: &ResponseData) -> Vec<Trade> {
+    let result = response.data.as_array().unwrap();
+    let mut trades = vec![];
+
+    for item in result {
+        // 因为gate的量都是张数，所以要进行真实交易量处理
+        let mut size = Decimal::from_str(item["v"].as_str().unwrap()).unwrap();
+        let price = Decimal::from_str(item["p"].as_str().unwrap().to_string().as_str()).unwrap();
+        let side = item["S"].as_str().unwrap().to_string();
+        size = match side.as_str() {
+            "Buy" => {
+                size
+            }
+            "Sell" => {
+                -size
+            }
+            _ => {
+                error!("{}", item.to_string());
+                panic!("Bybit trade error side(bybit_swap_handle_156)")
+            }
+        };
+        let value = (size * price).abs();
+
+        trades.push(Trade {
+            id: item["i"].as_str().unwrap().to_string(),
+            time: Decimal::from_i64(item["T"].as_i64().unwrap()).unwrap(),
+            size,
+            price,
+            value,
+            symbol: item["s"].as_str().unwrap().to_string(),
+        })
+    }
+
+    return trades
+}
 
 pub fn handle_book_ticker(res_data: &ResponseData, mul: &Decimal) -> Depth {
     let asks = format_depth_items(res_data.data["a"].clone(), mul);

standard/src/exchange_struct_handler.rs

@@ -116,8 +116,8 @@ impl ExchangeStructHandler {
             ExchangeEnum::BinanceSwap => {
                 binance_swap_handle::format_trade_items(&res_data)
             }
-            ExchangeEnum::BybitSwap => { // 未使用暂不实现
-                vec![]
+            ExchangeEnum::BybitSwap => {
+                bybit_swap_handle::format_trade_items(&res_data)
             }
             ExchangeEnum::CoinexSwap => {
                 coinex_swap_handle::format_trade_items(&res_data)

strategy/src/avellaneda_stoikov.rs

@@ -479,7 +479,7 @@ impl AvellanedaStoikov {
         self.update_t_diff();
         // info!(?self.t_diff);
         self.update_flow_ratio();
-        // info!(?self.flow_ratio);
+        // info!(?self.flow_ratio_long);
         self.update_sigma_square();
         // info!(?self.sigma_square);
         self.update_gamma();
@@ -489,7 +489,7 @@ impl AvellanedaStoikov {
         self.update_ref_price();
         // info!(?self.ref_price);
         self.update_delta();
-        // info!(?self.delta_ask, ?self.delta_bid);
+        // info!(?self.ask_delta, ?self.bid_delta);
         self.update_optimal_ask_and_bid();
         // info!("=============================================");
 

strategy/src/bybit_usdt_swap.rs

@@ -13,8 +13,9 @@ use global::trace_stack::TraceStack;
 use standard::exchange::ExchangeEnum::BybitSwap;
 use standard::exchange_struct_handler::ExchangeStructHandler;
 use standard::{Depth, OrderBook};
+use standard::exchange::ExchangeEnum;
 use crate::core::Core;
-use crate::exchange_disguise::on_depth;
+use crate::exchange_disguise::{on_depth, on_trade};
 use crate::model::OrderInfo;
 
 // 参考 币安 合约 启动
@@ -28,7 +29,8 @@ pub(crate) async fn reference_bybit_swap_run(is_shutdown_arc: Arc<AtomicBool>,
         let (write_tx, write_rx) = futures_channel::mpsc::unbounded::<Message>();
         let mut ws = BybitSwapWs::new_label(name, is_colo, None, BybitSwapWsType::Public);
         ws.set_subscribe(vec![
-            BybitSwapSubscribeType::PuOrderBook1
+            BybitSwapSubscribeType::PuOrderBook1,
+            BybitSwapSubscribeType::PuTrade
         ]);
 
         // 读取数据
@@ -102,18 +104,20 @@ pub(crate) async fn bybit_swap_run(is_shutdown_arc: Arc<AtomicBool>,
     });
 }
 
-async fn on_public_data(core_arc_clone: Arc<Mutex<Core>>, ct_val: &Decimal, response: &ResponseData, depth_asks: &mut Vec<OrderBook>, depth_bids: &mut Vec<OrderBook>) {
+async fn on_public_data(core_arc: Arc<Mutex<Core>>, mul: &Decimal, response: &ResponseData, depth_asks: &mut Vec<OrderBook>, depth_bids: &mut Vec<OrderBook>) {
     let mut trace_stack = TraceStack::new(response.time, response.ins);
     trace_stack.on_after_span_line();
 
     match response.channel.as_str() {
         "orderbook" => {
+            trace_stack.set_source("bybit_usdt_swap.bookTicker".to_string());
+
             let mut is_update = false;
             let data_type = response.data_type.clone();
             if data_type == "delta"  {
                 is_update = true;
             }
-            let mut depth = ExchangeStructHandler::book_ticker_handle(BybitSwap, &response, ct_val);
+            let mut depth = ExchangeStructHandler::book_ticker_handle(BybitSwap, &response, mul);
             // 是增量更新
             if is_update {
                 update_order_book(depth_asks, depth_bids, depth.asks, depth.bids);
@@ -134,7 +138,19 @@ async fn on_public_data(core_arc_clone: Arc<Mutex<Core>>, ct_val: &Decimal, resp
             };
             trace_stack.on_after_format();
 
-            on_depth(core_arc_clone, &response.label, &mut trace_stack, &result_depth).await;
+            on_depth(core_arc, &response.label, &mut trace_stack, &result_depth).await;
+        }
+        "trade" => {
+            trace_stack.set_source("bybit_usdt_swap.trade".to_string());
+
+            let mut trades = ExchangeStructHandler::trades_handle(ExchangeEnum::BybitSwap, response, mul);
+            trace_stack.on_after_format();
+
+            for trade in trades.iter_mut() {
+                let core_arc_clone = core_arc.clone();
+
+                on_trade(core_arc_clone, &response.label, &mut trace_stack, &trade).await;
+            }
         }
         _ => {
             error!("未知推送类型");