添加bitget

exchanges/src/bitget_swap_rest.rs

@@ -126,6 +126,16 @@ impl BitgetSwapRest {
         ).await
     }
 
+    // 获取K线
+    pub async fn get_market_candles(&mut self, params: Value) -> ResponseData {
+        self.request("GET".to_string(),
+                     "/api/v2".to_string(),
+                     "/mix/market/candles".to_string(),
+                     true,
+                     params.to_string(),
+        ).await
+    }
+
     // 下单
     pub async fn swap_order(&mut self, params: Value) -> ResponseData {
         self.request("POST".to_string(),

exchanges/src/bitget_swap_ws.rs

@@ -19,6 +19,8 @@ pub enum BitgetSwapWsType {
 pub enum BitgetSwapSubscribeType {
     PuTrade,
     PuBooks1,
+    PuTickers,
+    PuKline(String),
 
     PrAccount,
     PrPosition,
@@ -70,7 +72,7 @@ impl BitgetSwapWs {
             login_param,
             symbol_s: vec![],
             subscribe_types: vec![],
-            heartbeat_time: 1000 * 10
+            heartbeat_time: 1000 * 10,
         }
     }
 
@@ -97,6 +99,8 @@ impl BitgetSwapWs {
             if match t {
                 BitgetSwapSubscribeType::PuTrade => false,
                 BitgetSwapSubscribeType::PuBooks1 => false,
+                BitgetSwapSubscribeType::PuTickers => false,
+                BitgetSwapSubscribeType::PuKline(_) => false,
 
                 BitgetSwapSubscribeType::PrAccount => true,
                 BitgetSwapSubscribeType::PrOrders => true,
@@ -121,14 +125,28 @@ impl BitgetSwapWs {
                     "channel": "trade",
                     "instId": symbol,
                 })
-            },
+            }
             BitgetSwapSubscribeType::PuBooks1 => {
                 json!({
                     "instType": "USDT-FUTURES",
                     "channel": "books1",
                     "instId": symbol,
                 })
-            },
+            }
+            BitgetSwapSubscribeType::PuTickers => {
+                json!({
+                    "instType": "USDT-FUTURES",
+                    "channel": "ticker",
+                    "instId": symbol,
+                })
+            }
+            BitgetSwapSubscribeType::PuKline(t) => {
+                json!({
+                    "instType": "USDT-FUTURES",
+                    "channel": format!("candle{}m", t),
+                    "instId": symbol,
+                })
+            }
 
             // 私有订阅
             BitgetSwapSubscribeType::PrAccount => {
@@ -137,21 +155,21 @@ impl BitgetSwapWs {
                     "channel": "account",
                     "coin": "default",
                 })
-            },
+            }
             BitgetSwapSubscribeType::PrPosition => {
                 json!({
                     "instType": "USDT-FUTURES",
                     "channel": "positions",
                     "instId": "default"
                 })
-            },
+            }
             BitgetSwapSubscribeType::PrOrders => {
                 json!({
                     "instType": "USDT-FUTURES",
                     "channel": "orders",
                     "instId": "default"
                 })
-            },
+            }
         }
     }
 
@@ -176,13 +194,13 @@ impl BitgetSwapWs {
     /*****************************************socket基本*****************************************************/
     /*******************************************************************************************************/
     pub async fn ws_connect_async<F, Future>(&mut self,
-                                            is_shutdown_arc: Arc<AtomicBool>,
-                                            handle_function: F,
-                                            write_tx_am: &Arc<Mutex<UnboundedSender<Message>>>,
-                                            write_to_socket_rx: UnboundedReceiver<Message>) -> Result<(), Error>
-        where
-            F: Fn(ResponseData) -> Future + Clone + Send + 'static + Sync,
-            Future: std::future::Future<Output=()> + Send + 'static, // 确保 Fut 是一个 Future，且输出类型为 ()
+                                             is_shutdown_arc: Arc<AtomicBool>,
+                                             handle_function: F,
+                                             write_tx_am: &Arc<Mutex<UnboundedSender<Message>>>,
+                                             write_to_socket_rx: UnboundedReceiver<Message>) -> Result<(), Error>
+    where
+        F: Fn(ResponseData) -> Future + Clone + Send + 'static + Sync,
+        Future: std::future::Future<Output=()> + Send + 'static, // 确保 Fut 是一个 Future，且输出类型为 ()
     {
         let login_is = self.contains_pr();
         let address_url = self.address_url.clone();
@@ -279,7 +297,7 @@ impl BitgetSwapWs {
                 res_data.code = -301;
                 res_data.channel = "pong".to_string();
                 res_data.message = "success".to_string();
-            },
+            }
             _ => {
                 let json_value: Value = serde_json::from_str(&text).unwrap();
 
@@ -298,15 +316,41 @@ impl BitgetSwapWs {
                     res_data.channel = format!("{}", json_value["arg"]["channel"].as_str().unwrap());
                     res_data.message = "success".to_string();
                 } else if json_value.get("action").is_some() {
-                    res_data.data = json_value["data"].clone();
-                    if res_data.data == "[]" {
-                        res_data.code = -1;
+                    let channel = format!("{}", json_value["arg"]["channel"].as_str().unwrap());
+                    res_data.data = json_value.clone();
+                    res_data.reach_time = json_value["ts"].as_i64().unwrap() * 1000;
+                    res_data.message = "success".to_string();
+
+                    res_data.code = 200;
+
+                    if channel.contains("books1") {
+                        res_data.channel = "orderbook".to_string();
+                        res_data.data_type = json_value["action"].as_str().unwrap().to_string();
+                        // bybit 时间在data块外
+                        res_data.reach_time = json_value.get("ts").unwrap().as_i64().unwrap_or(0i64);
+                    } else if channel.contains("trade") {
+                        res_data.channel = "trade".to_string();
+                        res_data.data_type = json_value["action"].as_str().unwrap().to_string();
+                    } else if channel.contains("ticker") {
+                        res_data.channel = "tickers".to_string();
+                        res_data.data["ts"] = json_value["ts"].clone();
+                        res_data.data_type = json_value["action"].as_str().unwrap().to_string();
+                    } else if channel.contains("candle") {
+                        res_data.channel = "kline".to_string();
+                        res_data.data_type = json_value["action"].as_str().unwrap().to_string();
+                    } else if channel.contains("positions") {
+                        res_data.channel = "position".to_string();
+                        res_data.data_type = json_value["action"].as_str().unwrap().to_string();
+                    } else if channel.contains("orders") {
+                        res_data.channel = "order".to_string();
+                        res_data.data_type = json_value["action"].as_str().unwrap().to_string();
+                    } else if channel.contains("account") {
+                        res_data.channel = "wallet".to_string();
+                        res_data.data_type = json_value["action"].as_str().unwrap().to_string();
                     } else {
-                        res_data.code = 200;
+                        res_data.code = -1;
+                        res_data.channel = "未知的频道".to_string();
                     }
-                    res_data.message = "success".to_string();
-                    res_data.channel = format!("{}", json_value["arg"]["channel"].as_str().unwrap());
-                    res_data.reach_time = json_value["ts"].as_i64().unwrap() * 1000;
                 }
             }
         }

standard/Cargo.toml

@@ -12,7 +12,7 @@ tokio = { version = "1.31.0", features = ["full"] }
 async-trait = "0.1.73"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0.104"
-rust_decimal = "1.32.0"
+rust_decimal = { version = "1.32.0", features = ["maths"] }
 rust_decimal_macros = "1.32.0"
 chrono = "0.4.30"
 futures = "0.3"

standard/src/binance_swap.rs

@@ -439,7 +439,6 @@ impl Platform for BinanceSwap {
         });
         if order_id != "" { params["orderId"] = json!(order_id) }
         if custom_id != "" { params["origClientOrderId"] = json!(custom_id) }
-        // println!("{}", params);
         let res_data = self.request.cancel_order(params).await;
         if res_data.code == 200 {
             let res_data_json = &res_data.data;
@@ -473,7 +472,6 @@ impl Platform for BinanceSwap {
             "symbol": symbol_format.clone(),
         });
         let res_data = self.request.cancel_order_all(params).await;
