添加下单,转账等接口

添加深度信息特殊处理

standard/Cargo.toml

@@ -6,6 +6,7 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+global = { path = "../global" }
 exchanges = { path = "../exchanges" }
 tokio = { version = "1.31.0", features = ["full"] }
 async-trait = "0.1.73"

standard/src/binance_spot.rs

@@ -2,10 +2,9 @@ use std::collections::BTreeMap;
 use std::io::{Error};
 use std::result::Result;
 use async_trait::async_trait;
-use rust_decimal_macros::dec;
-use crate::{Platform, ExchangeEnum, Account, Depth, MarketOrder, binance_lib, Position, PositionModeEnum, Ticker, Market, Order};
+use rust_decimal::Decimal;
+use crate::{Platform, ExchangeEnum, Account, binance_handle, Position, PositionModeEnum, Ticker, Market, Order};
 use exchanges::binance_spot_rest::BinanceSpotRest;
-use exchanges::binance_spot_ws::BinanceSpotWs;
 use exchanges::response_base::ResponseData;
 
 #[allow(dead_code)]
@@ -15,7 +14,6 @@ pub struct BinanceSpot {
     is_login: bool,
     params: BTreeMap<String, String>,
     request: BinanceSpotRest,
-    wss: BinanceSpotWs,
 }
 
 impl BinanceSpot {
@@ -26,7 +24,6 @@ impl BinanceSpot {
             is_login,
             params: params.clone(),
             request: BinanceSpotRest::new(is_colo, is_login, params.clone()),
-            wss: BinanceSpotWs::new(is_colo, is_login, params.clone()),
         }
     }
 }
@@ -57,7 +54,7 @@ impl Platform for BinanceSpot {
             data: "[]".to_string(),
             channel: "".to_string(),
         };
