修改Account结构体

添加get_spot_account方法

standard/src/binance_spot.rs

@@ -75,6 +75,9 @@ impl Platform for BinanceSpot {
 
     // 获取账号信息
     async fn get_account(&mut self) -> Result<Account, Error> { Err(Error::new(ErrorKind::NotFound, "binance_spot：该交易所方法未实现".to_string())) }
+
+    async fn get_spot_account(&mut self) -> Result<Vec<Account>, Error> { Err(Error::new(ErrorKind::NotFound, "binance_spot：该交易所方法未实现".to_string())) }
+
     // 获取仓位信息
     async fn get_position(&mut self) -> Result<Vec<Position>, Error> { Err(Error::new(ErrorKind::NotFound, "binance_spot：该交易所方法未实现".to_string())) }
 

standard/src/binance_swap.rs

@@ -2,7 +2,6 @@ use std::collections::BTreeMap;
 use std::io::{Error, ErrorKind};
 use std::result::Result;
 use std::str::FromStr;
-
 use async_trait::async_trait;
 use rust_decimal::Decimal;
 use rust_decimal_macros::dec;
@@ -100,6 +99,7 @@ impl Platform for BinanceSwap {
                     let available_balance = Decimal::from_str(value["availableBalance"].as_str().unwrap()).unwrap();
                     let frozen_balance = balance - available_balance;
                     let result = Account {
+                        coin: value["asset"].as_str().unwrap().to_string(),
                         balance,
                         available_balance,
                         frozen_balance,
@@ -114,6 +114,11 @@ impl Platform for BinanceSwap {
             Err(Error::new(ErrorKind::Other, res_data.to_string()))
         }
     }
+
+    async fn get_spot_account(&mut self) -> Result<Vec<Account>, Error> {
+        Err(Error::new(ErrorKind::NotFound, "binance_swap：该交易所方法未实现".to_string()))
+    }
+
     // 获取仓位信息
     async fn get_position(&mut self) -> Result<Vec<Position>, Error> {
         let symbol_format = utils::format_symbol(self.symbol.clone(), "");
@@ -292,7 +297,7 @@ impl Platform for BinanceSwap {
                 avg_price: Decimal::from_str(res_data_json["avgPrice"].as_str().unwrap()).unwrap(),
                 status: custom_status,
                 order_type: res_data_json["type"].as_str().unwrap().parse().unwrap(),
-                trace_stack: TraceStack::default(),
+                trace_stack: TraceStack::default().on_special("300 binance_swap".to_string()),
             };
             Ok(result)
         } else {
@@ -322,10 +327,9 @@ impl Platform for BinanceSwap {
                     avg_price: Decimal::from_str(item["avgPrice"].as_str().unwrap()).unwrap(),
                     status: custom_status,
                     order_type: item["type"].as_str().unwrap().parse().unwrap(),
-                    trace_stack: TraceStack::default(),
+                    trace_stack: TraceStack::default().on_special("330 binance_swap".to_string()),
                 }
-            }
-            ).collect();
+            }).collect();
             Ok(result)
         } else {
             Err(Error::new(ErrorKind::Other, res_data.to_string()))

standard/src/bitget_spot.rs

@@ -79,24 +79,15 @@ impl Platform for BitgetSpot {
     }
 
     async fn get_account(&mut self) -> Result<Account, Error> {
+        Err(Error::new(ErrorKind::NotFound, "bitget_spot：该交易所方法未实现".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 account_info = res_data_json[0].clone();
-
-            let available_balance = Decimal::from_str(account_info["available"].as_str().unwrap()).unwrap();
-            let frozen_balance = Decimal::from_str(account_info["frozen"].as_str().unwrap()).unwrap();
-            let balance = available_balance + frozen_balance;
-
-            let result = Account {
-                balance,
-                available_balance,
-                frozen_balance,
-                stocks: Decimal::ZERO,
-                available_stocks: Decimal::ZERO,
-                frozen_stocks: Decimal::ZERO,
-            };
+            let result = res_data_json.iter().map(|item| bitget_spot_handle::format_account_info(item.clone())).collect();
             Ok(result)
         } else {
             Err(Error::new(ErrorKind::Other, res_data.to_string()))
@@ -316,7 +307,7 @@ impl Platform for BitgetSpot {
                 avg_price: Decimal::ZERO,
                 status: "NEW".to_string(),
                 order_type: "".to_string(),
-                trace_stack: TraceStack::default().on_special("319 bitget_spot".to_string()),
+                trace_stack: TraceStack::default().on_special("310 bitget_spot".to_string()),
             };
             Ok(result)
         } else {
@@ -363,7 +354,7 @@ impl Platform for BitgetSpot {
                 avg_price: Decimal::ZERO,
                 status: "NEW".to_string(),
                 order_type: "".to_string(),
-                trace_stack: TraceStack::default().on_special("366 bitget_spot".to_string()),
+                trace_stack: TraceStack::default().on_special("357 bitget_spot".to_string()),
             };
             Ok(result)
         } else {
@@ -386,7 +377,7 @@ impl Platform for BitgetSpot {
                 avg_price: Decimal::ZERO,
                 status: "REMOVE".to_string(),
                 order_type: "".to_string(),
-                trace_stack: TraceStack::default().on_special("389 bitget_spot".to_string()),
+                trace_stack: TraceStack::default().on_special("380 bitget_spot".to_string()),
             };
             Ok(result)
         } else {
@@ -411,7 +402,7 @@ impl Platform for BitgetSpot {
                     avg_price: Decimal::ZERO,
                     status: "REMOVE".to_string(),
                     order_type: "".to_string(),
-                    trace_stack: TraceStack::default().on_special("414 bitget_spot".to_string()),
+                    trace_stack: TraceStack::default().on_special("405 bitget_spot".to_string()),
                 }
             ).collect();
             Ok(result)

standard/src/bitget_spot_handle.rs

@@ -22,6 +22,7 @@ pub fn format_account_info(data: serde_json::Value) -> Account {
     let frozen_balance = Decimal::from_str(data["frozen"].as_str().unwrap()).unwrap();
     let balance = available_balance + frozen_balance;
     Account {
+        coin: data["coin"].as_str().unwrap().to_string().to_uppercase(),
         balance,
         available_balance,
         frozen_balance,
@@ -73,7 +74,7 @@ pub fn format_order_item(order: serde_json::Value, ct_val: Decimal) -> Order {
         avg_price,
         status: custom_status,
         order_type: order["orderType"].as_str().unwrap().to_string(),
-        trace_stack: TraceStack::default().on_special("76 bitget_spot_handle".to_string()),
+        trace_stack: TraceStack::default().on_special("77 bitget_spot_handle".to_string()),
     }
 }
 

standard/src/gate_handle.rs

@@ -16,6 +16,7 @@ pub fn handle_account_info(res_data: ResponseData, symbol: String) -> Account {
 }
 
 pub fn format_account_info(data: Vec<serde_json::Value>, symbol: String) -> Account {
+    let symbol_array: Vec<&str> = symbol.split("_").collect();
     let balance_info = data.iter().find(|&item| item["text"].as_str().unwrap().contains(&symbol));
     match balance_info {
         None => {
@@ -25,6 +26,7 @@ pub fn format_account_info(data: Vec<serde_json::Value>, symbol: String) -> Acco
         Some(value) => {
             let balance = Decimal::from_str(&value["balance"].to_string()).unwrap();
             Account {
+                coin: symbol_array[1].to_string(),
                 balance,
                 available_balance: Decimal::ZERO,
                 frozen_balance: Decimal::ZERO,
@@ -115,7 +117,7 @@ pub fn format_order_item(order: serde_json::Value, ct_val: Decimal) -> Order {
         avg_price: Decimal::from_str(&order["fill_price"].to_string()).unwrap(),
         status: custom_status,
         order_type: "limit".to_string(),
-        trace_stack: TraceStack::default().on_special("118 gate_handle".to_string()),
+        trace_stack: TraceStack::default().on_special("120 gate_handle".to_string()),
     };
 
     debug!(?rst_order);

standard/src/gate_spot.rs

@@ -73,6 +73,8 @@ impl Platform for GateSpot {
 
     async fn get_account(&mut self) -> Result<Account, Error> { Err(Error::new(ErrorKind::NotFound, "gate_spot：该交易所方法未实现".to_string())) }
 
+    async fn get_spot_account(&mut self) -> Result<Vec<Account>, Error> { Err(Error::new(ErrorKind::NotFound, "gate_spot：该交易所方法未实现".to_string())) }
+
     async fn get_position(&mut self) -> Result<Vec<Position>, Error> { Err(Error::new(ErrorKind::NotFound, "gate_spot：该交易所方法未实现".to_string())) }
 
     async fn get_positions(&mut self) -> Result<Vec<Position>, Error> { Err(Error::new(ErrorKind::NotFound, "gate_spot：该交易所方法未实现".to_string())) }

standard/src/gate_swap.rs

@@ -5,7 +5,7 @@ use tokio::sync::mpsc::Sender;
 use async_trait::async_trait;
 use rust_decimal::Decimal;
 use rust_decimal::prelude::{FromPrimitive, ToPrimitive};
-use serde_json::{json};
+use serde_json::json;
 use futures::stream::FuturesUnordered;
 use futures::{TryStreamExt};
 use tracing::{error, debug, trace};
@@ -107,6 +107,7 @@ impl Platform for GateSwap {
             let available_balance = Decimal::from_str(res_data_json["available"].as_str().unwrap()).unwrap();
             let frozen_balance = balance - available_balance;
             let result = Account {
+                coin: symbol_array[1].to_string(),
                 balance,
                 available_balance,
                 frozen_balance,
@@ -119,6 +120,11 @@ impl Platform for GateSwap {
             Err(Error::new(ErrorKind::Other, res_data.to_string()))
         }
     }
+
+    async fn get_spot_account(&mut self) -> Result<Vec<Account>, Error> {
+        Err(Error::new(ErrorKind::NotFound, "gate_swap：该交易所方法未实现".to_string()))
+    }
+
     // 获取持仓信息
     async fn get_position(&mut self) -> Result<Vec<Position>, Error> {
         let symbol_array: Vec<&str> = self.symbol.split("_").collect();
@@ -211,7 +217,6 @@ impl Platform for GateSwap {
     async fn get_market(&mut self) -> Result<Market, Error> {
         let symbol_array: Vec<&str> = self.symbol.split("_").collect();
         let res_data = self.request.get_market_details(symbol_array[1].to_string().to_lowercase()).await;
-        println!("{:?}", res_data);
         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();
@@ -439,7 +444,7 @@ impl Platform for GateSwap {
     // 批量撤销订单
     async fn cancel_orders(&mut self) -> Result<Vec<Order>, Error> {
         let symbol_array: Vec<&str> = self.symbol.split("_").collect();
-        let ct_val = self.market.tick_size;
+        let ct_val = self.market.ct_val;
         let res_data = self.request.cancel_orders(symbol_array[1].to_string().to_lowercase(), self.symbol.to_string()).await;
         if res_data.code == "200" {
             let res_data_str = &res_data.data;
@@ -451,7 +456,31 @@ impl Platform for GateSwap {
         }
     }
 
-    async fn cancel_orders_all(&mut self) -> Result<Vec<Order>, Error> { Err(Error::new(ErrorKind::NotFound, "gate：该交易所方法未实现".to_string())) }
+    async fn cancel_orders_all(&mut self) -> Result<Vec<Order>, Error> {
+        let symbol_array: Vec<&str> = self.symbol.split("_").collect();
+        let ct_val = self.market.ct_val;
+        let orders_res_data = self.request.get_orders(symbol_array[1].to_string().to_lowercase(), "open".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 cancel_res_data = self.request.cancel_orders(symbol_array[1].to_string().to_lowercase(), order["contract"].as_str().unwrap().to_string()).await;
+                if cancel_res_data.code == "200" {
+                    let cancel_res_data_str = &cancel_res_data.data;
+                    let cancel_res_data_json: Vec<serde_json::Value> = serde_json::from_str(cancel_res_data_str).unwrap();
+                    for cancel in cancel_res_data_json {
+                        result.push(format_order_item(cancel.clone(), ct_val))
+                    };
+                } 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()))
+        }
+    }
 
     // 设置持仓模式
     async fn set_dual_mode(&mut self, coin: &str, is_dual_mode: bool) -> Result<String, Error> {
@@ -465,6 +494,7 @@ impl Platform for GateSwap {
             Err(Error::new(ErrorKind::Other, res_data.to_string()))
         }
     }
+
     // 更新双持仓模式下杠杆
     async fn set_dual_leverage(&mut self, leverage: &str) -> Result<String, Error> {
         let symbol_array: Vec<&str> = self.symbol.split("_").collect();
@@ -492,6 +522,7 @@ impl Platform for GateSwap {
             Err(Error::new(ErrorKind::Other, res_data.to_string()))
         }
     }
+
     // 指令下单
     async fn command_order(&mut self, order_command: OrderCommand, trace_stack: TraceStack) {
         let mut handles = vec![];
@@ -656,7 +687,7 @@ pub fn format_order_item(order: serde_json::Value, ct_val: Decimal) -> Order {
         avg_price: Decimal::from_str(&order["fill_price"].as_str().unwrap()).unwrap(),
         status: custom_status,
         order_type: "limit".to_string(),
-        trace_stack: TraceStack::default().on_special("659 trace_stack".to_string()),
+        trace_stack: TraceStack::default().on_special("690 trace_stack".to_string()),
     };
     debug!(?rst_order);
     debug!("format-order-end, gate_swap");

standard/src/kucoin_handle.rs

@@ -8,17 +8,19 @@ use crate::exchange::ExchangeEnum;
 use crate::handle_info::HandleSwapInfo;
 
 // 处理账号信息
-pub fn handle_account_info(res_data: ResponseData, _symbol: String) -> Account {
+pub fn handle_account_info(res_data: ResponseData, symbol: String) -> Account {
     let res_data_str = res_data.data;
     let res_data_json: serde_json::Value = serde_json::from_str(&res_data_str).unwrap();
-    format_account_info(res_data_json)
+    format_account_info(res_data_json, symbol)
 }
 
-pub fn format_account_info(data: serde_json::Value) -> Account {
+pub fn format_account_info(data: serde_json::Value, symbol: String) -> Account {
+    let symbol_array: Vec<&str> = symbol.split("_").collect();
     let available_balance = Decimal::from_str(data["availableBalance"].as_str().unwrap()).unwrap();
     let frozen_balance = Decimal::from_str(data["holdBalance"].as_str().unwrap()).unwrap();
     let balance = available_balance + frozen_balance;
     Account {
+        coin: symbol_array[1].to_string(),
         balance,
         available_balance,
         frozen_balance,
@@ -114,12 +116,12 @@ pub fn format_order_item(order: serde_json::Value, ct_val: Decimal) -> Order {
     let amount = size * ct_val;
     let deal_amount = filled_size * ct_val;
     let custom_status;
-     if ["filled", "canceled"].contains(&type_) {
-         custom_status = "REMOVE".to_string();
+    if ["filled", "canceled"].contains(&type_) {
+        custom_status = "REMOVE".to_string();
     } else if ["open"].contains(&status) {
-         custom_status = "NEW".to_string();
+        custom_status = "NEW".to_string();
     } else {
-         custom_status = "NULL".to_string();
+        custom_status = "NULL".to_string();
     }
     Order {
         id: order["orderId"].as_str().unwrap().to_string(),
@@ -130,7 +132,7 @@ pub fn format_order_item(order: serde_json::Value, ct_val: Decimal) -> Order {
         avg_price,
         status: custom_status,
         order_type: order["type"].as_str().unwrap().to_string(),
-        trace_stack: TraceStack::default().on_special("133 kucoin_handle".to_string()),
+        trace_stack: TraceStack::default().on_special("135 kucoin_handle".to_string()),
     }
 }
 

standard/src/kucoin_swap.rs

@@ -8,8 +8,8 @@ use futures::TryStreamExt;
 use rust_decimal::Decimal;
 use rust_decimal::prelude::{FromPrimitive, ToPrimitive};
 use rust_decimal_macros::dec;
-use serde_json::{json, Value};
-use tracing::{error};
+use serde_json::json;
+use tracing::error;
 use exchanges::kucoin_swap_rest::KucoinSwapRest;
 use global::trace_stack::TraceStack;
 use crate::exchange::ExchangeEnum;
@@ -97,6 +97,7 @@ impl Platform for KucoinSwap {
             let available_balance = Decimal::from_str(&res_data_json["availableBalance"].to_string()).unwrap();
             let frozen_balance = balance - available_balance;
             let result = Account {
+                coin: symbol_array[1].to_string(),
                 balance,
                 available_balance,
                 frozen_balance,
@@ -110,6 +111,10 @@ impl Platform for KucoinSwap {
         }
     }
 
+    async fn get_spot_account(&mut self) -> Result<Vec<Account>, Error> {
+        Err(Error::new(ErrorKind::NotFound, "kucoin_swap：该交易所方法未实现".to_string()))
+    }
+
     async fn get_position(&mut self) -> Result<Vec<Position>, Error> {
         let symbol_format = format!("{}M", utils::format_symbol(self.symbol.clone(), ""));
         let ct_val = self.market.ct_val;
@@ -350,7 +355,7 @@ impl Platform for KucoinSwap {
                 avg_price: Decimal::ZERO,
                 status: "NEW".to_string(),
                 order_type: "".to_string(),
-                trace_stack: TraceStack::default().on_special("353 kucoin_swap".to_string()),
+                trace_stack: TraceStack::default().on_special("358 kucoin_swap".to_string()),
             };
             Ok(result)
         } else {
@@ -400,7 +405,7 @@ impl Platform for KucoinSwap {
                 avg_price: Decimal::ZERO,
                 status: "NEW".to_string(),
                 order_type: "".to_string(),
-                trace_stack: TraceStack::default().on_special("403 kucoin_swap".to_string()),
+                trace_stack: TraceStack::default().on_special("408 kucoin_swap".to_string()),
             };
             Ok(result)
         } else {
@@ -428,7 +433,7 @@ impl Platform for KucoinSwap {
                 avg_price: Decimal::ZERO,
                 status: "REMOVE".to_string(),
                 order_type: "".to_string(),
-                trace_stack: TraceStack::default().on_special("431 kucoin_swap".to_string()),
+                trace_stack: TraceStack::default().on_special("436 kucoin_swap".to_string()),
             };
             Ok(result)
         } else {
@@ -453,7 +458,7 @@ impl Platform for KucoinSwap {
                     avg_price: Decimal::ZERO,
                     status: "REMOVE".to_string(),
                     order_type: "".to_string(),
-                    trace_stack: TraceStack::default().on_special("456 kucoin_swap".to_string()),
+                    trace_stack: TraceStack::default().on_special("461 kucoin_swap".to_string()),
                 }
             ).collect();
             Ok(result)
@@ -478,7 +483,7 @@ impl Platform for KucoinSwap {
                     avg_price: Decimal::ZERO,
                     status: "REMOVE".to_string(),
                     order_type: "".to_string(),
-                    trace_stack: TraceStack::default().on_special("481 kucoin_swap".to_string()),
+                    trace_stack: TraceStack::default().on_special("486 kucoin_swap".to_string()),
                 }
             ).collect();
             Ok(result)
@@ -619,7 +624,7 @@ impl Platform for KucoinSwap {
     }
 }
 
-pub fn format_order_item(order: Value, ct_val: Decimal) -> Order {
+pub fn format_order_item(order: serde_json::Value, ct_val: Decimal) -> Order {
     let price = Decimal::from_str(order["price"].as_str().unwrap()).unwrap();
     let size = Decimal::from_str(&order["size"].to_string()).unwrap();
     let status = order["status"].as_str().unwrap_or("");
@@ -647,6 +652,6 @@ pub fn format_order_item(order: Value, ct_val: Decimal) -> Order {
         avg_price,
         status: custom_status,
         order_type: order["type"].as_str().unwrap().to_string(),
-        trace_stack: TraceStack::default().on_special("650 kucoin_swap".to_string()),
+        trace_stack: TraceStack::default().on_special("655 kucoin_swap".to_string()),
     }
 }

standard/src/lib.rs

@@ -83,6 +83,7 @@ impl fmt::Display for OrderCommand {
 }
 
 /// Account结构体(账户信息)
+/// - `coin(String)`: 货币;
 /// - `balance(Decimal)`: 总计计价币数量;
 /// - `available_balance(Decimal)`: 可用计价币数量;
 /// - `frozen_balance(Decimal)`: balance挂单的冻结数量
@@ -91,6 +92,7 @@ impl fmt::Display for OrderCommand {
 /// - `frozen_stocks(Decimal)`: stocks挂单的冻结数量
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Account {
+    pub coin: String,
     pub balance: Decimal,
     pub available_balance: Decimal,
     pub frozen_balance: Decimal,
@@ -102,6 +104,7 @@ pub struct Account {
 impl Account {
     pub fn new() -> Account {
         Account {
+            coin: "".to_string(),
             balance: Default::default(),
             available_balance: Default::default(),
             frozen_balance: Default::default(),
@@ -502,6 +505,8 @@ pub trait Platform {
     async fn get_server_time(&mut self) -> Result<String, Error>;
     // 获取账号信息
     async fn get_account(&mut self) -> Result<Account, Error>;
+    // 获取现货账号信息
+    async fn get_spot_account(&mut self) -> Result<Vec<Account>, Error>;
     // 获取持仓信息
     async fn get_position(&mut self) -> Result<Vec<Position>, Error>;
     // 获取所有持仓

standard/src/okx_handle.rs

@@ -9,16 +9,18 @@ use crate::exchange::ExchangeEnum;
 use crate::handle_info::HandleSwapInfo;
 
 // 处理账号信息
-pub fn handle_account_info(res_data: ResponseData, _symbol: String) -> Account {
+pub fn handle_account_info(res_data: ResponseData, symbol: String) -> Account {
     let res_data_str = res_data.data;
     let res_data_json: serde_json::Value = serde_json::from_str(&res_data_str).unwrap();
     let account_info = res_data_json[0]["details"].clone();
     let details = account_info[0].clone();
-    format_account_info(details)
+    format_account_info(details, symbol)
 }
 
-pub fn format_account_info(data: serde_json::Value) -> Account {
+pub fn format_account_info(data: serde_json::Value, symbol: String) -> Account {
+    let symbol_array: Vec<&str> = symbol.split("_").collect();
     Account {
+        coin: symbol_array[1].to_string(),
         balance: Decimal::from_str(data["cashBal"].as_str().unwrap()).unwrap(),
         available_balance: Decimal::from_str(data["availBal"].as_str().unwrap()).unwrap(),
         frozen_balance: Decimal::from_str(data["fixedBal"].as_str().unwrap()).unwrap(),
@@ -71,7 +73,7 @@ pub fn format_order_item(order: serde_json::Value, ct_val: Decimal) -> Order {
         avg_price,
         status: custom_status,
         order_type: order["ordType"].as_str().unwrap().to_string(),
-        trace_stack: TraceStack::default().on_special("74 okx_handle".to_string()),
+        trace_stack: TraceStack::default().on_special("76 okx_handle".to_string()),
     }
 }
 

standard/src/okx_swap.rs

@@ -88,6 +88,7 @@ impl Platform for OkxSwap {
             let frozen_balance = Decimal::from_str(&account_info["fixedBal"].as_str().unwrap()).unwrap();
             let balance = available_balance + frozen_balance;
             let result = Account {
+                coin: symbol_array[1].to_string(),
                 balance,
                 available_balance,
                 frozen_balance,
@@ -101,6 +102,10 @@ impl Platform for OkxSwap {
         }
     }
 
+    async fn get_spot_account(&mut self) -> Result<Vec<Account>, Error> {
+        Err(Error::new(ErrorKind::NotFound, "okx_swap：该交易所方法未实现".to_string()))
+    }
+
     async fn get_position(&mut self) -> Result<Vec<Position>, Error> {
         let symbol_format = utils::format_symbol(self.symbol.to_string(), "-");
         let ct_val = self.market.ct_val;
@@ -111,8 +116,8 @@ impl Platform for OkxSwap {
             let position_info = res_data_json.iter().find(|&item| item["instId"].as_str().unwrap() == format!("{}-SWAP", symbol_format));
             match position_info {
                 None => {
-                    error!("Okx：获取Position信息错误!\nget_position:res_data={:?}", res_data_str);
-                    panic!("Okx：获取Position信息错误!\nget_position:res_data={:?}", res_data_str)
+                    error!("okx_swap：获取Position信息错误!\nget_position:res_data={:?}", res_data_str);
+                    panic!("okx_swap：获取Position信息错误!\nget_position:res_data={:?}", res_data_str)
                 }
                 Some(value) => {
                     let result = okx_handle::format_position_item(value.clone(), ct_val);
@@ -146,8 +151,8 @@ impl Platform for OkxSwap {
             let ticker_info = res_data_json.iter().find(|item| item["instId"].as_str().unwrap() == format!("{}-SWAP", symbol_format.clone()));
             match ticker_info {
                 None => {
-                    error!("Okx：获取Ticker信息错误!\nget_ticker:res_data={:?}", res_data_str);
-                    panic!("Okx：获取Ticker信息错误!\nget_ticker:res_data={:?}", res_data_str)
+                    error!("okx_swap：获取Ticker信息错误!\nget_ticker:res_data={:?}", res_data_str);
+                    panic!("okx_swap：获取Ticker信息错误!\nget_ticker:res_data={:?}", res_data_str)
                 }
                 Some(value) => {
                     let result = Ticker {
@@ -176,8 +181,8 @@ impl Platform for OkxSwap {
             let ticker_info = res_data_json.iter().find(|item| item["instId"].as_str().unwrap() == format!("{}-SWAP", symbol_format.clone()));
             match ticker_info {
                 None => {
-                    error!("Okx：获取Ticker信息错误!\nget_ticker:res_data={:?}", res_data_str);
-                    panic!("Okx：获取Ticker信息错误!\nget_ticker:res_data={:?}", res_data_str)
+                    error!("okx_swap：获取Ticker信息错误!\nget_ticker:res_data={:?}", res_data_str);
+                    panic!("okx_swap：获取Ticker信息错误!\nget_ticker:res_data={:?}", res_data_str)
                 }
                 Some(value) => {
                     let result = Ticker {
@@ -206,8 +211,8 @@ impl Platform for OkxSwap {
             let market_info = res_data_json.iter().find(|item| item["instId"].as_str().unwrap() == format!("{}-SWAP", symbol_format));
             match market_info {
                 None => {
-                    error!("Okx：获取Market信息错误!\nget_market:res_data={:?}", res_data_str);
-                    panic!("Okx：获取Market信息错误!\nget_market:res_data={:?}", res_data_str)
+                    error!("okx_swap：获取Market信息错误!\nget_market:res_data={:?}", res_data_str);
+                    panic!("okx_swap：获取Market信息错误!\nget_market:res_data={:?}", res_data_str)
                 }
                 Some(value) => {
                     let base_asset = value["ctValCcy"].as_str().unwrap_or("").to_string();
@@ -255,8 +260,8 @@ impl Platform for OkxSwap {
             let market_info = res_data_json.iter().find(|item| item["instId"].as_str().unwrap() == format!("{}-SWAP", symbol_format));
             match market_info {
                 None => {
-                    error!("Okx：获取Market信息错误!\nget_market:res_data={:?}", res_data_str);
-                    panic!("Okx：获取Market信息错误!\nget_market:res_data={:?}", res_data_str)
+                    error!("okx_swap：获取Market信息错误!\nget_market:res_data={:?}", res_data_str);
+                    panic!("okx_swap：获取Market信息错误!\nget_market:res_data={:?}", res_data_str)
                 }
                 Some(value) => {
                     let base_asset = value["ctValCcy"].as_str().unwrap_or("").to_string();
@@ -361,14 +366,14 @@ impl Platform for OkxSwap {
         }
     }
 
-    async fn take_order_symbol(&mut self, _symbol: String, _custom_id: &str, _origin_side: &str, _price: Decimal, _amount: Decimal) -> Result<Order, Error> { Err(Error::new(ErrorKind::NotFound, "okx：该交易所方法未实现".to_string())) }
+    async fn take_order_symbol(&mut self, _symbol: String, _custom_id: &str, _origin_side: &str, _price: Decimal, _amount: Decimal) -> Result<Order, Error> { Err(Error::new(ErrorKind::NotFound, "okx_swap：该交易所方法未实现".to_string())) }
 
     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 res_data = self.request.cancel_order(symbol_format, order_id.to_string(), custom_id.to_string()).await;
         if order_id == "" {
-            error!("Okx：撤销订单错误,该交易所为提供自定义订单号撤销订单!\ncancel_order:order_id={:?},custom_id={:?}", order_id, custom_id);
-            panic!("Okx：撤销订单错误,该交易所为提供自定义订单号撤销订单!\ncancel_order:order_id={:?},custom_id={:?}", order_id, custom_id)
+            error!("okx_swap：撤销订单错误,该交易所为提供自定义订单号撤销订单!\ncancel_order:order_id={:?},custom_id={:?}", order_id, custom_id);
+            panic!("okx_swap：撤销订单错误,该交易所为提供自定义订单号撤销订单!\ncancel_order:order_id={:?},custom_id={:?}", order_id, custom_id)
         }
         if res_data.code == "200" {
             let res_data_str = &res_data.data;
@@ -385,7 +390,7 @@ impl Platform for OkxSwap {
                 avg_price: Decimal::ZERO,
                 status: "REMOVE".to_string(),
                 order_type: "".to_string(),
-                trace_stack: TraceStack::default().on_special("388 okx_handle".to_string()),
+                trace_stack: TraceStack::default().on_special("393 okx_handle".to_string()),
             };
             Ok(result)
         } else {
@@ -394,11 +399,11 @@ impl Platform for OkxSwap {
     }
 
     async fn cancel_orders(&mut self) -> Result<Vec<Order>, Error> {
-        Err(Error::new(ErrorKind::NotFound, "okx：该交易所方法未实现".to_string()))
+        Err(Error::new(ErrorKind::NotFound, "okx_swap：该交易所方法未实现".to_string()))
     }
 
     async fn cancel_orders_all(&mut self) -> Result<Vec<Order>, Error> {
-        Err(Error::new(ErrorKind::NotFound, "okx：该交易所方法未实现".to_string()))
+        Err(Error::new(ErrorKind::NotFound, "okx_swap：该交易所方法未实现".to_string()))
     }
 
     async fn set_dual_mode(&mut self, _coin: &str, _is_dual_mode: bool) -> Result<String, Error> {
@@ -424,9 +429,9 @@ impl Platform for OkxSwap {
         }
     }
 
-    async fn set_auto_deposit_status(&mut self, _status: bool) -> Result<String, Error> { Err(Error::new(ErrorKind::NotFound, "okx：该交易所方法未实现".to_string())) }
+    async fn set_auto_deposit_status(&mut self, _status: bool) -> Result<String, Error> { Err(Error::new(ErrorKind::NotFound, "okx_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, "okx：该交易所方法未实现".to_string())) }
+    async fn wallet_transfers(&mut self, _coin: &str, _from: &str, _to: &str, _amount: Decimal) -> Result<String, Error> { Err(Error::new(ErrorKind::NotFound, "okx_swap：该交易所方法未实现".to_string())) }
 
     async fn command_order(&mut self, order_command: OrderCommand, trace_stack: TraceStack) {
         let mut handles = vec![];

standard/tests/bitget_spot_test.rs

@@ -109,12 +109,12 @@ async fn test_get_server_time() {
 // 测试获取账号信息
 #[tokio::test]
 #[instrument(level = "TRACE")]
-async fn test_get_account() {
+async fn test_get_spot_account() {
     global::log_utils::init_log_with_trace();
 
     let mut bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSpot, SYMBOL).await;
-    let bitget_get_account = bitget_swap_exchange.get_account().await;
-    trace!(?bitget_get_account);
+    let bitget_get_spot_account = bitget_swap_exchange.get_spot_account().await;
+    trace!(?bitget_get_spot_account);
 }
 
 // 测试获取Ticker信息