-        println!("{:?}", res_data);
         if res_data.code == 200 {
             let result = vec![Order {
                 id: "".to_string(),

standard/src/bitget_swap.rs

@@ -1,670 +1,791 @@
-// use std::collections::{BTreeMap};
-// use exchanges::bitget_swap_rest::BitgetSwapRest;
-// use std::io::{Error, ErrorKind};
-// use tokio::sync::mpsc::Sender;
-// use std::str::FromStr;
-// use async_trait::async_trait;
-// use futures::stream::FuturesUnordered;
-// use futures::TryStreamExt;
-// use rust_decimal::{Decimal, MathematicalOps};
-// use rust_decimal::prelude::ToPrimitive;
-// use rust_decimal_macros::dec;
-// use serde_json::{json, Value};
-// use tokio::spawn;
-// use tokio::time::Instant;
-// use tracing::{error, info};
-// use global::trace_stack::TraceStack;
-// use crate::exchange::ExchangeEnum;
-// use crate::{Account, Market, Order, OrderCommand, Platform, Position, PositionModeEnum, Ticker, utils};
-//
-// #[allow(dead_code)]
-// #[derive(Clone)]
-// pub struct BitgetSwap {
-//     exchange: ExchangeEnum,
-//     symbol: String,
-//     is_colo: bool,
-//     params: BTreeMap<String, String>,
-//     request: BitgetSwapRest,
-//     market: Market,
-//     order_sender: Sender<Order>,
-//     error_sender: Sender<Error>,
-// }
-//
-// impl BitgetSwap {
-//     pub async fn new(symbol: String, is_colo: bool, params: BTreeMap<String, String>, order_sender: Sender<Order>, error_sender: Sender<Error>) -> BitgetSwap {
-//         let market = Market::new();
-//         let mut bitget_swap = BitgetSwap {
-//             exchange: ExchangeEnum::BitgetSwap,
-//             symbol: symbol.to_uppercase(),
-//             is_colo,
-//             params: params.clone(),
-//             request: BitgetSwapRest::new(is_colo, params.clone()),
-//             market,
-//             order_sender,
-//             error_sender,
-//         };
-//         bitget_swap.market = BitgetSwap::get_market(&mut bitget_swap).await.unwrap();
-//         // 修改持仓模式
-//         let mode_result = bitget_swap.set_dual_mode("", true).await;
-//         match mode_result {
-//             Ok(ok) => {
-//                 info!("BitgetSwap:设置持仓模式成功！{:?}", ok);
-//             }
-//             Err(error) => {
-//                 error!("BitgetSwap:设置持仓模式失败！{:?}", error)
-//             }
-//         }
-//         // 设置持仓杠杆
-//         // let lever_rate_result = bitget_swap.set_dual_leverage("10").await;
-//         // match lever_rate_result {
-//         //     Ok(ok) => {
-//         //         info!("BitgetSwap:设置持仓杠杆成功！{:?}", ok);
-//         //     }
-//         //     Err(error) => {
-//         //         error!("BitgetSwap:设置持仓杠杆失败！{:?}", error)
-//         //     }
-//         // }
-//
-//         return bitget_swap;
-//     }
-// }
-//
-// #[async_trait]
-// impl Platform for BitgetSwap {
-//     fn clone_box(&self) -> Box<dyn Platform + Send + Sync> { Box::new(self.clone()) }
-//
-//     fn get_self_exchange(&self) -> ExchangeEnum { ExchangeEnum::BitgetSwap }
-//
-//     fn get_self_symbol(&self) -> String { self.symbol.clone() }
-//
-//     fn get_self_is_colo(&self) -> bool { self.is_colo }
-//
-//     fn get_self_params(&self) -> BTreeMap<String, String> { self.params.clone() }
-//
-//     fn get_self_market(&self) -> Market { self.market.clone() }
-//
-//     fn get_request_delays(&self) -> Vec<i64> {
-//         // self.request.get_delays()
-//         vec![]
-//     }
-//
-//     fn get_request_avg_delay(&self) -> Decimal {
-//         // self.request.get_avg_delay()
-//         Decimal::ZERO
-//     }
-//
-//     fn get_request_max_delay(&self) -> i64 { 0 }
-//
-//     async fn get_server_time(&mut self) -> Result<String, Error> {
-//         let res_data = self.request.get_server_time().await;
-//         if res_data.code == 200 {
-//             let res_data_json = res_data.data;
-//             let result = res_data_json["serverTime"].as_str().unwrap().to_string();
-//             Ok(result)
-//         } else {
-//             Err(Error::new(ErrorKind::Other, res_data.to_string()))
-//         }
-//     }
-//
-//     async fn get_account(&mut self) -> Result<Account, Error> {
-//         let response = self.request.get_account_info().await;
-//
-//         if response.code == 200 {
-//             for data in response.data.as_array().unwrap() {
-//                 if data["marginCoin"].as_str().unwrap() != "USDT" {
-//                     continue
-//                 }
-//
-//                 // 格式化account信息
-//                 let mut account = Account {
-//                     coin: data["marginCoin"].to_string(),
-//                     balance: Decimal::from_str(data["accountEquity"].as_str().unwrap()).unwrap(),
-//                     available_balance: Decimal::from_str(data["available"].as_str().unwrap()).unwrap(),
-//                     frozen_balance: Default::default(),
-//                     stocks: Default::default(),
-//                     available_stocks: Default::default(),
-//                     frozen_stocks: Default::default(),
-//                 };
-//                 account.frozen_balance = account.balance - account.available_balance;
-//
-//                 return Ok(account)
-//             }
-//
-//             Err(Error::new(ErrorKind::NotFound, format!("bitget_usdt_swap 未能找到USDT账户：{}。", response.to_string())))
-//         } else {
-//             Err(Error::new(ErrorKind::Other, response.to_string()))
-//         }
-//     }
-//
-//     async fn get_spot_account(&mut self) -> Result<Vec<Account>, Error> {
-//         Err(Error::new(ErrorKind::NotFound, "bitget_swap get_spot_account：该交易所方法未实现".to_string()))
-//     }
-//
-//     async fn get_position(&mut self) -> Result<Vec<Position>, Error> { Err(Error::new(ErrorKind::NotFound, "bitget_swap get_position：该交易所方法未实现".to_string())) }
-//
-//     async fn get_positions(&mut self) -> Result<Vec<Position>, Error> {
-//         let params = json!({
-//             "productType": "USDT-FUTURES",
-//             "marginCoin": "USDT"
-//         });
-//         let response = self.request.get_all_position(params).await;
-//         info!(?response);
-//
-//         if response.code != 200 {
-//             return Err(Error::new(ErrorKind::NotFound, format!("bitget_swap 获取仓位异常{:?}", response).to_string()))
-//         }
-//
-//         // 正常处理持仓信息
-//         let mut positions: Vec<Position> = vec![];
-//         if response.data.is_null() {
-//             return Ok(positions)
-//         }
-//
-//         let positions_json = response.data.as_array().unwrap();
-//         for position_json in positions_json {
-//             let symbol = position_json["symbol"].as_str().unwrap().to_string();
-//             let margin_level = Decimal::from_str(position_json["leverage"].as_str().unwrap()).unwrap();
-//             let amount = Decimal::from_str(position_json["total"].as_str().unwrap()).unwrap();
-//             let frozen_amount = Decimal::from_str(position_json["locked"].as_str().unwrap()).unwrap();
-//             let price = Decimal::from_str(position_json["openPriceAvg"].as_str().unwrap()).unwrap();
-//             let profit = Decimal::from_str(position_json["unrealizedPL"].as_str().unwrap()).unwrap();
-//             let position_mode = match position_json["posMode"].as_str().unwrap() {
-//                 "hedge_mode" => {
-//                     match position_json["holdSide"].as_str().unwrap() {
-//                         "short" => {
-//                             PositionModeEnum::Short
-//                         }
-//                         "long" => {
-//                             PositionModeEnum::Long
-//                         },
-//                         _ => {
-//                             panic!("bitget_usdt_swap: 未知的持仓模式与持仓方向: {}, {}",
-//                                    position_json["posMode"].as_str().unwrap(), position_json["holdSide"].as_str().unwrap())
-//                         }
-//                     }
-//                 },
-//                 "one_way_mode" => {
-//                     PositionModeEnum::Both
-//                 },
-//                 _ => {
-//                     panic!("bitget_usdt_swap: 未知的持仓模式: {}", position_json["posMode"].as_str().unwrap())
-//                 }
-//             };
-//             let margin = Decimal::from_str(position_json["marginSize"].as_str().unwrap()).unwrap();
-//
-//             positions.push(Position {
-//                 symbol,
-//                 margin_level,
-//                 amount,
-//                 frozen_amount,
-//                 price,
-//                 profit,
-//                 position_mode,
-//                 margin,
-//             });
-//         }
-//
-//         Ok(positions)
-//     }
-//
-//     async fn get_ticker(&mut self) -> Result<Ticker, Error> {
-//         return self.get_ticker_symbol(self.symbol.clone()).await
-//     }
-//
-//     async fn get_ticker_symbol(&mut self, symbol: String) -> Result<Ticker, Error> {
-//         let symbol_format = utils::format_symbol(symbol.clone(), "");
-//         let res_data = self.request.get_tickers(symbol_format).await;
-//         if res_data.code == 200 {
-//             let res_data_json = res_data.data;
-//             let ticker_info = res_data_json[0].clone();
-//             let time = (Decimal::from_str(&*ticker_info["ts"].as_str().unwrap()).unwrap() / dec!(1000)).floor().to_i64().unwrap();
-//             let result = Ticker {
-//                 time,
-//                 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(),
-//                 buy: Decimal::from_str(ticker_info["bidPr"].as_str().unwrap()).unwrap(),
-//                 last: Decimal::from_str(ticker_info["lastPr"].as_str().unwrap()).unwrap(),
-//                 volume: Decimal::from_str(ticker_info["quoteVolume"].as_str().unwrap()).unwrap(),
-//             };
-//             Ok(result)
-//         } else {
-//             Err(Error::new(ErrorKind::Other, res_data.to_string()))
-//         }
-//     }
-//
-//     async fn get_market(&mut self) -> Result<Market, Error> {
-//         self.get_market_symbol(self.symbol.clone()).await
-//     }
-//
-//     async fn get_market_symbol(&mut self, symbol: String) -> Result<Market, Error> {
-//         let symbol_format = utils::format_symbol(symbol.clone(), "");
-//         let response = self.request.get_contracts(symbol_format.clone()).await;
-//
-//         if response.code == 200 {
-//             let res_data_json = response.data.as_array().unwrap();
-//             let market_info = res_data_json[0].clone();
-//
-//             info!(?market_info);
-//             if !market_info["symbol"].as_str().unwrap().to_string().eq(&symbol_format) {
-//                 return Err(Error::new(ErrorKind::NotFound, format!("符号未找到：symbol={}, response={:?}", symbol_format, response))).unwrap();
-//             }
-//
-//             let base_asset = market_info["baseCoin"].as_str().unwrap().to_string();
-//             let quote_asset = market_info["quoteCoin"].as_str().unwrap().to_string();
-//             let price_precision = Decimal::from_str(market_info["pricePlace"].as_str().unwrap()).unwrap();
-//             let tick_size = Decimal::TEN.powd(Decimal::NEGATIVE_ONE * price_precision);
-//             let amount_precision = Decimal::from_str(market_info["volumePlace"].as_str().unwrap()).unwrap();
-//             let amount_size = Decimal::TEN.powd(Decimal::NEGATIVE_ONE * amount_precision);
-//             let min_qty = Decimal::NEGATIVE_ONE;
-//             let max_qty = Decimal::NEGATIVE_ONE;
-//             // let ct_val = Decimal::from_str(&market_info["sizeMultiplier"].as_str().unwrap()).unwrap();
-//             let ct_val = Decimal::ONE;
-//
-//             let result = Market {
-//                 symbol: format!("{}_{}", base_asset, quote_asset),
-//                 base_asset,
-//                 quote_asset,
-//                 tick_size,
-//                 amount_size,
-//                 price_precision,
-//                 amount_precision,
-//                 min_qty,
-//                 max_qty,
-//                 min_notional: min_qty,
-//                 max_notional: max_qty,
-//                 ct_val,
-//             };
-//             Ok(result)
-//         } else {
-//             Err(Error::new(ErrorKind::Other, response.to_string()))
-//         }
-//     }
-//
-//     async fn get_order_detail(&mut self, order_id: &str, custom_id: &str) -> Result<Order, Error> {
-//         let symbol_format = utils::format_symbol(self.symbol.clone(), "");
-//         let params = json!({
-//             "symbol": symbol_format,
-//             "productType": "USDT-FUTURES",
-//             "clientOid": custom_id,
-//             "orderId": order_id
-//         });
-//
-//         let ct_val = self.market.ct_val;
-//         let response = self.request.get_order(params).await;
-//         if response.code == 200 {
-//             let res_data_json = response.data;
-//             let result = format_order_item(res_data_json, ct_val);
-//             Ok(result)
-//         } else {
-//             Err(Error::new(ErrorKind::Other, response.to_string()))
-//         }
-//     }
-//
-//     async fn get_orders_list(&mut self, _status: &str) -> Result<Vec<Order>, Error> {
-//         Err(Error::new(ErrorKind::NotFound, "bitget_swap get_orders_list：该交易所方法未实现".to_string()))
-//         // let symbol_format = utils::format_symbol(self.symbol.clone(), "");
-//         // let ct_val = self.market.ct_val;
-//         // let res_data = self.request.get_unfilled_orders(symbol_format.to_string(), "".to_string(), "".to_string(), "".to_string(), "100".to_string(), "".to_string()).await;
-//         // if res_data.code == 200 {
-//         //     let res_data_str = &res_data.data;
-//         //     let res_data_json: Vec<serde_json::Value> = serde_json::from_str(res_data_str).unwrap();
-//         //     let result = res_data_json.iter().map(|item| format_order_item(item.clone(), ct_val)).collect();
-//         //     Ok(result)
-//         // } else {
-//         //     Err(Error::new(ErrorKind::Other, res_data.to_string()))
-//         // }
-//     }
-//
-//     async fn take_order(&mut self, custom_id: &str, origin_side: &str, price: Decimal, amount: Decimal) -> Result<Order, Error> {
-//         let ct_val = self.market.ct_val;
-//
-//         return self.take_order_symbol(self.symbol.clone(), ct_val, custom_id, origin_side, price, amount).await;
-//     }
-//
-//     async fn take_order_symbol(&mut self, symbol: String, ct_val: Decimal, custom_id: &str, origin_side: &str, price: Decimal, amount: Decimal) -> Result<Order, Error> {
-//         let symbol_format = utils::format_symbol(symbol, "");
-//         let final_size = amount / ct_val;
-//         let mut params = json!({
-//             "symbol": symbol_format,
-//             "clientOid": custom_id,
-//             "productType": "USDT-FUTURES",
-//             "marginMode": "crossed",
-//             "marginCoin": "USDT",
-//             "size": final_size.to_string()
-//         });
-//         if price.eq(&Decimal::ZERO) {
-//             params["orderType"] = json!("market");
-//             params["force"] = json!("gtc");
-//         } else {
-//             params["price"] = json!(price.to_string());
-//             params["orderType"] = json!("limit");
-//             params["force"] = json!("gtc");
-//         };
-//         match origin_side {
-//             "kd" => {
-//                 params["side"] = json!("buy");
-//                 params["tradeSide"] = json!("open");
-//             }
-//             "pd" => {
-//                 params["side"] = json!("buy");
-//                 params["tradeSide"] = json!("close");
-//             }
-//             "kk" => {
-//                 params["side"] = json!("sell");
-//                 params["tradeSide"] = json!("open");
-//             }
-//             "pk" => {
-//                 params["side"] = json!("sell");
-//                 params["tradeSide"] = json!("close");
-//             }
-//             _ => { panic!("bitget_usdt_swap 下单参数错误"); }
-//         };
-//         let res_data = self.request.swap_order(params).await;
-//         if res_data.code != 200 {
-//             return Err(Error::new(ErrorKind::Other, res_data.to_string()))
-//         }
-//
-//         let res_data_json = res_data.data;
-//         let result = Order {
-//             id: res_data_json["orderId"].as_str().unwrap().to_string(),
-//             custom_id: res_data_json["clientOid"].as_str().unwrap().to_string(),
-//             price: Decimal::ZERO,
-//             amount: Decimal::ZERO,
-//             deal_amount: Decimal::ZERO,
-//             avg_price: Decimal::ZERO,
-//             status: "NEW".to_string(),
-//             order_type: "".to_string(),
-//             trace_stack: TraceStack::new(0, Instant::now()).on_special("328 bitget_swap".to_string()),
-//         };
-//         return Ok(result)
-//     }
-//
-//     async fn cancel_order(&mut self, order_id: &str, custom_id: &str) -> Result<Order, Error> {
-//         let symbol_format = utils::format_symbol(self.symbol.clone(), "");
-//         let params = json!({
-//             "symbol": symbol_format,
-//             "productType": "USDT-FUTURES",
-//             "clientOid": custom_id,
-//             "orderId": order_id
-//         });
-//         let response = self.request.cancel_order(params).await;
-//
-//         // 取消失败，进行报错
-//         if response.code != 200 {
-//             return Err(Error::new(ErrorKind::NotFound, response.to_string()));
-//         }
-//
-//         let res_data_json = response.data;
-//         let result = Order {
-//             id: res_data_json["orderId"].as_str().unwrap().to_string(),
-//             custom_id: res_data_json["clientOid"].as_str().unwrap().to_string(),
-//             price: Decimal::ZERO,
-//             amount: Decimal::ZERO,
-//             deal_amount: Decimal::ZERO,
-//             avg_price: Decimal::ZERO,
-//             status: "REMOVE".to_string(),
-//             order_type: "".to_string(),
-//             trace_stack: TraceStack::new(0, Instant::now()).on_special("443 bitget_swap".to_string()),
-//         };
-//         Ok(result)
-//     }
-//
-//     async fn cancel_orders(&mut self) -> Result<Vec<Order>, Error> {
-//         Err(Error::new(ErrorKind::NotFound, "bitget_swap cancel_orders：该交易所方法未实现".to_string()))
-//     }
-//
-//     async fn cancel_orders_all(&mut self) -> Result<Vec<Order>, Error> {
-//         let response = self.request.get_pending_orders().await;
-//         if response.code == 200 {
-//             info!("{}", response.data.to_string());
-//             let mut result = vec![];
-//
-//             if !response.data["entrustedList"].is_null() {
-//                 let orders_res_data_json = response.data["entrustedList"].as_array().unwrap();
-//                 for order in orders_res_data_json {
-//                     let symbol = order["symbol"].as_str().unwrap().to_string();
-//                     let order_id = order["orderId"].as_str().unwrap().to_string();
-//                     let params = json!({
-//                         "symbol": symbol,
-//                         "productType": "USDT-FUTURES",
-//                         "orderId": order_id,
-//                     });
-//                     let cancel_res_data = self.request.cancel_order(params).await;
-//                     if cancel_res_data.code == 200 {
-//                         let cancel_res_data_json = cancel_res_data.data;
-//                         result.push(Order {
-//                             id: cancel_res_data_json["orderId"].as_str().unwrap().to_string(),
-//                             custom_id: cancel_res_data_json["clientOid"].as_str().unwrap().to_string(),
-//                             price: Decimal::ZERO,
-//                             amount: Decimal::ZERO,
-//                             deal_amount: Decimal::ZERO,
-//                             avg_price: Decimal::ZERO,
-//                             status: "REMOVE".to_string(),
-//                             order_type: "".to_string(),
-//                             trace_stack: TraceStack::new(0, Instant::now()).on_special("457 bitget_swap".to_string()),
-//                         });
-//                     } else {
-//                         return Err(Error::new(ErrorKind::Other, cancel_res_data.to_string()));
-//                     }
-//                 }
-//             }
-//             Ok(result)
-//         } else {
-//             Err(Error::new(ErrorKind::Other, response.to_string()))
-//         }
-//     }
-//
-//     async fn take_stop_loss_order(&mut self, _stop_price: Decimal, _price: Decimal, _side: &str) -> Result<Value, Error> {
-//         Err(Error::new(ErrorKind::NotFound, "bitget_swap take_stop_loss_order：该交易所方法未实现".to_string()))
-//     }
-//
-//     async fn cancel_stop_loss_order(&mut self, _order_id: &str) -> Result<Value, Error> {
-//         Err(Error::new(ErrorKind::NotFound, "bitget_swap cancel_stop_loss_order：该交易所方法未实现".to_string()))
-//     }
-//
-//     async fn set_dual_mode(&mut self, _coin: &str, is_dual_mode: bool) -> Result<String, Error> {
-//         let pos_mode = if is_dual_mode {
-//             "hedge_mode"
-//         } else {
-//             "one_way_mode"
-//         };
-//         let params = json!({
-//             "productType": "USDT-FUTURES",
-//             "posMode": pos_mode,
-//         });
-//         let response = self.request.set_position_mode(params).await;
-//
-//         if response.code != 200 {
-//             return Err(Error::new(ErrorKind::Other, format!("设置持仓模式失败:{:?}", response).to_string()))
-//         }
-//
-//         return Ok(response.data.to_string());
-//     }
-//
-//     async fn set_dual_leverage(&mut self, leverage: &str) -> Result<String, Error> {
-//         let params = json!({
-//             "symbol": "ETHUSDT",
-//             "productType": "USDT-FUTURES",
-//             "marginCoin": "USDT",
-//             "leverage": leverage
-//         });
-//         let response = self.request.set_leverage(params).await;
-//
-//         if response.code != 200 {
-//             return Err(Error::new(ErrorKind::Other, format!("设置杠杆失败:{:?}", response).to_string()))
-//         }
-//
-//         return Ok(response.data.to_string());
-//     }
-//
-//     async fn set_auto_deposit_status(&mut self, _status: bool) -> Result<String, Error> {
-//         Err(Error::new(ErrorKind::NotFound, "bitget_swap set_auto_deposit_status：该交易所方法未实现".to_string()))
-//     }
-//
-//     async fn wallet_transfers(&mut self, _coin: &str, _from: &str, _to: &str, _amount: Decimal) -> Result<String, Error> {
-//         Err(Error::new(ErrorKind::NotFound, "bitget_swap wallet_transfers：该交易所方法未实现".to_string()))
-//         // let coin_format = coin.to_string().to_uppercase();
-//         // let res_data = self.request.wallet_transfer(from.to_string(), to.to_string(), amount.to_string(), coin_format.clone(), "".to_string(), "".to_string()).await;
-//         // if res_data.code == 200 {
-//         //     let res_data_str = &res_data.data;
-//         //     let result = res_data_str.clone();
-//         //     Ok(result)
-//         // } else {
-//         //     Err(Error::new(ErrorKind::Other, res_data.to_string()))
-//         // }
-//     }
-//
-//     async fn command_order(&mut self, order_command: &mut OrderCommand, trace_stack: &TraceStack) {
-//         let mut handles = vec![];
-//
-//         // 下单指令
-//         for item in order_command.limits_open.keys() {
-//             let mut ts = trace_stack.clone();
-//
-//             let amount = Decimal::from_str(&*order_command.limits_open[item].get(0).unwrap().clone()).unwrap();
-//             let side = order_command.limits_open[item].get(1).unwrap().clone();
-//             let price = Decimal::from_str(&*order_command.limits_open[item].get(2).unwrap().clone()).unwrap();
-//             let cid = order_command.limits_open[item].get(3).unwrap().clone();
-//
-//             //  order_name: [数量，方向，价格，c_id]
-//             let mut self_clone = self.clone();
-//             let handle = spawn(async move {
-//                 // TraceStack::show_delay(&ts.ins);
-//                 ts.on_before_send();
-//                 let result = self_clone.take_order(cid.as_str(), side.as_str(), price, amount).await;
-//                 ts.on_after_send();
-//
-//                 match result {
-//                     Ok(mut result) => {
-//                         result.trace_stack = ts;
-//
-//                         self_clone.order_sender.send(result).await.unwrap();
-//                     }
-//                     Err(error) => {
-//                         info!(?error);
-//                         let mut err_order = Order::new();
-//                         err_order.custom_id = cid.clone();
-//                         err_order.status = "REMOVE".to_string();
-//
-//                         self_clone.order_sender.send(err_order).await.unwrap();
-//                         self_clone.error_sender.send(error).await.unwrap();
-//                     }
-//                 }
-//             });
-//             handles.push(handle)
-//         }
-//         let futures = FuturesUnordered::from_iter(handles);
-//         // 等待所有任务完成
-//         let _: Result<Vec<_>, _> = futures.try_collect().await;
-//
-//         // 撤销订单
-//         let mut cancel_handlers = vec![];
-//         for item in order_command.cancel.keys() {
-//             let order_id = order_command.cancel[item].get(1).unwrap().clone();
-//             let custom_id = order_command.cancel[item].get(0).unwrap().clone();
-//
-//             let mut self_clone = self.clone();
-//             let handle = spawn(async move {
-//                 let result = self_clone.cancel_order(&order_id, &custom_id).await;
-//                 match result {
-//                     Ok(_) => {
-//                         // result_sd.send(result).await.unwrap();
-//                     }
-//                     Err(error) => {
-//                         // 取消失败去查订单。
-//                         let query_rst = self_clone.get_order_detail(&order_id, &custom_id).await;
-//                         match query_rst {
-//                             Ok(order) => {
-//                                 self_clone.order_sender.send(order).await.unwrap();
-//                             }
-//                             Err(err) => {
-//                                 error!("撤单失败，而且查单也失败了，bitget_swap，oid={}, cid={}, err={:?}。", order_id.clone(), custom_id.clone(), err);
-//                             }
-//                         }
-//                         self_clone.error_sender.send(error).await.unwrap();
-//                     }
-//                 }
-//             });
-//             cancel_handlers.push(handle)
-//         }
-//         let futures = FuturesUnordered::from_iter(cancel_handlers);
-//         // 等待所有任务完成
-//         let _: Result<Vec<_>, _> = futures.try_collect().await;
-//
-//         // 检查订单指令
-//         let mut check_handlers = vec![];
-//         for item in order_command.check.keys() {
-//             let order_id = order_command.check[item].get(1).unwrap().clone();
-//             let custom_id = order_command.check[item].get(0).unwrap().clone();
-//
-//             let mut self_clone = self.clone();
-//             let handle = spawn(async move {
-//                 let result = self_clone.get_order_detail(order_id.as_str(), custom_id.as_str()).await;
-//                 match result {
-//                     Ok(result) => {
-//                         self_clone.order_sender.send(result).await.unwrap();
-//                     }
-//                     Err(error) => {
-//                         self_clone.error_sender.send(error).await.unwrap();
-//                     }
-//                 }
-//             });
-//             check_handlers.push(handle)
-//         }
-//
-//         let futures = FuturesUnordered::from_iter(check_handlers);
-//         // 等待所有任务完成
-//         let _: Result<Vec<_>, _> = futures.try_collect().await;
-//     }
-// }
-//
-// // pub fn format_account_info(balance_data: Value) -> Account {
-// //     let balance_coin = balance_data["coin"].as_str().unwrap().to_string().to_uppercase();
-// //     let available_balance = Decimal::from_str(balance_data["available"].as_str().unwrap()).unwrap();
-// //     let frozen_balance = Decimal::from_str(balance_data["frozen"].as_str().unwrap()).unwrap();
-// //     let balance = available_balance + frozen_balance;
-// //
-// //     Account {
-// //         coin: balance_coin,
-// //         balance,
-// //         available_balance,
-// //         frozen_balance,
-// //         stocks: Decimal::ZERO,
-// //         available_stocks: Decimal::ZERO,
-// //         frozen_stocks: Decimal::ZERO,
-// //     }
-// // }
-//
-// pub fn format_order_item(order: Value, ct_val: Decimal) -> Order {
-//     let price = Decimal::from_str(order["price"].as_str().unwrap_or(order["priceAvg"].as_str().unwrap())).unwrap();
-//     let size = Decimal::from_str(order["size"].as_str().unwrap()).unwrap();
-//     let status = order["state"].as_str().unwrap();
-//     let base_volume = Decimal::from_str(order["quoteVolume"].as_str().unwrap()).unwrap();
-//     let avg_price = if order["priceAvg"].is_null() || order["priceAvg"].as_str().unwrap().is_empty() {
-//         Decimal::ZERO
-//     } else {
-//         Decimal::from_str(order["priceAvg"].as_str().unwrap().to_string().as_str()).unwrap()
-//     };
-//
-//     let amount = size * ct_val;
-//     let deal_amount = base_volume * ct_val;
-//     let custom_status = if ["filled", "cancelled"].contains(&status) {
-//         "REMOVE".to_string()
-//     } else if ["init", "live", "new", "partially_filled"].contains(&status) {
-//         "NEW".to_string()
-//     } else {
-//         "NULL".to_string()
-//     };
-//     Order {
-//         id: order["orderId"].as_str().unwrap().to_string(),
-//         custom_id: order["clientOid"].as_str().unwrap().to_string(),
-//         price,
-//         amount,
-//         deal_amount,
-//         avg_price,
-//         status: custom_status,
-//         order_type: order["orderType"].as_str().unwrap().to_string(),
-//         trace_stack: TraceStack::new(0, Instant::now()).on_special("700 bitget_swap".to_string()),
+use std::collections::{BTreeMap};
+use exchanges::bitget_swap_rest::BitgetSwapRest;
+use std::io::{Error, ErrorKind};
+use tokio::sync::mpsc::Sender;
+use std::str::FromStr;
+use async_trait::async_trait;
+use futures::stream::FuturesUnordered;
+use futures::TryStreamExt;
+use rust_decimal::{Decimal, MathematicalOps};
+use rust_decimal_macros::dec;
+use serde_json::{json, Value};
+use tokio::spawn;
+use tokio::time::Instant;
+use tracing::{error, info};
+use global::trace_stack::TraceStack;
+use crate::exchange::ExchangeEnum;
+use crate::{Account, Market, Order, OrderCommand, Platform, Position, PositionModeEnum, Record, Ticker, utils};
+
+#[allow(dead_code)]
+#[derive(Clone)]
+pub struct BitgetSwap {
+    exchange: ExchangeEnum,
+    symbol: String,
+    is_colo: bool,
+    params: BTreeMap<String, String>,
+    request: BitgetSwapRest,
+    market: Market,
+    order_sender: Sender<Order>,
+    error_sender: Sender<Error>,
+}
+
+impl BitgetSwap {
+    pub async fn new(symbol: String, is_colo: bool, params: BTreeMap<String, String>, order_sender: Sender<Order>, error_sender: Sender<Error>) -> BitgetSwap {
+        let market = Market::new();
+        let mut bitget_swap = BitgetSwap {
+            exchange: ExchangeEnum::BitgetSwap,
+            symbol: symbol.to_uppercase(),
+            is_colo,
+            params: params.clone(),
+            request: BitgetSwapRest::new(is_colo, params.clone()),
+            market,
+            order_sender,
+            error_sender,
+        };
+        bitget_swap.market = BitgetSwap::get_market(&mut bitget_swap).await.unwrap();
+        // 修改持仓模式
+        let mode_result = bitget_swap.set_dual_mode("", false).await;
+        match mode_result {
+            Ok(ok) => {
+                info!("BitgetSwap:设置持仓模式成功！{:?}", ok);
+            }
+            Err(error) => {
+                error!("BitgetSwap:设置持仓模式失败！{:?}", error)
+            }
+        }
+        // 设置持仓杠杆
+        let lever_rate_result = bitget_swap.set_dual_leverage("1").await;
+        match lever_rate_result {
+            Ok(ok) => {
+                info!("BitgetSwap:设置持仓杠杆成功！{:?}", ok);
+            }
+            Err(error) => {
+                error!("BitgetSwap:设置持仓杠杆失败！{:?}", error)
+            }
+        }
+
+        return bitget_swap;
+    }
+}
+
+#[async_trait]
+impl Platform for BitgetSwap {
+    fn clone_box(&self) -> Box<dyn Platform + Send + Sync> { Box::new(self.clone()) }
+
+    fn get_self_exchange(&self) -> ExchangeEnum { ExchangeEnum::BitgetSwap }
+
+    fn get_self_symbol(&self) -> String { self.symbol.clone() }
+
+    fn get_self_is_colo(&self) -> bool { self.is_colo }
+
+    fn get_self_params(&self) -> BTreeMap<String, String> { self.params.clone() }
+
+    fn get_self_market(&self) -> Market { self.market.clone() }
+
+    fn get_request_delays(&self) -> Vec<i64> {
+        // self.request.get_delays()
+        vec![]
+    }
+
+    fn get_request_avg_delay(&self) -> Decimal {
+        // self.request.get_avg_delay()
+        Decimal::ZERO
+    }
+
+    fn get_request_max_delay(&self) -> i64 { 0 }
+
+    async fn get_server_time(&mut self) -> Result<String, Error> {
+        let res_data = self.request.get_server_time().await;
+        if res_data.code == 200 {
+            let res_data_json = res_data.data;
+            let result = res_data_json["serverTime"].as_str().unwrap().to_string();
+            Ok(result)
+        } else {
+            Err(Error::new(ErrorKind::Other, res_data.to_string()))
+        }
+    }
+
+    async fn get_account(&mut self) -> Result<Account, Error> {
+        let response = self.request.get_account_info().await;
+
+        if response.code == 200 {
+            for data in response.data.as_array().unwrap() {
+                if data["marginCoin"].as_str().unwrap() != "USDT" {
+                    continue;
+                }
+
+                // 格式化account信息
+                let mut account = Account {
+                    coin: data["marginCoin"].as_str().unwrap().to_string(),
+                    balance: Decimal::from_str(data["accountEquity"].as_str().unwrap()).unwrap(),
+                    available_balance: Decimal::from_str(data["available"].as_str().unwrap()).unwrap(),
+                    frozen_balance: Default::default(),
+                    stocks: Default::default(),
+                    available_stocks: Default::default(),
+                    frozen_stocks: Default::default(),
+                };
+                account.frozen_balance = account.balance - account.available_balance;
+
+                return Ok(account);
+            }
+
+            Err(Error::new(ErrorKind::NotFound, format!("bitget_usdt_swap 未能找到USDT账户：{}。", response.to_string())))
+        } else {
+            Err(Error::new(ErrorKind::Other, response.to_string()))
+        }
+    }
+
+    async fn get_spot_account(&mut self) -> Result<Vec<Account>, Error> {
+        Err(Error::new(ErrorKind::NotFound, "bitget_swap get_spot_account：该交易所方法未实现".to_string()))
+    }
+
+    async fn get_position(&mut self) -> Result<Vec<Position>, Error> {
+        let symbol_format = utils::format_symbol(self.symbol.clone(), "");
+        let params = json!({
+            "productType": "USDT-FUTURES",
+            "marginCoin": "USDT",
+            "symbol": symbol_format
+        });
+        let response = self.request.get_single_position(params).await;
+        if response.code != 200 {
+            return Err(Error::new(ErrorKind::NotFound, format!("bitget_swap 获取仓位异常{:?}", response).to_string()));
+        }
+
+        // 正常处理持仓信息
+        let mut positions: Vec<Position> = vec![];
+        if response.data.is_null() {
+            return Ok(positions);
+        }
+
+        let positions_json = response.data.as_array().unwrap();
+        for position_json in positions_json {
+            let symbol = position_json["symbol"].as_str().unwrap().to_string();
+            let margin_level = Decimal::from_str(position_json["leverage"].as_str().unwrap()).unwrap();
+            let amount = Decimal::from_str(position_json["total"].as_str().unwrap()).unwrap();
+            let frozen_amount = Decimal::from_str(position_json["locked"].as_str().unwrap()).unwrap();
+            let price = Decimal::from_str(position_json["openPriceAvg"].as_str().unwrap()).unwrap();
+            let profit = Decimal::from_str(position_json["unrealizedPL"].as_str().unwrap()).unwrap();
+            let mut position_mode = match position_json["posMode"].as_str().unwrap() {
+                "hedge_mode" => {
+                    match position_json["holdSide"].as_str().unwrap() {
+                        "short" => {
+                            PositionModeEnum::Short
+                        }
+                        "long" => {
+                            PositionModeEnum::Long
+                        }
+                        _ => {
+                            panic!("bitget_usdt_swap: 未知的持仓模式与持仓方向: {}, {}",
+                                   position_json["posMode"].as_str().unwrap(), position_json["holdSide"].as_str().unwrap())
+                        }
+                    }
+                }
+                "one_way_mode" => {
+                    PositionModeEnum::Both
+                }
+                _ => {
+                    panic!("bitget_usdt_swap: 未知的持仓模式: {}", position_json["posMode"].as_str().unwrap())
+                }
+            };
+            let margin = Decimal::from_str(position_json["marginSize"].as_str().unwrap()).unwrap();
+
+            let side = position_json["holdSide"].as_str().unwrap();
+            match position_mode {
+                PositionModeEnum::Both => {
+                    position_mode = match side {
+                        "long" => PositionModeEnum::Long,
+                        "short" => PositionModeEnum::Short,
+                        _ => { PositionModeEnum::Both }
+                    }
+                }
+                _ => {}
+            }
+
+            positions.push(Position {
+                symbol,
+                margin_level,
+                amount,
+                frozen_amount,
+                price,
+                profit,
+                position_mode,
+                margin,
+            });
+        }
+
+        Ok(positions)
+    }
+
+    async fn get_positions(&mut self) -> Result<Vec<Position>, Error> {
+        let params = json!({
+            "productType": "USDT-FUTURES",
+            "marginCoin": "USDT"
+        });
+        let response = self.request.get_all_position(params).await;
+
+        if response.code != 200 {
+            return Err(Error::new(ErrorKind::NotFound, format!("bitget_swap 获取仓位异常{:?}", response).to_string()));
+        }
+
+        // 正常处理持仓信息
+        let mut positions: Vec<Position> = vec![];
+        if response.data.is_null() {
+            return Ok(positions);
+        }
+
+        let positions_json = response.data.as_array().unwrap();
+        for position_json in positions_json {
+            let symbol = position_json["symbol"].as_str().unwrap().to_string();
+            let margin_level = Decimal::from_str(position_json["leverage"].as_str().unwrap()).unwrap();
+            let amount = Decimal::from_str(position_json["total"].as_str().unwrap()).unwrap();
+            let frozen_amount = Decimal::from_str(position_json["locked"].as_str().unwrap()).unwrap();
+            let price = Decimal::from_str(position_json["openPriceAvg"].as_str().unwrap()).unwrap();
+            let profit = Decimal::from_str(position_json["unrealizedPL"].as_str().unwrap()).unwrap();
+            let mut position_mode = match position_json["posMode"].as_str().unwrap() {
+                "hedge_mode" => {
+                    match position_json["holdSide"].as_str().unwrap() {
+                        "short" => {
+                            PositionModeEnum::Short
+                        }
+                        "long" => {
+                            PositionModeEnum::Long
+                        }
+                        _ => {
+                            panic!("bitget_usdt_swap: 未知的持仓模式与持仓方向: {}, {}",
+                                   position_json["posMode"].as_str().unwrap(), position_json["holdSide"].as_str().unwrap())
+                        }
+                    }
+                }
+                "one_way_mode" => {
+                    PositionModeEnum::Both
+                }
+                _ => {
+                    panic!("bitget_usdt_swap: 未知的持仓模式: {}", position_json["posMode"].as_str().unwrap())
+                }
+            };
+            let margin = Decimal::from_str(position_json["marginSize"].as_str().unwrap()).unwrap();
+
+            let side = position_json["holdSide"].as_str().unwrap();
+            match position_mode {
+                PositionModeEnum::Both => {
+                    position_mode = match side {
+                        "long" => PositionModeEnum::Long,
+                        "short" => PositionModeEnum::Short,
+                        _ => { PositionModeEnum::Both }
+                    }
+                }
+                _ => {}
+            }
+
+            positions.push(Position {
+                symbol,
+                margin_level,
+                amount,
+                frozen_amount,
+                price,
+                profit,
+                position_mode,
+                margin,
+            });
+        }
+
+        Ok(positions)
+    }
+
+    async fn get_ticker(&mut self) -> Result<Ticker, Error> {
+        return self.get_ticker_symbol(self.symbol.clone()).await;
+    }
+
+    async fn get_record(&mut self, interval: String) -> Result<Vec<Record>, Error> {
+        let symbol_format = utils::format_symbol(self.symbol.clone(), "");
+
+        let params = json!({
+            "symbol": symbol_format.clone(),
+            "productType": "USDT-FUTURES",
+            "granularity": format!("{}m",interval),
+            "limit": "3"
+        });
+
+        let res_data = self.request.get_market_candles(params).await;
+        if res_data.code == 200 {
+            let mut records: Vec<Record> = vec![];
+            for record_value in res_data.data.as_array().unwrap() {
+                records.push(Record {
+                    time: Decimal::from_str(record_value[0].as_str().unwrap()).unwrap(),
+                    open: Decimal::from_str(record_value[1].as_str().unwrap()).unwrap(),
+                    high: Decimal::from_str(record_value[2].as_str().unwrap()).unwrap(),
+                    low: Decimal::from_str(record_value[3].as_str().unwrap()).unwrap(),
+                    close: Decimal::from_str(record_value[4].as_str().unwrap()).unwrap(),
+                    volume: Decimal::from_str(record_value[5].as_str().unwrap()).unwrap(),
+                    symbol: symbol_format.clone(),
+                });
+            }
+
+            records.reverse();
+            Ok(records)
+        } else {
+            Err(Error::new(ErrorKind::Other, res_data.to_string()))
+        }
+    }
+
+    async fn get_ticker_symbol(&mut self, symbol: String) -> Result<Ticker, Error> {
+        let symbol_format = utils::format_symbol(symbol.clone(), "");
+        let res_data = self.request.get_tickers(symbol_format).await;
+        if res_data.code == 200 {
+            let res_data_json = res_data.data;
+            let ticker_info = res_data_json[0].clone();
+            let time = Decimal::from_str(&*ticker_info["ts"].as_str().unwrap()).unwrap() / dec!(1000);
+            let result = Ticker {
+                time,
+                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(),
+                buy: Decimal::from_str(ticker_info["bidPr"].as_str().unwrap()).unwrap(),
+                last: Decimal::from_str(ticker_info["lastPr"].as_str().unwrap()).unwrap(),
+                volume: Decimal::from_str(ticker_info["quoteVolume"].as_str().unwrap()).unwrap(),
+                open_interest: Default::default(),
+            };
+            Ok(result)
+        } else {
+            Err(Error::new(ErrorKind::Other, res_data.to_string()))
+        }
+    }
+
+    async fn get_market(&mut self) -> Result<Market, Error> {
+        self.get_market_symbol(self.symbol.clone()).await
+    }
+
+    async fn get_market_symbol(&mut self, symbol: String) -> Result<Market, Error> {
+        let symbol_format = utils::format_symbol(symbol.clone(), "");
+        let response = self.request.get_contracts(symbol_format.clone()).await;
+
+        if response.code == 200 {
+            let res_data_json = response.data.as_array().unwrap();
+            let market_info = res_data_json[0].clone();
+
+            if !market_info["symbol"].as_str().unwrap().to_string().eq(&symbol_format) {
+                return Err(Error::new(ErrorKind::NotFound, format!("符号未找到：symbol={}, response={:?}", symbol_format, response))).unwrap();
+            }
+
+            let base_asset = market_info["baseCoin"].as_str().unwrap().to_string();
+            let quote_asset = market_info["quoteCoin"].as_str().unwrap().to_string();
+            let price_precision = Decimal::from_str(market_info["pricePlace"].as_str().unwrap()).unwrap();
+            let tick_size = Decimal::TEN.powd(Decimal::NEGATIVE_ONE * price_precision);
+            let amount_precision = Decimal::from_str(market_info["volumePlace"].as_str().unwrap()).unwrap();
+            let amount_size = Decimal::TEN.powd(Decimal::NEGATIVE_ONE * amount_precision);
+            let min_qty = Decimal::from_str(market_info["minTradeNum"].as_str().unwrap()).unwrap();
+            let max_qty = Decimal::NEGATIVE_ONE;
+            let min_notional = Decimal::from_str(market_info["minTradeUSDT"].as_str().unwrap()).unwrap();
+            let max_notional = Decimal::NEGATIVE_ONE;
+            let multiplier = Decimal::from_str(&market_info["sizeMultiplier"].as_str().unwrap()).unwrap();
+            // let multiplier = Decimal::ONE;
+
+            let result = Market {
+                symbol: format!("{}_{}", base_asset, quote_asset),
+                base_asset,
+                quote_asset,
+                tick_size,
+                amount_size,
+                price_precision,
+                amount_precision,
+                min_qty,
+                max_qty,
+                min_notional,
+                max_notional,
+                multiplier,
+            };
+            Ok(result)
+        } else {
+            Err(Error::new(ErrorKind::Other, response.to_string()))
+        }
+    }
+
+    async fn get_order_detail(&mut self, order_id: &str, custom_id: &str) -> Result<Order, Error> {
+        let symbol_format = utils::format_symbol(self.symbol.clone(), "");
+        let params = json!({
+            "symbol": symbol_format,
+            "productType": "USDT-FUTURES",
+            "clientOid": custom_id,
+            "orderId": order_id
+        });
+
+        let multiplier = self.market.multiplier;
+        let response = self.request.get_order(params).await;
+        if response.code == 200 {
+            let res_data_json = response.data;
+            let result = format_order_item(res_data_json, multiplier);
+            Ok(result)
+        } else {
+            Err(Error::new(ErrorKind::Other, response.to_string()))
+        }
+    }
+
+    async fn get_orders_list(&mut self, _status: &str) -> Result<Vec<Order>, Error> {
+        Err(Error::new(ErrorKind::NotFound, "bitget_swap get_orders_list：该交易所方法未实现".to_string()))
+        // let symbol_format = utils::format_symbol(self.symbol.clone(), "");
+        // let multiplier = self.market.multiplier;
+        // let res_data = self.request.get_unfilled_orders(symbol_format.to_string(), "".to_string(), "".to_string(), "".to_string(), "100".to_string(), "".to_string()).await;
+        // if res_data.code == 200 {
+        //     let res_data_str = &res_data.data;
+        //     let res_data_json: Vec<serde_json::Value> = serde_json::from_str(res_data_str).unwrap();
+        //     let result = res_data_json.iter().map(|item| format_order_item(item.clone(), multiplier)).collect();
+        //     Ok(result)
+        // } else {
+        //     Err(Error::new(ErrorKind::Other, res_data.to_string()))
+        // }
+    }
+
+    async fn take_order(&mut self, custom_id: &str, origin_side: &str, price: Decimal, amount: Decimal) -> Result<Order, Error> {
+        let multiplier = self.market.multiplier;
+        return self.take_order_symbol(self.symbol.clone(), multiplier, custom_id, origin_side, price, amount).await;
+    }
+
+    async fn take_order_symbol(&mut self, symbol: String, multiplier: Decimal, custom_id: &str, origin_side: &str, price: Decimal, amount: Decimal) -> Result<Order, Error> {
+        let symbol_format = utils::format_symbol(symbol, "");
+        let mut params = json!({
+            "symbol": symbol_format,
+            "clientOid": custom_id,
+            "productType": "USDT-FUTURES",
+            "marginMode": "crossed",
+            "marginCoin": "USDT",
+            "size": amount.to_string()
+        });
+        if price.eq(&Decimal::ZERO) {
+            params["orderType"] = json!("market");
+            params["force"] = json!("gtc");
+        } else {
+            params["price"] = json!(price.to_string());
+            params["orderType"] = json!("limit");
+            params["force"] = json!("gtc");
+            if amount % multiplier != dec!(0) {
+                params["size"] = json!(((amount / multiplier).ceil() * multiplier).to_string());
+            }
+        };
+        match origin_side {
+            "kd" => {
+                params["side"] = json!("buy");
+                params["reduceOnly"] = json!("NO");
+            }
+            "pd" => {
+                params["side"] = json!("sell");
+                params["reduceOnly"] = json!("YES");
+            }
+            "kk" => {
+                params["side"] = json!("sell");
+                params["reduceOnly"] = json!("NO");
+            }
+            "pk" => {
+                params["side"] = json!("buy");
+                params["reduceOnly"] = json!("YES");
+            }
+            _ => { panic!("bitget_usdt_swap 下单参数错误"); }
+        };
+
+        let res_data = self.request.swap_order(params).await;
+        if res_data.code != 200 {
+            return Err(Error::new(ErrorKind::Other, res_data.to_string()));
+        }
+
+        let res_data_json = res_data.data;
+        let result = Order {
+            id: res_data_json["orderId"].as_str().unwrap().to_string(),
+            custom_id: res_data_json["clientOid"].as_str().unwrap().to_string(),
+            price: Decimal::ZERO,
+            amount: Decimal::ZERO,
+            deal_amount: Decimal::ZERO,
+            avg_price: Decimal::ZERO,
+            status: "NEW".to_string(),
+            order_type: "".to_string(),
+            trace_stack: TraceStack::new(0, Instant::now()).on_special("500 bitget_swap".to_string()),
+        };
+        return Ok(result);
+    }
+
+    async fn cancel_order(&mut self, order_id: &str, custom_id: &str) -> Result<Order, Error> {
+        let symbol_format = utils::format_symbol(self.symbol.clone(), "");
+        let params = json!({
+            "symbol": symbol_format,
+            "productType": "USDT-FUTURES",
+            "clientOid": custom_id,
+            "orderId": order_id
+        });
+        let response = self.request.cancel_order(params).await;
+
+        // 取消失败，进行报错
+        if response.code != 200 {
+            return Err(Error::new(ErrorKind::NotFound, response.to_string()));
+        }
+
+        let res_data_json = response.data;
+        let result = Order {
+            id: res_data_json["orderId"].as_str().unwrap().to_string(),
+            custom_id: res_data_json["clientOid"].as_str().unwrap().to_string(),
+            price: Decimal::ZERO,
+            amount: Decimal::ZERO,
+            deal_amount: Decimal::ZERO,
+            avg_price: Decimal::ZERO,
+            status: "REMOVE".to_string(),
+            order_type: "".to_string(),
+            trace_stack: TraceStack::new(0, Instant::now()).on_special("530 bitget_swap".to_string()),
+        };
+        Ok(result)
+    }
+
+    async fn cancel_orders(&mut self) -> Result<Vec<Order>, Error> {
+        Err(Error::new(ErrorKind::NotFound, "bitget_swap cancel_orders：该交易所方法未实现".to_string()))
+    }
+
+    async fn cancel_orders_all(&mut self) -> Result<Vec<Order>, Error> {
+        let response = self.request.get_pending_orders().await;
+        if response.code == 200 {
+            let mut result = vec![];
+
+            if !response.data["entrustedList"].is_null() {
+                let orders_res_data_json = response.data["entrustedList"].as_array().unwrap();
+                for order in orders_res_data_json {
+                    let symbol = order["symbol"].as_str().unwrap().to_string();
+                    let order_id = order["orderId"].as_str().unwrap().to_string();
+                    let params = json!({
+                        "symbol": symbol,
+                        "productType": "USDT-FUTURES",
+                        "orderId": order_id,
+                    });
+                    let cancel_res_data = self.request.cancel_order(params).await;
+                    if cancel_res_data.code == 200 {
+                        let cancel_res_data_json = cancel_res_data.data;
+                        result.push(Order {
+                            id: cancel_res_data_json["orderId"].as_str().unwrap().to_string(),
+                            custom_id: cancel_res_data_json["clientOid"].as_str().unwrap().to_string(),
+                            price: Decimal::ZERO,
+                            amount: Decimal::ZERO,
+                            deal_amount: Decimal::ZERO,
+                            avg_price: Decimal::ZERO,
+                            status: "REMOVE".to_string(),
+                            order_type: "".to_string(),
+                            trace_stack: TraceStack::new(0, Instant::now()).on_special("567 bitget_swap".to_string()),
+                        });
+                    } else {
+                        return Err(Error::new(ErrorKind::Other, cancel_res_data.to_string()));
+                    }
+                }
+            }
+            Ok(result)
+        } else {
+            Err(Error::new(ErrorKind::Other, response.to_string()))
+        }
+    }
+
+    async fn take_stop_loss_order(&mut self, _stop_price: Decimal, _price: Decimal, _side: &str) -> Result<Value, Error> {
+        Err(Error::new(ErrorKind::NotFound, "bitget_swap take_stop_loss_order：该交易所方法未实现".to_string()))
+    }
+
+    async fn cancel_stop_loss_order(&mut self, _order_id: &str) -> Result<Value, Error> {
+        Err(Error::new(ErrorKind::NotFound, "bitget_swap cancel_stop_loss_order：该交易所方法未实现".to_string()))
+    }
+
+    async fn set_dual_mode(&mut self, _coin: &str, is_dual_mode: bool) -> Result<String, Error> {
+        let pos_mode = if is_dual_mode {
+            "hedge_mode"
+        } else {
+            "one_way_mode"
+        };
+        let params = json!({
+            "productType": "USDT-FUTURES",
+            "posMode": pos_mode,
+        });
+        let response = self.request.set_position_mode(params).await;
+
+        if response.code != 200 {
+            return Err(Error::new(ErrorKind::Other, format!("设置持仓模式失败:{:?}", response).to_string()));
+        }
+
+        return Ok(response.data.to_string());
+    }
+
+    async fn set_dual_leverage(&mut self, leverage: &str) -> Result<String, Error> {
+        let symbol_format = utils::format_symbol(self.symbol.clone(), "");
+        let params = json!({
+            "symbol": symbol_format,
+            "productType": "USDT-FUTURES",
+            "marginCoin": "USDT",
+            "leverage": leverage
+        });
+        let response = self.request.set_leverage(params).await;
+
+        if response.code != 200 {
+            return Err(Error::new(ErrorKind::Other, format!("设置杠杆失败:{:?}", response).to_string()));
+        }
+
+        return Ok(response.data.to_string());
+    }
+
+    async fn set_auto_deposit_status(&mut self, _status: bool) -> Result<String, Error> {
+        Err(Error::new(ErrorKind::NotFound, "bitget_swap set_auto_deposit_status：该交易所方法未实现".to_string()))
+    }
+
+    async fn wallet_transfers(&mut self, _coin: &str, _from: &str, _to: &str, _amount: Decimal) -> Result<String, Error> {
+        Err(Error::new(ErrorKind::NotFound, "bitget_swap wallet_transfers：该交易所方法未实现".to_string()))
+        // let coin_format = coin.to_string().to_uppercase();
+        // let res_data = self.request.wallet_transfer(from.to_string(), to.to_string(), amount.to_string(), coin_format.clone(), "".to_string(), "".to_string()).await;
+        // if res_data.code == 200 {
+        //     let res_data_str = &res_data.data;
+        //     let result = res_data_str.clone();
+        //     Ok(result)
+        // } else {
+        //     Err(Error::new(ErrorKind::Other, res_data.to_string()))
+        // }
+    }
+
+    async fn command_order(&mut self, order_command: &mut OrderCommand, trace_stack: &TraceStack) {
+        let mut handles = vec![];
+
+        // 下单指令
+        for item in order_command.limits_open.keys() {
+            let mut ts = trace_stack.clone();
+
+            let amount = Decimal::from_str(&*order_command.limits_open[item].get(0).unwrap().clone()).unwrap();
+            let side = order_command.limits_open[item].get(1).unwrap().clone();
+            let price = Decimal::from_str(&*order_command.limits_open[item].get(2).unwrap().clone()).unwrap();
+            let cid = order_command.limits_open[item].get(3).unwrap().clone();
+
+            //  order_name: [数量，方向，价格，c_id]
+            let mut self_clone = self.clone();
+            let handle = spawn(async move {
+                // TraceStack::show_delay(&ts.ins);
+                ts.on_before_send();
+                let result = self_clone.take_order(cid.as_str(), side.as_str(), price, amount).await;
+                ts.on_after_send();
+
+                match result {
+                    Ok(mut result) => {
+                        result.trace_stack = ts;
+
+                        self_clone.order_sender.send(result).await.unwrap();
+                    }
+                    Err(error) => {
+                        error!(?error);
+                        let mut err_order = Order::new();
+                        err_order.custom_id = cid.clone();
+                        err_order.status = "REMOVE".to_string();
+
+                        self_clone.order_sender.send(err_order).await.unwrap();
+                        self_clone.error_sender.send(error).await.unwrap();
+                    }
+                }
+            });
+            handles.push(handle)
+        }
+        let futures = FuturesUnordered::from_iter(handles);
+        // 等待所有任务完成
+        let _: Result<Vec<_>, _> = futures.try_collect().await;
+
+        // 撤销订单
+        let mut cancel_handlers = vec![];
+        for item in order_command.cancel.keys() {
+            let order_id = order_command.cancel[item].get(1).unwrap().clone();
+            let custom_id = order_command.cancel[item].get(0).unwrap().clone();
+
+            let mut self_clone = self.clone();
+            let handle = spawn(async move {
+                let result = self_clone.cancel_order(&order_id, &custom_id).await;
+                match result {
+                    Ok(_) => {
+                        // result_sd.send(result).await.unwrap();
+                    }
+                    Err(error) => {
+                        // 取消失败去查订单。
+                        let query_rst = self_clone.get_order_detail(&order_id, &custom_id).await;
+                        match query_rst {
+                            Ok(order) => {
+                                self_clone.order_sender.send(order).await.unwrap();
+                            }
+                            Err(err) => {
+                                error!("撤单失败，而且查单也失败了，bitget_swap，oid={}, cid={}, err={:?}。", order_id.clone(), custom_id.clone(), err);
+                            }
+                        }
+                        self_clone.error_sender.send(error).await.unwrap();
+                    }
+                }
+            });
+            cancel_handlers.push(handle)
+        }
+        let futures = FuturesUnordered::from_iter(cancel_handlers);
+        // 等待所有任务完成
+        let _: Result<Vec<_>, _> = futures.try_collect().await;
+
+        // 检查订单指令
+        let mut check_handlers = vec![];
+        for item in order_command.check.keys() {
+            let order_id = order_command.check[item].get(1).unwrap().clone();
+            let custom_id = order_command.check[item].get(0).unwrap().clone();
+
+            let mut self_clone = self.clone();
+            let handle = spawn(async move {
+                let result = self_clone.get_order_detail(order_id.as_str(), custom_id.as_str()).await;
+                match result {
+                    Ok(result) => {
+                        self_clone.order_sender.send(result).await.unwrap();
+                    }
+                    Err(error) => {
+                        self_clone.error_sender.send(error).await.unwrap();
+                    }
+                }
+            });
+            check_handlers.push(handle)
+        }
+
+        let futures = FuturesUnordered::from_iter(check_handlers);
+        // 等待所有任务完成
+        let _: Result<Vec<_>, _> = futures.try_collect().await;
+    }
+}
+
+// pub fn format_account_info(balance_data: Value) -> Account {
+//     let balance_coin = balance_data["coin"].as_str().unwrap().to_string().to_uppercase();
+//     let available_balance = Decimal::from_str(balance_data["available"].as_str().unwrap()).unwrap();
+//     let frozen_balance = Decimal::from_str(balance_data["frozen"].as_str().unwrap()).unwrap();
+//     let balance = available_balance + frozen_balance;
+//
+//     Account {
+//         coin: balance_coin,
+//         balance,
+//         available_balance,
+//         frozen_balance,
+//         stocks: Decimal::ZERO,
+//         available_stocks: Decimal::ZERO,
+//         frozen_stocks: Decimal::ZERO,
 //     }
 // }
+
+pub fn format_order_item(order: Value, _multiplier: Decimal) -> Order {
+    let price = Decimal::from_str(order["price"].as_str().unwrap_or(order["priceAvg"].as_str().unwrap())).unwrap();
+    let size = Decimal::from_str(order["size"].as_str().unwrap()).unwrap();
+    let status = order["state"].as_str().unwrap();
+    let base_volume = Decimal::from_str(order["quoteVolume"].as_str().unwrap()).unwrap();
+    let avg_price = if order["priceAvg"].is_null() || order["priceAvg"].as_str().unwrap().is_empty() {
+        Decimal::ZERO
+    } else {
+        Decimal::from_str(order["priceAvg"].as_str().unwrap().to_string().as_str()).unwrap()
+    };
+
+    let amount = size;
+    let deal_amount = base_volume;
+    let custom_status = if ["filled", "canceled"].contains(&status) {
+        "REMOVE".to_string()
+    } else if ["init", "live", "new", "partially_filled"].contains(&status) {
+        "NEW".to_string()
+    } else {
+        "NULL".to_string()
+    };
+    Order {
+        id: order["orderId"].as_str().unwrap().to_string(),
+        custom_id: order["clientOid"].as_str().unwrap().to_string(),
+        price,
+        amount,
+        deal_amount,
+        avg_price,
+        status: custom_status,
+        order_type: order["orderType"].as_str().unwrap().to_string(),
+        trace_stack: TraceStack::new(0, Instant::now()).on_special("791 bitget_swap".to_string()),
+    }
+}

standard/src/bitget_swap_handle.rs

@@ -1,224 +1,314 @@
-// use std::str::FromStr;
-// use rust_decimal::Decimal;
-// use rust_decimal::prelude::FromPrimitive;
-// use serde_json::Value;
-// use exchanges::response_base::ResponseData;
-// use crate::{Account, OrderBook, Order, Position, PositionModeEnum, SpecialOrder, Trade, Record};
-//
-// // 处理账号信息
-// pub fn handle_account_info(response: &ResponseData, _symbol: &String) -> Account {
-//     let mut rst = Account::new();
-//
-//     for data in response.data.as_array().unwrap() {
-//         if data["marginCoin"].as_str().unwrap() != "USDT" {
-//             continue
-//         }
-//
-//         // 格式化account信息
-//         let mut account = Account {
-//             coin: data["marginCoin"].to_string(),
-//             balance: Decimal::from_str(data["usdtEquity"].as_str().unwrap()).unwrap(),
-//             available_balance: Decimal::from_str(data["available"].as_str().unwrap()).unwrap(),
-//             frozen_balance: Decimal::from_str(data["frozen"].as_str().unwrap()).unwrap(),
-//             stocks: Default::default(),
-//             available_stocks: Default::default(),
-//             frozen_stocks: Default::default(),
-//         };
-//         account.frozen_balance = account.balance - account.available_balance;
-//
-//         rst = account
-//     }
-//
-//     return rst;
+use std::str::FromStr;
+use std::sync::Arc;
+use chrono::Utc;
+use lazy_static::lazy_static;
+use rust_decimal::Decimal;
+use rust_decimal::prelude::FromPrimitive;
+use serde_json::Value;
+use tokio::sync::Mutex;
+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, Trade, Record, Ticker};
+
+// 处理账号信息
+pub fn handle_account_info(response: &ResponseData, _symbol: &String) -> Account {
+    let mut rst = Account::new();
+    let data_info = response.data["data"].clone();
+    for data in data_info.as_array().unwrap() {
+        if data["marginCoin"].as_str().unwrap() != "USDT" {
+            continue;
+        }
+
+        // 格式化account信息
+        let mut account = Account {
+            coin: data["marginCoin"].to_string(),
+            balance: Decimal::from_str(data["usdtEquity"].as_str().unwrap()).unwrap(),
+            available_balance: Decimal::from_str(data["available"].as_str().unwrap()).unwrap(),
+            frozen_balance: Decimal::from_str(data["frozen"].as_str().unwrap()).unwrap(),
+            stocks: Default::default(),
+            available_stocks: Default::default(),
+            frozen_stocks: Default::default(),
+        };
+        account.frozen_balance = account.balance - account.available_balance;
+
+        rst = account
+    }
+
+    return rst;
+}
+
+// 处理order信息
+pub fn handle_order(res_data: &ResponseData, multiplier: &Decimal) -> SpecialOrder {
+    let data_info = res_data.data["data"].clone();
+    let res_data_json = data_info.as_array().unwrap();
+    let mut order_info = Vec::new();
+    for item in res_data_json.iter() {
+        order_info.push(format_order_item(item.clone(), multiplier.clone()));
+    }
+    SpecialOrder {
+        name: res_data.label.clone(),
+        order: order_info,
+    }
+}
+
+// 处理订单信息
+pub fn format_order_item(order: Value, _multiplier: Decimal) -> Order {
+    let price = Decimal::from_str(order["price"].as_str().unwrap().to_string().as_str()).unwrap();
+    let size = Decimal::from_str(order["size"].as_str().unwrap().to_string().as_str()).unwrap();
+    let binding = order["status"].clone().as_str().unwrap().to_string();
+    let status = binding.as_str();
+    let acc_base_volume = Decimal::from_str(order["accBaseVolume"].as_str().unwrap().to_string().as_str()).unwrap();
+    let avg_price = if order["priceAvg"].is_null() || order["priceAvg"].as_str().unwrap().is_empty() {
+        Decimal::ZERO
+    } else {
+        Decimal::from_str(order["priceAvg"].as_str().unwrap().to_string().as_str()).unwrap()
+    };
+    let c_id = if order["clientOid"].is_null() {
+        ""
+    } else {
+        order["clientOid"].as_str().unwrap()
+    };
+
+    let amount = size;
+    let deal_amount = acc_base_volume;
+    let custom_status = if ["filled", "canceled"].contains(&status) {
+        "REMOVE".to_string()
+    } else if ["init", "live", "new", "partially_filled"].contains(&status) {
+        "NEW".to_string()
+    } else {
+        "NULL".to_string()
+    };
+    Order {
+        id: order["orderId"].as_str().unwrap().to_string(),
+        custom_id: c_id.to_string(),
+        price,
+        amount,
+        deal_amount,
+        avg_price,
+        status: custom_status,
+        order_type: order["orderType"].as_str().unwrap().to_string(),
+        trace_stack: TraceStack::new(0, Instant::now()).on_special("86 bitget_swap_handle".to_string()),
+    }
+}
+
+// 格式化深度信息
+pub fn format_depth_items(value: Value, mul: &Decimal) -> Vec<OrderBook> {
+    let mut depth_items: Vec<OrderBook> = vec![];
+    for value in value.as_array().unwrap() {
+        let price = Decimal::from_str(value[0].as_str().unwrap()).unwrap();
+        let size = Decimal::from_str(value[1].as_str().unwrap()).unwrap();
+        depth_items.push(OrderBook {
+            price,
+            size,
+            value: price * size * mul,
+        })
+    }
+    return depth_items;
+}
+
+// 处理position信息
+pub fn handle_position(res_data: &ResponseData, multiplier: &Decimal) -> Vec<Position> {
+    let data_info = res_data.data["data"].clone();
+    let data_info_json = data_info.as_array().unwrap();
+    data_info_json.iter().map(|item| { format_position_item(item, multiplier) }).collect()
+}
+
+pub fn format_position_item(position_json: &Value, _multiplier: &Decimal) -> Position {
+    let symbol = position_json["instId"].as_str().unwrap().to_string();
+    let margin_level = Decimal::from_i64(position_json["leverage"].as_i64().unwrap()).unwrap();
+    let amount = Decimal::from_str(position_json["total"].as_str().unwrap()).unwrap();
+    let frozen_amount = Decimal::from_str(position_json["frozen"].as_str().unwrap()).unwrap();
+    let price = Decimal::from_str(position_json["openPriceAvg"].as_str().unwrap()).unwrap();
+    let profit = Decimal::from_str(position_json["unrealizedPL"].as_str().unwrap()).unwrap();
+    let mut position_mode = match position_json["posMode"].as_str().unwrap() {
+        "hedge_mode" => {
+            match position_json["holdSide"].as_str().unwrap() {
+                "short" => {
+                    PositionModeEnum::Short
+                }
+                "long" => {
+                    PositionModeEnum::Long
+                }
+                _ => {
+                    panic!("bitget_usdt_swap: 未知的持仓模式与持仓方向: {}, {}",
+                           position_json["posMode"].as_str().unwrap(), position_json["holdSide"].as_str().unwrap())
+                }
+            }
+        }
+        "one_way_mode" => {
+            PositionModeEnum::Both
+        }
+        _ => {
+            panic!("bitget_usdt_swap: 未知的持仓模式: {}", position_json["posMode"].as_str().unwrap())
+        }
+    };
+    let margin = Decimal::from_str(position_json["marginSize"].as_str().unwrap()).unwrap();
+
+    let side = position_json["holdSide"].as_str().unwrap();
+    match position_mode {
+        PositionModeEnum::Both => {
+            position_mode = match side {
+                "long" => PositionModeEnum::Long,
+                "short" => PositionModeEnum::Short,
+                _ => { PositionModeEnum::Both }
+            }
+        }
+        _ => {}
+    }
+
+    Position {
+        symbol,
+        margin_level,
+        amount,
+        frozen_amount,
+        price,
+        profit,
+        position_mode,
+        margin,
+    }
+}
+
+pub fn format_trade_items(response: &ResponseData) -> Vec<Trade> {
+    let data_info = response.data["data"].clone();
+    let result = data_info.as_array().unwrap();
+    let mut trades = vec![];
+
+    for item in result {
+        // 因为gate的量都是张数，所以要进行真实交易量处理
+        let mut size = Decimal::from_str(item["size"].as_str().unwrap()).unwrap();
+        let price = Decimal::from_str(item["price"].as_str().unwrap().to_string().as_str()).unwrap();
+        let side = item["side"].as_str().unwrap().to_string();
+        size = match side.as_str() {
+            "buy" => {
+                size
+            }
+            "sell" => {
+                -size
+            }
+            _ => {
+                error!("{}", item.to_string());
+                panic!("Bitget trade error side(bitget_swap_handle_156)")
+            }
+        };
+        let value = (size * price).abs();
+
+        trades.push(Trade {
+            id: item["tradeId"].as_str().unwrap().to_string(),
+            time: Decimal::from_str(item["ts"].as_str().unwrap()).unwrap(),
+            size,
+            price,
+            value,
+            symbol: response.data["arg"]["instId"].as_str().unwrap().replace("USDT", "_USDT"),
+        })
+    }
+
+    return trades;
+}
+pub fn handle_book_ticker(res_data: &ResponseData, mul: &Decimal) -> Depth {
+    let data_info = res_data.data["data"].clone();
+    let asks = format_depth_items(data_info[0]["asks"].clone(), mul);
+    let bids = format_depth_items(data_info[0]["bids"].clone(), mul);
+    let t = Decimal::from_i64(res_data.reach_time).unwrap();
+    let s = res_data.data["arg"]["instId"].as_str().unwrap().replace("USDT", "_USDT");
+
+    Depth {
+        time: t,
+        symbol: s.to_string(),
+        asks,
+        bids,
+    }
+}
+
+pub fn handle_records(value: &Value) -> Vec<Record> {
+    let data_info = value["data"].clone();
+    let mut records = vec![];
+    for record_value in data_info.as_array().unwrap() {
+        records.push(Record {
+            time: Decimal::from_str(record_value[0].as_str().unwrap()).unwrap(),
+            open: Decimal::from_str(record_value[1].as_str().unwrap()).unwrap(),
+            high: Decimal::from_str(record_value[2].as_str().unwrap()).unwrap(),
+            low: Decimal::from_str(record_value[3].as_str().unwrap()).unwrap(),
+            close: Decimal::from_str(record_value[4].as_str().unwrap()).unwrap(),
+            volume: Decimal::from_str(record_value[5].as_str().unwrap()).unwrap(),
+            symbol: value["arg"]["instId"].as_str().unwrap().replace("USDT", "_USDT"),
+        });
+    }
+
+    return records;
+}
+
+lazy_static! {
+    static ref TICKER: Arc<Mutex<Ticker>> = Arc::new(Mutex::new(Ticker::new()));
+}
+
+pub async fn handle_ticker(res_data: &ResponseData) -> Ticker {
+    let mut ticker = crate::bitget_swap_handle::TICKER.lock().await;
+
+    let data_info = res_data.data["data"][0].clone();
+    ticker.time = Decimal::from_i64(Utc::now().timestamp_millis()).unwrap();
+    ticker.high = match data_info["high24h"].as_str() {
+        Some(str) => { Decimal::from_str(str).unwrap() }
+        None => { ticker.high }
+    };
+    ticker.low = match data_info["low24h"].as_str() {
+        Some(str) => { Decimal::from_str(str).unwrap() }
+        None => { ticker.low }
+    };
+    ticker.sell = match data_info["askPr"].as_str() {
+        Some(str) => { Decimal::from_str(str).unwrap() }
+        None => { ticker.sell }
+    };
+    ticker.buy = match data_info["bidPr"].as_str() {
+        Some(str) => { Decimal::from_str(str).unwrap() }
+        None => { ticker.buy }
+    };
+    ticker.last = match data_info["lastPr"].as_str() {
+        Some(str) => { Decimal::from_str(str).unwrap() }
+        None => { ticker.last }
+    };
+    ticker.volume = match data_info["quoteVolume"].as_str() {
+        Some(str) => { Decimal::from_str(str).unwrap() }
+        None => { ticker.volume }
+    };
+    ticker.open_interest = match data_info["holdingAmount"].as_str() {
+        Some(str) => { Decimal::from_str(str).unwrap() }
+        None => { ticker.open_interest }
+    };
+    // let s = res_data.data["symbol"].as_str().unwrap().replace("USDT", "_USDT");
+
+    ticker.clone()
+}
+
+// 处理特殊深度数据
+// pub fn handle_special_depth(res_data: ResponseData) -> SpecialDepth {
+//     HandleSwapInfo::handle_special_depth(ExchangeEnum::BitgetSwap, res_data)
 // }
-//
-// // 处理order信息
-// pub fn handle_order(res_data: &ResponseData, ct_val: Decimal) -> SpecialOrder {
-//     let res_data_json = res_data.data.as_array().unwrap();
-//     let mut order_info = Vec::new();
-//     for item in res_data_json.iter() {
-//         order_info.push(format_order_item(item.clone(), ct_val));
-//     }
-//     SpecialOrder {
-//         name: res_data.label.clone(),
-//         order: order_info,
-//     }
+
+// // 处理特殊Ticker信息
+// pub fn handle_special_ticker(res_data: ResponseData) -> SpecialDepth {
+//     let res_data_str = res_data.data;
+//     let res_data_json: Vec<serde_json::Value> = serde_json::from_str(&*res_data_str).unwrap();
+//     format_special_ticker(res_data_json[0].clone(), res_data.label)
 // }
 //
-// // 处理订单信息
-// pub fn format_order_item(order: Value, ct_val: Decimal) -> Order {
-//     let price = Decimal::from_str(order["price"].as_str().unwrap().to_string().as_str()).unwrap();
-//     let size = Decimal::from_str(order["size"].as_str().unwrap().to_string().as_str()).unwrap();
-//     let binding = order["status"].clone().as_str().unwrap().to_string();
-//     let status = binding.as_str();
-//     let acc_base_volume = Decimal::from_str(order["accBaseVolume"].as_str().unwrap().to_string().as_str()).unwrap();
-//     let avg_price = if order["priceAvg"].is_null() || order["priceAvg"].as_str().unwrap().is_empty() {
-//         Decimal::ZERO
-//     } else {
-//         Decimal::from_str(order["priceAvg"].as_str().unwrap().to_string().as_str()).unwrap()
-//     };
-//     let c_id = if order["clientOid"].is_null() {
-//         ""
-//     } else {
-//         order["clientOid"].as_str().unwrap()
-//     };
+// pub fn format_special_ticker(data: serde_json::Value, label: String) -> SpecialDepth {
+//     let bp = Decimal::from_str(data["bidPr"].as_str().unwrap()).unwrap();
+//     let bq = Decimal::from_str(data["bidSz"].as_str().unwrap()).unwrap();
+//     let ap = Decimal::from_str(data["askPr"].as_str().unwrap()).unwrap();
+//     let aq = Decimal::from_str(data["askSz"].as_str().unwrap()).unwrap();
+//     let mp = (bp + ap) * dec!(0.5);
+//     let t = Decimal::from_str(data["ts"].as_str().unwrap()).unwrap();
+//     let create_at = data["ts"].as_str().unwrap().parse::<i64>().unwrap() * 1000;
 //
-//     let amount = size * ct_val;
-//     let deal_amount = acc_base_volume * ct_val;
-//     let custom_status = if ["filled", "canceled"].contains(&status) {
-//         "REMOVE".to_string()
-//     } else if ["init", "live", "new", "partially_filled"].contains(&status) {
-//         "NEW".to_string()
-//     } else {
-//         "NULL".to_string()
-//     };
-//     Order {
-//         id: order["orderId"].as_str().unwrap().to_string(),
-//         custom_id: c_id.to_string(),
-//         price,
-//         amount,
-//         deal_amount,
-//         avg_price,
-//         status: custom_status,
-//         order_type: order["orderType"].as_str().unwrap().to_string()
+//     let ticker_info = SpecialTicker { sell: ap, buy: bp, mid_price: mp, t, create_at };
+//     let depth_info = vec![bp, bq, ap, aq];
+//     SpecialDepth {
+//         name: label,
+//         depth: depth_info,
+//         ticker: ticker_info,
+//         t,
+//         create_at,
 //     }
-// }
-//
-// // 格式化深度信息
-// pub fn format_depth_items(value: Value) -> Vec<OrderBook> {
-//     let mut depth_items: Vec<OrderBook> = vec![];
-//     for value in value.as_array().unwrap() {
-//         depth_items.push(OrderBook {
-//             price: Decimal::from_str(value[0].as_str().unwrap()).unwrap(),
-//             amount: Decimal::from_str(value[1].as_str().unwrap()).unwrap(),
-//         })
-//     }
-//     return depth_items;
-// }
-//
-// // 处理position信息
-// pub fn handle_position(res_data: &ResponseData, ct_val: &Decimal) -> Vec<Position> {
-//     let res_data_json = res_data.data.as_array().unwrap();
-//     res_data_json.iter().map(|item| { format_position_item(item, ct_val) }).collect()
-// }
-//
-// pub fn format_position_item(position_json: &Value, ct_val: &Decimal) -> Position {
-//     let symbol = position_json["instId"].as_str().unwrap().to_string();
-//     let margin_level = Decimal::from_i64(position_json["leverage"].as_i64().unwrap()).unwrap();
-//     let amount = Decimal::from_str(position_json["total"].as_str().unwrap()).unwrap() * ct_val;
-//     let frozen_amount = Decimal::from_str(position_json["frozen"].as_str().unwrap()).unwrap() * ct_val;
-//     let price = Decimal::from_str(position_json["openPriceAvg"].as_str().unwrap()).unwrap();
-//     let profit = Decimal::from_str(position_json["unrealizedPL"].as_str().unwrap()).unwrap();
-//     let position_mode = match position_json["posMode"].as_str().unwrap() {
-//         "hedge_mode" => {
-//             match position_json["holdSide"].as_str().unwrap() {
-//                 "short" => {
-//                     PositionModeEnum::Short
-//                 }
-//                 "long" => {
-//                     PositionModeEnum::Long
-//                 },
-//                 _ => {
-//                     panic!("bitget_usdt_swap: 未知的持仓模式与持仓方向: {}, {}",
-//                            position_json["posMode"].as_str().unwrap(), position_json["holdSide"].as_str().unwrap())
-//                 }
-//             }
-//         },
-//         "one_way_mode" => {
-//             PositionModeEnum::Both
-//         },
-//         _ => {
-//             panic!("bitget_usdt_swap: 未知的持仓模式: {}", position_json["posMode"].as_str().unwrap())
-//         }
-//     };
-//     let margin = Decimal::from_str(position_json["marginSize"].as_str().unwrap()).unwrap();
-//
-//     Position {
-//         symbol,
-//         margin_level,
-//         amount,
-//         frozen_amount,
-//         price,
-//         profit,
-//         position_mode,
-//         margin,
-//     }
-// }
-//
-// pub fn format_trade_items(res_data: &ResponseData) -> Vec<Trade> {
-//     let arg = res_data.data["arg"].clone();
-//     let symbol = arg["instId"].as_str().unwrap().to_string().replace("USDT", "_USDT");
-//     let result = res_data.data["data"].as_array().unwrap();
-//     let mut trades = vec![];
-//
-//     for item in result {
-//         let mut trade = Trade {
-//             id: item["tradeId"].as_str().unwrap().to_string(),
-//             time: Decimal::from_str(item["ts"].as_str().unwrap()).unwrap(),
-//             size: Decimal::from_str(item["size"].as_str().unwrap()).unwrap(),
-//             price: Decimal::from_str(item["price"].as_str().unwrap().to_string().as_str()).unwrap(),
-//             symbol: symbol.to_string(),
-//         };
-//
-//         if item["side"].as_str().unwrap().eq("sell") {
-//             trade.size = trade.size * Decimal::NEGATIVE_ONE;
-//         }
-//
-//         trades.push(trade)
-//     }
-//
-//     return trades
-// }
-//
-// pub fn handle_records(value: &Value) -> Vec<Record> {
-//     let mut records = vec![];
-//
-//     let record_value_vec = value["data"].as_array().unwrap();
-//     let symbol = value["arg"]["instId"].as_str().unwrap().to_string().replace("USDT", "_USDT");
-//     for record_value in record_value_vec {
-//         let arr = record_value.as_array().unwrap();
-//         records.push(Record {
-//             time: Decimal::from_str(arr[0].as_str().unwrap()).unwrap(),
-//             open: Decimal::from_str(arr[1].as_str().unwrap()).unwrap(),
-//             high: Decimal::from_str(arr[2].as_str().unwrap()).unwrap(),
-//             low: Decimal::from_str(arr[3].as_str().unwrap()).unwrap(),
-//             close: Decimal::from_str(arr[4].as_str().unwrap()).unwrap(),
-//             volume: Decimal::from_str(arr[6].as_str().unwrap()).unwrap(),
-//             symbol: symbol.clone(),
-//         });
-//     }
-//
-//     return records
-// }
-//
-// // 处理特殊深度数据
-// // pub fn handle_special_depth(res_data: ResponseData) -> SpecialDepth {
-// //     HandleSwapInfo::handle_special_depth(ExchangeEnum::BitgetSwap, res_data)
-// // }
-//
-// // // 处理特殊Ticker信息
-// // pub fn handle_special_ticker(res_data: ResponseData) -> SpecialDepth {
-// //     let res_data_str = res_data.data;
-// //     let res_data_json: Vec<serde_json::Value> = serde_json::from_str(&*res_data_str).unwrap();
-// //     format_special_ticker(res_data_json[0].clone(), res_data.tag)
-// // }
-// //
-// // pub fn format_special_ticker(data: serde_json::Value, tag: String) -> SpecialDepth {
-// //     let bp = Decimal::from_str(data["bidPr"].as_str().unwrap()).unwrap();
-// //     let bq = Decimal::from_str(data["bidSz"].as_str().unwrap()).unwrap();
-// //     let ap = Decimal::from_str(data["askPr"].as_str().unwrap()).unwrap();
-// //     let aq = Decimal::from_str(data["askSz"].as_str().unwrap()).unwrap();
-// //     let mp = (bp + ap) * dec!(0.5);
-// //     let t = Decimal::from_str(data["ts"].as_str().unwrap()).unwrap();
-// //     let create_at = data["ts"].as_str().unwrap().parse::<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 {
-// //         name: tag,
-// //         depth: depth_info,
-// //         ticker: ticker_info,
-// //         t,
-// //         create_at,
-// //     }
-// // }
+// }

standard/src/bybit_swap.rs

@@ -89,7 +89,7 @@ impl Platform for BybitSwap {
     fn clone_box(&self) -> Box<dyn Platform + Send + Sync> { Box::new(self.clone()) }
     // 获取交易所模式
     fn get_self_exchange(&self) -> ExchangeEnum {
-        ExchangeEnum::GateSwap
+        ExchangeEnum::BybitSwap
     }
     // 获取交易对
     fn get_self_symbol(&self) -> String { self.symbol.clone() }

standard/src/exchange.rs

@@ -3,6 +3,7 @@ use std::io::Error;
 use tokio::sync::mpsc::Sender;
 use crate::{Order, Platform};
 use crate::binance_swap::BinanceSwap;
+use crate::bitget_swap::BitgetSwap;
 use crate::bybit_swap::BybitSwap;
 use crate::coinex_swap::CoinexSwap;
 use crate::gate_swap::GateSwap;
@@ -24,7 +25,7 @@ pub enum ExchangeEnum {
     // KucoinSpot,
     // OkxSwap,
     // BitgetSpot,
-    // BitgetSwap,
+    BitgetSwap,
     BybitSwap,
     // HtxSwap,
     // BingxSwap,
@@ -99,9 +100,9 @@ impl Exchange {
             // ExchangeEnum::BitgetSpot => {
             //     Box::new(BitgetSpot::new(symbol, is_colo, params, order_sender, error_sender).await)
             // }
-            // ExchangeEnum::BitgetSwap => {
-            //     Box::new(BitgetSwap::new(symbol, is_colo, params, order_sender, error_sender).await)
-            // }
+            ExchangeEnum::BitgetSwap => {
+                Box::new(BitgetSwap::new(symbol, is_colo, params, order_sender, error_sender).await)
+            }
             ExchangeEnum::BybitSwap => {
                 Box::new(BybitSwap::new(symbol, is_colo, params, order_sender, error_sender).await)
             }

standard/src/exchange_struct_handler.rs

@@ -4,7 +4,7 @@ use rust_decimal::prelude::FromPrimitive;
 use tracing::error;
 use exchanges::response_base::ResponseData;
 use crate::exchange::ExchangeEnum;
-use crate::{binance_swap_handle, bybit_swap_handle, coinex_swap_handle, gate_swap_handle, Ticker};
+use crate::{binance_swap_handle, bitget_swap_handle, bybit_swap_handle, coinex_swap_handle, gate_swap_handle, Ticker};
 use crate::{Record, Trade, Depth};
 use crate::{Account, OrderBook, Position, SpecialOrder};
 
@@ -109,9 +109,9 @@ impl ExchangeStructHandler {
             // ExchangeEnum::GateSpot => {
             //     gate_spot_handle::format_trade_items(&res_data)
             // }
-            // ExchangeEnum::BitgetSwap => {
-            //     bitget_swap_handle::format_trade_items(&res_data)
-            // }
+            ExchangeEnum::BitgetSwap => {
+                bitget_swap_handle::format_trade_items(&res_data)
+            }
             ExchangeEnum::BinanceSwap => {
                 binance_swap_handle::format_trade_items(&res_data)
             }
@@ -166,6 +166,9 @@ impl ExchangeStructHandler {
             ExchangeEnum::BinanceSwap => {
                 binance_swap_handle::handle_book_ticker(&res_data, mul)
             }
+            ExchangeEnum::BitgetSwap => {
+                bitget_swap_handle::handle_book_ticker(&res_data, mul)
+            }
             ExchangeEnum::BybitSwap => {
                 bybit_swap_handle::handle_book_ticker(&res_data, mul)
             }
@@ -184,12 +187,12 @@ impl ExchangeStructHandler {
             // ExchangeEnum::GateSpot => {
             //     gate_spot_handle::handle_records(&res_data.data)
             // }
-            // ExchangeEnum::BitgetSwap => {
-            //     bitget_swap_handle::handle_records(&res_data.data)
-            // }
             ExchangeEnum::BinanceSwap => {
                 binance_swap_handle::handle_records(&res_data.data)
             }
+            ExchangeEnum::BitgetSwap => {
+                bitget_swap_handle::handle_records(&res_data.data)
+            }
             ExchangeEnum::BybitSwap => { // 未使用暂不实现
                 bybit_swap_handle::handle_records(&res_data.data)
             }
@@ -235,9 +238,12 @@ impl ExchangeStructHandler {
             ExchangeEnum::BybitSwap => {
                 bybit_swap_handle::handle_ticker(res_data).await
             },
+            ExchangeEnum::BitgetSwap => {
+                bitget_swap_handle::handle_ticker(res_data).await
+            },
             _ => {
-                error!("未找到该交易所！trades_handle: {:?}", exchange);
-                panic!("未找到该交易所！trades_handle: {:?}", exchange);
+                error!("未找到该交易所！ticker_handle: {:?}", exchange);
+                panic!("未找到该交易所！ticker_handle: {:?}", exchange);
             }
         }
     }
@@ -250,9 +256,9 @@ impl ExchangeStructHandler {
             ExchangeEnum::BinanceSwap => {
                 binance_swap_handle::handle_account_info(res_data, symbol)
             }
-            // ExchangeEnum::BitgetSwap => {
-            //     bitget_swap_handle::handle_account_info(res_data, symbol)
-            // }
+            ExchangeEnum::BitgetSwap => {
+                bitget_swap_handle::handle_account_info(res_data, symbol)
+            }
             ExchangeEnum::BybitSwap => {
                 bybit_swap_handle::handle_account_info(res_data, symbol)
             }
@@ -274,9 +280,9 @@ impl ExchangeStructHandler {
             // ExchangeEnum::KucoinSwap => {
             //     kucoin_swap_handle::handle_position(res_data, ct_val)
             // }
-            // ExchangeEnum::BitgetSwap => {
-            //     bitget_swap_handle::handle_position(res_data, ct_val)
-            // }
+            ExchangeEnum::BitgetSwap => {
+                bitget_swap_handle::handle_position(res_data, mul)
+            }
             ExchangeEnum::BybitSwap => {
                 bybit_swap_handle::handle_position(res_data, mul)
             }
@@ -298,9 +304,9 @@ impl ExchangeStructHandler {
             // ExchangeEnum::KucoinSwap => {
             //     kucoin_swap_handle::handle_order(res_data, ct_val)
             // }
-            // ExchangeEnum::BitgetSwap => {
-            //     bitget_swap_handle::handle_order(res_data, ct_val)
-            // }
+            ExchangeEnum::BitgetSwap => {
+                bitget_swap_handle::handle_order(res_data, ct_val)
+            }
             ExchangeEnum::BybitSwap => {
                 bybit_swap_handle::handle_order(res_data, ct_val)
             }

standard/src/lib.rs

@@ -428,6 +428,7 @@ impl Order {
 /// - `buy(Decimal)`: 买一价
 /// - `last(Decimal)`: 最后成交价
 /// - `volume(Decimal)`: 最近成交量
+/// - `open_interest(Decimal)`: 未平仓合约数量
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Ticker {
     pub time: Decimal,

standard/tests/bitget_swap_test.rs

@@ -0,0 +1,255 @@
+mod exchange_test;
+
+use std::collections::BTreeMap;
+use std::env;
+use std::io::Error;
+use rust_decimal_macros::dec;
+use tokio::sync::mpsc;
+use tracing::{instrument, trace};
+use standard::exchange::{Exchange, ExchangeEnum};
+use standard::{Order, OrderCommand, Platform, utils};
+use crate::exchange_test::{test_new_exchange};
+
+const SYMBOL: &str = "XTZ_USDT";
+
+// 测试获取Exchange实体
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_get_self_exchange() {
+    global::log_utils::init_log_with_trace();
+
+    let bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSwap, SYMBOL).await;
+    let bitget_get_self_exchange = bitget_swap_exchange.get_self_exchange();
+    trace!(?bitget_get_self_exchange);
+}
+
+// 测试获取交易对信息
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_get_self_symbol() {
+    global::log_utils::init_log_with_trace();
+
+    let bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSwap, SYMBOL).await;
+    let bitget_get_self_symbol = bitget_swap_exchange.get_self_symbol();
+    trace!(?bitget_get_self_symbol);
+}
+
+// 测试获取是否使用高速通道
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_get_self_is_colo() {
+    global::log_utils::init_log_with_trace();
+
+    let bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSwap, SYMBOL).await;
+    let bitget_get_self_is_colo = bitget_swap_exchange.get_self_is_colo();
+    trace!(?bitget_get_self_is_colo);
+}
+
+// 测试获取登录params信息
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_get_self_params() {
+    global::log_utils::init_log_with_trace();
+
+    let bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSwap, SYMBOL).await;
+    let bitget_get_self_params = bitget_swap_exchange.get_self_params();
+    trace!("bitget_get_self_params={:?}",bitget_get_self_params);
+}
+
+// 测试获取Market信息
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_get_self_market() {
+    global::log_utils::init_log_with_trace();
+
+    let bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSwap, SYMBOL).await;
+    let bitget_get_self_market = bitget_swap_exchange.get_self_market();
+    trace!(?bitget_get_self_market);
+}
+
+// 测试获取请求时间信息
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_get_request_delays() {
+    global::log_utils::init_log_with_trace();
+
+    let bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSwap, SYMBOL).await;
+    let bitget_get_request_delays = bitget_swap_exchange.get_request_delays();
+    trace!(?bitget_get_request_delays);
+}
+
+// 测试获取请求平均时间信息
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_get_request_avg_delay() {
+    global::log_utils::init_log_with_trace();
+
+    let bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSwap, SYMBOL).await;
+    let bitget_get_request_avg_delay = bitget_swap_exchange.get_request_avg_delay();
+    trace!(?bitget_get_request_avg_delay);
+}
+
+// 测试获取最大请求时间信息
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_get_request_max_delay() {
+    global::log_utils::init_log_with_trace();
+
+    let bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSwap, SYMBOL).await;
+    let bitget_get_request_max_delay = bitget_swap_exchange.get_request_max_delay();
+    trace!(?bitget_get_request_max_delay);
+}
+
+// 测试获取服务器时间
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_get_server_time() {
+    global::log_utils::init_log_with_trace();
+
+    let mut bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSwap, SYMBOL).await;
+    let bitget_get_server_time = bitget_swap_exchange.get_server_time().await;
+    trace!(?bitget_get_server_time);
+}
+
+// 测试获取账号信息
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_get_account() {
+    global::log_utils::init_log_with_trace();
+
+    let mut bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSwap, SYMBOL).await;
+    let bitget_get_account = bitget_swap_exchange.get_account().await;
+    trace!(?bitget_get_account);
+}
+
+// 测试获取持仓信息
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_get_position() {
+    global::log_utils::init_log_with_trace();
+
+    let mut bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSwap, SYMBOL).await;
+    let bitget_get_position = bitget_swap_exchange.get_position().await;
+    trace!(?bitget_get_position);
+}
+
+// 测试获取所有持仓信息
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_get_positions() {
+    global::log_utils::init_log_with_trace();
+
+    let mut bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSwap, SYMBOL).await;
+    let bitget_get_positions = bitget_swap_exchange.get_positions().await;
+    trace!(?bitget_get_positions);
+}
+
+// 测试获取Ticker信息
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_get_ticker() {
+    global::log_utils::init_log_with_trace();
+
+    let mut bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSwap, SYMBOL).await;
+    let bitget_get_ticker = bitget_swap_exchange.get_ticker().await;
+    trace!(?bitget_get_ticker);
+}
+
+// 测试获取Market信息
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_get_market() {
+    global::log_utils::init_log_with_trace();
+
+    let mut bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSwap, SYMBOL).await;
+    let bitget_get_market = bitget_swap_exchange.get_market().await;
+    trace!(?bitget_get_market);
+}
+
+// 测试获取Kline信息
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_get_record() {
+    global::log_utils::init_log_with_trace();
+
+    let mut bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSwap, SYMBOL).await;
+    let bitget_get_market = bitget_swap_exchange.get_record("3".to_string()).await;
+    trace!(?bitget_get_market);
+}
+
+// 测试获取Order详情信息
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_get_order_detail() {
+    global::log_utils::init_log_with_trace();
+
+    let mut bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSwap, SYMBOL).await;
+    let bitget_get_order_detail = bitget_swap_exchange.get_order_detail("", "999993").await;
+    trace!(?bitget_get_order_detail);
+}
+
+// 测试获取Order列表信息
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_get_orders_list() {
+    global::log_utils::init_log_with_trace();
+
+    let mut bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSwap, SYMBOL).await;
+    let bitget_get_orders_list = bitget_swap_exchange.get_orders_list("finished").await;
+    trace!(?bitget_get_orders_list);
+}
+
+// 测试下单
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_take_order() {
+    global::log_utils::init_log_with_trace();
+
+    let mut bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSwap, SYMBOL).await;
+    let bitget_take_order = bitget_swap_exchange.take_order("999994", "pd", dec!(0), dec!(7)).await;
+    trace!(?bitget_take_order);
+}
+
+// 测试撤销订单
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_cancel_order() {
+    global::log_utils::init_log_with_trace();
+
+    let mut bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSwap, SYMBOL).await;
+    let bitget_cancel_order = bitget_swap_exchange.cancel_order("", "999992").await;
+    trace!(?bitget_cancel_order);
+}
+
+// 测试批量撤销订单
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_cancel_orders() {
+    global::log_utils::init_log_with_trace();
+
+    let mut bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSwap, SYMBOL).await;
+    let bitget_cancel_orders = bitget_swap_exchange.cancel_orders().await;
+    trace!(?bitget_cancel_orders);
+}
+
+// 测试设置持仓模式
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_set_dual_mode() {
+    global::log_utils::init_log_with_trace();
+
+    let mut bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSwap, SYMBOL).await;
+    let bitget_set_dual_mode = bitget_swap_exchange.set_dual_mode("usdt", true).await;
+    trace!(?bitget_set_dual_mode);
+}
+
+// 测试设置杠杆
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_set_dual_leverage() {
+    global::log_utils::init_log_with_trace();
+
+    let mut bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSwap, SYMBOL).await;
+    let bitget_set_dual_leverage = bitget_swap_exchange.set_dual_leverage("1").await;
+    trace!(?bitget_set_dual_leverage);
+}