-        binance_lib::handle_account_info(res_data, symbol)
+        binance_handle::handle_account_info(res_data, symbol)
     }
     // 获取仓位信息
     async fn get_position(&self, _symbol: &str, _mode: PositionModeEnum) -> Result<Position, Error> {
@@ -80,53 +77,19 @@ impl Platform for BinanceSpot {
         todo!()
     }
 
-    // 获取深度信息
-    fn get_depth(&self) -> Depth {
-        let depth_asks = vec![MarketOrder { price: dec!(0.0), amount: dec!(0.0) }];
-        let depth_bids = vec![MarketOrder { price: dec!(0.0), amount: dec!(0.0) }];
-        Depth {
-            time: 0,
-            asks: depth_asks,
-            bids: depth_bids,
-        }
-    }
-
-    fn take_order(&self) {
+    async fn set_dual_mode(&self, _coin: &str, _is_dual_mode: bool) -> Result<String, Error> {
         todo!()
     }
 
-    fn get_order_list(&self) {
+    async fn set_dual_leverage(&self, _symbol: &str, _leverage: &str) -> Result<String, Error> {
         todo!()
     }
 
-    fn cancel_order(&self) {
+    async fn wallet_transfers(&self, _coin: &str, _from: &str, _to: &str, _amount: Decimal) -> Result<String, Error> {
         todo!()
     }
 
-    fn subscribe_account(&self) -> Account {
-        Account {
-            balance: dec!(0.1),
-            available_balance: dec!(0.0),
-            frozen_balance: dec!(0.0),
-            stocks: dec!(0.0),
-            available_stocks: dec!(0.0),
-            frozen_stocks: dec!(0.0),
-        }
-    }
-
-    fn subscribe_depth(&self, _symbol: &str) {
-        let depth_asks = vec![MarketOrder { price: dec!(0.0), amount: dec!(0.0) }];
-        let depth_bids = vec![MarketOrder { price: dec!(0.0), amount: dec!(0.0) }];
-        Depth {
-            time: 0,
-            asks: depth_asks,
-            bids: depth_bids,
-        };
-    }
-
-    fn subscribe_special_depth(&self, symbol: &str) {
+    async fn take_order(&self, _custom_id: &str, _origin_side: &str, _coin: &str, _symbol: &str, _amount: Decimal) -> Result<Order, Error> {
         todo!()
     }
-
-    fn subscribe_kline(&self) {}
 }

standard/src/binance_swap.rs

@@ -1,14 +1,12 @@
-use std::cmp::Ordering;
 use std::collections::BTreeMap;
 use std::io::{Error, ErrorKind};
 use std::result::Result;
 use async_trait::async_trait;
+use rust_decimal::Decimal;
 use rust_decimal_macros::dec;
 use serde_json::json;
-use crate::{Platform, ExchangeEnum, Account, Depth, MarketOrder, Position, PositionModeEnum, utils, Ticker, Market, Order};
+use crate::{Platform, ExchangeEnum, Account, Position, PositionModeEnum, Ticker, Market, Order};
 use exchanges::binance_usdt_swap_rest::BinanceUsdtSwapRest;
-use exchanges::binance_usdt_swap_ws::BinanceUsdtSwapWs;
-use exchanges::response_base::ResponseData;
 
 #[allow(dead_code)]
 pub struct BinanceSwap {
@@ -17,7 +15,6 @@ pub struct BinanceSwap {
     is_login: bool,
     params: BTreeMap<String, String>,
     request: BinanceUsdtSwapRest,
-    wss: BinanceUsdtSwapWs,
 }
 
 impl BinanceSwap {
@@ -28,7 +25,6 @@ impl BinanceSwap {
             is_login,
             params: params.clone(),
             request: BinanceUsdtSwapRest::new(is_colo, is_login, params.clone()),
-            wss: BinanceUsdtSwapWs::new(is_colo, is_login, params.clone()),
         }
     }
 }
@@ -98,113 +94,129 @@ impl Platform for BinanceSwap {
         todo!()
     }
 
-    // 获取深度信息
-    fn get_depth(&self) -> Depth {
-        let depth_asks = vec![MarketOrder { price: dec!(1.0), amount: dec!(0.0) }];
-        let depth_bids = vec![MarketOrder { price: dec!(0.0), amount: dec!(0.0) }];
-
-        Depth {
-            time: 0,
-            asks: depth_asks,
-            bids: depth_bids,
-        }
+    async fn set_dual_mode(&self, _coin: &str, _is_dual_mode: bool) -> Result<String, Error> {
+        todo!()
     }
 
-
-    fn take_order(&self) {
+    async fn set_dual_leverage(&self, _symbol: &str, _leverage: &str) -> Result<String, Error> {
         todo!()
     }
 
-    fn get_order_list(&self) {
+    async fn wallet_transfers(&self, _coin: &str, _from: &str, _to: &str, _amount: Decimal) -> Result<String, Error> {
         todo!()
     }
 
-    fn cancel_order(&self) {
+    async fn take_order(&self, _custom_id: &str, _origin_side: &str, _coin: &str, _symbol: &str, _amount: Decimal) -> Result<Order, Error> {
         todo!()
     }
 
-    fn subscribe_account(&self) -> Account {
-        Account {
-            balance: dec!(1.1),
-            available_balance: dec!(0.0),
-            frozen_balance: dec!(0.0),
-            stocks: dec!(0.0),
-            available_stocks: dec!(0.0),
-            frozen_stocks: dec!(0.0),
-        }
-    }
     // 订阅深度信息
-    fn subscribe_depth(&self, symbol: &str) {
-        ;
-        let symbol_format = &utils::format_symbol(symbol, "");
-        let get_res_data = move |res_data: ResponseData| {
-            async move {
-                if res_data.code == "200" && res_data.channel == "depth" {
-                    let res_data_str = res_data.data;
-                    let res_data_json: serde_json::Value = serde_json::from_str(&*res_data_str).unwrap();
-                    let mut depth_asks: Vec<MarketOrder> = parse_depth_items(&res_data_json["asks"]);
-                    let mut depth_bids: Vec<MarketOrder> = parse_depth_items(&res_data_json["bids"]);
-                    depth_asks.sort_by(|a, b| a.price.partial_cmp(&b.price).unwrap_or(Ordering::Equal));
-                    depth_bids.sort_by(|a, b| b.price.partial_cmp(&a.price).unwrap_or(Ordering::Equal));
-                    let result = Depth {
-                        time: 123456,
-                        asks: depth_asks,
-                        bids: depth_bids,
-                    };
-                    println!("subscribe_depth: {:?}", result);
-                }
-            }
-        };
-        self.wss.custom_subscribe(vec![symbol_format], 0, 0, get_res_data)
-    }
+    // fn subscribe_depth(&self, symbol: &str) {
+    //     let symbol_format = &utils::format_symbol(symbol, "");
+    //     let get_res_data = move |res_data: ResponseData| {
+    //         async move {
+    //             if res_data.code == "200" && res_data.channel == "depth" {
+    //                 let res_data_str = res_data.data;
+    //                 let res_data_json: serde_json::Value = serde_json::from_str(&*res_data_str).unwrap();
+    //                 let mut depth_asks: Vec<MarketOrder> = parse_depth_items(&res_data_json["asks"]);
+    //                 let mut depth_bids: Vec<MarketOrder> = parse_depth_items(&res_data_json["bids"]);
+    //                 depth_asks.sort_by(|a, b| a.price.partial_cmp(&b.price).unwrap_or(Ordering::Equal));
+    //                 depth_bids.sort_by(|a, b| b.price.partial_cmp(&a.price).unwrap_or(Ordering::Equal));
+    //                 let result = Depth {
+    //                     time: 123456,
+    //                     asks: depth_asks,
+    //                     bids: depth_bids,
+    //                 };
+    //                 println!("subscribe_depth: {:?}", result);
+    //             }
+    //         }
+    //     };
+    //     self.wss.custom_subscribe(vec![symbol_format], 0, 0, get_res_data)
+    // }
 
     // 订阅深度信息
-    fn subscribe_special_depth(&self, symbol: &str) {
-        let symbol_format = &utils::format_symbol(symbol, "");
-        let get_res_data = move |res_data: ResponseData| {
-            async move {
-                if res_data.code == "200" && res_data.channel == "depth" {
-                    let res_data_str = res_data.data;
-                    let res_data_json: serde_json::Value = serde_json::from_str(&*res_data_str).unwrap();
-                    let mut depth_asks: Vec<MarketOrder> = parse_depth_items(&res_data_json["asks"]);
-                    let mut depth_bids: Vec<MarketOrder> = parse_depth_items(&res_data_json["bids"]);
-                    depth_asks.sort_by(|a, b| a.price.partial_cmp(&b.price).unwrap_or(Ordering::Equal));
-                    depth_bids.sort_by(|a, b| b.price.partial_cmp(&a.price).unwrap_or(Ordering::Equal));
-                    let mp = (depth_asks[0].price + depth_bids[0].price) * dec!(0.5);
-                    // let step = round(mp * utils::EFF_RANGE / utils::LEVEL, self.decimal);
-                    // TODO  引入有问题
-
-
-                    let result = Depth {
-                        time: 123456,
-                        asks: depth_asks,
-                        bids: depth_bids,
-                    };
-
-                }
-            }
-        };
-        self.wss.custom_subscribe(vec![symbol_format], 0, 0, get_res_data)
-    }
-
-    fn subscribe_kline(&self) {
-        let get_res_data = move |res_data: ResponseData| {
-            async move {
-                println!("?????{:?}", res_data);
-            }
-        };
-
-        self.wss.kline(vec![&"BTCUSDT"], get_res_data);
-    }
+    // fn subscribe_special_depth(&self, symbol: &str) {
+    //     let symbol_format = &utils::format_symbol(symbol, "");
+    //     let get_res_data = move |res_data: ResponseData| {
+    //         async move {
+    //             if res_data.code == "200" && res_data.channel == "depth" {
+    //                 let res_data_str = res_data.data;
+    //                 let res_data_json: serde_json::Value = serde_json::from_str(&*res_data_str).unwrap();
+    //                 let mut depth_asks: Vec<MarketOrder> = parse_depth_items(&res_data_json["asks"]);
+    //                 let mut depth_bids: Vec<MarketOrder> = parse_depth_items(&res_data_json["bids"]);
+    //                 depth_asks.sort_by(|a, b| a.price.partial_cmp(&b.price).unwrap_or(Ordering::Equal));
+    //                 depth_bids.sort_by(|a, b| b.price.partial_cmp(&a.price).unwrap_or(Ordering::Equal));
+    //                 let mp = (depth_asks[0].price + depth_bids[0].price) * dec!(0.5);
+    //                 let step = (public_params::EFF_RANGE * mp / Decimal::from_usize(public_params::LEVEL).unwrap()).round();
+    //                 let mut ap = Vec::new();
+    //                 let mut bp = Vec::new();
+    //                 let mut av: Vec<Decimal> = Vec::new();
+    //                 let mut bv: Vec<Decimal> = Vec::new();
+    //                 for i in 0..public_params::LEVEL {
+    //                     let price = (depth_asks[0].price + step * Decimal::from_f64(i as f64).unwrap()).round();
+    //                     ap.push(price);
+    //                 }
+    //                 for i in 0..public_params::LEVEL {
+    //                     let price = (depth_asks[0].price - step * Decimal::from_f64(i as f64).unwrap()).round();
+    //                     bp.push(price);
+    //                 }
+    //                 let mut ap_price_tag = depth_asks[0].price + step;
+    //                 let mut ap_index = 0;
+    //                 for item in depth_asks.iter() {
+    //                     let price = item.price;
+    //                     let amount = item.amount;
+    //                     println!("{} {}", price, amount);
+    //                     if price > ap_price_tag {
+    //                         av[ap_index] += amount;
+    //                     } else {
+    //                         ap_price_tag += step;
+    //                         ap_index += 1;
+    //                         if ap_index == public_params::LEVEL {
+    //                             break;
+    //                         }
+    //                         av[ap_index] += amount
+    //                     }
+    //                 }
+    //
+    //                 let mut bp_price_tag = depth_bids[0].price - step;
+    //                 let mut bp_index = 0;
+    //                 for item in depth_bids.iter() {
+    //                     let price = item.price;
+    //                     let amount = item.amount;
+    //                     if price > bp_price_tag {
+    //                         bv[bp_index] += amount;
+    //                     } else {
+    //                         bp_price_tag -= step;
+    //                         bp_index += 1;
+    //                         if bp_index == public_params::LEVEL {
+    //                             break;
+    //                         }
+    //                         bv[bp_index] += amount
+    //                     }
+    //                 }
+    //
+    //                 let aa: Vec<&Decimal> = bp.iter().clone().chain(bv.iter().clone()).chain(ap.iter().clone()).chain(av.iter().clone()).collect::<Vec<_>>();
+    //                 println!("{:?}", aa);
+    //                 let result = Depth {
+    //                     time: 123456,
+    //                     asks: depth_asks,
+    //                     bids: depth_bids,
+    //                 };
+    //                 println!("subscribe_special_depth: {:?}", result)
+    //             }
+    //         }
+    //     };
+    //     self.wss.custom_subscribe(vec![symbol_format], 0, 0, get_res_data)
+    // }
 }
 
-fn parse_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: value[0].as_str().unwrap_or("0").parse().unwrap_or(dec!(0)),
-            amount: value[1].as_str().unwrap_or("0").parse().unwrap_or(dec!(0)),
-        })
-    }
-    return depth_items;
-}
+// fn parse_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: value[0].as_str().unwrap_or("0").parse().unwrap_or(dec!(0)),
+//             amount: value[1].as_str().unwrap_or("0").parse().unwrap_or(dec!(0)),
+//         })
+//     }
+//     return depth_items;
+// }

standard/src/gate_spot.rs

@@ -1,10 +1,9 @@
 use std::collections::BTreeMap;
 use std::io::{Error};
 use async_trait::async_trait;
-use rust_decimal_macros::dec;
-use crate::{Platform, ExchangeEnum, Account, Depth, MarketOrder, gate_lib, Position, PositionModeEnum, Ticker, Market, Order};
+use rust_decimal::Decimal;
+use crate::{Platform, ExchangeEnum, Account, gate_handle, Position, PositionModeEnum, Ticker, Market, Order};
 use exchanges::gate_spot_rest::GateSpotRest;
-use exchanges::gate_spot_ws::GateSpotWs;
 use exchanges::response_base::ResponseData;
 
 #[allow(dead_code)]
@@ -14,7 +13,6 @@ pub struct GateSpot {
     is_login: bool,
     params: BTreeMap<String, String>,
     request: GateSpotRest,
-    wss: GateSpotWs,
 }
 
 impl GateSpot {
@@ -25,7 +23,6 @@ impl GateSpot {
             is_login,
             params: params.clone(),
             request: GateSpotRest::new(is_colo, is_login, params.clone()),
-            wss: GateSpotWs::new(is_colo, is_login, params.clone()),
         }
     }
 }
@@ -58,7 +55,7 @@ impl Platform for GateSpot {
             data: "[]".to_string(),
             channel: "".to_string(),
         };
-        gate_lib::handle_account_info(res_data, symbol)
+        gate_handle::handle_account_info(res_data, symbol)
     }
     // 获取仓位信息
     async fn get_position(&self, _symbol: &str, _mode: PositionModeEnum) -> Result<Position, Error> {
@@ -81,56 +78,19 @@ impl Platform for GateSpot {
         todo!()
     }
 
-    // 获取深度信息
-    fn get_depth(&self) -> Depth {
-        let depth_asks = vec![MarketOrder { price: dec!(2.0), amount: dec!(0.0) }];
-        let depth_bids = vec![MarketOrder { price: dec!(0.0), amount: dec!(0.0) }];
-        Depth {
-            time: 0,
-            asks: depth_asks,
-            bids: depth_bids,
-        }
-    }
-
-
-    fn take_order(&self) {
-        todo!()
-    }
-
-    fn get_order_list(&self) {
+    async fn set_dual_mode(&self, _coin: &str, _is_dual_mode: bool) -> Result<String, Error> {
         todo!()
     }
 
-    fn cancel_order(&self) {
+    async fn set_dual_leverage(&self, _symbol: &str, _leverage: &str) -> Result<String, Error> {
         todo!()
     }
 
-    fn subscribe_account(&self) -> Account {
-        Account {
-            balance: dec!(2.1),
-            available_balance: dec!(0.0),
-            frozen_balance: dec!(0.0),
-            stocks: dec!(0.0),
-            available_stocks: dec!(0.0),
-            frozen_stocks: dec!(0.0),
-        }
-    }
-
-    fn subscribe_depth(&self, _symbol: &str) {
-        let depth_asks = vec![MarketOrder { price: dec!(2.0), amount: dec!(0.0) }];
-        let depth_bids = vec![MarketOrder { price: dec!(0.0), amount: dec!(0.0) }];
-        Depth {
-            time: 0,
-            asks: depth_asks,
-            bids: depth_bids,
-        };
-    }
-
-    fn subscribe_special_depth(&self, symbol: &str) {
+    async fn wallet_transfers(&self, _coin: &str, _from: &str, _to: &str, _amount: Decimal) -> Result<String, Error> {
         todo!()
     }
 
-    fn subscribe_kline(&self) {
+    async fn take_order(&self, _custom_id: &str, _origin_side: &str, _coin: &str, _symbol: &str, _amount: Decimal) -> Result<Order, Error> {
         todo!()
     }
 }

standard/src/gate_swap.rs

@@ -1,14 +1,12 @@
 use std::collections::BTreeMap;
 use std::io::{Error, ErrorKind};
-use std::sync::Arc;
 use async_trait::async_trait;
 use rust_decimal::Decimal;
-use rust_decimal::prelude::FromPrimitive;
+use rust_decimal::prelude::{FromPrimitive, ToPrimitive};
 use rust_decimal_macros::dec;
 use serde_json::{json};
-use crate::{Platform, ExchangeEnum, Account, Depth, MarketOrder, Position, PositionModeEnum, Ticker, Market, Order};
+use crate::{Platform, ExchangeEnum, Account, Position, PositionModeEnum, Ticker, Market, Order, utils};
 use exchanges::gate_swap_rest::GateSwapRest;
-use exchanges::gate_swap_ws::GateSwapWs;
 use crate::PositionModeEnum::{Both, Long};
 
 #[allow(dead_code)]
@@ -18,7 +16,6 @@ pub struct GateSwap {
     is_login: bool,
     params: BTreeMap<String, String>,
     request: GateSwapRest,
-    wss: GateSwapWs,
 }
 
 impl GateSwap {
@@ -29,7 +26,6 @@ impl GateSwap {
             is_login,
             params: params.clone(),
             request: GateSwapRest::new(is_colo, is_login, params.clone()),
-            wss: GateSwapWs::new(is_colo, is_login, params.clone()),
         }
     }
 }
@@ -174,7 +170,7 @@ impl Platform for GateSwap {
             Err(Error::new(ErrorKind::Other, res_data.message))
         }
     }
-
+    // 获取订单列表
     async fn get_orders_list(&self, symbol: &str, status: &str) -> Result<Vec<Order>, Error> {
         let symbol_array: Vec<&str> = symbol.split("_").collect();
         let res_data = self.request.get_orders(symbol_array[1].to_string().to_lowercase(), status.to_string()).await;
@@ -189,65 +185,64 @@ impl Platform for GateSwap {
             Err(Error::new(ErrorKind::Other, res_data.message))
         }
     }
-
-    fn get_depth(&self) -> Depth {
-        let depth_asks = vec![MarketOrder { price: dec!(3.0), amount: dec!(0.0) }];
-        let depth_bids = vec![MarketOrder { price: dec!(0.0), amount: dec!(0.0) }];
-        Depth {
-            time: 0,
-            asks: depth_asks,
-            bids: depth_bids,
+    // 设置持仓模式
+    async fn set_dual_mode(&self, coin: &str, is_dual_mode: bool) -> Result<String, Error> {
+        let coin_format = coin.to_string().to_lowercase();
+        let res_data = self.request.setting_dual_mode(coin_format, is_dual_mode).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.message))
         }
     }
-
-    fn take_order(&self) {
-        todo!()
-    }
-
-    fn get_order_list(&self) {
-        todo!()
-    }
-
-    fn cancel_order(&self) {
-        todo!()
-    }
-
-    fn subscribe_account(&self) -> Account {
-        Account {
-            balance: dec!(3.1),
-            available_balance: dec!(0.0),
-            frozen_balance: dec!(0.0),
-            stocks: dec!(0.0),
-            available_stocks: dec!(0.0),
-            frozen_stocks: dec!(0.0),
+    // 更新双持仓模式下杠杆
+    async fn set_dual_leverage(&self, symbol: &str, leverage: &str) -> Result<String, Error> {
+        let symbol_array: Vec<&str> = symbol.split("_").collect();
+        let res_data = self.request.setting_dual_leverage(symbol_array[1].to_string().to_lowercase(), symbol.to_string(), leverage.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.message))
         }
     }
-
-    fn subscribe_depth(&self, _symbol: &str) {
-        let depth_asks = vec![MarketOrder { price: dec!(3.0), amount: dec!(0.0) }];
-        let depth_bids = vec![MarketOrder { price: dec!(0.0), amount: dec!(0.0) }];
-        Depth {
-            time: 0,
-            asks: depth_asks,
-            bids: depth_bids,
-        };
+    // 交易账户互转
+    async fn wallet_transfers(&self, coin: &str, from: &str, to: &str, amount: Decimal) -> Result<String, Error> {
+        let coin_format = coin.to_string().to_lowercase();
+        let res_data = self.request.wallet_transfers(coin_format.clone(), from.to_string(), to.to_string(), amount.to_string(), coin_format.clone()).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.message))
+        }
     }
