chore(rust): update Rust edition to 2024.

nkaz001 · Feb 25, 2025 · c76d8e7 · c76d8e7
1 parent 9b21279
commit c76d8e7
Show file tree

Hide file tree

Showing 61 changed files with 291 additions and 289 deletions.
diff --git a/collector/Cargo.toml b/collector/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "collect-data"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 

diff --git a/collector/src/binance/http.rs b/collector/src/binance/http.rs
@@ -7,10 +7,10 @@ use std::{
 use anyhow::Error;
 use chrono::{DateTime, Utc};
 use futures_util::{SinkExt, StreamExt};
-use tokio::sync::mpsc::{unbounded_channel, UnboundedSender};
+use tokio::sync::mpsc::{UnboundedSender, unbounded_channel};
 use tokio_tungstenite::{
     connect_async,
-    tungstenite::{client::IntoClientRequest, Bytes, Message, Utf8Bytes},
+    tungstenite::{Bytes, Message, Utf8Bytes, client::IntoClientRequest},
 };
 use tracing::{error, warn};
 

diff --git a/collector/src/binance/mod.rs b/collector/src/binance/mod.rs
@@ -4,7 +4,7 @@ use std::collections::HashMap;
 
 use chrono::{DateTime, Utc};
 pub use http::{fetch_depth_snapshot, keep_connection};
-use tokio::sync::mpsc::{unbounded_channel, UnboundedSender};
+use tokio::sync::mpsc::{UnboundedSender, unbounded_channel};
 use tokio_tungstenite::tungstenite::Utf8Bytes;
 use tracing::{error, warn};
 

diff --git a/collector/src/binancefuturescm/http.rs b/collector/src/binancefuturescm/http.rs
@@ -7,10 +7,10 @@ use std::{
 use anyhow::Error;
 use chrono::{DateTime, Utc};
 use futures_util::{SinkExt, StreamExt};
-use tokio::sync::mpsc::{unbounded_channel, UnboundedSender};
+use tokio::sync::mpsc::{UnboundedSender, unbounded_channel};
 use tokio_tungstenite::{
     connect_async,
-    tungstenite::{client::IntoClientRequest, Bytes, Message, Utf8Bytes},
+    tungstenite::{Bytes, Message, Utf8Bytes, client::IntoClientRequest},
 };
 use tracing::{error, warn};
 

diff --git a/collector/src/binancefuturescm/mod.rs b/collector/src/binancefuturescm/mod.rs
@@ -4,7 +4,7 @@ use std::collections::HashMap;
 
 use chrono::{DateTime, Utc};
 pub use http::{fetch_depth_snapshot, keep_connection};
-use tokio::sync::mpsc::{unbounded_channel, UnboundedSender};
+use tokio::sync::mpsc::{UnboundedSender, unbounded_channel};
 use tokio_tungstenite::tungstenite::Utf8Bytes;
 use tracing::{error, warn};
 

diff --git a/collector/src/binancefuturesum/http.rs b/collector/src/binancefuturesum/http.rs
@@ -7,10 +7,10 @@ use std::{
 use anyhow::Error;
 use chrono::{DateTime, Utc};
 use futures_util::{SinkExt, StreamExt};
-use tokio::sync::mpsc::{unbounded_channel, UnboundedSender};
+use tokio::sync::mpsc::{UnboundedSender, unbounded_channel};
 use tokio_tungstenite::{
     connect_async,
-    tungstenite::{client::IntoClientRequest, Bytes, Message, Utf8Bytes},
+    tungstenite::{Bytes, Message, Utf8Bytes, client::IntoClientRequest},
 };
 use tracing::{error, warn};
 

diff --git a/collector/src/binancefuturesum/mod.rs b/collector/src/binancefuturesum/mod.rs
@@ -4,7 +4,7 @@ use std::collections::HashMap;
 
 use chrono::{DateTime, Utc};
 pub use http::{fetch_depth_snapshot, keep_connection};
-use tokio::sync::mpsc::{unbounded_channel, UnboundedSender};
+use tokio::sync::mpsc::{UnboundedSender, unbounded_channel};
 use tokio_tungstenite::tungstenite::Utf8Bytes;
 use tracing::{error, warn};
 

diff --git a/collector/src/bybit/http.rs b/collector/src/bybit/http.rs
@@ -9,11 +9,11 @@ use chrono::{DateTime, Utc};
 use futures_util::{SinkExt, StreamExt};
 use tokio::{
     select,
-    sync::mpsc::{unbounded_channel, UnboundedSender},
+    sync::mpsc::{UnboundedSender, unbounded_channel},
 };
 use tokio_tungstenite::{
     connect_async,
-    tungstenite::{client::IntoClientRequest, Bytes, Message, Utf8Bytes},
+    tungstenite::{Bytes, Message, Utf8Bytes, client::IntoClientRequest},
 };
 use tracing::{error, warn};
 

diff --git a/collector/src/bybit/mod.rs b/collector/src/bybit/mod.rs
@@ -1,5 +1,5 @@
 use chrono::{DateTime, Utc};
-use tokio::sync::mpsc::{unbounded_channel, UnboundedSender};
+use tokio::sync::mpsc::{UnboundedSender, unbounded_channel};
 use tokio_tungstenite::tungstenite::Utf8Bytes;
 use tracing::error;
 

diff --git a/collector/src/file.rs b/collector/src/file.rs
@@ -1,12 +1,12 @@
 use std::{
-    collections::{hash_map::Entry, HashMap},
+    collections::{HashMap, hash_map::Entry},
     fs::File,
     io,
     io::Write,
 };
 
 use chrono::{DateTime, NaiveDate, Utc};
-use flate2::{write::GzEncoder, Compression};
+use flate2::{Compression, write::GzEncoder};
 use tracing::info;
 
 pub struct RotatingFile {

diff --git a/connector/Cargo.toml b/connector/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "connector"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 
 [features]
 default = ["binancefutures", "bybit"]

diff --git a/connector/src/binancefutures/market_data_stream.rs b/connector/src/binancefutures/market_data_stream.rs
@@ -6,25 +6,25 @@ use hftbacktest::{live::ipc::TO_ALL, prelude::*};
 use tokio::{
     select,
     sync::{
-        broadcast::{error::RecvError, Receiver},
-        mpsc::{unbounded_channel, UnboundedReceiver, UnboundedSender},
+        broadcast::{Receiver, error::RecvError},
+        mpsc::{UnboundedReceiver, UnboundedSender, unbounded_channel},
     },
 };
 use tokio_tungstenite::{
     connect_async,
-    tungstenite::{client::IntoClientRequest, Message},
+    tungstenite::{Message, client::IntoClientRequest},
 };
 use tracing::{debug, error};
 
 use crate::{
     binancefutures::{
+        BinanceFuturesError,
         msg::{
             rest,
             stream,
             stream::{EventStream, Stream},
         },
         rest::BinanceFuturesClient,
-        BinanceFuturesError,
     },
     connector::PublishEvent,
     utils::{generate_rand_string, parse_depth, parse_px_qty_tup},

diff --git a/connector/src/binancefutures/msg/mod.rs b/connector/src/binancefutures/msg/mod.rs
@@ -1,8 +1,8 @@
 use hftbacktest::types::{OrdType, Side, Status, TimeInForce};
 use serde::{
-    de::{Error, Unexpected},
     Deserialize,
     Deserializer,
+    de::{Error, Unexpected},
 };
 
 #[allow(dead_code)]

diff --git a/connector/src/binancefutures/ordermanager.rs b/connector/src/binancefutures/ordermanager.rs
@@ -7,11 +7,11 @@ use tracing::error;
 
 use crate::{
     binancefutures::{
-        msg::{rest::OrderResponse, stream::OrderTradeUpdate},
         BinanceFuturesError,
+        msg::{rest::OrderResponse, stream::OrderTradeUpdate},
     },
     connector::GetOrders,
-    utils::{generate_rand_string, RefSymbolOrderId, SymbolOrderId},
+    utils::{RefSymbolOrderId, SymbolOrderId, generate_rand_string},
 };
 
 #[derive(Debug)]
@@ -117,7 +117,9 @@ impl OrderManager {
             }
             BinanceFuturesError::OrderError { code: -1008, .. } => {
                 // Server is currently overloaded with other requests. Please try again in a few minutes.
-                error!("Server is currently overloaded with other requests. Please try again in a few minutes.");
+                error!(
+                    "Server is currently overloaded with other requests. Please try again in a few minutes."
+                );
             }
             BinanceFuturesError::OrderError { code: -2019, .. } => {
                 // Margin is insufficient.

diff --git a/connector/src/binancefutures/rest.rs b/connector/src/binancefutures/rest.rs
@@ -5,11 +5,11 @@ use serde::Deserialize;
 use super::msg::{rest, rest::PositionInformationV2};
 use crate::{
     binancefutures::{
+        BinanceFuturesError,
         msg::{
             rest::{OrderResponse, OrderResponseResult},
             stream::ListenKey,
         },
-        BinanceFuturesError,
     },
     utils::sign_hmac_sha256,
 };

diff --git a/connector/src/binancefutures/user_data_stream.rs b/connector/src/binancefutures/user_data_stream.rs
@@ -5,24 +5,24 @@ use hftbacktest::prelude::*;
 use tokio::{
     select,
     sync::{
-        broadcast::{error::RecvError, Receiver},
+        broadcast::{Receiver, error::RecvError},
         mpsc::UnboundedSender,
     },
     time,
 };
 use tokio_tungstenite::{
     connect_async,
-    tungstenite::{client::IntoClientRequest, Message},
+    tungstenite::{Message, client::IntoClientRequest},
 };
 use tracing::{debug, error};
 
 use crate::{
     binancefutures::{
+        BinanceFuturesError,
+        SharedSymbolSet,
         msg::stream::{EventStream, Stream},
         ordermanager::SharedOrderManager,
         rest::BinanceFuturesClient,
-        BinanceFuturesError,
-        SharedSymbolSet,
     },
     connector::PublishEvent,
 };

diff --git a/connector/src/bybit/msg.rs b/connector/src/bybit/msg.rs
@@ -2,11 +2,11 @@ use std::{collections::HashMap, fmt, fmt::Debug};
 
 use hftbacktest::types::{OrdType, Side, Status, TimeInForce};
 use serde::{
-    de,
-    de::{Error, Unexpected, Visitor},
     Deserialize,
     Deserializer,
     Serialize,
+    de,
+    de::{Error, Unexpected, Visitor},
 };
 
 use crate::utils::{from_str_to_f64, from_str_to_f64_opt, from_str_to_i64};

diff --git a/connector/src/bybit/ordermanager.rs b/connector/src/bybit/ordermanager.rs
@@ -8,11 +8,11 @@ use hftbacktest::{
 
 use crate::{
     bybit::{
-        msg::{Execution, FastExecution, Order as BybitOrder, PrivateOrder},
         BybitError,
+        msg::{Execution, FastExecution, Order as BybitOrder, PrivateOrder},
     },
     connector::GetOrders,
-    utils::{generate_rand_string, RefSymbolOrderId, SymbolOrderId},
+    utils::{RefSymbolOrderId, SymbolOrderId, generate_rand_string},
 };
 
 pub type SharedOrderManager = Arc<Mutex<OrderManager>>;

diff --git a/connector/src/bybit/private_stream.rs b/connector/src/bybit/private_stream.rs
@@ -1,32 +1,32 @@
 use std::time::Duration;
 
 use chrono::Utc;
-use futures_util::{stream::SplitSink, SinkExt, StreamExt};
+use futures_util::{SinkExt, StreamExt, stream::SplitSink};
 use hftbacktest::prelude::LiveEvent;
 use tokio::{
     net::TcpStream,
     select,
     sync::{
-        broadcast::{error::RecvError, Receiver},
+        broadcast::{Receiver, error::RecvError},
         mpsc::UnboundedSender,
     },
     time,
 };
 use tokio_tungstenite::{
-    connect_async,
-    tungstenite::{client::IntoClientRequest, Bytes, Message},
     MaybeTlsStream,
     WebSocketStream,
+    connect_async,
+    tungstenite::{Bytes, Message, client::IntoClientRequest},
 };
 use tracing::{debug, error};
 
 use crate::{
     bybit::{
+        BybitError,
+        SharedSymbolSet,
         msg::{Op, PrivateStreamMsg, PrivateStreamTopicMsg},
         ordermanager::{OrderExt, SharedOrderManager},
         rest::BybitClient,
-        BybitError,
-        SharedSymbolSet,
     },
     connector::PublishEvent,
     utils::sign_hmac_sha256,

diff --git a/connector/src/bybit/public_stream.rs b/connector/src/bybit/public_stream.rs
@@ -4,34 +4,34 @@ use chrono::Utc;
 use futures_util::{SinkExt, StreamExt};
 use hftbacktest::prelude::{
     Event,
-    LiveEvent,
-    Side,
     LOCAL_ASK_DEPTH_BBO_EVENT,
     LOCAL_ASK_DEPTH_EVENT,
     LOCAL_BID_DEPTH_BBO_EVENT,
     LOCAL_BID_DEPTH_EVENT,
     LOCAL_BUY_TRADE_EVENT,
     LOCAL_SELL_TRADE_EVENT,
+    LiveEvent,
+    Side,
 };
 use tokio::{
     select,
     sync::{
-        broadcast::{error::RecvError, Receiver},
+        broadcast::{Receiver, error::RecvError},
         mpsc::UnboundedSender,
     },
     time,
 };
 use tokio_tungstenite::{
     connect_async,
-    tungstenite::{client::IntoClientRequest, Bytes, Message},
+    tungstenite::{Bytes, Message, client::IntoClientRequest},
 };
 use tracing::{debug, error};
 
 use crate::{
     bybit::{
+        BybitError,
         msg,
         msg::{Op, OrderBook, PublicStreamMsg},
-        BybitError,
     },
     connector::PublishEvent,
     utils::parse_depth,

diff --git a/connector/src/bybit/rest.rs b/connector/src/bybit/rest.rs
@@ -3,8 +3,8 @@ use serde::Deserialize;
 
 use crate::{
     bybit::{
-        msg::{Position, RestResponse},
         BybitError,
+        msg::{Position, RestResponse},
     },
     utils::sign_hmac_sha256,
 };

diff --git a/connector/src/bybit/trade_stream.rs b/connector/src/bybit/trade_stream.rs
@@ -6,22 +6,22 @@ use hftbacktest::types::{ErrorKind, LiveError, LiveEvent};
 use tokio::{
     select,
     sync::{
-        broadcast::{error::RecvError, Receiver},
+        broadcast::{Receiver, error::RecvError},
         mpsc::UnboundedSender,
     },
     time,
 };
 use tokio_tungstenite::{
     connect_async,
-    tungstenite::{client::IntoClientRequest, Bytes, Message},
+    tungstenite::{Bytes, Message, client::IntoClientRequest},
 };
 use tracing::{error, info};
 
 use crate::{
     bybit::{
+        BybitError,
         msg::{Op, Order, TradeOp, TradeStreamMsg},
         ordermanager::{OrderExt, SharedOrderManager},
-        BybitError,
     },
     connector::PublishEvent,
     utils::{generate_rand_string, sign_hmac_sha256},

diff --git a/connector/src/fuse.rs b/connector/src/fuse.rs
@@ -1,8 +1,8 @@
 use std::collections::HashMap;
 
 use hftbacktest::{
-    prelude::{Side, DEPTH_SNAPSHOT_EVENT, EXCH_EVENT, INVALID_MAX, INVALID_MIN, LOCAL_EVENT},
-    types::{Event, BUY_EVENT, SELL_EVENT},
+    prelude::{DEPTH_SNAPSHOT_EVENT, EXCH_EVENT, INVALID_MAX, INVALID_MIN, LOCAL_EVENT, Side},
+    types::{BUY_EVENT, Event, SELL_EVENT},
 };
 
 pub struct QtyTimestamp {
@@ -186,7 +186,7 @@ impl FusedHashMapMarketDepth {
         let mut bid_depth = self
             .bid_depth
             .iter()
-            .filter(|(&px_tick, _)| px_tick <= self.best_bid_tick)
+            .filter(|&(&px_tick, _)| px_tick <= self.best_bid_tick)
             .map(|(&px_tick, depth)| (px_tick, depth))
             .collect::<Vec<_>>();
         bid_depth.sort_by(|a, b| b.0.cmp(&a.0));
@@ -207,7 +207,7 @@ impl FusedHashMapMarketDepth {
         let mut ask_depth = self
             .ask_depth
             .iter()
-            .filter(|(&px_tick, _)| px_tick >= self.best_ask_tick)
+            .filter(|&(&px_tick, _)| px_tick >= self.best_ask_tick)
             .map(|(&px_tick, depth)| (px_tick, depth))
             .collect::<Vec<_>>();
         ask_depth.sort_by(|a, b| a.0.cmp(&b.0));