standard/tests/exchange_test.rs

@@ -107,26 +107,24 @@ pub async fn test_new_exchange(exchange: ExchangeEnum, symbol: &str) -> Box<dyn
         //     params.insert("pass_key".to_string(), pass_key);
         //     Exchange::new(exchange, symbol.to_string(), false, params, order_sender, error_sender).await
         // }
-        // ExchangeEnum::BitgetSwap => {
-        //     let mut params: BTreeMap<String, String> = BTreeMap::new();
-        //     let access_key = account_info.bitget_access_key;
-        //     let secret_key = account_info.bitget_secret_key;
-        //     let pass_key = account_info.bitget_pass;
-        //     params.insert("access_key".to_string(), access_key);
-        //     params.insert("secret_key".to_string(), secret_key);
-        //     params.insert("pass_key".to_string(), pass_key);
-        //     Exchange::new(exchange, symbol.to_string(), false, params, order_sender, error_sender).await
-        // }
-        // ExchangeEnum::BybitSwap => {
-        //     let mut params: BTreeMap<String, String> = BTreeMap::new();
-        //     let access_key = account_info.bybit_access_key;
-        //     let secret_key = account_info.bybit_secret_key;
-        //     let pass_key = account_info.bybit_pass;
-        //     params.insert("access_key".to_string(), access_key);
-        //     params.insert("secret_key".to_string(), secret_key);
-        //     params.insert("pass_key".to_string(), pass_key);
-        //     Exchange::new(exchange, symbol.to_string(), false, params, order_sender, error_sender).await
-        // }
+        ExchangeEnum::BitgetSwap => {
+            let mut params: BTreeMap<String, String> = BTreeMap::new();
+            let access_key = account_info.bitget_access_key;
+            let secret_key = account_info.bitget_secret_key;
+            let pass_key = account_info.bitget_pass;
+            params.insert("access_key".to_string(), access_key);
+            params.insert("secret_key".to_string(), secret_key);
+            params.insert("pass_key".to_string(), pass_key);
+            Exchange::new(exchange, symbol.to_string(), false, params, order_sender, error_sender).await
+        }
+        ExchangeEnum::BybitSwap => {
+            let mut params: BTreeMap<String, String> = BTreeMap::new();
+            let access_key = account_info.bybit_access_key;
+            let secret_key = account_info.bybit_secret_key;
+            params.insert("access_key".to_string(), access_key);
+            params.insert("secret_key".to_string(), secret_key);
+            Exchange::new(exchange, symbol.to_string(), false, params, order_sender, error_sender).await
+        }
         // ExchangeEnum::HtxSwap => {
         //     let mut params: BTreeMap<String, String> = BTreeMap::new();
         //     let access_key = account_info.htx_access_key;