-
-    fn subscribe_special_depth(&self, symbol: &str) {
-        todo!()
+    // 下单接口
+    async fn take_order(&self, custom_id: &str, origin_side: &str, coin: &str, symbol: &str, amount: Decimal) -> Result<Order, Error>{
+        let symbol_format = utils::format_symbol(symbol.clone(), "_");
+        let coin_format = coin.to_string().to_lowercase();
+        let res_data = self.request.swap_bazaar_order(custom_id.to_string(), origin_side.to_string(), coin_format.clone(), symbol_format, amount.to_i64().unwrap()).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 = parse_order_item(&res_data_json);
+            Ok(result)
+        } else {
+            Err(Error::new(ErrorKind::Other, res_data.message))
+        }
     }
 
-    fn subscribe_kline(&self) {
-        todo!()
-    }
 }
-
 fn parse_order_item(order: &serde_json::Value) -> Order {
     Order {
         id: order["id"].to_string(),
         custom_id: order["text"].as_str().unwrap_or("0").to_string(),
         price: order["price"].as_str().unwrap_or("0").parse().unwrap_or(dec!(0)),
-        amount: order["size"].as_i64().unwrap(),
+        amount: Decimal::from(order["size"].as_i64().unwrap()),
         deal_amount: Default::default(),
         avg_price: Default::default(),
         status: "".to_string(),

standard/src/lib.rs

@@ -1,5 +1,5 @@
 use std::collections::BTreeMap;
-use std::io::Error;
+use std::io::{Error};
 use async_trait::async_trait;
 use rust_decimal::Decimal;
 use crate::exchange::ExchangeEnum;
@@ -9,11 +9,11 @@ pub mod exchange;
 // 引入binance模块
 mod binance_swap;
 mod binance_spot;
-mod binance_lib;
+mod binance_handle;
 // 引入gate模块
 mod gate_swap;
 mod gate_spot;
-mod gate_lib;
+mod gate_handle;
 // 引入工具模块
 pub mod utils;
 
@@ -83,7 +83,7 @@ pub struct Record {
 /// - `id(String)`: 交易单唯一标识
 /// - `custom_id(String)`: 自定义Id
 /// - `price(Decimal)`: 下单价格
-/// - `amount(i64)`: 下单数量
+/// - `amount(Decimal)`: 下单数量
 /// - `deal_amount(Decimal)`: 成交数量
 /// - `avg_price(Decimal)`: 成交均价
 /// - `status(String)`: 订单状态
@@ -93,7 +93,7 @@ pub struct Order {
     pub id: String,
     pub custom_id: String,
     pub price: Decimal,
-    pub amount: i64,
+    pub amount: Decimal,
     pub deal_amount: Decimal,
     pub avg_price: Decimal,
     pub status: String,
@@ -272,20 +272,13 @@ pub trait Platform {
     async fn get_order_detail(&self, symbol: &str, id: &str) -> Result<Order, Error>;
     // 获取订单列表
     async fn get_orders_list(&self, symbol: &str, status: &str) -> Result<Vec<Order>, Error>;
-    // 获取深度信息
-    fn get_depth(&self) -> Depth;
+    // 设置持仓模式
+    async fn set_dual_mode(&self, coin: &str, is_dual_mode: bool) -> Result<String, Error>;
+    // 更新双持仓模式下杠杆
+    async fn set_dual_leverage(&self, symbol: &str, leverage: &str) -> Result<String, Error>;
+    // 交易账户互转
+    async fn wallet_transfers(&self, coin: &str, from: &str, to: &str, amount: Decimal) -> Result<String, Error>;
     // 下单接口
-    fn take_order(&self);
-    // 获取订单列表
-    fn get_order_list(&self);
-    // 取消订单
-    fn cancel_order(&self);
-    // 订阅账号信息
-    fn subscribe_account(&self) -> Account;
-    // 订阅深度信息
-    fn subscribe_depth(&self, symbol: &str);
-    // 订阅深度信息
-    fn subscribe_special_depth(&self, symbol: &str);
-    fn subscribe_kline(&self);
+    async fn take_order(&self, custom_id: &str, origin_side: &str, coin: &str, symbol: &str, amount: Decimal) -> Result<Order, Error>;
 }
 

standard/tests/libs_test.rs

@@ -134,3 +134,9 @@ async fn test_gate_swap_get_orders_list() {
     let gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap);
     println!("gate_swap orders_list:{:?}", gate_swap_exchange.get_orders_list("CYBER_USDT", "finished").await);
 }
+// 设置持仓模式
+#[tokio::test]
+async fn test_set_dual_mode() {
+    let gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap);
+    println!("gate_swap orders_list:{:?}", gate_swap_exchange.set_dual_mode("usdt", true).await);
+}