做完了币对市场信息获取，以及订单批量撤销，下一步是做清仓操作。

exchanges/src/bitget_swap_rest.rs

@@ -50,18 +50,19 @@ impl BitgetSwapRest {
         }
     }
 
-    // 获取账户信息
-    pub async fn get_account_info(&mut self) -> ResponseData {
+    //获取行情信息
+    pub async fn get_contracts(&mut self, symbol: String) -> ResponseData {
         let params = serde_json::json!({
+            "symbol": symbol,
             "productType": "USDT-FUTURES"
-        });
-
-        self.request("GET".to_string(),
-                     "/api/v2".to_string(),
-                     "/mix/account/accounts".to_string(),
-                     true,
-                     params.to_string(),
-        ).await
+         });
+        let data = self.request("GET".to_string(),
+                                "/api/v2".to_string(),
+                                "/mix/market/contracts".to_string(),
+                                true,
+                                params.to_string(),
+        ).await;
+        data
     }
 
     //获取行情信息
@@ -79,6 +80,7 @@ impl BitgetSwapRest {
         data
     }
 
+    // 获取服务器时间
     pub async fn get_server_time(&mut self) -> ResponseData {
         let params = serde_json::json!({});
         self.request("GET".to_string(),
@@ -89,6 +91,20 @@ impl BitgetSwapRest {
         ).await
     }
 
+    // 获取账户信息
+    pub async fn get_account_info(&mut self) -> ResponseData {
+        let params = serde_json::json!({
+            "productType": "USDT-FUTURES"
+        });
+
+        self.request("GET".to_string(),
+                     "/api/v2".to_string(),
+                     "/mix/account/accounts".to_string(),
+                     true,
+                     params.to_string(),
+        ).await
+    }
+
     // 获取仓位信息（单个）
     pub async fn get_single_position(&mut self, params: Value) -> ResponseData {
         self.request("GET".to_string(),

global/src/log_utils.rs

@@ -101,14 +101,14 @@ pub fn final_init(level: &str, port: u32, account_name: String) -> WorkerGuard {
 
     let fmt_layer = fmt::layer()
         .with_timer(local_time.clone())
-        .with_target(false)
+        .with_target(true)
         .with_level(true)
         .with_writer(io::stdout)
         .with_span_events(fmt::format::FmtSpan::FULL);
 
     let file_layer = fmt::layer()
         .with_timer(local_time.clone())
-        .with_target(false)
+        .with_target(true)
         .with_ansi(false)
         .with_level(true)
         .with_writer(non_blocking.clone())

standard/src/bitget_usdt_swap.rs

@@ -4,11 +4,13 @@ use std::io::{Error, ErrorKind};
 use tokio::sync::mpsc::Sender;
 use std::str::FromStr;
 use async_trait::async_trait;
-use rust_decimal::Decimal;
+use rust_decimal::{Decimal, MathematicalOps};
 use rust_decimal::prelude::ToPrimitive;
 use rust_decimal_macros::dec;
-use serde_json::{Value};
+use serde_json::{json, Value};
 use tokio::time::Instant;
+use tracing::info;
+use tracing_subscriber::fmt::format;
 use global::trace_stack::TraceStack;
 use crate::exchange::ExchangeEnum;
 use crate::{Account, Market, Order, OrderCommand, Platform, Position, Ticker, utils};
@@ -39,7 +41,7 @@ impl BitgetSwap {
             order_sender,
             error_sender,
         };
-        bitget_swap.market = BitgetSwap::get_market(&mut bitget_swap).await.unwrap_or(bitget_swap.market);
+        bitget_swap.market = BitgetSwap::get_market(&mut bitget_swap).await.unwrap();
         return bitget_swap;
     }
 }
@@ -82,25 +84,44 @@ impl Platform for BitgetSwap {
     }
 
     async fn get_account(&mut self) -> Result<Account, Error> {
-        Err(Error::new(ErrorKind::NotFound, "bitget_swap：该交易所方法未实现".to_string()))
+        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> {
-        // 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()))
+        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_positions(&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 get_positions：该交易所方法未实现".to_string()))
+    }
 
     async fn get_ticker(&mut self) -> Result<Ticker, Error> {
         let symbol_format = utils::format_symbol(self.symbol.clone(), "");
@@ -125,139 +146,58 @@ impl Platform for BitgetSwap {
     }
 
     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()))
+        Err(Error::new(ErrorKind::NotFound, "bitget_swap get_ticker_symbol：该交易所方法未实现".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()))
+        let symbol_format = utils::format_symbol(self.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 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_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()))
+        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：该交易所方法未实现".to_string()))
+        Err(Error::new(ErrorKind::NotFound, "bitget_swap get_order_detail：该交易所方法未实现".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" {
@@ -276,7 +216,7 @@ impl Platform for BitgetSwap {
     }
 
     async fn get_orders_list(&mut self, _status: &str) -> Result<Vec<Order>, Error> {
-        Err(Error::new(ErrorKind::NotFound, "bitget_swap：该交易所方法未实现".to_string()))
+        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;
@@ -291,7 +231,7 @@ impl Platform for BitgetSwap {
     }
 
     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()))
+        Err(Error::new(ErrorKind::NotFound, "bitget_swap take_order：该交易所方法未实现".to_string()))
         // let symbol_format = utils::format_symbol(self.symbol.clone(), "");
         // let mut params = json!({
         //     "symbol": symbol_format.to_string(),
@@ -343,7 +283,7 @@ impl Platform for BitgetSwap {
     }
 
     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()))
+        Err(Error::new(ErrorKind::NotFound, "bitget_swap take_order_symbol：该交易所方法未实现".to_string()))
         // let symbol_format = utils::format_symbol(symbol.clone(), "");
         // let mut params = json!({
         //     "symbol": symbol_format.to_string(),
@@ -396,7 +336,7 @@ impl Platform for BitgetSwap {
     }
 
     async fn cancel_order(&mut self, order_id: &str, custom_id: &str) -> Result<Order, Error> {
-        Err(Error::new(ErrorKind::NotFound, "bitget_swap：该交易所方法未实现".to_string()))
+        Err(Error::new(ErrorKind::NotFound, "bitget_swap cancel_order：该交易所方法未实现".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" {
@@ -420,66 +360,73 @@ impl Platform for BitgetSwap {
     }
 
     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()))
+        Err(Error::new(ErrorKind::NotFound, "bitget_swap cancel_orders：该交易所方法未实现".to_string()))
     }
 
     async fn cancel_orders_all(&mut self) -> Result<Vec<Order>, Error> {
-        Err(Error::new(ErrorKind::NotFound, "bitget_swap：该交易所方法未实现".to_string()))
+        let response = self.request.get_pending_orders().await;
+        info!(?response);
+        if response.code == "200" {
+            let mut result = vec![];
+            let symbol_format = utils::format_symbol(self.symbol.clone(), "");
+
+            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 order_id = order["orderId"].as_str().unwrap().to_string();
+                    let symbol = symbol_format.clone();
+                    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：该交易所方法未实现".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：该交易所方法未实现".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> {
-        Err(Error::new(ErrorKind::NotFound, "bitget_swap：该交易所方法未实现".to_string()))
+        Err(Error::new(ErrorKind::NotFound, "bitget_swap set_dual_mode：该交易所方法未实现".to_string()))
     }
 
     async fn set_dual_leverage(&mut self, _leverage: &str) -> Result<String, Error> {
-        Err(Error::new(ErrorKind::NotFound, "bitget_swap：该交易所方法未实现".to_string()))
+        Err(Error::new(ErrorKind::NotFound, "bitget_swap set_dual_leverage：该交易所方法未实现".to_string()))
     }
 
     async fn set_auto_deposit_status(&mut self, _status: bool) -> Result<String, Error> {
-        Err(Error::new(ErrorKind::NotFound, "bitget_swap：该交易所方法未实现".to_string()))
+        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：该交易所方法未实现".to_string()))
+        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" {
@@ -595,11 +542,11 @@ impl Platform for BitgetSwap {
         // let futures = FuturesUnordered::from_iter(handles);
         // let _: Result<Vec<_>, _> = futures.try_collect().await;
 
-        panic!("bitget_swap：该交易所方法未实现")
+        panic!("bitget_swap command_order：该交易所方法未实现")
     }
 }
 
-pub fn format_account_info(balance_data: serde_json::Value) -> Account {
+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();
@@ -616,7 +563,7 @@ pub fn format_account_info(balance_data: serde_json::Value) -> Account {
     }
 }
 
-pub fn format_order_item(order: serde_json::Value, ct_val: Decimal) -> Order {
+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["status"].as_str().unwrap_or("");

strategy/src/core.rs

@@ -866,6 +866,7 @@ impl Core {
     // #[instrument(skip(self), level="TRACE")]
     pub async fn get_exchange_info(&mut self) {
         self.market = self.platform_rest.get_self_market();
+        info!(?self.market);
     }
 
     // #[instrument(skip(self, data), level="TRACE")]
@@ -884,13 +885,13 @@ impl Core {
     // #[instrument(skip(self), level="TRACE")]
     pub async fn update_equity_rest_swap(&mut self) {
         match self.platform_rest.get_account().await {
-            Ok(val) => {
+            Ok(account) => {
                 /*
                    更新保证金信息
                    合约一直更新
                    现货只有当出现异常时更新
                */
-                self.local_cash = val.balance * self.used_pct
+                self.local_cash = account.balance * self.used_pct
             }
             Err(e) => {
                 info!("获取账户信息错误: {:?}", e);
@@ -1447,7 +1448,7 @@ impl Core {
 
     // #[instrument(skip(self), level="TRACE")]
     pub async fn exit(&mut self) {
-        info!("-------------------------启动退出流程----------------------------");
+        info!("-------------------------启动退出流程({})----------------------------", self.exit_msg);
         info!("");
 
         // 循环清空仓位，如若彻底清空，才进行退出。