@@ -137,9 +135,9 @@ pub async fn test_new_exchange(exchange: ExchangeEnum, symbol: &str) -> Box<dyn
         //     params.insert("pass_key".to_string(), pass_key);
         //     Exchange::new(exchange, symbol.to_string(), false, params, order_sender, error_sender).await
         // }
-        // _ => {
-        //     panic!("该交易所未实现！")
-        // }
+        _ => {
+            panic!("该交易所未实现！")
+        }
     }
 }
 
@@ -709,9 +707,9 @@ where
         //     };
         //     exchange_wss.ws_connect_async(bool_v3_clone, fun, &write_tx_am, write_rx).await.expect("链接失败(内部一个心跳线程应该已经关闭了)");
         // }
-        // _ => {
-        //     error!("该交易所不支持！test_new_exchange_wss：{:?}", exchange);
-        //     panic!("该交易所不支持！test_new_exchange_wss：{:?}", exchange)
-        // }
+        _ => {
+            error!("该交易所不支持！test_new_exchange_wss：{:?}", exchange);
+            panic!("该交易所不支持！test_new_exchange_wss：{:?}", exchange)
+        }
     }
 }

strategy/src/bitget_usdt_swap.rs

@@ -1,190 +1,245 @@
-// use std::collections::BTreeMap;
-// use std::sync::Arc;
-// use std::sync::atomic::AtomicBool;
-// use rust_decimal::Decimal;
-// use tokio::spawn;
-// use tokio::sync::Mutex;
-// use tracing::{error, info};
-// use tokio_tungstenite::tungstenite::Message;
-// use exchanges::bitget_swap_ws::{BitgetSwapLogin, BitgetSwapSubscribeType, BitgetSwapWs, BitgetSwapWsType};
-// use exchanges::response_base::ResponseData;
-// use global::trace_stack::TraceStack;
-// use standard::exchange::ExchangeEnum::{BitgetSwap};
-// use standard::{Position, PositionModeEnum};
-// use crate::core::Core;
-// use crate::exchange_disguise::on_special_depth;
-// use crate::model::OrderInfo;
-//
-// pub async fn bitget_usdt_swap_run(is_shutdown_arc :Arc<AtomicBool>,
-//                                   is_trade: bool,
-//                                   core_arc: Arc<Mutex<Core>>,
-//                                   name: String,
-//                                   symbols: Vec<String>,
-//                                   is_colo: bool,
-//                                   exchange_params: BTreeMap<String, String>) {
-//     // 开启公共频道
-//     let (write_tx_public, write_rx_public) = futures_channel::mpsc::unbounded::<Message>();
-//
-//     // 开启公共连接
-//     let is_shutdown_arc_c1 = is_shutdown_arc.clone();
-//     let write_tx_am_public = Arc::new(Mutex::new(write_tx_public));
-//     let name_clone = name.clone();
-//     let core_arc_clone = core_arc.clone();
-//     let symbols_clone = symbols.clone();
-//     spawn(async move {
-//         // 构建链接ws
-//         let mut bg_public = BitgetSwapWs::new_label(name_clone.clone(),
-//                                                     is_colo,
-//                                                     None,
-//                                                     BitgetSwapWsType::Public);
-//
-//         // 消费数据的函数
-//         let mut update_flag_u = Decimal::ZERO;
-//         let fun = move |data: ResponseData| {
-//             let core_arc_cc = core_arc_clone.clone();
-//
-//             async move {
-//                 on_public_data(core_arc_cc, &mut update_flag_u, data).await
-//             }
-//         };
-//
-//         // 准备链接
-//         bg_public.set_subscribe(vec![BitgetSwapSubscribeType::PuBooks1]); // 只用订阅深度数据
-//         bg_public.set_symbols(symbols_clone);
-//         // bg_public.ws_connect_async(is_shutdown_arc_c1, fun, &write_tx_am_public, write_rx_public).await.expect("bitget_usdt_swap 链接有异常")
-//     });
-//
-//     // 不需要交易就不用开启私有频道了
-//     if !is_trade {
-//         return;
-//     }
-//
-//     // 开启私有频道
-//     let (write_tx_private, write_rx_private) = futures_channel::mpsc::unbounded();
-//
-//     // 开启公共连接
-//     let is_shutdown_arc_c1 = is_shutdown_arc.clone();
-//     let write_tx_am_private = Arc::new(Mutex::new(write_tx_private));
-//     spawn(async move {
-//         // 构建链接ws
-//         let mut bg_private = BitgetSwapWs::new_label(name.clone(),
-//                                                      is_colo,
-//                                                      Some(parse_btree_map_to_bitget_swap_login(exchange_params)),
-//                                                      BitgetSwapWsType::Private);
-//
-//         // 消费数据的函数
-//         let core_arc_clone = core_arc.clone();
-//         let run_symbol = symbols[0].clone();
-//         let ct_val = core_arc_clone.lock().await.platform_rest.get_self_market().ct_val;
-//         let fun = move |data: ResponseData| {
-//             let core_arc_cc = core_arc_clone.clone();
-//             let run_symbol_c = run_symbol.clone();
-//
-//             async move {
-//                 on_private_data(core_arc_cc, ct_val, data, &run_symbol_c).await
-//             }
-//         };
-//
-//         // 准备链接
-//         bg_private.set_subscribe(vec![
-//             BitgetSwapSubscribeType::PrOrders,
-//             BitgetSwapSubscribeType::PrAccount,
-//             BitgetSwapSubscribeType::PrPosition
-//         ]);
-//         bg_private.set_symbols(symbols.clone());
-//         bg_private.ws_connect_async(is_shutdown_arc_c1, fun, &write_tx_am_private, write_rx_private).await.expect("bitget_usdt_swap 链接有异常")
-//     });
-// }
-//
-// async fn on_private_data(core_arc_clone: Arc<Mutex<Core>>,
-//                          ct_val: Decimal,
-//                          response: ResponseData,
-//                          run_symbol: &String) {
-//     let mut trace_stack = TraceStack::new(response.time, response.ins);
-//     trace_stack.on_after_span_line();
-//
-//     // public类型，目前只考虑订单流数据
-//     match response.channel.as_str() {
-//         // "account" => {
-//         //     let account = standard::handle_info::HandleSwapInfo::handle_account_info(BitgetSwap, &response, run_symbol);
-//         //     let mut core = core_arc_clone.lock().await;
-//         //     core.update_equity(account).await;
-//         // },
-//         // "positions" => {
-//         //     let mut positions = standard::handle_info::HandleSwapInfo::handle_position(BitgetSwap, &response, &ct_val);
-//         //
-//         //     // bitget如果没有仓位不会给0，会给个空数组
-//         //     if positions.is_empty() {
-//         //         positions.push(Position {
-//         //             symbol: run_symbol.replace("_", "").to_uppercase(),
-//         //             margin_level: Default::default(),
-//         //             amount: Default::default(),
-//         //             frozen_amount: Default::default(),
-//         //             price: Default::default(),
-//         //             profit: Default::default(),
-//         //             position_mode: PositionModeEnum::Both,
-//         //             margin: Default::default(),
-//         //         });
-//         //     }
-//         //
-//         //     let mut core = core_arc_clone.lock().await;
-//         //     core.update_position(positions).await;
-//         // },
-//         // "orders" => {
-//         //     trace_stack.set_source("gate_swap.orders".to_string());
-//         //     let orders = standard::handle_info::HandleSwapInfo::handle_order(BitgetSwap, response.clone(), ct_val.clone());
-//         //
-//         //     let mut order_infos:Vec<OrderInfo> = Vec::new();
-//         //     for mut order in orders.order {
-//         //         if order.status == "NULL" {
-//         //             error!("bitget_usdt_swap 未识别的订单状态：{:?}", response);
-//         //
-//         //             continue;
-//         //         }
-//         //
-//         //         let order_info = OrderInfo::parse_order_to_order_info(&mut order);
-//         //         order_infos.push(order_info);
-//         //     }
-//         //
-//         //     {
-//         //         let mut core = core_arc_clone.lock().await;
-//         //         core.update_order(order_infos, trace_stack).await;
-//         //     }
-//         // },
-//         "pong" => {}
-//         _ => {
-//             info!("bitget_usdt_swap 113 未知的订阅数据: {:?}", response);
-//         }
-//     }
-// }
-//
-// async fn on_public_data(_core_arc_clone: Arc<Mutex<Core>>,
-//                         _update_flag_u: &mut Decimal,
-//                         response: ResponseData) {
-//     let mut trace_stack = TraceStack::new(response.time, response.ins);
-//     trace_stack.on_after_span_line();
-//
-//     // public类型，目前只考虑订单流数据
-//     match response.channel.as_str() {
-//         "books1" => {
-//             // trace_stack.set_source("bitget_usdt_swap.books1".to_string());
-//             // let special_depth = standard::handle_info::HandleSwapInfo::handle_special_depth(BitgetSwap, &response);
-//             // trace_stack.on_after_format();
-//             //
-//             // on_special_depth(core_arc_clone, update_flag_u, &response.label, &mut trace_stack, &special_depth).await;
-//         },
-//         "pong" => {},
-//         _ => {
-//             info!("bitget_usdt_swap 125 未知的订阅数据");
-//             info!(?response)
-//         }
-//     }
-// }
-//
-// fn parse_btree_map_to_bitget_swap_login(exchange_params: BTreeMap<String, String>) -> BitgetSwapLogin {
-//     BitgetSwapLogin {
-//         api_key: exchange_params.get("access_key").unwrap().clone(),
-//         secret_key: exchange_params.get("secret_key").unwrap().clone(),
-//         passphrase_key: exchange_params.get("pass_key").unwrap().clone(),
-//     }
-// }
+use std::collections::BTreeMap;
+use std::sync::Arc;
+use std::sync::atomic::AtomicBool;
+use rust_decimal::Decimal;
+use tokio::spawn;
+use tokio::sync::Mutex;
+use tracing::{error, info};
+use tokio_tungstenite::tungstenite::Message;
+use exchanges::bitget_swap_ws::{BitgetSwapLogin, BitgetSwapSubscribeType, BitgetSwapWs, BitgetSwapWsType};
+use exchanges::response_base::ResponseData;
+use global::trace_stack::TraceStack;
+use standard::exchange::ExchangeEnum::BitgetSwap;
+use standard::exchange_struct_handler::ExchangeStructHandler;
+use standard::{Depth, OrderBook};
+use crate::core::Core;
+use crate::exchange_disguise::{on_depth, on_record, on_ticker, on_trade};
+use crate::model::OrderInfo;
+
+pub async fn reference_bitget_swap_run(is_shutdown_arc: Arc<AtomicBool>,
+                                       core_arc: Arc<Mutex<Core>>,
+                                       name: String,
+                                       symbols: Vec<String>,
+                                       is_colo: bool) {
+    spawn(async move {
+        // 开启公共频道
+        let (write_tx, write_rx) = futures_channel::mpsc::unbounded::<Message>();
+        let mut ws = BitgetSwapWs::new_label(name, is_colo, None, BitgetSwapWsType::Public);
+        ws.set_subscribe(vec![
+            BitgetSwapSubscribeType::PuBooks1,
+            BitgetSwapSubscribeType::PuTrade,
+            BitgetSwapSubscribeType::PuTickers,
+            BitgetSwapSubscribeType::PuKline("1".to_string()),
+        ]);
+
+
+        // 读取数据
+        let core_arc_clone = Arc::clone(&core_arc);
+        let mut rest = core_arc_clone.lock().await.platform_rest.clone_box();
+        let multiplier = rest.get_self_market().multiplier;
+        let mut records = rest.get_record("1".to_string()).await.unwrap();
+        for record in records.iter_mut() {
+            let core_arc_clone = core_arc.clone();
+
+            on_record(core_arc_clone, record).await
+        }
+
+        let depth_asks = Arc::new(Mutex::new(Vec::new()));
+        let depth_bids = Arc::new(Mutex::new(Vec::new()));
+
+        let fun = move |data: ResponseData| {
+            // 在 async 块之前克隆 Arc
+            let core_arc_cc = core_arc_clone.clone();
+            let mul = multiplier.clone();
+
+            let depth_asks = Arc::clone(&depth_asks);
+            let depth_bids = Arc::clone(&depth_bids);
+
+            async move {
+                let mut depth_asks = depth_asks.lock().await;
+                let mut depth_bids = depth_bids.lock().await;
+                // 使用克隆后的 Arc，避免 move 语义
+                on_public_data(core_arc_cc, &mul, &data, &mut depth_asks, &mut depth_bids).await
+            }
+        };
+
+        // 链接
+        let write_tx_am = Arc::new(Mutex::new(write_tx));
+        ws.set_symbols(symbols);
+        ws.ws_connect_async(is_shutdown_arc, fun, &write_tx_am, write_rx).await.expect("bitget_usdt_swap 链接有异常");
+    });
+}
+
+// 交易 bybit 合约 启动
+pub(crate) async fn bitget_swap_run(is_shutdown_arc: Arc<AtomicBool>,
+                                    core_arc: Arc<Mutex<Core>>,
+                                    name: String,
+                                    symbols: Vec<String>,
+                                    is_colo: bool,
+                                    exchange_params: BTreeMap<String, String>) {
+    spawn(async move {
+        let (write_tx, write_rx) = futures_channel::mpsc::unbounded();
+        let auth = Some(parse_btree_map_to_bitget_swap_login(exchange_params));
+        let mut ws = BitgetSwapWs::new_label(name.clone(), is_colo, auth, BitgetSwapWsType::Private);
+        ws.set_subscribe(vec![
+            BitgetSwapSubscribeType::PrOrders,
+            BitgetSwapSubscribeType::PrAccount,
+            BitgetSwapSubscribeType::PrPosition,
+        ]);
+
+        let core_arc_clone_private = core_arc.clone();
+        let multiplier = core_arc_clone_private.lock().await.platform_rest.get_self_market().multiplier;
+        let run_symbol = symbols.clone()[0].clone();
+
+        // 挂起私有ws
+        let fun = move |data: ResponseData| {
+            // 在 async 块之前克隆 Arc
+            let core_arc_cc = core_arc_clone_private.clone();
+            let mul = multiplier.clone();
+            let rs = run_symbol.clone();
+
+            async move {
+                // 使用克隆后的 Arc，避免 move 语义
+                on_private_data(core_arc_cc, &mul, &rs, &data).await;
+            }
+        };
+
+        // 链接
+        let write_tx_am = Arc::new(Mutex::new(write_tx));
+        ws.set_symbols(symbols);
+        ws.ws_connect_async(is_shutdown_arc, fun, &write_tx_am, write_rx).await.expect("bitget_usdt_swap 链接有异常");
+    });
+}
+
+async fn on_private_data(core_arc_clone: Arc<Mutex<Core>>, ct_val: &Decimal, run_symbol: &String, response: &ResponseData) {
+    let mut trace_stack = TraceStack::new(response.time, response.ins);
+    trace_stack.on_after_span_line();
+
+    match response.channel.as_str() {
+        "wallet" => {
+            let account = ExchangeStructHandler::account_info_handle(BitgetSwap, response, run_symbol);
+            let mut core = core_arc_clone.lock().await;
+            core.update_equity(account).await;
+        }
+        "order" => {
+            let orders = ExchangeStructHandler::order_handle(BitgetSwap, response, ct_val);
+            trace_stack.on_after_format();
+
+            let mut order_infos: Vec<OrderInfo> = Vec::new();
+            for mut order in orders.order {
+                if order.status == "NULL" {
+                    error!("bitget_usdt_swap 未识别的订单状态：{:?}", response);
+                    continue;
+                }
+
+                if order.deal_amount != Decimal::ZERO {
+                    info!("bitget order 消息原文：{:?}", response);
+                }
+
+                let order_info = OrderInfo::parse_order_to_order_info(&mut order);
+                order_infos.push(order_info);
+            }
+
+            let mut core = core_arc_clone.lock().await;
+            core.update_order(order_infos, trace_stack).await;
+        }
+        "position" => {
+            let positions = ExchangeStructHandler::position_handle(BitgetSwap, response, ct_val);
+            let mut core = core_arc_clone.lock().await;
+            core.update_position(positions).await;
+        }
+        _ => {
+            error!("未知推送类型");
+            error!(?response);
+        }
+    }
+}
+
+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("bitget_usdt_swap.bookTicker".to_string());
+
+            let mut is_update = false;
+            if response.data_type == "delta" {
+                is_update = true;
+            }
+            let mut depth = ExchangeStructHandler::book_ticker_handle(BitgetSwap, &response, mul);
+            // 是增量更新
+            if is_update {
+                if depth.asks.len() != 0 {
+                    depth_asks.clear();
+                    depth_asks.append(&mut depth.asks);
+                } else if depth.bids.len() != 0 {
+                    depth_bids.clear();
+                    depth_bids.append(&mut depth.bids);
+                }
+
+                let result_depth = Depth {
+                    time: depth.time,
+                    symbol: depth.symbol,
+                    asks: depth_asks.clone(),
+                    bids: depth_bids.clone(),
+                };
+
+                trace_stack.on_after_format();
+                on_depth(core_arc, &response.label, &mut trace_stack, &result_depth).await;
+            }
+            // 全量
+            else {
+                trace_stack.on_after_format();
+                on_depth(core_arc, &response.label, &mut trace_stack, &depth).await;
+
+                depth_asks.clear();
+                depth_asks.append(&mut depth.asks);
+                depth_bids.clear();
+                depth_bids.append(&mut depth.bids);
+            }
+        }
+        "trade" => {
+            trace_stack.set_source("bitget_usdt_swap.trade".to_string());
+
+            let trades = ExchangeStructHandler::trades_handle(BitgetSwap, response, mul);
+            trace_stack.on_after_format();
+
+            let core_arc_clone = core_arc.clone();
+            on_trade(core_arc_clone, &response.label, &mut trace_stack, trades).await;
+        }
+        "tickers" => {
+            trace_stack.set_source("bitget_usdt_swap.tickers".to_string());
+            let tickers = ExchangeStructHandler::ticker_handle(BitgetSwap, response).await;
+            trace_stack.on_after_format();
+
+            on_ticker(core_arc, &mut trace_stack, &tickers).await;
+        }
+        // k线数据
+        "kline" => {
+            let mut records = ExchangeStructHandler::records_handle(BitgetSwap, &response);
+
+            if records.is_empty() {
+                return;
+            }
+
+            for record in records.iter_mut() {
+                let core_arc_clone = core_arc.clone();
+
+                on_record(core_arc_clone, record).await
+            }
+        }
+        _ => {
+            error!("未知推送类型");
+            error!(?response);
+        }
+    }
+}
+
+fn parse_btree_map_to_bitget_swap_login(exchange_params: BTreeMap<String, String>) -> BitgetSwapLogin {
+    BitgetSwapLogin {
+        api_key: exchange_params.get("access_key").unwrap().clone(),
+        secret_key: exchange_params.get("secret_key").unwrap().clone(),
+        passphrase_key: exchange_params.get("pass_key").unwrap().clone(),
+    }
+}

