bitget_usdt_swap的基础支持，编译通过，可以对接逻辑，以及基础的启动运行。

exchanges/src/bitget_swap_rest.rs

@@ -64,6 +64,16 @@ impl BitgetSwapRest {
         ).await
     }
 
+    pub async fn get_server_time(&mut self) -> ResponseData {
+        let params = serde_json::json!({});
+        self.request("GET".to_string(),
+                     "/api/v2".to_string(),
+                     "/public/time".to_string(),
+                     false,
+                     params.to_string(),
+        ).await
+    }
+
     // 获取仓位信息（单个）
     pub async fn get_single_position(&mut self, params: Value) -> ResponseData {
         self.request("GET".to_string(),

standard/src/bitget_swap_handle.rs

@@ -0,0 +1,136 @@
+// use std::str::FromStr;
+// use rust_decimal::Decimal;
+// use rust_decimal_macros::dec;
+// use serde_json::json;
+// use tokio::time::Instant;
+// use tracing::trace;
+// use exchanges::response_base::ResponseData;
+// use global::trace_stack::TraceStack;
+// use crate::{Account, MarketOrder, Order, SpecialDepth, SpecialOrder, SpecialTicker};
+// use crate::exchange::ExchangeEnum;
+// use crate::handle_info::HandleSwapInfo;
+//
+// // 处理账号信息
+// pub fn handle_account_info(res_data: ResponseData, symbol: String) -> Account {
+//     let symbol_upper = symbol.to_uppercase();
+//     let symbol_array: Vec<&str> = symbol_upper.split("_").collect();
+//     let res_data_str = res_data.data;
+//     let res_data_json: Vec<serde_json::Value> = serde_json::from_str(&res_data_str).unwrap();
+//     let balance_info_default = json!({"available":"0","coin": symbol_array[1],"frozen":"0","limitAvailable":"0","locked":"0","uTime":"0"});
+//     let balance_info = res_data_json.iter().find(|&item| item["coin"].as_str().unwrap() == symbol_array[1]).unwrap_or(&balance_info_default);
+//     let stocks_info_default = json!({"available":"0","coin": symbol_array[0],"frozen":"0","limitAvailable":"0","locked":"0","uTime":"0"});
+//     let stocks_info = res_data_json.iter().find(|&item| item["coin"].as_str().unwrap() == symbol_array[0]).unwrap_or(&stocks_info_default);
+//     format_account_info(balance_info.clone(), stocks_info.clone())
+// }
+//
+// pub fn format_account_info(balance_data: serde_json::Value, stocks_data: serde_json::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;
+//
+//     let stocks_coin = stocks_data["coin"].as_str().unwrap().to_string().to_uppercase();
+//     let available_stocks = Decimal::from_str(stocks_data["available"].as_str().unwrap()).unwrap();
+//     let frozen_stocks = Decimal::from_str(stocks_data["frozen"].as_str().unwrap()).unwrap();
+//     let stocks = available_stocks + frozen_stocks;
+//
+//     Account {
+//         coin: format!("{}_{}", stocks_coin, balance_coin),
+//         balance,
+//         available_balance,
+//         frozen_balance,
+//         stocks,
+//         available_stocks,
+//         frozen_stocks,
+//     }
+// }
+//
+// // 处理order信息
+// pub fn handle_order(res_data: ResponseData, ct_val: Decimal) -> SpecialOrder {
+//     let res_data_str = res_data.data;
+//     let res_data_json: Vec<serde_json::Value> = serde_json::from_str(&*res_data_str).unwrap();
+//     let mut order_info = Vec::new();
+//     for item in res_data_json.iter() {
+//         order_info.push(format_order_item(item.clone(), ct_val));
+//     }
+//     trace!(?order_info);
+//     SpecialOrder {
+//         name: res_data.label,
+//         order: order_info,
+//     }
+// }
+//
+// // 处理订单信息
+// pub fn format_order_item(order: serde_json::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["status"].as_str().unwrap_or("");
+//     let acc_base_volume = Decimal::from_str(order["accBaseVolume"].as_str().unwrap()).unwrap();
+//
+//     let avg_price = Decimal::from_str(order["priceAvg"].as_str().unwrap()).unwrap();
+//
+//     let amount = size * ct_val;
+//     let deal_amount = acc_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("89 bitget_spot_handle".to_string()),
+//     }
+// }
+//
+// // 处理特殊深度数据
+// pub fn handle_special_depth(res_data: ResponseData) -> SpecialDepth {
+//     HandleSwapInfo::handle_special_depth(ExchangeEnum::BitgetSpot, res_data)
+// }
+//
+// // 格式化深度信息
+// pub fn format_depth_items(value: serde_json::Value) -> Vec<MarketOrder> {
+//     let mut depth_items: Vec<MarketOrder> = vec![];
+//     for value in value.as_array().unwrap() {
+//         depth_items.push(MarketOrder {
+//             price: Decimal::from_str(value[0].as_str().unwrap()).unwrap(),
+//             amount: Decimal::from_str(value[1].as_str().unwrap()).unwrap(),
+//         })
+//     }
+//     return depth_items;
+// }
+//
+// // 处理特殊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_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 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,
+//     }
+// }

standard/src/bitget_usdt_swap.rs

@@ -0,0 +1,647 @@
+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 rust_decimal::Decimal;
+use serde_json::{Value};
+use tokio::time::Instant;
+use global::trace_stack::TraceStack;
+use crate::exchange::ExchangeEnum;
+use crate::{Account, Market, Order, OrderCommand, Platform, Position, Ticker};
+
+#[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_or(bitget_swap.market);
+        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> {
+        Err(Error::new(ErrorKind::NotFound, "bitget_swap：该交易所方法未实现".to_string()))
+    }
+
+    async fn get_spot_account(&mut self) -> Result<Vec<Account>, Error> {
+        // let res_data = self.request.get_account_assets().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_account_info(item.clone())).collect();
+        //     Ok(result)
+        // } else {
+        //     Err(Error::new(ErrorKind::Other, res_data.to_string()))
+        // }
+        Err(Error::new(ErrorKind::NotFound, "bitget_swap：该交易所方法未实现".to_string()))
+    }
+
+    async fn get_position(&mut self) -> Result<Vec<Position>, Error> { Err(Error::new(ErrorKind::NotFound, "bitget_swap：该交易所方法未实现".to_string())) }
+
+    async fn get_positions(&mut self) -> Result<Vec<Position>, Error> { Err(Error::new(ErrorKind::NotFound, "bitget_swap：该交易所方法未实现".to_string())) }
+
+    async fn get_ticker(&mut self) -> Result<Ticker, Error> {
+        // let symbol_format = utils::format_symbol(self.symbol.clone(), "");
+        // let res_data = self.request.get_tickers(symbol_format).await;
+        // if res_data.code == "200" {
+        //     let res_data_str = &res_data.data;
+        //     let res_data_json: serde_json::Value = serde_json::from_str(res_data_str).unwrap();
+        //     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()))
+        // }
+        Err(Error::new(ErrorKind::NotFound, "bitget_swap：该交易所方法未实现".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_str = &res_data.data;
+        //     let res_data_json: serde_json::Value = serde_json::from_str(res_data_str).unwrap();
+        //     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()))
+        // }
+        Err(Error::new(ErrorKind::NotFound, "bitget_swap：该交易所方法未实现".to_string()))
+    }
+
+    async fn get_market(&mut self) -> Result<Market, Error> {
+        // let symbol_format = utils::format_symbol(self.symbol.clone(), "");
+        // let res_data = self.request.get_symbols(symbol_format.clone()).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 market_info = res_data_json.iter().find(|&item| item["symbol"].as_str().unwrap() == symbol_format.clone());
+        //     match market_info {
+        //         None => {
+        //             error!("bitget_swap：获取Market信息错误!\nget_market:res_data={:?}", res_data);
+        //             Err(Error::new(ErrorKind::Other, res_data.to_string()))
+        //         }
+        //         Some(value) => {
+        //             let base_asset = value["baseCoin"].as_str().unwrap().to_string();
+        //             let quote_asset = value["quoteCoin"].as_str().unwrap().to_string();
+        //             let price_precision = Decimal::from_str(value["pricePrecision"].as_str().unwrap()).unwrap();
+        //             let amount_precision = Decimal::from_str(value["quantityPrecision"].as_str().unwrap()).unwrap();
+        //             let min_qty = Decimal::from_str(&value["minTradeAmount"].as_str().unwrap()).unwrap();
+        //             let max_qty = Decimal::from_str(&value["maxTradeAmount"].as_str().unwrap()).unwrap();
+        //
+        //             let tick_size = if price_precision > dec!(0) {
+        //                 Decimal::from_str(&format!("0.{}1", "0".repeat(usize::try_from(price_precision - dec!(1)).unwrap()))).unwrap()
+        //             } else {
+        //                 Decimal::ONE
+        //             };
+        //             let amount_size = if amount_precision > dec!(0) {
+        //                 Decimal::from_str(&format!("0.{}1", "0".repeat(usize::try_from(amount_precision - dec!(1)).unwrap()))).unwrap()
+        //             } else {
+        //                 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: Decimal::ONE,
+        //             };
+        //             Ok(result)
+        //         }
+        //     }
+        // } else {
+        //     Err(Error::new(ErrorKind::Other, res_data.to_string()))
+        // }
+        Err(Error::new(ErrorKind::NotFound, "bitget_swap：该交易所方法未实现".to_string()))
+    }
+
+    async fn get_market_symbol(&mut self, symbol: String) -> Result<Market, Error> {
+        // let symbol_format = utils::format_symbol(symbol.clone(), "");
+        // let res_data = self.request.get_symbols(symbol_format.clone()).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 market_info = res_data_json.iter().find(|&item| item["symbol"].as_str().unwrap() == symbol_format.clone());
+        //     match market_info {
+        //         None => {
+        //             error!("bitget_swap：获取Market信息错误!\nget_market:res_data={:?}", res_data);
+        //             Err(Error::new(ErrorKind::Other, res_data.to_string()))
+        //         }
+        //         Some(value) => {
+        //             let base_asset = value["baseCoin"].as_str().unwrap().to_string();
+        //             let quote_asset = value["quoteCoin"].as_str().unwrap().to_string();
+        //             let price_precision = Decimal::from_str(value["pricePrecision"].as_str().unwrap()).unwrap();
+        //             let amount_precision = Decimal::from_str(value["quantityPrecision"].as_str().unwrap()).unwrap();
+        //             let min_qty = Decimal::from_str(&value["minTradeAmount"].as_str().unwrap()).unwrap();
+        //             let max_qty = Decimal::from_str(&value["maxTradeAmount"].as_str().unwrap()).unwrap();
+        //
+        //             let tick_size = if price_precision > dec!(0) {
+        //                 Decimal::from_str(&format!("0.{}1", "0".repeat(usize::try_from(price_precision - dec!(1)).unwrap()))).unwrap()
+        //             } else {
+        //                 Decimal::ONE
+        //             };
+        //             let amount_size = if amount_precision > dec!(0) {
+        //                 Decimal::from_str(&format!("0.{}1", "0".repeat(usize::try_from(amount_precision - dec!(1)).unwrap()))).unwrap()
+        //             } else {
+        //                 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: Decimal::ONE,
+        //             };
+        //             Ok(result)
+        //         }
+        //     }
+        // } else {
+        //     Err(Error::new(ErrorKind::Other, res_data.to_string()))
+        // }
+        Err(Error::new(ErrorKind::NotFound, "bitget_swap：该交易所方法未实现".to_string()))
+    }
+
+    async fn get_order_detail(&mut self, order_id: &str, custom_id: &str) -> Result<Order, Error> {
+        Err(Error::new(ErrorKind::NotFound, "bitget_swap：该交易所方法未实现".to_string()))
+        // let ct_val = self.market.ct_val;
+        // let res_data = self.request.get_order(order_id.to_string(), custom_id.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();
+        //     if res_data_json.len() == 0 {
+        //         Err(Error::new(ErrorKind::Other, res_data.to_string()))
+        //     } else {
+        //         let order_info = res_data_json[0].clone();
+        //         let result = format_order_item(order_info, ct_val);
+        //         Ok(result)
+        //     }
+        // } else {
+        //     Err(Error::new(ErrorKind::Other, res_data.to_string()))
+        // }
+    }
+
+    async fn get_orders_list(&mut self, _status: &str) -> Result<Vec<Order>, Error> {
+        Err(Error::new(ErrorKind::NotFound, "bitget_swap：该交易所方法未实现".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> {
+        Err(Error::new(ErrorKind::NotFound, "bitget_swap：该交易所方法未实现".to_string()))
+        // let symbol_format = utils::format_symbol(self.symbol.clone(), "");
+        // let mut params = json!({
+        //     "symbol": symbol_format.to_string(),
+        //     "clientOid": custom_id,
+        //     "price": price.to_string(),
+        // });
+        // if price.eq(&Decimal::ZERO) {
+        //     params["orderType"] = json!("market");
+        //     params["force"] = json!("post_only");
+        // } else {
+        //     params["orderType"] = json!("limit");
+        //     params["force"] = json!("gtc");
+        // };
+        // params["size"] = json!(amount);
+        // match origin_side {
+        //     "kd" => {
+        //         params["side"] = json!("buy");
+        //     }
+        //     "pd" => {
+        //         params["side"] = json!("sell");
+        //     }
+        //     "kk" => {
+        //         params["side"] = json!("sell");
+        //     }
+        //     "pk" => {
+        //         params["side"] = json!("buy");
+        //     }
+        //     _ => { error!("下单参数错误"); }
+        // };
+        // let res_data = self.request.spot_order(params).await;
+        // if res_data.code == "200" {
+        //     let res_data_str = &res_data.data;
+        //     let res_data_json: serde_json::Value = serde_json::from_str(res_data_str).unwrap();
+        //     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()),
+        //     };
+        //     Ok(result)
+        // } else {
+        //     Err(Error::new(ErrorKind::Other, res_data.to_string()))
+        // }
+    }
+
+    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> {
+        Err(Error::new(ErrorKind::NotFound, "bitget_swap：该交易所方法未实现".to_string()))
+        // let symbol_format = utils::format_symbol(symbol.clone(), "");
+        // let mut params = json!({
+        //     "symbol": symbol_format.to_string(),
+        //     "clientOid": custom_id,
+        //     "price": price.to_string(),
+        // });
+        // if price.eq(&Decimal::ZERO) {
+        //     params["orderType"] = json!("market");
+        //     params["force"] = json!("post_only");
+        // } else {
+        //     params["orderType"] = json!("limit");
+        //     params["force"] = json!("gtc");
+        // };
+        // let size = (amount / ct_val).floor();
+        // params["size"] = json!(size);
+        // match origin_side {
+        //     "kd" => {
+        //         params["side"] = json!("buy");
+        //     }
+        //     "pd" => {
+        //         params["side"] = json!("sell");
+        //     }
+        //     "kk" => {
+        //         params["side"] = json!("sell");
+        //     }
+        //     "pk" => {
+        //         params["side"] = json!("buy");
+        //     }
+        //     _ => { error!("下单参数错误"); }
+        // };
+        // let res_data = self.request.spot_order(params).await;
+        // if res_data.code == "200" {
+        //     let res_data_str = &res_data.data;
+        //     let res_data_json: serde_json::Value = serde_json::from_str(res_data_str).unwrap();
+        //     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("380 bitget_swap".to_string()),
+        //     };
+        //     Ok(result)
+        // } else {
+        //     Err(Error::new(ErrorKind::Other, res_data.to_string()))
+        // }
+    }
+
+    async fn cancel_order(&mut self, order_id: &str, custom_id: &str) -> Result<Order, Error> {
+        Err(Error::new(ErrorKind::NotFound, "bitget_swap：该交易所方法未实现".to_string()))
+        // let symbol_format = utils::format_symbol(self.symbol.clone(), "");
+        // let res_data = self.request.spot_cancel_order(symbol_format.clone(), order_id.to_string(), custom_id.to_string()).await;
+        // if res_data.code == "200" {
+        //     let res_data_str = &res_data.data;
+        //     let res_data_json: serde_json::Value = serde_json::from_str(res_data_str).unwrap();
+        //     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("403 bitget_swap".to_string()),
+        //     };
+        //     Ok(result)
+        // } else {
+        //     Err(Error::new(ErrorKind::Other, res_data.to_string()))
+        // }
+    }
+
+    async fn cancel_orders(&mut self) -> Result<Vec<Order>, Error> {
+        // let symbol_format = utils::format_symbol(self.symbol.clone(), "");
+        // let orders_res_data = self.request.get_unfilled_orders(symbol_format.to_string(), "".to_string(), "".to_string(), "".to_string(), "100".to_string(), "".to_string()).await;
+        // if orders_res_data.code == "200" {
+        //     let mut result = vec![];
+        //     let orders_res_data_str = &orders_res_data.data;
+        //     let orders_res_data_json: Vec<serde_json::Value> = serde_json::from_str(orders_res_data_str).unwrap();
+        //     for order in orders_res_data_json {
+        //         let order_id = order["orderId"].as_str().unwrap().to_string();
+        //         let cancel_res_data = self.request.spot_cancel_order(symbol_format.clone(), order_id, "".to_string()).await;
+        //         if cancel_res_data.code == "200" {
+        //             let cancel_res_data_str = &cancel_res_data.data;
+        //             let cancel_res_data_json: serde_json::Value = serde_json::from_str(cancel_res_data_str).unwrap();
+        //             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("434 bitget_swap".to_string()),
+        //             });
+        //         } else {
+        //             return Err(Error::new(ErrorKind::Other, cancel_res_data.to_string()));
+        //         }
+        //     }
+        //     Ok(result)
+        // } else {
+        //     Err(Error::new(ErrorKind::Other, orders_res_data.to_string()))
+        // }
+        Err(Error::new(ErrorKind::NotFound, "bitget_swap：该交易所方法未实现".to_string()))
+    }
+
+    async fn cancel_orders_all(&mut self) -> Result<Vec<Order>, Error> {
+        Err(Error::new(ErrorKind::NotFound, "bitget_swap：该交易所方法未实现".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：该交易所方法未实现".to_string()))
+    }
+
+    async fn cancel_stop_loss_order(&mut self, order_id: &str) -> Result<Value, Error> {
+        Err(Error::new(ErrorKind::NotFound, "bitget_swap：该交易所方法未实现".to_string()))
+    }
+
+    async fn set_dual_mode(&mut self, _coin: &str, _is_dual_mode: bool) -> Result<String, Error> {
+        Err(Error::new(ErrorKind::NotFound, "bitget_swap：该交易所方法未实现".to_string()))
+    }
+
+    async fn set_dual_leverage(&mut self, _leverage: &str) -> Result<String, Error> {
+        Err(Error::new(ErrorKind::NotFound, "bitget_swap：该交易所方法未实现".to_string()))
+    }
+
+    async fn set_auto_deposit_status(&mut self, _status: bool) -> Result<String, Error> {
+        Err(Error::new(ErrorKind::NotFound, "bitget_swap：该交易所方法未实现".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：该交易所方法未实现".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![];
+        // // 撤销订单
+        // let cancel = order_command.cancel;
+        // for item in cancel.keys() {
+        //     let mut self_clone = self.clone();
+        //     let cancel_clone = cancel.clone();
+        //     let item_clone = item.clone();
+        //     let order_id = cancel_clone[&item_clone].get(1).unwrap_or(&"".to_string()).clone();
+        //     let custom_id = cancel_clone[&item_clone].get(0).unwrap_or(&"".to_string()).clone();
+        //     let result_sd = self.order_sender.clone();
+        //     let err_sd = self.error_sender.clone();
+        //     let handle = tokio::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) => {
+        //                         result_sd.send(order).await.unwrap();
+        //                     }
+        //                     Err(_query_err) => {
+        //                         // error!(?_query_err);
+        //                         // error!("撤单失败，而且查单也失败了，bitget_swap，oid={}, cid={}。", order_id.clone(), custom_id.clone());
+        //                     }
+        //                 }
+        //                 err_sd.send(error).await.unwrap();
+        //             }
+        //         }
+        //     });
+        //     handles.push(handle)
+        // }
+        // // 下单指令
+        // let mut limits = HashMap::new();
+        // limits.extend(order_command.limits_open);
+        // limits.extend(order_command.limits_close);
+        // for item in limits.keys() {
+        //     let mut self_clone = self.clone();
+        //     let limits_clone = limits.clone();
+        //     let item_clone = item.clone();
+        //     let result_sd = self.order_sender.clone();
+        //     let err_sd = self.error_sender.clone();
+        //     let ts = trace_stack.clone();
+        //
+        //     let handle = tokio::spawn(async move {
+        //         let value = limits_clone[&item_clone].clone();
+        //         let amount = Decimal::from_str(value.get(0).unwrap_or(&"0".to_string())).unwrap();
+        //         let side = value.get(1).unwrap();
+        //         let price = Decimal::from_str(value.get(2).unwrap_or(&"0".to_string())).unwrap();
+        //         let cid = value.get(3).unwrap();
+        //
+        //         //  order_name: [数量，方向，价格，c_id]
+        //         let result = self_clone.take_order(cid, side, price, amount).await;
+        //         match result {
+        //             Ok(mut result) => {
+        //                 // 记录此订单完成时间
+        //                 // ts.on_after_send();
+        //                 result.trace_stack = ts;
+        //
+        //                 result_sd.send(result).await.unwrap();
+        //             }
+        //             Err(error) => {
+        //                 let mut err_order = Order::new();
+        //                 err_order.custom_id = cid.clone();
+        //                 err_order.status = "REMOVE".to_string();
+        //
+        //                 result_sd.send(err_order).await.unwrap();
+        //                 err_sd.send(error).await.unwrap();
+        //             }
+        //         }
+        //     });
+        //     handles.push(handle)
+        // }
+        // // 检查订单指令
+        // let check = order_command.check;
+        // for item in check.keys() {
+        //     let mut self_clone = self.clone();
+        //     let check_clone = check.clone();
+        //     let item_clone = item.clone();
+        //     let order_id = check_clone[&item_clone].get(1).unwrap_or(&"".to_string()).clone();
+        //     let custom_id = check_clone[&item_clone].get(0).unwrap_or(&"".to_string()).clone();
+        //     let result_sd = self.order_sender.clone();
+        //     let err_sd = self.error_sender.clone();
+        //     let handle = tokio::spawn(async move {
+        //         let result = self_clone.get_order_detail(&order_id, &custom_id).await;
+        //         match result {
+        //             Ok(result) => {
+        //                 result_sd.send(result).await.unwrap();
+        //             }
+        //             Err(error) => {
+        //                 err_sd.send(error).await.unwrap();
+        //             }
+        //         }
+        //     });
+        //     handles.push(handle)
+        // }
+        //
+        // let futures = FuturesUnordered::from_iter(handles);
+        // let _: Result<Vec<_>, _> = futures.try_collect().await;
+
+        panic!("bitget_swap：该交易所方法未实现")
+    }
+}
+
+pub fn format_account_info(balance_data: serde_json::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: serde_json::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["status"].as_str().unwrap_or("");
+    let base_volume = Decimal::from_str(order["baseVolume"].as_str().unwrap()).unwrap();
+
+    let avg_price = Decimal::from_str(order["priceAvg"].as_str().unwrap()).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("622 bitget_swap".to_string()),
+    }
+}

standard/src/exchange.rs

@@ -9,6 +9,7 @@ use crate::gate_swap::GateSwap;
 // use crate::kucoin_swap::KucoinSwap;
 // use crate::bitget_spot::BitgetSpot;
 use crate::bybit_swap::BybitSwap;
+use crate::bitget_usdt_swap::BitgetSwap;
 // use crate::kucoin_spot::KucoinSpot;
 // use crate::okx_swap::OkxSwap;
 
@@ -28,6 +29,7 @@ pub enum ExchangeEnum {
     // KucoinSpot,
     // OkxSwap,
     // BitgetSpot,
+    BitgetSwap,
     BybitSwap
 }
 
@@ -94,6 +96,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::BybitSwap => {
                 Box::new(BybitSwap::new(symbol, is_colo, params, order_sender, error_sender).await)
             }

standard/src/handle_info.rs

@@ -3,11 +3,11 @@ use std::str::FromStr;
 use rust_decimal::{Decimal};
 use rust_decimal::prelude::FromPrimitive;
 use rust_decimal_macros::dec;
-use tracing::{error};
+use tracing::{error, info};
 use exchanges::response_base::ResponseData;
 use global::public_params;
 use crate::exchange::ExchangeEnum;
-use crate::{binance_swap_handle, gate_swap_handle, bybit_swap_handle};
+use crate::{binance_swap_handle, gate_swap_handle, bybit_swap_handle, bitget_swap_handle};
 use crate::{Account, MarketOrder, Position, SpecialDepth, SpecialOrder, SpecialTicker};
 
 #[allow(dead_code)]
@@ -77,6 +77,11 @@ impl HandleSwapInfo {
             // ExchangeEnum::BitgetSpot => {
             //     bitget_spot_handle::handle_special_ticker(res_data)
             // },
+            ExchangeEnum::BitgetSwap => {
+                info!(?res_data);
+                panic!("未实现格式化");
+                // bitget_swap_handle::handle_special_ticker(res_data)
+            },
             ExchangeEnum::BybitSwap => {
                 bybit_swap_handle::handle_ticker(res_data)
             }
@@ -106,6 +111,10 @@ impl HandleSwapInfo {
             //     error!("暂未提供此交易所方法！handle_position：{:?}", exchange);
             //     panic!("暂未提供此交易所方法！handle_position：{:?}", exchange);
             // },
+            ExchangeEnum::BitgetSwap => {
+                info!(?res_data);
+                panic!("未实现格式化");
+            },
             ExchangeEnum::BybitSwap => {
                 bybit_swap_handle::handle_position(res_data, ct_val)
             }
@@ -133,6 +142,11 @@ impl HandleSwapInfo {
             // ExchangeEnum::BitgetSpot => {
             //     bitget_spot_handle::handle_order(res_data, ct_val)
             // },
+            ExchangeEnum::BitgetSwap => {
+                info!(?res_data);
+                panic!("未实现格式化");
+                // bitget_spot_handle::handle_order(res_data, ct_val)
+            },
             ExchangeEnum::BybitSwap => {
                 bybit_swap_handle::handle_order(res_data, ct_val)
             }
@@ -264,6 +278,16 @@ pub fn format_depth(exchange: ExchangeEnum, res_data: &ResponseData) -> DepthPar
         //     t = Decimal::from_str(res_data_json[0]["ts"].as_str().unwrap()).unwrap();
         //     create_at = res_data_json[0]["ts"].as_str().unwrap().parse::<i64>().unwrap() * 1000;
         // }
+        ExchangeEnum::BitgetSwap => {
+            depth_asks = vec![];
+            depth_bids = vec![];
+            t = Decimal::ZERO;
+            create_at = 0;
+            // depth_asks = bitget_spot_handle::format_depth_items(res_data_json[0]["asks"].clone());
+            // depth_bids = bitget_spot_handle::format_depth_items(res_data_json[0]["bids"].clone());
+            // t = Decimal::from_str(res_data_json[0]["ts"].as_str().unwrap()).unwrap();
+            // create_at = res_data_json[0]["ts"].as_str().unwrap().parse::<i64>().unwrap() * 1000;
+        }
         ExchangeEnum::BybitSwap => {
             depth_asks = bybit_swap_handle::format_depth_items(res_data.data["a"].clone());
             depth_bids = bybit_swap_handle::format_depth_items(res_data.data["b"].clone());
@@ -272,7 +296,7 @@ pub fn format_depth(exchange: ExchangeEnum, res_data: &ResponseData) -> DepthPar
         }
     }
 
-    DepthParam{
+    DepthParam {
         depth_asks,
         depth_bids,
         t,

standard/src/lib.rs

@@ -34,6 +34,8 @@ mod kucoin_spot;
 pub mod kucoin_spot_handle;
 mod bybit_swap;
 mod bybit_swap_handle;
+mod bitget_usdt_swap;
+mod bitget_swap_handle;
 
 /// 持仓模式枚举
 /// - `Both`：单持仓方向

strategy/src/bitget_usdt_swap.rs

@@ -91,7 +91,7 @@ pub async fn bitget_usdt_swap_run(is_shutdown_arc :Arc<AtomicBool>,
 async fn on_private_data(core_arc_clone: Arc<Mutex<Core>>,
                          ct_val: Decimal,
                          response: ResponseData) {
-
+    info!(?response)
 }
 
 async fn on_public_data(core_arc_clone: Arc<Mutex<Core>>,

strategy/src/core.rs

@@ -22,7 +22,7 @@ use global::public_params::{ASK_PRICE_INDEX, BID_PRICE_INDEX, LENGTH};
 use global::trace_stack::TraceStack;
 use standard::{Account, Market, Order, OrderCommand, Platform, Position, PositionModeEnum, SpecialTicker, Ticker};
 use standard::exchange::{Exchange};
-use standard::exchange::ExchangeEnum::{BinanceSwap, BybitSwap, GateSwap};
+use standard::exchange::ExchangeEnum::{BinanceSwap, BitgetSwap, BybitSwap, GateSwap};
 
 use crate::model::{LocalPosition, OrderInfo, TokenParam};
 use crate::predictor::Predictor;
@@ -221,6 +221,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
+                }
                 // "okex_usdt_swap" => {
                 //     Exchange::new(OkxSwap, symbol, params.colo != 0i8, exchange_params, order_sender, error_sender).await
                 // }

strategy/src/exchange_disguise.rs

@@ -7,6 +7,7 @@ use global::trace_stack::TraceStack;
 use standard::SpecialDepth;
 
 use crate::binance_usdt_swap::reference_binance_swap_run;
+use crate::bitget_usdt_swap::bitget_usdt_swap_run;
 use crate::gate_swap::gate_swap_run;
 // use crate::binance_spot::reference_binance_spot_run;
 // use crate::bitget_spot::bitget_spot_run;
@@ -32,13 +33,16 @@ pub async fn run_transactional_exchange(is_shutdown_arc :Arc<AtomicBool>,
         //     kucoin_swap_run(is_shutdown_arc, true, core_arc, name, symbols, is_colo, exchange_params).await;
         // },
         // "okex_usdt_swap" => {
-        //     okex_swap_run(is_shutdown_arc,true, core_arc, name, symbols, is_colo, exchange_params).await;
+        //     okex_swap_run(is_shutdown_arc, true, core_arc, name, symbols, is_colo, exchange_params).await;
         // },
         // "bitget_spot" => {
-        //     bitget_spot_run(is_shutdown_arc,true, core_arc, name, symbols, is_colo, exchange_params).await;
+        //     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;
+        }
         "bybit_usdt_swap" => {
-            bybit_swap_run(is_shutdown_arc,true, core_arc, name, symbols, is_colo, exchange_params).await;
+            bybit_swap_run(is_shutdown_arc, true, core_arc, name, symbols, is_colo, exchange_params).await;
         }
         _ => {
             let msg = format!("不支持的交易交易所：{}", exchange_name);
@@ -77,6 +81,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;
+        }
         "bybit_usdt_swap" => {
             bybit_swap_run(is_shutdown_arc, false, core_arc, name, symbols, is_colo, exchange_params).await;
         },

strategy/src/lib.rs

@@ -12,4 +12,4 @@ mod kucoin_spot;
 mod bitget_spot;
 mod okx_usdt_swap;
 mod bybit_usdt_swap;
-mod bitget_usdt_swap;
+mod bitget_usdt_swap;

strategy/src/utils.rs

@@ -65,6 +65,8 @@ pub fn get_limit_requests_num_per_second(exchange: String) -> i64 {
         return public_params::OKEX_USDT_SWAP_LIMIT * public_params::RATIO;
     } else if exchange.eq("bitget_spot") {
         return public_params::BITGET_USDT_SPOT_LIMIT * public_params::RATIO;
+    } else if exchange.eq("bitget_usdt_swap") {
+        return public_params::BITGET_USDT_SWAP_LIMIT * public_params::RATIO;
     } else if exchange.eq("bybit_usdt_swap"){
         return public_params::BYBIT_USDT_SWAP_LIMIT * public_params::RATIO;
     } else {
@@ -95,6 +97,8 @@ pub fn get_limit_order_requests_num_per_second(exchange: String) -> i64 {
         return public_params::OKEX_USDT_SWAP_LIMIT
     } else if exchange.eq("bitget_spot") {
         return public_params::BITGET_USDT_SPOT_LIMIT
+    }  else if exchange.eq("bitget_spot") {
+        return public_params::BITGET_USDT_SWAP_LIMIT
     } else if exchange.eq("bybit_usdt_swap") {
         return public_params::BYBIT_USDT_SWAP_LIMIT
     } else {