完成bitget

standard/src/bitget_swap.rs

@@ -146,7 +146,6 @@ impl Platform for BitgetSwap {
             "marginCoin": "USDT",
             "symbol": symbol_format
         });
-        let multiplier = self.market.multiplier;
         let response = self.request.get_single_position(params).await;
         if response.code != 200 {
             return Err(Error::new(ErrorKind::NotFound, format!("bitget_swap 获取仓位异常{:?}", response).to_string()));
@@ -162,7 +161,7 @@ impl Platform for BitgetSwap {
         for position_json in positions_json {
             let symbol = position_json["symbol"].as_str().unwrap().to_string();
             let margin_level = Decimal::from_str(position_json["leverage"].as_str().unwrap()).unwrap();
-            let amount = Decimal::from_str(position_json["total"].as_str().unwrap()).unwrap() * multiplier;
+            let amount = Decimal::from_str(position_json["total"].as_str().unwrap()).unwrap();
             let frozen_amount = Decimal::from_str(position_json["locked"].as_str().unwrap()).unwrap();
             let price = Decimal::from_str(position_json["openPriceAvg"].as_str().unwrap()).unwrap();
             let profit = Decimal::from_str(position_json["unrealizedPL"].as_str().unwrap()).unwrap();
@@ -327,7 +326,6 @@ impl Platform for BitgetSwap {
         } else {
             Err(Error::new(ErrorKind::Other, res_data.to_string()))
         }
-
     }
 
     async fn get_ticker_symbol(&mut self, symbol: String) -> Result<Ticker, Error> {
@@ -444,15 +442,15 @@ impl Platform for BitgetSwap {
 
     async fn take_order_symbol(&mut self, symbol: String, multiplier: Decimal, custom_id: &str, origin_side: &str, price: Decimal, amount: Decimal) -> Result<Order, Error> {
         let symbol_format = utils::format_symbol(symbol, "");
-        let final_size = amount / multiplier;
         let mut params = json!({
             "symbol": symbol_format,
             "clientOid": custom_id,
             "productType": "USDT-FUTURES",
             "marginMode": "crossed",
             "marginCoin": "USDT",
-            "size": final_size.to_string()
+            "size": amount.to_string()
         });
+        println!("000000000000000000000000000000 {},{},{},{},{},{}", price.eq(&Decimal::ZERO), amount, multiplier, amount % multiplier, amount % multiplier != dec!(0), ((amount / multiplier).ceil() * multiplier).to_string());
         if price.eq(&Decimal::ZERO) {
             params["orderType"] = json!("market");
             params["force"] = json!("gtc");
@@ -460,6 +458,9 @@ impl Platform for BitgetSwap {
             params["price"] = json!(price.to_string());
             params["orderType"] = json!("limit");
             params["force"] = json!("gtc");
+            if amount % multiplier != dec!(0) {
+                params["size"] = json!(((amount / multiplier).ceil() * multiplier).to_string());
+            }
         };
         match origin_side {
             "kd" => {
@@ -759,7 +760,7 @@ impl Platform for BitgetSwap {
 //     }
 // }
 
-pub fn format_order_item(order: Value, multiplier: Decimal) -> Order {
+pub fn format_order_item(order: Value, _multiplier: 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["state"].as_str().unwrap();
@@ -770,8 +771,8 @@ pub fn format_order_item(order: Value, multiplier: Decimal) -> Order {
         Decimal::from_str(order["priceAvg"].as_str().unwrap().to_string().as_str()).unwrap()
     };
 
-    let amount = size * multiplier;
-    let deal_amount = base_volume * multiplier;
+    let amount = size;
+    let deal_amount = base_volume;
     let custom_status = if ["filled", "canceled"].contains(&status) {
         "REMOVE".to_string()
     } else if ["init", "live", "new", "partially_filled"].contains(&status) {

standard/src/bitget_swap_handle.rs

@@ -36,12 +36,12 @@ pub fn handle_account_info(response: &ResponseData, _symbol: &String) -> Account
 }
 
 // 处理order信息
-pub fn handle_order(res_data: &ResponseData, ct_val: &Decimal) -> SpecialOrder {
+pub fn handle_order(res_data: &ResponseData, multiplier: &Decimal) -> SpecialOrder {
     let data_info = res_data.data["data"].clone();
     let res_data_json = data_info.as_array().unwrap();
     let mut order_info = Vec::new();
     for item in res_data_json.iter() {
-        order_info.push(format_order_item(item.clone(), ct_val.clone()));
+        order_info.push(format_order_item(item.clone(), multiplier.clone()));
     }
     SpecialOrder {
         name: res_data.label.clone(),
@@ -50,7 +50,7 @@ pub fn handle_order(res_data: &ResponseData, ct_val: &Decimal) -> SpecialOrder {
 }
 
 // 处理订单信息
-pub fn format_order_item(order: Value, ct_val: Decimal) -> Order {
+pub fn format_order_item(order: Value, _multiplier: Decimal) -> Order {
     let price = Decimal::from_str(order["price"].as_str().unwrap().to_string().as_str()).unwrap();
     let size = Decimal::from_str(order["size"].as_str().unwrap().to_string().as_str()).unwrap();
     let binding = order["status"].clone().as_str().unwrap().to_string();
@@ -67,8 +67,8 @@ pub fn format_order_item(order: Value, ct_val: Decimal) -> Order {
         order["clientOid"].as_str().unwrap()
     };
 
-    let amount = size * ct_val;
-    let deal_amount = acc_base_volume * ct_val;
+    let amount = size;
+    let deal_amount = acc_base_volume;
     let custom_status = if ["filled", "canceled"].contains(&status) {
         "REMOVE".to_string()
     } else if ["init", "live", "new", "partially_filled"].contains(&status) {
@@ -105,17 +105,17 @@ pub fn format_depth_items(value: Value, mul: &Decimal) -> Vec<OrderBook> {
 }
 
 // 处理position信息
-pub fn handle_position(res_data: &ResponseData, ct_val: &Decimal) -> Vec<Position> {
+pub fn handle_position(res_data: &ResponseData, multiplier: &Decimal) -> Vec<Position> {
     let data_info = res_data.data["data"].clone();
     let data_info_json = data_info.as_array().unwrap();
-    data_info_json.iter().map(|item| { format_position_item(item, ct_val) }).collect()
+    data_info_json.iter().map(|item| { format_position_item(item, multiplier) }).collect()
 }
 
-pub fn format_position_item(position_json: &Value, ct_val: &Decimal) -> Position {
+pub fn format_position_item(position_json: &Value, _multiplier: &Decimal) -> Position {
     let symbol = position_json["instId"].as_str().unwrap().to_string();
     let margin_level = Decimal::from_i64(position_json["leverage"].as_i64().unwrap()).unwrap();
-    let amount = Decimal::from_str(position_json["total"].as_str().unwrap()).unwrap() * ct_val;
-    let frozen_amount = Decimal::from_str(position_json["frozen"].as_str().unwrap()).unwrap() * ct_val;
+    let amount = Decimal::from_str(position_json["total"].as_str().unwrap()).unwrap();
+    let frozen_amount = Decimal::from_str(position_json["frozen"].as_str().unwrap()).unwrap();
     let price = Decimal::from_str(position_json["openPriceAvg"].as_str().unwrap()).unwrap();
     let profit = Decimal::from_str(position_json["unrealizedPL"].as_str().unwrap()).unwrap();
     let mut position_mode = match position_json["posMode"].as_str().unwrap() {

strategy/src/strategy.rs

@@ -996,8 +996,6 @@ impl Strategy {
             // 取消大小限制
             target_sell_price = utils::fix_price(target_sell_price, self.tick_size);
 
-
-            println!("-0000000000000000000000000000        {},{},{}",self.min_amount_value,target_sell_price,self.step_size);
             let amount = if predictor.inventory >= dec!(3) {
                 utils::get_amount_by_min_amount_value(self.min_amount_value * predictor.inventory.abs(), target_sell_price, self.step_size)
             } else {