设置持仓模式、设置持仓杠杆。

standard/src/bitget_usdt_swap.rs

@@ -9,7 +9,7 @@ use rust_decimal::prelude::ToPrimitive;
 use rust_decimal_macros::dec;
 use serde_json::{json, Value};
 use tokio::time::Instant;
-use tracing::info;
+use tracing::{error, info, trace};
 use tracing_subscriber::fmt::format;
 use global::trace_stack::TraceStack;
 use crate::exchange::ExchangeEnum;
@@ -42,6 +42,27 @@ impl BitgetSwap {
             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;
     }
 }
@@ -117,7 +138,7 @@ impl Platform for BitgetSwap {
         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：该交易所方法未实现".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!({
@@ -147,9 +168,6 @@ impl Platform for BitgetSwap {
             let profit = Decimal::from_str(position_json["unrealizedPL"].as_str().unwrap()).unwrap();
             let position_mode = match position_json["posMode"].as_str().unwrap() {
                 "hedge_mode" => {
-                    PositionModeEnum::Both
-                },
-                "one_way_mode" => {
                     match position_json["holdSide"].as_str().unwrap() {
                         "short" => {
                             PositionModeEnum::Short
@@ -163,6 +181,9 @@ impl Platform for BitgetSwap {
                         }
                     }
                 },
+                "one_way_mode" => {
+                    PositionModeEnum::Both
+                },
                 _ => {
                     panic!("bitget_usdt_swap: 未知的持仓模式: {}", position_json["posMode"].as_str().unwrap())
                 }
@@ -185,7 +206,11 @@ impl Platform for BitgetSwap {
     }
 
     async fn get_ticker(&mut self) -> Result<Ticker, Error> {
-        let symbol_format = utils::format_symbol(self.symbol.clone(), "");
+        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;
@@ -206,12 +231,12 @@ impl Platform for BitgetSwap {
         }
     }
 
-    async fn get_ticker_symbol(&mut self, symbol: String) -> Result<Ticker, Error> {
-        Err(Error::new(ErrorKind::NotFound, "bitget_swap get_ticker_symbol：该交易所方法未实现".to_string()))
+    async fn get_market(&mut self) -> Result<Market, Error> {
+        self.get_market_symbol(self.symbol.clone()).await
     }
 
-    async fn get_market(&mut self) -> Result<Market, Error> {
-        let symbol_format = utils::format_symbol(self.symbol.clone(), "");
+    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" {
@@ -253,10 +278,6 @@ impl Platform for BitgetSwap {
         }
     }
 
-    async fn get_market_symbol(&mut self, symbol: String) -> Result<Market, Error> {
-        Err(Error::new(ErrorKind::NotFound, "bitget_swap get_market_symbol：该交易所方法未实现".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 get_order_detail：该交易所方法未实现".to_string()))
         // let ct_val = self.market.ct_val;
@@ -474,12 +495,39 @@ impl Platform for BitgetSwap {
         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> {
-        Err(Error::new(ErrorKind::NotFound, "bitget_swap set_dual_mode：该交易所方法未实现".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> {
-        Err(Error::new(ErrorKind::NotFound, "bitget_swap set_dual_leverage：该交易所方法未实现".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> {

standard/src/gate_swap.rs

@@ -10,7 +10,7 @@ use rust_decimal::prelude::{FromPrimitive, ToPrimitive};
 use serde_json::{json, Value};
 use tokio::spawn;
 use tokio::time::Instant;
-use tracing::{error, trace};
+use tracing::{error, info, trace};
 use crate::{Platform, ExchangeEnum, Account, Position, Ticker, Market, Order, OrderCommand, PositionModeEnum};
 use exchanges::gate_swap_rest::GateSwapRest;
 use global::trace_stack::TraceStack;
@@ -46,8 +46,8 @@ impl GateSwap {
         let symbol_array: Vec<&str> = symbol.split("_").collect();
         let mode_result = gate_swap.set_dual_mode(symbol_array[1], true).await;
         match mode_result {
-            Ok(_) => {
-                trace!("Gate:设置持仓模式成功！")
+            Ok(ok) => {
+                info!("Gate:设置持仓模式成功！{:?}", ok);
             }
             Err(error) => {
                 error!("Gate:设置持仓模式失败！mode_result={}", error)