添加下单订单类型判断

修改下指定交易对接口

standard/src/binance_spot.rs

@@ -98,7 +98,7 @@ impl Platform for BinanceSpot {
 
     async fn take_order(&mut self, _custom_id: &str, _origin_side: &str, _price: Decimal, _amount: Decimal) -> Result<Order, Error> { Err(Error::new(ErrorKind::NotFound, "binance_spot：该交易所方法未实现".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, "binance_spot：该交易所方法未实现".to_string())) }
+    async fn take_order_symbol(&mut self, _symbol: String, _ct_val: Decimal, _custom_id: &str, _origin_side: &str, _price: Decimal, _amount: Decimal) -> Result<Order, Error> { Err(Error::new(ErrorKind::NotFound, "binance_spot：该交易所方法未实现".to_string())) }
 
     async fn cancel_order(&mut self, _order_id: &str, _custom_id: &str) -> Result<Order, Error> { Err(Error::new(ErrorKind::NotFound, "binance_spot：该交易所方法未实现".to_string())) }
 

standard/src/binance_swap.rs

@@ -339,7 +339,7 @@ impl Platform for BinanceSwap {
 
     async fn take_order(&mut self, _custom_id: &str, _origin_side: &str, _price: Decimal, _amount: Decimal) -> Result<Order, Error> { Err(Error::new(ErrorKind::NotFound, "binance_swap：该交易所方法未实现".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, "binance_swap：该交易所方法未实现".to_string())) }
+    async fn take_order_symbol(&mut self, _symbol: String, _ct_val: Decimal, _custom_id: &str, _origin_side: &str, _price: Decimal, _amount: Decimal) -> Result<Order, Error> { Err(Error::new(ErrorKind::NotFound, "binance_swap：该交易所方法未实现".to_string())) }
 
     async fn cancel_order(&mut self, _order_id: &str, _custom_id: &str) -> Result<Order, Error> { Err(Error::new(ErrorKind::NotFound, "binance_swap：该交易所方法未实现".to_string())) }
 

standard/src/bitget_spot.rs

@@ -166,9 +166,6 @@ impl Platform for BitgetSpot {
 
                     let tick_size = Decimal::from_str(&format!("0.{}", "0".repeat(usize::try_from(price_precision).unwrap()))).unwrap();
                     let amount_size = Decimal::from_str(&format!("0.{}", "0".repeat(usize::try_from(amount_precision).unwrap()))).unwrap();
-                    let ct_val = Decimal::ONE;
-                    let min_notional = min_qty * ct_val;
-                    let max_notional = max_qty * ct_val;
 
                     let result = Market {
                         symbol: format!("{}_{}", base_asset, quote_asset),
@@ -180,9 +177,9 @@ impl Platform for BitgetSpot {
                         amount_precision,
                         min_qty,
                         max_qty,
-                        min_notional,
-                        max_notional,
-                        ct_val,
+                        min_notional: min_qty,
+                        max_notional: max_qty,
+                        ct_val: Decimal::ONE,
                     };
                     Ok(result)
                 }
@@ -214,9 +211,6 @@ impl Platform for BitgetSpot {
 
                     let tick_size = Decimal::from_str(&format!("0.{}", "0".repeat(usize::try_from(price_precision).unwrap()))).unwrap();
                     let amount_size = Decimal::from_str(&format!("0.{}", "0".repeat(usize::try_from(amount_precision).unwrap()))).unwrap();
-                    let ct_val = Decimal::ONE;
-                    let min_notional = min_qty * ct_val;
-                    let max_notional = max_qty * ct_val;
 
                     let result = Market {
                         symbol: format!("{}_{}", base_asset, quote_asset),
@@ -228,9 +222,9 @@ impl Platform for BitgetSpot {
                         amount_precision,
                         min_qty,
                         max_qty,
-                        min_notional,
-                        max_notional,
-                        ct_val,
+                        min_notional: min_qty,
+                        max_notional: max_qty,
+                        ct_val: Decimal::ONE,
                     };
                     Ok(result)
                 }
@@ -273,12 +267,16 @@ impl Platform for BitgetSpot {
         let mut params = json!({
             "symbol": symbol_format.to_string(),
             "clientOid": custom_id,
-            "orderType": "limit",
             "price": price.to_string(),
-            "force": "gtc"
         });
-        let size = amount;
-        params["size"] = json!(size);
+        if price.eq(&Decimal::ZERO) {
+            params["orderType"] = json!("market");
+            params["force"] = json!("post_only ");
+        } else {
+            params["orderType"] = json!("limit");
+            params["force"] = json!("gtc");
+        };
+        params["size"] = json!(amount);
         match origin_side {
             "kd" => {
                 params["side"] = json!("buy");
@@ -315,16 +313,21 @@ impl Platform for BitgetSpot {
         }
     }
 
-    async fn take_order_symbol(&mut self, symbol: String, custom_id: &str, origin_side: &str, price: Decimal, amount: Decimal) -> Result<Order, Error> {
+    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> {
         let symbol_format = utils::format_symbol(symbol.clone(), "");
         let mut params = json!({
             "symbol": symbol_format.to_string(),
             "clientOid": custom_id,
-            "orderType": "limit",
             "price": price.to_string(),
-            "force": "gtc"
         });
-        let size = amount;
+        if price.eq(&Decimal::ZERO) {
+            params["orderType"] = json!("market");
+            params["force"] = json!("post_only");
+        } else {
+            params["orderType"] = json!("limit");
+            params["force"] = json!("gtc");
+        };
+        let size = (amount / ct_val).floor();
         params["size"] = json!(size);
         match origin_side {
             "kd" => {

standard/src/gate_spot.rs

@@ -93,7 +93,7 @@ impl Platform for GateSpot {
 
     async fn take_order(&mut self, _custom_id: &str, _origin_side: &str, _price: Decimal, _amount: Decimal) -> Result<Order, Error> { Err(Error::new(ErrorKind::NotFound, "gate_spot：该交易所方法未实现".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, "gate_spot：该交易所方法未实现".to_string())) }
+    async fn take_order_symbol(&mut self, _symbol: String, _ct_val: Decimal, _custom_id: &str, _origin_side: &str, _price: Decimal, _amount: Decimal) -> Result<Order, Error> { Err(Error::new(ErrorKind::NotFound, "gate_spot：该交易所方法未实现".to_string())) }
 
     async fn cancel_order(&mut self, _order_id: &str, _custom_id: &str) -> Result<Order, Error> { Err(Error::new(ErrorKind::NotFound, "gate_spot：该交易所方法未实现".to_string())) }
 

standard/src/gate_swap.rs

@@ -142,12 +142,11 @@ impl Platform for GateSwap {
     // 获取所有持仓
     async fn get_positions(&mut self) -> Result<Vec<Position>, Error> {
         let symbol_array: Vec<&str> = self.symbol.split("_").collect();
-        let ct_val = self.market.ct_val;
         let res_data = self.request.get_user_position(symbol_array[1].to_string().to_lowercase()).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_position_item(item, ct_val) }).collect();
+            let result = res_data_json.iter().map(|item| { format_position_item(item, Decimal::ONE) }).collect();
             Ok(result)
         } else {
             Err(Error::new(ErrorKind::Other, res_data.to_string()))
@@ -383,9 +382,8 @@ impl Platform for GateSwap {
         }
     }
 
-    async fn take_order_symbol(&mut self, symbol: String, custom_id: &str, origin_side: &str, price: Decimal, amount: Decimal) -> Result<Order, Error> {
+    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> {
         let symbol_array: Vec<&str> = symbol.split("_").collect();
-        let ct_val = self.market.ct_val;
         let mut params = json!({
             "text": format!("t-my-custom-id_{}", custom_id),
             "contract": self.symbol.to_string(),

standard/src/kucoin_swap.rs

@@ -323,6 +323,7 @@ impl Platform for KucoinSwap {
             "reduceOnly":false,
             "price": price.to_string(),
         });
+        params["type"] = if price.eq(&Decimal::ZERO) { json!("market") } else { json!("limit") };
         let size = (amount / ct_val).floor();
         params["size"] = json!(size);
         match origin_side {
@@ -363,9 +364,8 @@ impl Platform for KucoinSwap {
         }
     }
 
-    async fn take_order_symbol(&mut self, symbol: String, custom_id: &str, origin_side: &str, price: Decimal, amount: Decimal) -> Result<Order, Error> {
+    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> {
         let symbol_format = format!("{}M", utils::format_symbol(symbol.clone(), ""));
-        let ct_val = self.market.ct_val;
         let mut params = json!({
             "clientOid": custom_id,
             "symbol": symbol_format,

standard/src/lib.rs

@@ -526,7 +526,7 @@ pub trait Platform {
     // 下单接口
     async fn take_order(&mut self, custom_id: &str, origin_side: &str, price: Decimal, amount: Decimal) -> Result<Order, Error>;
     // 下单接口自定义交易对
-    async fn take_order_symbol(&mut self, symbol: String, custom_id: &str, origin_side: &str, price: Decimal, amount: Decimal) -> Result<Order, Error>;
+    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>;
     // 撤销订单
     async fn cancel_order(&mut self, order_id: &str, custom_id: &str) -> Result<Order, Error>;
     // 批量撤销订单

standard/src/okx_swap.rs

@@ -336,8 +336,8 @@ impl Platform for OkxSwap {
             "clOrdId": custom_id.to_string(),
             "instId": symbol_format,
             "px": price.to_string(),
-            "ordType": "limit",
         });
+        params["ordType"] = if price.eq(&Decimal::ZERO) { json!("market") } else { json!("limit") };
         let size = (amount / ct_val).floor();
         params["sz"] = json!(size);
         match origin_side {
@@ -366,7 +366,42 @@ 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_swap：该交易所方法未实现".to_string())) }
+    async fn take_order_symbol(&mut self, symbol: String, ct_val: Decimal, custom_id: &str, origin_side: &str, price: Decimal, amount: Decimal) -> Result<Order, Error> {
+        let symbol_format = utils::format_symbol(symbol.clone(), "-");
+        let mut params = json!({
+            "tdMode": "cross",
+            "clOrdId": custom_id.to_string(),
+            "instId": symbol_format,
+            "px": price.to_string(),
+        });
+        params["ordType"] = if price.eq(&Decimal::ZERO) { json!("market") } else { json!("limit") };
+        let size = (amount / ct_val).floor();
+        params["sz"] = json!(size);
+        match origin_side {
+            "kd" => {
+                params["side"] = json!("buy");
+            }
+            "pd" => {
+                params["side"] = json!("sell");
+            }
+            "kk" => {
+                params["side"] = json!("sell");
+            }
+            "pk" => {
+                params["side"] = json!("buy");
+            }
+            _ => { error!("下单参数错误"); }
+        };
+        let res_data = self.request.swap_order(params).await;
+        if res_data.code == "200" {
+            let res_data_str = &res_data.data;
+            let res_data_json: serde_json::Value = serde_json::from_str(res_data_str).unwrap();
+            let result = okx_handle::format_order_item(res_data_json, ct_val);
+            Ok(result)
+        } else {
+            Err(Error::new(ErrorKind::Other, res_data.to_string()))
+        }
+    }
 
     async fn cancel_order(&mut self, order_id: &str, custom_id: &str) -> Result<Order, Error> {
         let symbol_format = utils::format_symbol(self.symbol.clone(), "-");