strategy/src/clear_core.rs

@@ -18,7 +18,7 @@ use global::params::Params;
 use global::trace_stack::TraceStack;
 use standard::{Account, Market, Order, Platform, Position, PositionModeEnum, SpecialTicker};
 use standard::exchange::{Exchange};
-use standard::exchange::ExchangeEnum::{BinanceSwap, GateSwap};
+use standard::exchange::ExchangeEnum::{BinanceSwap, GateSwap, BitgetSwap};
 
 use crate::model::{LocalPosition, OrderInfo};
 use crate::avellaneda_stoikov::AvellanedaStoikov;
@@ -207,9 +207,9 @@ impl ClearCore {
                 // "bitget_spot" => {
                 //     Exchange::new(BitgetSpot, symbol, params.colo != 0i8, exchange_params, order_sender, error_sender).await
                 // }
-                // "bitget_usdt_swap" => {
-                //     Exchange::new(BitgetSwap, symbol, params.colo != 0i8, exchange_params, order_sender, error_sender).await
-                // }
+                "bitget_usdt_swap" => {
+                    Exchange::new(BitgetSwap, symbol, params.colo != 0i8, exchange_params, order_sender, error_sender).await
+                }
                 // "okex_usdt_swap" => {
                 //     Exchange::new(OkxSwap, symbol, params.colo != 0i8, exchange_params, order_sender, error_sender).await
                 // }
@@ -413,7 +413,7 @@ impl ClearCore {
                 let length = val.len();
                 result.clear_order_num = length.to_string();
                 result.clear_order_str = format!("清空所有挂单：{:?}", val);
-                if length > 0{
+                if length > 0 {
                     info!("已清空所有挂单（{}条）", length);
                     for o in val {
                         info!("    {:?}", o);
@@ -427,7 +427,7 @@ impl ClearCore {
                         let length = val.len();
                         result.clear_order_num = length.to_string();
                         result.clear_order_str = format!("清空所有挂单(备用)：{:?}", val);
-                        if length > 0{
+                        if length > 0 {
                             info!("清空所有挂单（{}条）：{:?}", length, val);
                         }
                     }
@@ -485,14 +485,14 @@ impl ClearCore {
                         Ok(order) => {
                             ts.on_after_send();
                             info!("    {}仓位清除市价下单成功 {:?}, {}", position.symbol.clone(), order, ts.to_string());
-                            result.clear_position_str = format!("{} >仓位信息：{:?} 下单信息: {:?}",result.clear_position_str, position, order);
+                            result.clear_position_str = format!("{} >仓位信息：{:?} 下单信息: {:?}", result.clear_position_str, position, order);
                             // 执行完当前币对  结束循环
                             continue;
                         }
                         Err(error) => {
                             // ts.on_after_send();
                             error!("    {}仓位清除市价下单异常 {}, {}", position.symbol.clone(), error, ts.to_string());
-                            result.clear_other_str = format!("{} >仓位信息：{:?} 下单异常信息: {:?}",result.clear_other_str, position, error);
+                            result.clear_other_str = format!("{} >仓位信息：{:?} 下单异常信息: {:?}", result.clear_other_str, position, error);
                             // 执行完当前币对  结束循环
                             continue;
                         }
@@ -520,7 +520,7 @@ impl ClearCore {
         result.r_id = r_id;
         info!("清仓程序结果 {:?}", result);
         // 判断是否有清仓，是否有异常
-        if result.clear_position_num != "0" || result.clear_order_num != "0" || result.clear_other_err{
+        if result.clear_position_num != "0" || result.clear_order_num != "0" || result.clear_other_err {
             info!("上报了清仓信息！！！");
             send_clear_msg_request(&result).await;
             // 上报清仓日志
@@ -601,7 +601,6 @@ impl ClearCore {
 
         // 买入平台币
         if self.exchange.contains("spot") { // 现货
-
         }
 
         // 清空挂单和仓位
@@ -639,7 +638,7 @@ pub async fn send_clear_msg_request(body_params: &ClearPositionResult) {
             } else {
                 println!("清仓结果上报中控，请求失败: 响应异常码 {}，响应文本 {}", status, response_text);
             }
-        },
+        }
         Err(e) => {
             error!("清仓结果上报中控，请求发送失败，异常：{}", e)
         }

strategy/src/core.rs

@@ -20,7 +20,7 @@ use global::params::Params;
 use global::trace_stack::TraceStack;
 use standard::{Account, Depth, Market, Order, OrderCommand, Platform, Position, PositionModeEnum, Record, SpecialTicker, Ticker, Trade};
 use standard::exchange::{Exchange};
-use standard::exchange::ExchangeEnum::{BinanceSwap, BybitSwap, GateSwap};
+use standard::exchange::ExchangeEnum::{BinanceSwap, BybitSwap, BitgetSwap, GateSwap};
 
 use crate::model::{LocalPosition, OrderInfo, TokenParam};
 use crate::avellaneda_stoikov::AvellanedaStoikov;
@@ -209,9 +209,9 @@ impl Core {
                 // "bitget_spot" => {
                 //     Exchange::new(BitgetSpot, symbol, params.colo != 0i8, exchange_params, order_sender, error_sender).await
                 // }
-                // "bitget_usdt_swap" => {
-                //     Exchange::new(BitgetSwap, symbol, params.colo != 0i8, exchange_params, order_sender, error_sender).await
-                // }
+                "bitget_usdt_swap" => {
+                    Exchange::new(BitgetSwap, symbol, params.colo != 0i8, exchange_params, order_sender, error_sender).await
+                }
                 // "okex_usdt_swap" => {
                 //     Exchange::new(OkxSwap, symbol, params.colo != 0i8, exchange_params, order_sender, error_sender).await
                 // }
@@ -383,7 +383,7 @@ impl Core {
                                 self.local_cash -= filled * filled_price;
                                 self.local_coin = filled - fee;
 
-                            // sell 平多
+                                // sell 平多
                             } else if side == "pd" {
                                 self.local_sell_amount += filled;
                                 self.local_sell_value += filled * filled_price;
@@ -398,7 +398,7 @@ impl Core {
                                 self.local_cash += filled * filled_price - fee;
                                 self.local_coin -= filled;
 
-                            // buy 平空
+                                // buy 平空
                             } else if side == "pk" {
                                 self.local_buy_amount += filled - fee;
                                 self.local_buy_value += (filled - fee) * filled_price;
@@ -413,7 +413,7 @@ impl Core {
                                 self.local_cash -= filled * filled_price;
                                 self.local_coin += filled - fee;
 
-                            // sell 开空
+                                // sell 开空
                             } else if side == "kk" {
                                 self.local_sell_amount += filled;
                                 self.local_sell_value += filled * filled_price;
@@ -432,7 +432,7 @@ impl Core {
                                 info!("错误的仓位方向{}", side);
                             }
 
-                        // 合约订单流仓位计算
+                            // 合约订单流仓位计算
                         } else {
                             // buy 开多
                             if side == "kd" {
@@ -448,7 +448,7 @@ impl Core {
                                     self.local_position_by_orders.long_pos = self.local_position_by_orders.long_pos + filled;
                                 }
 
-                            // sell 开空
+                                // sell 开空
                             } else if side == "kk" {
                                 self.local_sell_amount += filled;
                                 self.local_sell_value += filled * filled_price;
@@ -461,7 +461,7 @@ impl Core {
                                     self.local_position_by_orders.short_pos = self.local_position_by_orders.short_pos + filled;
                                 }
 
-                            // sell 平多
+                                // sell 平多
                             } else if side == "pd" {
                                 self.local_sell_amount += filled;
                                 self.local_sell_value += filled * filled_price;
@@ -470,7 +470,7 @@ impl Core {
                                     self.local_position_by_orders.long_avg = Decimal::ZERO;
                                 }
 
-                            // buy 平空
+                                // buy 平空
                             } else if side == "pk" {
                                 self.local_buy_amount += filled;
                                 self.local_buy_value += filled * filled_price;
@@ -1579,14 +1579,14 @@ impl Core {
             if clear_count >= 1 {
                 info!("连续{}次清理完成。", clear_count);
                 info!("");
-                break
+                break;
             }
 
             // 最大次数判定
             if total_clear_count >= 500 {
                 info!("清理次数达到上限：{}次，不再执行清理。", total_clear_count);
                 info!("");
-                break
+                break;
             }
 
             clear_count += 1;

strategy/src/exchange_disguise.rs

@@ -6,6 +6,7 @@ use global::trace_stack::TraceStack;
 use standard::{Depth, Record, Ticker, Trade};
 use crate::binance_usdt_swap::{binance_swap_run, reference_binance_swap_run};
 use crate::bybit_usdt_swap::{bybit_swap_run, reference_bybit_swap_run};
+use crate::bitget_usdt_swap::{bitget_swap_run, reference_bitget_swap_run};
 use crate::coinex_usdt_swap::coinex_swap_run;
 use crate::gate_usdt_swap::gate_swap_run;
 use crate::core::Core;
@@ -34,9 +35,9 @@ pub async fn run_transactional_exchange(is_shutdown_arc :Arc<AtomicBool>,
         // "bitget_spot" => {
         //     bitget_spot_run(is_shutdown_arc,true, core_arc, name, symbols, is_colo, exchange_params).await;
         // },
-        // "bitget_usdt_swap" => {
-        //     bitget_usdt_swap_run(is_shutdown_arc, true, core_arc, name, symbols, is_colo, exchange_params).await;
-        // }
+        "bitget_usdt_swap" => {
+            bitget_swap_run(is_shutdown_arc, core_arc, name, symbols, is_colo, exchange_params).await;
+        }
         "bybit_usdt_swap" => {
             bybit_swap_run(is_shutdown_arc, core_arc, name, symbols, is_colo, exchange_params).await;
         }
@@ -83,9 +84,9 @@ pub async fn run_reference_exchange(is_shutdown_arc: Arc<AtomicBool>,
         // "bitget_spot" => {
         //     bitget_spot_run(is_shutdown_arc, false, core_arc, name, symbols, is_colo, exchange_params).await;
         // },
-        // "bitget_usdt_swap" => {
-        //     bitget_usdt_swap_run(is_shutdown_arc, false, core_arc, name, symbols, is_colo, exchange_params).await;
-        // }
+        "bitget_usdt_swap" => {
+            reference_bitget_swap_run(is_shutdown_arc, core_arc, name, symbols, is_colo).await;
+        }
         "bybit_usdt_swap" => {
             reference_bybit_swap_run(is_shutdown_arc,  core_arc, name, symbols, is_colo).await;
         },

strategy/src/strategy.rs

@@ -867,7 +867,6 @@ impl Strategy {
     pub fn _check_local_orders(&mut self,
                                command: &mut OrderCommand,
                                local_orders: &HashMap<String, OrderInfo>) {
-        // debug!(?command);
         // 超时检测
         if self.local_time - self._check_local_orders_time < self._check_local_orders_interval {
             return;
@@ -1001,6 +1000,7 @@ impl Strategy {
             // target_sell_price = utils::clip(target_sell_price, self.bp * dec!(0.9995), self.ap * dec!(1.03));
             // 取消大小限制
             target_sell_price = utils::fix_price(target_sell_price, self.tick_size);
+
             let amount = if predictor.inventory >= dec!(3) {
                 utils::get_amount_by_min_amount_value(self.min_amount_value * predictor.inventory.abs(), target_sell_price, self.step_size)
             } else {