|
|
@@ -1,670 +1,771 @@
|
|
|
-// use std::collections::{BTreeMap};
|
|
|
-// use exchanges::bitget_swap_rest::BitgetSwapRest;
|
|
|
-// use std::io::{Error, ErrorKind};
|
|
|
-// use tokio::sync::mpsc::Sender;
|
|
|
-// use std::str::FromStr;
|
|
|
-// use async_trait::async_trait;
|
|
|
-// use futures::stream::FuturesUnordered;
|
|
|
-// use futures::TryStreamExt;
|
|
|
-// use rust_decimal::{Decimal, MathematicalOps};
|
|
|
-// use rust_decimal::prelude::ToPrimitive;
|
|
|
-// use rust_decimal_macros::dec;
|
|
|
-// use serde_json::{json, Value};
|
|
|
-// use tokio::spawn;
|
|
|
-// use tokio::time::Instant;
|
|
|
-// use tracing::{error, info};
|
|
|
-// use global::trace_stack::TraceStack;
|
|
|
-// use crate::exchange::ExchangeEnum;
|
|
|
-// use crate::{Account, Market, Order, OrderCommand, Platform, Position, PositionModeEnum, Ticker, utils};
|
|
|
-//
|
|
|
-// #[allow(dead_code)]
|
|
|
-// #[derive(Clone)]
|
|
|
-// pub struct BitgetSwap {
|
|
|
-// exchange: ExchangeEnum,
|
|
|
-// symbol: String,
|
|
|
-// is_colo: bool,
|
|
|
-// params: BTreeMap<String, String>,
|
|
|
-// request: BitgetSwapRest,
|
|
|
-// market: Market,
|
|
|
-// order_sender: Sender<Order>,
|
|
|
-// error_sender: Sender<Error>,
|
|
|
-// }
|
|
|
-//
|
|
|
-// impl BitgetSwap {
|
|
|
-// pub async fn new(symbol: String, is_colo: bool, params: BTreeMap<String, String>, order_sender: Sender<Order>, error_sender: Sender<Error>) -> BitgetSwap {
|
|
|
-// let market = Market::new();
|
|
|
-// let mut bitget_swap = BitgetSwap {
|
|
|
-// exchange: ExchangeEnum::BitgetSwap,
|
|
|
-// symbol: symbol.to_uppercase(),
|
|
|
-// is_colo,
|
|
|
-// params: params.clone(),
|
|
|
-// request: BitgetSwapRest::new(is_colo, params.clone()),
|
|
|
-// market,
|
|
|
-// order_sender,
|
|
|
-// error_sender,
|
|
|
-// };
|
|
|
-// bitget_swap.market = BitgetSwap::get_market(&mut bitget_swap).await.unwrap();
|
|
|
-// // 修改持仓模式
|
|
|
-// let mode_result = bitget_swap.set_dual_mode("", true).await;
|
|
|
-// match mode_result {
|
|
|
-// Ok(ok) => {
|
|
|
-// info!("BitgetSwap:设置持仓模式成功！{:?}", ok);
|
|
|
-// }
|
|
|
-// Err(error) => {
|
|
|
-// error!("BitgetSwap:设置持仓模式失败！{:?}", error)
|
|
|
-// }
|
|
|
-// }
|
|
|
-// // 设置持仓杠杆
|
|
|
-// // let lever_rate_result = bitget_swap.set_dual_leverage("10").await;
|
|
|
-// // match lever_rate_result {
|
|
|
-// // Ok(ok) => {
|
|
|
-// // info!("BitgetSwap:设置持仓杠杆成功！{:?}", ok);
|
|
|
-// // }
|
|
|
-// // Err(error) => {
|
|
|
-// // error!("BitgetSwap:设置持仓杠杆失败！{:?}", error)
|
|
|
-// // }
|
|
|
-// // }
|
|
|
-//
|
|
|
-// return bitget_swap;
|
|
|
-// }
|
|
|
-// }
|
|
|
-//
|
|
|
-// #[async_trait]
|
|
|
-// impl Platform for BitgetSwap {
|
|
|
-// fn clone_box(&self) -> Box<dyn Platform + Send + Sync> { Box::new(self.clone()) }
|
|
|
-//
|
|
|
-// fn get_self_exchange(&self) -> ExchangeEnum { ExchangeEnum::BitgetSwap }
|
|
|
-//
|
|
|
-// fn get_self_symbol(&self) -> String { self.symbol.clone() }
|
|
|
-//
|
|
|
-// fn get_self_is_colo(&self) -> bool { self.is_colo }
|
|
|
-//
|
|
|
-// fn get_self_params(&self) -> BTreeMap<String, String> { self.params.clone() }
|
|
|
-//
|
|
|
-// fn get_self_market(&self) -> Market { self.market.clone() }
|
|
|
-//
|
|
|
-// fn get_request_delays(&self) -> Vec<i64> {
|
|
|
-// // self.request.get_delays()
|
|
|
-// vec![]
|
|
|
-// }
|
|
|
-//
|
|
|
-// fn get_request_avg_delay(&self) -> Decimal {
|
|
|
-// // self.request.get_avg_delay()
|
|
|
-// Decimal::ZERO
|
|
|
-// }
|
|
|
-//
|
|
|
-// fn get_request_max_delay(&self) -> i64 { 0 }
|
|
|
-//
|
|
|
-// async fn get_server_time(&mut self) -> Result<String, Error> {
|
|
|
-// let res_data = self.request.get_server_time().await;
|
|
|
-// if res_data.code == 200 {
|
|
|
-// let res_data_json = res_data.data;
|
|
|
-// let result = res_data_json["serverTime"].as_str().unwrap().to_string();
|
|
|
-// Ok(result)
|
|
|
-// } else {
|
|
|
-// Err(Error::new(ErrorKind::Other, res_data.to_string()))
|
|
|
-// }
|
|
|
-// }
|
|
|
-//
|
|
|
-// async fn get_account(&mut self) -> Result<Account, Error> {
|
|
|
-// 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> {
|
|
|
-// 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 get_position：该交易所方法未实现".to_string())) }
|
|
|
-//
|
|
|
-// async fn get_positions(&mut self) -> Result<Vec<Position>, Error> {
|
|
|
-// let params = json!({
|
|
|
-// "productType": "USDT-FUTURES",
|
|
|
-// "marginCoin": "USDT"
|
|
|
-// });
|
|
|
-// let response = self.request.get_all_position(params).await;
|
|
|
-// info!(?response);
|
|
|
-//
|
|
|
-// if response.code != 200 {
|
|
|
-// return Err(Error::new(ErrorKind::NotFound, format!("bitget_swap 获取仓位异常{:?}", response).to_string()))
|
|
|
-// }
|
|
|
-//
|
|
|
-// // 正常处理持仓信息
|
|
|
-// let mut positions: Vec<Position> = vec![];
|
|
|
-// if response.data.is_null() {
|
|
|
-// return Ok(positions)
|
|
|
-// }
|
|
|
-//
|
|
|
-// let positions_json = response.data.as_array().unwrap();
|
|
|
-// 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();
|
|
|
-// 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();
|
|
|
-// let position_mode = match position_json["posMode"].as_str().unwrap() {
|
|
|
-// "hedge_mode" => {
|
|
|
-// match position_json["holdSide"].as_str().unwrap() {
|
|
|
-// "short" => {
|
|
|
-// PositionModeEnum::Short
|
|
|
-// }
|
|
|
-// "long" => {
|
|
|
-// PositionModeEnum::Long
|
|
|
-// },
|
|
|
-// _ => {
|
|
|
-// panic!("bitget_usdt_swap: 未知的持仓模式与持仓方向: {}, {}",
|
|
|
-// position_json["posMode"].as_str().unwrap(), position_json["holdSide"].as_str().unwrap())
|
|
|
-// }
|
|
|
-// }
|
|
|
-// },
|
|
|
-// "one_way_mode" => {
|
|
|
-// PositionModeEnum::Both
|
|
|
-// },
|
|
|
-// _ => {
|
|
|
-// panic!("bitget_usdt_swap: 未知的持仓模式: {}", position_json["posMode"].as_str().unwrap())
|
|
|
-// }
|
|
|
-// };
|
|
|
-// let margin = Decimal::from_str(position_json["marginSize"].as_str().unwrap()).unwrap();
|
|
|
-//
|
|
|
-// positions.push(Position {
|
|
|
-// symbol,
|
|
|
-// margin_level,
|
|
|
-// amount,
|
|
|
-// frozen_amount,
|
|
|
-// price,
|
|
|
-// profit,
|
|
|
-// position_mode,
|
|
|
-// margin,
|
|
|
-// });
|
|
|
-// }
|
|
|
-//
|
|
|
-// Ok(positions)
|
|
|
-// }
|
|
|
-//
|
|
|
-// async fn get_ticker(&mut self) -> Result<Ticker, Error> {
|
|
|
-// return self.get_ticker_symbol(self.symbol.clone()).await
|
|
|
-// }
|
|
|
-//
|
|
|
-// 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_json = res_data.data;
|
|
|
-// 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()))
|
|
|
-// }
|
|
|
-// }
|
|
|
-//
|
|
|
-// async fn get_market(&mut self) -> Result<Market, Error> {
|
|
|
-// self.get_market_symbol(self.symbol.clone()).await
|
|
|
-// }
|
|
|
-//
|
|
|
-// async fn get_market_symbol(&mut self, symbol: String) -> Result<Market, Error> {
|
|
|
-// let symbol_format = utils::format_symbol(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 ct_val = 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,
|
|
|
-// };
|
|
|
-// Ok(result)
|
|
|
-// } else {
|
|
|
-// Err(Error::new(ErrorKind::Other, response.to_string()))
|
|
|
-// }
|
|
|
-// }
|
|
|
-//
|
|
|
-// async fn get_order_detail(&mut self, order_id: &str, custom_id: &str) -> Result<Order, Error> {
|
|
|
-// let symbol_format = utils::format_symbol(self.symbol.clone(), "");
|
|
|
-// let params = json!({
|
|
|
-// "symbol": symbol_format,
|
|
|
-// "productType": "USDT-FUTURES",
|
|
|
-// "clientOid": custom_id,
|
|
|
-// "orderId": order_id
|
|
|
-// });
|
|
|
-//
|
|
|
-// let ct_val = self.market.ct_val;
|
|
|
-// let response = self.request.get_order(params).await;
|
|
|
-// if response.code == 200 {
|
|
|
-// let res_data_json = response.data;
|
|
|
-// let result = format_order_item(res_data_json, ct_val);
|
|
|
-// Ok(result)
|
|
|
-// } else {
|
|
|
-// Err(Error::new(ErrorKind::Other, response.to_string()))
|
|
|
-// }
|
|
|
-// }
|
|
|
-//
|
|
|
-// async fn get_orders_list(&mut self, _status: &str) -> Result<Vec<Order>, Error> {
|
|
|
-// 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;
|
|
|
-// // 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_order_item(item.clone(), ct_val)).collect();
|
|
|
-// // Ok(result)
|
|
|
-// // } else {
|
|
|
-// // Err(Error::new(ErrorKind::Other, res_data.to_string()))
|
|
|
-// // }
|
|
|
-// }
|
|
|
-//
|
|
|
-// async fn take_order(&mut self, custom_id: &str, origin_side: &str, price: Decimal, amount: Decimal) -> Result<Order, Error> {
|
|
|
-// let ct_val = self.market.ct_val;
|
|
|
-//
|
|
|
-// return self.take_order_symbol(self.symbol.clone(), ct_val, custom_id, origin_side, price, amount).await;
|
|
|
-// }
|
|
|
-//
|
|
|
-// 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, "");
|
|
|
-// let final_size = amount / ct_val;
|
|
|
-// let mut params = json!({
|
|
|
-// "symbol": symbol_format,
|
|
|
-// "clientOid": custom_id,
|
|
|
-// "productType": "USDT-FUTURES",
|
|
|
-// "marginMode": "crossed",
|
|
|
-// "marginCoin": "USDT",
|
|
|
-// "size": final_size.to_string()
|
|
|
-// });
|
|
|
-// if price.eq(&Decimal::ZERO) {
|
|
|
-// params["orderType"] = json!("market");
|
|
|
-// params["force"] = json!("gtc");
|
|
|
-// } else {
|
|
|
-// params["price"] = json!(price.to_string());
|
|
|
-// params["orderType"] = json!("limit");
|
|
|
-// params["force"] = json!("gtc");
|
|
|
-// };
|
|
|
-// match origin_side {
|
|
|
-// "kd" => {
|
|
|
-// params["side"] = json!("buy");
|
|
|
-// params["tradeSide"] = json!("open");
|
|
|
-// }
|
|
|
-// "pd" => {
|
|
|
-// params["side"] = json!("buy");
|
|
|
-// params["tradeSide"] = json!("close");
|
|
|
-// }
|
|
|
-// "kk" => {
|
|
|
-// params["side"] = json!("sell");
|
|
|
-// params["tradeSide"] = json!("open");
|
|
|
-// }
|
|
|
-// "pk" => {
|
|
|
-// params["side"] = json!("sell");
|
|
|
-// params["tradeSide"] = json!("close");
|
|
|
-// }
|
|
|
-// _ => { panic!("bitget_usdt_swap 下单参数错误"); }
|
|
|
-// };
|
|
|
-// let res_data = self.request.swap_order(params).await;
|
|
|
-// if res_data.code != 200 {
|
|
|
-// return Err(Error::new(ErrorKind::Other, res_data.to_string()))
|
|
|
-// }
|
|
|
-//
|
|
|
-// let res_data_json = res_data.data;
|
|
|
-// let result = Order {
|
|
|
-// id: res_data_json["orderId"].as_str().unwrap().to_string(),
|
|
|
-// custom_id: res_data_json["clientOid"].as_str().unwrap().to_string(),
|
|
|
-// price: Decimal::ZERO,
|
|
|
-// amount: Decimal::ZERO,
|
|
|
-// deal_amount: Decimal::ZERO,
|
|
|
-// avg_price: Decimal::ZERO,
|
|
|
-// status: "NEW".to_string(),
|
|
|
-// order_type: "".to_string(),
|
|
|
-// trace_stack: TraceStack::new(0, Instant::now()).on_special("328 bitget_swap".to_string()),
|
|
|
-// };
|
|
|
-// return Ok(result)
|
|
|
-// }
|
|
|
-//
|
|
|
-// 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 params = json!({
|
|
|
-// "symbol": symbol_format,
|
|
|
-// "productType": "USDT-FUTURES",
|
|
|
-// "clientOid": custom_id,
|
|
|
-// "orderId": order_id
|
|
|
-// });
|
|
|
-// let response = self.request.cancel_order(params).await;
|
|
|
-//
|
|
|
-// // 取消失败，进行报错
|
|
|
-// if response.code != 200 {
|
|
|
-// return Err(Error::new(ErrorKind::NotFound, response.to_string()));
|
|
|
-// }
|
|
|
-//
|
|
|
-// let res_data_json = response.data;
|
|
|
-// let result = Order {
|
|
|
-// id: res_data_json["orderId"].as_str().unwrap().to_string(),
|
|
|
-// custom_id: 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("443 bitget_swap".to_string()),
|
|
|
-// };
|
|
|
-// Ok(result)
|
|
|
-// }
|
|
|
-//
|
|
|
-// async fn cancel_orders(&mut self) -> Result<Vec<Order>, Error> {
|
|
|
-// Err(Error::new(ErrorKind::NotFound, "bitget_swap cancel_orders：该交易所方法未实现".to_string()))
|
|
|
-// }
|
|
|
-//
|
|
|
-// async fn cancel_orders_all(&mut self) -> Result<Vec<Order>, Error> {
|
|
|
-// let response = self.request.get_pending_orders().await;
|
|
|
-// if response.code == 200 {
|
|
|
-// info!("{}", response.data.to_string());
|
|
|
-// let mut result = vec![];
|
|
|
-//
|
|
|
-// 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 symbol = order["symbol"].as_str().unwrap().to_string();
|
|
|
-// let order_id = order["orderId"].as_str().unwrap().to_string();
|
|
|
-// 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 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 cancel_stop_loss_order：该交易所方法未实现".to_string()))
|
|
|
-// }
|
|
|
-//
|
|
|
-// async fn set_dual_mode(&mut self, _coin: &str, is_dual_mode: bool) -> Result<String, Error> {
|
|
|
-// let pos_mode = if is_dual_mode {
|
|
|
-// "hedge_mode"
|
|
|
-// } else {
|
|
|
-// "one_way_mode"
|
|
|
-// };
|
|
|
-// let params = json!({
|
|
|
-// "productType": "USDT-FUTURES",
|
|
|
-// "posMode": pos_mode,
|
|
|
-// });
|
|
|
-// let response = self.request.set_position_mode(params).await;
|
|
|
-//
|
|
|
-// if response.code != 200 {
|
|
|
-// return Err(Error::new(ErrorKind::Other, format!("设置持仓模式失败:{:?}", response).to_string()))
|
|
|
-// }
|
|
|
-//
|
|
|
-// return Ok(response.data.to_string());
|
|
|
-// }
|
|
|
-//
|
|
|
-// async fn set_dual_leverage(&mut self, leverage: &str) -> Result<String, Error> {
|
|
|
-// let params = json!({
|
|
|
-// "symbol": "ETHUSDT",
|
|
|
-// "productType": "USDT-FUTURES",
|
|
|
-// "marginCoin": "USDT",
|
|
|
-// "leverage": leverage
|
|
|
-// });
|
|
|
-// let response = self.request.set_leverage(params).await;
|
|
|
-//
|
|
|
-// if response.code != 200 {
|
|
|
-// return Err(Error::new(ErrorKind::Other, format!("设置杠杆失败:{:?}", response).to_string()))
|
|
|
-// }
|
|
|
-//
|
|
|
-// return Ok(response.data.to_string());
|
|
|
-// }
|
|
|
-//
|
|
|
-// async fn set_auto_deposit_status(&mut self, _status: bool) -> Result<String, Error> {
|
|
|
-// 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 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 {
|
|
|
-// // let res_data_str = &res_data.data;
|
|
|
-// // let result = res_data_str.clone();
|
|
|
-// // Ok(result)
|
|
|
-// // } else {
|
|
|
-// // Err(Error::new(ErrorKind::Other, res_data.to_string()))
|
|
|
-// // }
|
|
|
-// }
|
|
|
-//
|
|
|
-// async fn command_order(&mut self, order_command: &mut OrderCommand, trace_stack: &TraceStack) {
|
|
|
-// let mut handles = vec![];
|
|
|
-//
|
|
|
-// // 下单指令
|
|
|
-// for item in order_command.limits_open.keys() {
|
|
|
-// let mut ts = trace_stack.clone();
|
|
|
-//
|
|
|
-// let amount = Decimal::from_str(&*order_command.limits_open[item].get(0).unwrap().clone()).unwrap();
|
|
|
-// let side = order_command.limits_open[item].get(1).unwrap().clone();
|
|
|
-// let price = Decimal::from_str(&*order_command.limits_open[item].get(2).unwrap().clone()).unwrap();
|
|
|
-// let cid = order_command.limits_open[item].get(3).unwrap().clone();
|
|
|
-//
|
|
|
-// // order_name: [数量，方向，价格，c_id]
|
|
|
-// let mut self_clone = self.clone();
|
|
|
-// let handle = spawn(async move {
|
|
|
-// // TraceStack::show_delay(&ts.ins);
|
|
|
-// ts.on_before_send();
|
|
|
-// let result = self_clone.take_order(cid.as_str(), side.as_str(), price, amount).await;
|
|
|
-// ts.on_after_send();
|
|
|
-//
|
|
|
-// match result {
|
|
|
-// Ok(mut result) => {
|
|
|
-// result.trace_stack = ts;
|
|
|
-//
|
|
|
-// self_clone.order_sender.send(result).await.unwrap();
|
|
|
-// }
|
|
|
-// Err(error) => {
|
|
|
-// info!(?error);
|
|
|
-// let mut err_order = Order::new();
|
|
|
-// err_order.custom_id = cid.clone();
|
|
|
-// err_order.status = "REMOVE".to_string();
|
|
|
-//
|
|
|
-// self_clone.order_sender.send(err_order).await.unwrap();
|
|
|
-// self_clone.error_sender.send(error).await.unwrap();
|
|
|
-// }
|
|
|
-// }
|
|
|
-// });
|
|
|
-// handles.push(handle)
|
|
|
-// }
|
|
|
-// let futures = FuturesUnordered::from_iter(handles);
|
|
|
-// // 等待所有任务完成
|
|
|
-// let _: Result<Vec<_>, _> = futures.try_collect().await;
|
|
|
-//
|
|
|
-// // 撤销订单
|
|
|
-// let mut cancel_handlers = vec![];
|
|
|
-// for item in order_command.cancel.keys() {
|
|
|
-// let order_id = order_command.cancel[item].get(1).unwrap().clone();
|
|
|
-// let custom_id = order_command.cancel[item].get(0).unwrap().clone();
|
|
|
-//
|
|
|
-// let mut self_clone = self.clone();
|
|
|
-// let handle = spawn(async move {
|
|
|
-// let result = self_clone.cancel_order(&order_id, &custom_id).await;
|
|
|
-// match result {
|
|
|
-// Ok(_) => {
|
|
|
-// // result_sd.send(result).await.unwrap();
|
|
|
-// }
|
|
|
-// Err(error) => {
|
|
|
-// // 取消失败去查订单。
|
|
|
-// let query_rst = self_clone.get_order_detail(&order_id, &custom_id).await;
|
|
|
-// match query_rst {
|
|
|
-// Ok(order) => {
|
|
|
-// self_clone.order_sender.send(order).await.unwrap();
|
|
|
-// }
|
|
|
-// Err(err) => {
|
|
|
-// error!("撤单失败，而且查单也失败了，bitget_swap，oid={}, cid={}, err={:?}。", order_id.clone(), custom_id.clone(), err);
|
|
|
-// }
|
|
|
-// }
|
|
|
-// self_clone.error_sender.send(error).await.unwrap();
|
|
|
-// }
|
|
|
-// }
|
|
|
-// });
|
|
|
-// cancel_handlers.push(handle)
|
|
|
-// }
|
|
|
-// let futures = FuturesUnordered::from_iter(cancel_handlers);
|
|
|
-// // 等待所有任务完成
|
|
|
-// let _: Result<Vec<_>, _> = futures.try_collect().await;
|
|
|
-//
|
|
|
-// // 检查订单指令
|
|
|
-// let mut check_handlers = vec![];
|
|
|
-// for item in order_command.check.keys() {
|
|
|
-// let order_id = order_command.check[item].get(1).unwrap().clone();
|
|
|
-// let custom_id = order_command.check[item].get(0).unwrap().clone();
|
|
|
-//
|
|
|
-// let mut self_clone = self.clone();
|
|
|
-// let handle = spawn(async move {
|
|
|
-// let result = self_clone.get_order_detail(order_id.as_str(), custom_id.as_str()).await;
|
|
|
-// match result {
|
|
|
-// Ok(result) => {
|
|
|
-// self_clone.order_sender.send(result).await.unwrap();
|
|
|
-// }
|
|
|
-// Err(error) => {
|
|
|
-// self_clone.error_sender.send(error).await.unwrap();
|
|
|
-// }
|
|
|
-// }
|
|
|
-// });
|
|
|
-// check_handlers.push(handle)
|
|
|
-// }
|
|
|
-//
|
|
|
-// let futures = FuturesUnordered::from_iter(check_handlers);
|
|
|
-// // 等待所有任务完成
|
|
|
-// let _: Result<Vec<_>, _> = futures.try_collect().await;
|
|
|
-// }
|
|
|
-// }
|
|
|
-//
|
|
|
-// // 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();
|
|
|
-// // let balance = available_balance + frozen_balance;
|
|
|
-// //
|
|
|
-// // Account {
|
|
|
-// // coin: balance_coin,
|
|
|
-// // balance,
|
|
|
-// // available_balance,
|
|
|
-// // frozen_balance,
|
|
|
-// // stocks: Decimal::ZERO,
|
|
|
-// // available_stocks: Decimal::ZERO,
|
|
|
-// // frozen_stocks: Decimal::ZERO,
|
|
|
-// // }
|
|
|
-// // }
|
|
|
-//
|
|
|
-// 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["state"].as_str().unwrap();
|
|
|
-// let base_volume = Decimal::from_str(order["quoteVolume"].as_str().unwrap()).unwrap();
|
|
|
-// let avg_price = if order["priceAvg"].is_null() || order["priceAvg"].as_str().unwrap().is_empty() {
|
|
|
-// Decimal::ZERO
|
|
|
-// } else {
|
|
|
-// Decimal::from_str(order["priceAvg"].as_str().unwrap().to_string().as_str()).unwrap()
|
|
|
-// };
|
|
|
-//
|
|
|
-// let amount = size * ct_val;
|
|
|
-// let deal_amount = base_volume * ct_val;
|
|
|
-// let custom_status = if ["filled", "cancelled"].contains(&status) {
|
|
|
-// "REMOVE".to_string()
|
|
|
-// } else if ["init", "live", "new", "partially_filled"].contains(&status) {
|
|
|
-// "NEW".to_string()
|
|
|
-// } else {
|
|
|
-// "NULL".to_string()
|
|
|
-// };
|
|
|
-// Order {
|
|
|
-// id: order["orderId"].as_str().unwrap().to_string(),
|
|
|
-// custom_id: order["clientOid"].as_str().unwrap().to_string(),
|
|
|
-// price,
|
|
|
-// amount,
|
|
|
-// deal_amount,
|
|
|
-// avg_price,
|
|
|
-// status: custom_status,
|
|
|
-// order_type: order["orderType"].as_str().unwrap().to_string(),
|
|
|
-// trace_stack: TraceStack::new(0, Instant::now()).on_special("700 bitget_swap".to_string()),
|
|
|
+use std::collections::{BTreeMap};
|
|
|
+use exchanges::bitget_swap_rest::BitgetSwapRest;
|
|
|
+use std::io::{Error, ErrorKind};
|
|
|
+use tokio::sync::mpsc::Sender;
|
|
|
+use std::str::FromStr;
|
|
|
+use async_trait::async_trait;
|
|
|
+use futures::stream::FuturesUnordered;
|
|
|
+use futures::TryStreamExt;
|
|
|
+use rust_decimal::{Decimal, MathematicalOps};
|
|
|
+use rust_decimal::prelude::ToPrimitive;
|
|
|
+use rust_decimal_macros::dec;
|
|
|
+use serde_json::{json, Value};
|
|
|
+use tokio::spawn;
|
|
|
+use tokio::time::Instant;
|
|
|
+use tracing::{error, info};
|
|
|
+use global::trace_stack::TraceStack;
|
|
|
+use crate::exchange::ExchangeEnum;
|
|
|
+use crate::{Account, Market, Order, OrderCommand, Platform, Position, PositionModeEnum, Record, Ticker, utils};
|
|
|
+use crate::bybit_swap::format_position_item;
|
|
|
+
|
|
|
+#[allow(dead_code)]
|
|
|
+#[derive(Clone)]
|
|
|
+pub struct BitgetSwap {
|
|
|
+ exchange: ExchangeEnum,
|
|
|
+ symbol: String,
|
|
|
+ is_colo: bool,
|
|
|
+ params: BTreeMap<String, String>,
|
|
|
+ request: BitgetSwapRest,
|
|
|
+ market: Market,
|
|
|
+ order_sender: Sender<Order>,
|
|
|
+ error_sender: Sender<Error>,
|
|
|
+}
|
|
|
+
|
|
|
+impl BitgetSwap {
|
|
|
+ pub async fn new(symbol: String, is_colo: bool, params: BTreeMap<String, String>, order_sender: Sender<Order>, error_sender: Sender<Error>) -> BitgetSwap {
|
|
|
+ let market = Market::new();
|
|
|
+ let mut bitget_swap = BitgetSwap {
|
|
|
+ exchange: ExchangeEnum::BitgetSwap,
|
|
|
+ symbol: symbol.to_uppercase(),
|
|
|
+ is_colo,
|
|
|
+ params: params.clone(),
|
|
|
+ request: BitgetSwapRest::new(is_colo, params.clone()),
|
|
|
+ market,
|
|
|
+ order_sender,
|
|
|
+ error_sender,
|
|
|
+ };
|
|
|
+ bitget_swap.market = BitgetSwap::get_market(&mut bitget_swap).await.unwrap();
|
|
|
+ // 修改持仓模式
|
|
|
+ let mode_result = bitget_swap.set_dual_mode("", false).await;
|
|
|
+ match mode_result {
|
|
|
+ Ok(ok) => {
|
|
|
+ info!("BitgetSwap:设置持仓模式成功！{:?}", ok);
|
|
|
+ }
|
|
|
+ Err(error) => {
|
|
|
+ error!("BitgetSwap:设置持仓模式失败！{:?}", error)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ // 设置持仓杠杆
|
|
|
+ let lever_rate_result = bitget_swap.set_dual_leverage("1").await;
|
|
|
+ match lever_rate_result {
|
|
|
+ Ok(ok) => {
|
|
|
+ info!("BitgetSwap:设置持仓杠杆成功！{:?}", ok);
|
|
|
+ }
|
|
|
+ Err(error) => {
|
|
|
+ error!("BitgetSwap:设置持仓杠杆失败！{:?}", error)
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return bitget_swap;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+#[async_trait]
|
|
|
+impl Platform for BitgetSwap {
|
|
|
+ fn clone_box(&self) -> Box<dyn Platform + Send + Sync> { Box::new(self.clone()) }
|
|
|
+
|
|
|
+ fn get_self_exchange(&self) -> ExchangeEnum { ExchangeEnum::BitgetSwap }
|
|
|
+
|
|
|
+ fn get_self_symbol(&self) -> String { self.symbol.clone() }
|
|
|
+
|
|
|
+ fn get_self_is_colo(&self) -> bool { self.is_colo }
|
|
|
+
|
|
|
+ fn get_self_params(&self) -> BTreeMap<String, String> { self.params.clone() }
|
|
|
+
|
|
|
+ fn get_self_market(&self) -> Market { self.market.clone() }
|
|
|
+
|
|
|
+ fn get_request_delays(&self) -> Vec<i64> {
|
|
|
+ // self.request.get_delays()
|
|
|
+ vec![]
|
|
|
+ }
|
|
|
+
|
|
|
+ fn get_request_avg_delay(&self) -> Decimal {
|
|
|
+ // self.request.get_avg_delay()
|
|
|
+ Decimal::ZERO
|
|
|
+ }
|
|
|
+
|
|
|
+ fn get_request_max_delay(&self) -> i64 { 0 }
|
|
|
+
|
|
|
+ async fn get_server_time(&mut self) -> Result<String, Error> {
|
|
|
+ let res_data = self.request.get_server_time().await;
|
|
|
+ if res_data.code == 200 {
|
|
|
+ let res_data_json = res_data.data;
|
|
|
+ let result = res_data_json["serverTime"].as_str().unwrap().to_string();
|
|
|
+ Ok(result)
|
|
|
+ } else {
|
|
|
+ Err(Error::new(ErrorKind::Other, res_data.to_string()))
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ async fn get_account(&mut self) -> Result<Account, Error> {
|
|
|
+ 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"].as_str().unwrap().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> {
|
|
|
+ Err(Error::new(ErrorKind::NotFound, "bitget_swap get_spot_account：该交易所方法未实现".to_string()))
|
|
|
+ }
|
|
|
+
|
|
|
+ async fn get_position(&mut self) -> Result<Vec<Position>, Error> {
|
|
|
+ let symbol_format = utils::format_symbol(self.symbol.clone(), "");
|
|
|
+ let params = json!({
|
|
|
+ "productType": "USDT-FUTURES",
|
|
|
+ "marginCoin": "USDT",
|
|
|
+ "symbol": symbol_format
|
|
|
+ });
|
|
|
+ let ct_val = self.market.multiplier;
|
|
|
+ println!("{:?}", params.clone());
|
|
|
+ let response = self.request.get_single_position(params).await;
|
|
|
+ println!("{:?}", response);
|
|
|
+ if response.code != 200 {
|
|
|
+ return Err(Error::new(ErrorKind::NotFound, format!("bitget_swap 获取仓位异常{:?}", response).to_string()));
|
|
|
+ }
|
|
|
+
|
|
|
+ // 正常处理持仓信息
|
|
|
+ let mut positions: Vec<Position> = vec![];
|
|
|
+ if response.data.is_null() {
|
|
|
+ return Ok(positions);
|
|
|
+ }
|
|
|
+
|
|
|
+ let positions_json = response.data.as_array().unwrap();
|
|
|
+ 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();
|
|
|
+ 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();
|
|
|
+ let position_mode = match position_json["posMode"].as_str().unwrap() {
|
|
|
+ "hedge_mode" => {
|
|
|
+ match position_json["holdSide"].as_str().unwrap() {
|
|
|
+ "short" => {
|
|
|
+ PositionModeEnum::Short
|
|
|
+ }
|
|
|
+ "long" => {
|
|
|
+ PositionModeEnum::Long
|
|
|
+ }
|
|
|
+ _ => {
|
|
|
+ panic!("bitget_usdt_swap: 未知的持仓模式与持仓方向: {}, {}",
|
|
|
+ position_json["posMode"].as_str().unwrap(), position_json["holdSide"].as_str().unwrap())
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ "one_way_mode" => {
|
|
|
+ PositionModeEnum::Both
|
|
|
+ }
|
|
|
+ _ => {
|
|
|
+ panic!("bitget_usdt_swap: 未知的持仓模式: {}", position_json["posMode"].as_str().unwrap())
|
|
|
+ }
|
|
|
+ };
|
|
|
+ let margin = Decimal::from_str(position_json["marginSize"].as_str().unwrap()).unwrap();
|
|
|
+
|
|
|
+ positions.push(Position {
|
|
|
+ symbol,
|
|
|
+ margin_level,
|
|
|
+ amount,
|
|
|
+ frozen_amount,
|
|
|
+ price,
|
|
|
+ profit,
|
|
|
+ position_mode,
|
|
|
+ margin,
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ Ok(positions)
|
|
|
+ }
|
|
|
+
|
|
|
+ async fn get_positions(&mut self) -> Result<Vec<Position>, Error> {
|
|
|
+ let params = json!({
|
|
|
+ "productType": "USDT-FUTURES",
|
|
|
+ "marginCoin": "USDT"
|
|
|
+ });
|
|
|
+ let response = self.request.get_all_position(params).await;
|
|
|
+ info!(?response);
|
|
|
+
|
|
|
+ if response.code != 200 {
|
|
|
+ return Err(Error::new(ErrorKind::NotFound, format!("bitget_swap 获取仓位异常{:?}", response).to_string()));
|
|
|
+ }
|
|
|
+
|
|
|
+ // 正常处理持仓信息
|
|
|
+ let mut positions: Vec<Position> = vec![];
|
|
|
+ if response.data.is_null() {
|
|
|
+ return Ok(positions);
|
|
|
+ }
|
|
|
+
|
|
|
+ let positions_json = response.data.as_array().unwrap();
|
|
|
+ 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();
|
|
|
+ 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();
|
|
|
+ let position_mode = match position_json["posMode"].as_str().unwrap() {
|
|
|
+ "hedge_mode" => {
|
|
|
+ match position_json["holdSide"].as_str().unwrap() {
|
|
|
+ "short" => {
|
|
|
+ PositionModeEnum::Short
|
|
|
+ }
|
|
|
+ "long" => {
|
|
|
+ PositionModeEnum::Long
|
|
|
+ }
|
|
|
+ _ => {
|
|
|
+ panic!("bitget_usdt_swap: 未知的持仓模式与持仓方向: {}, {}",
|
|
|
+ position_json["posMode"].as_str().unwrap(), position_json["holdSide"].as_str().unwrap())
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ "one_way_mode" => {
|
|
|
+ PositionModeEnum::Both
|
|
|
+ }
|
|
|
+ _ => {
|
|
|
+ panic!("bitget_usdt_swap: 未知的持仓模式: {}", position_json["posMode"].as_str().unwrap())
|
|
|
+ }
|
|
|
+ };
|
|
|
+ let margin = Decimal::from_str(position_json["marginSize"].as_str().unwrap()).unwrap();
|
|
|
+
|
|
|
+ positions.push(Position {
|
|
|
+ symbol,
|
|
|
+ margin_level,
|
|
|
+ amount,
|
|
|
+ frozen_amount,
|
|
|
+ price,
|
|
|
+ profit,
|
|
|
+ position_mode,
|
|
|
+ margin,
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ Ok(positions)
|
|
|
+ }
|
|
|
+
|
|
|
+ async fn get_ticker(&mut self) -> Result<Ticker, Error> {
|
|
|
+ return self.get_ticker_symbol(self.symbol.clone()).await;
|
|
|
+ }
|
|
|
+
|
|
|
+ async fn get_record(&mut self, interval: String) -> Result<Vec<Record>, Error> {
|
|
|
+ let symbol_format = utils::format_symbol(self.symbol.clone(), "");
|
|
|
+
|
|
|
+ let params = json!({
|
|
|
+ "symbol": symbol_format.clone(),
|
|
|
+ "productType": "USDT-FUTURES",
|
|
|
+ "granularity": format!("{}m",interval),
|
|
|
+ "limit": "3"
|
|
|
+ });
|
|
|
+
|
|
|
+ let res_data = self.request.get_market_candles(params).await;
|
|
|
+ if res_data.code == 200 {
|
|
|
+ let mut records: Vec<Record> = vec![];
|
|
|
+ for record_value in res_data.data.as_array().unwrap() {
|
|
|
+ records.push(Record {
|
|
|
+ time: Decimal::from_str(record_value[0].as_str().unwrap()).unwrap(),
|
|
|
+ open: Decimal::from_str(record_value[1].as_str().unwrap()).unwrap(),
|
|
|
+ high: Decimal::from_str(record_value[2].as_str().unwrap()).unwrap(),
|
|
|
+ low: Decimal::from_str(record_value[3].as_str().unwrap()).unwrap(),
|
|
|
+ close: Decimal::from_str(record_value[4].as_str().unwrap()).unwrap(),
|
|
|
+ volume: Decimal::from_str(record_value[5].as_str().unwrap()).unwrap(),
|
|
|
+ symbol: symbol_format.clone(),
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ records.reverse();
|
|
|
+ Ok(records)
|
|
|
+ } else {
|
|
|
+ Err(Error::new(ErrorKind::Other, res_data.to_string()))
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ 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_json = res_data.data;
|
|
|
+ let ticker_info = res_data_json[0].clone();
|
|
|
+ let time = Decimal::from_str(&*ticker_info["ts"].as_str().unwrap()).unwrap() / dec!(1000);
|
|
|
+ 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(),
|
|
|
+ open_interest: Default::default(),
|
|
|
+ };
|
|
|
+ Ok(result)
|
|
|
+ } else {
|
|
|
+ Err(Error::new(ErrorKind::Other, res_data.to_string()))
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ async fn get_market(&mut self) -> Result<Market, Error> {
|
|
|
+ self.get_market_symbol(self.symbol.clone()).await
|
|
|
+ }
|
|
|
+
|
|
|
+ async fn get_market_symbol(&mut self, symbol: String) -> Result<Market, Error> {
|
|
|
+ let symbol_format = utils::format_symbol(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();
|
|
|
+
|
|
|
+ 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 multiplier = Decimal::from_str(&market_info["sizeMultiplier"].as_str().unwrap()).unwrap();
|
|
|
+ let multiplier = 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,
|
|
|
+ multiplier,
|
|
|
+ };
|
|
|
+ Ok(result)
|
|
|
+ } else {
|
|
|
+ Err(Error::new(ErrorKind::Other, response.to_string()))
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ async fn get_order_detail(&mut self, order_id: &str, custom_id: &str) -> Result<Order, Error> {
|
|
|
+ let symbol_format = utils::format_symbol(self.symbol.clone(), "");
|
|
|
+ let params = json!({
|
|
|
+ "symbol": symbol_format,
|
|
|
+ "productType": "USDT-FUTURES",
|
|
|
+ "clientOid": custom_id,
|
|
|
+ "orderId": order_id
|
|
|
+ });
|
|
|
+
|
|
|
+ let multiplier = self.market.multiplier;
|
|
|
+ let response = self.request.get_order(params).await;
|
|
|
+ if response.code == 200 {
|
|
|
+ let res_data_json = response.data;
|
|
|
+ let result = format_order_item(res_data_json, multiplier);
|
|
|
+ Ok(result)
|
|
|
+ } else {
|
|
|
+ Err(Error::new(ErrorKind::Other, response.to_string()))
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ async fn get_orders_list(&mut self, _status: &str) -> Result<Vec<Order>, Error> {
|
|
|
+ Err(Error::new(ErrorKind::NotFound, "bitget_swap get_orders_list：该交易所方法未实现".to_string()))
|
|
|
+ // let symbol_format = utils::format_symbol(self.symbol.clone(), "");
|
|
|
+ // let multiplier = self.market.multiplier;
|
|
|
+ // let res_data = self.request.get_unfilled_orders(symbol_format.to_string(), "".to_string(), "".to_string(), "".to_string(), "100".to_string(), "".to_string()).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_order_item(item.clone(), multiplier)).collect();
|
|
|
+ // Ok(result)
|
|
|
+ // } else {
|
|
|
+ // Err(Error::new(ErrorKind::Other, res_data.to_string()))
|
|
|
+ // }
|
|
|
+ }
|
|
|
+
|
|
|
+ async fn take_order(&mut self, custom_id: &str, origin_side: &str, price: Decimal, amount: Decimal) -> Result<Order, Error> {
|
|
|
+ let multiplier = self.market.multiplier;
|
|
|
+
|
|
|
+ return self.take_order_symbol(self.symbol.clone(), multiplier, custom_id, origin_side, price, amount).await;
|
|
|
+ }
|
|
|
+
|
|
|
+ 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()
|
|
|
+ });
|
|
|
+ if price.eq(&Decimal::ZERO) {
|
|
|
+ params["orderType"] = json!("market");
|
|
|
+ params["force"] = json!("gtc");
|
|
|
+ } else {
|
|
|
+ params["price"] = json!(price.to_string());
|
|
|
+ params["orderType"] = json!("limit");
|
|
|
+ params["force"] = json!("gtc");
|
|
|
+ };
|
|
|
+ match origin_side {
|
|
|
+ "kd" => {
|
|
|
+ params["side"] = json!("buy");
|
|
|
+ params["reduceOnly"] = json!("NO");
|
|
|
+ }
|
|
|
+ "pd" => {
|
|
|
+ params["side"] = json!("sell");
|
|
|
+ params["reduceOnly"] = json!("YES");
|
|
|
+ }
|
|
|
+ "kk" => {
|
|
|
+ params["side"] = json!("sell");
|
|
|
+ params["reduceOnly"] = json!("NO");
|
|
|
+ }
|
|
|
+ "pk" => {
|
|
|
+ params["side"] = json!("buy");
|
|
|
+ params["reduceOnly"] = json!("YES");
|
|
|
+ }
|
|
|
+ _ => { panic!("bitget_usdt_swap 下单参数错误"); }
|
|
|
+ };
|
|
|
+ let res_data = self.request.swap_order(params).await;
|
|
|
+ if res_data.code != 200 {
|
|
|
+ return Err(Error::new(ErrorKind::Other, res_data.to_string()));
|
|
|
+ }
|
|
|
+
|
|
|
+ let res_data_json = res_data.data;
|
|
|
+ let result = Order {
|
|
|
+ id: res_data_json["orderId"].as_str().unwrap().to_string(),
|
|
|
+ custom_id: res_data_json["clientOid"].as_str().unwrap().to_string(),
|
|
|
+ price: Decimal::ZERO,
|
|
|
+ amount: Decimal::ZERO,
|
|
|
+ deal_amount: Decimal::ZERO,
|
|
|
+ avg_price: Decimal::ZERO,
|
|
|
+ status: "NEW".to_string(),
|
|
|
+ order_type: "".to_string(),
|
|
|
+ trace_stack: TraceStack::new(0, Instant::now()).on_special("328 bitget_swap".to_string()),
|
|
|
+ };
|
|
|
+ return Ok(result);
|
|
|
+ }
|
|
|
+
|
|
|
+ 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 params = json!({
|
|
|
+ "symbol": symbol_format,
|
|
|
+ "productType": "USDT-FUTURES",
|
|
|
+ "clientOid": custom_id,
|
|
|
+ "orderId": order_id
|
|
|
+ });
|
|
|
+ let response = self.request.cancel_order(params).await;
|
|
|
+
|
|
|
+ // 取消失败，进行报错
|
|
|
+ if response.code != 200 {
|
|
|
+ return Err(Error::new(ErrorKind::NotFound, response.to_string()));
|
|
|
+ }
|
|
|
+
|
|
|
+ let res_data_json = response.data;
|
|
|
+ let result = Order {
|
|
|
+ id: res_data_json["orderId"].as_str().unwrap().to_string(),
|
|
|
+ custom_id: 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("443 bitget_swap".to_string()),
|
|
|
+ };
|
|
|
+ Ok(result)
|
|
|
+ }
|
|
|
+
|
|
|
+ async fn cancel_orders(&mut self) -> Result<Vec<Order>, Error> {
|
|
|
+ Err(Error::new(ErrorKind::NotFound, "bitget_swap cancel_orders：该交易所方法未实现".to_string()))
|
|
|
+ }
|
|
|
+
|
|
|
+ async fn cancel_orders_all(&mut self) -> Result<Vec<Order>, Error> {
|
|
|
+ let response = self.request.get_pending_orders().await;
|
|
|
+ if response.code == 200 {
|
|
|
+ info!("{}", response.data.to_string());
|
|
|
+ let mut result = vec![];
|
|
|
+
|
|
|
+ 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 symbol = order["symbol"].as_str().unwrap().to_string();
|
|
|
+ let order_id = order["orderId"].as_str().unwrap().to_string();
|
|
|
+ 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 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 cancel_stop_loss_order：该交易所方法未实现".to_string()))
|
|
|
+ }
|
|
|
+
|
|
|
+ async fn set_dual_mode(&mut self, _coin: &str, is_dual_mode: bool) -> Result<String, Error> {
|
|
|
+ let pos_mode = if is_dual_mode {
|
|
|
+ "hedge_mode"
|
|
|
+ } else {
|
|
|
+ "one_way_mode"
|
|
|
+ };
|
|
|
+ let params = json!({
|
|
|
+ "productType": "USDT-FUTURES",
|
|
|
+ "posMode": pos_mode,
|
|
|
+ });
|
|
|
+ let response = self.request.set_position_mode(params).await;
|
|
|
+
|
|
|
+ if response.code != 200 {
|
|
|
+ return Err(Error::new(ErrorKind::Other, format!("设置持仓模式失败:{:?}", response).to_string()));
|
|
|
+ }
|
|
|
+
|
|
|
+ return Ok(response.data.to_string());
|
|
|
+ }
|
|
|
+
|
|
|
+ async fn set_dual_leverage(&mut self, leverage: &str) -> Result<String, Error> {
|
|
|
+ let symbol_format = utils::format_symbol(self.symbol.clone(), "");
|
|
|
+ let params = json!({
|
|
|
+ "symbol": symbol_format,
|
|
|
+ "productType": "USDT-FUTURES",
|
|
|
+ "marginCoin": "USDT",
|
|
|
+ "leverage": leverage
|
|
|
+ });
|
|
|
+ let response = self.request.set_leverage(params).await;
|
|
|
+
|
|
|
+ if response.code != 200 {
|
|
|
+ return Err(Error::new(ErrorKind::Other, format!("设置杠杆失败:{:?}", response).to_string()));
|
|
|
+ }
|
|
|
+
|
|
|
+ return Ok(response.data.to_string());
|
|
|
+ }
|
|
|
+
|
|
|
+ async fn set_auto_deposit_status(&mut self, _status: bool) -> Result<String, Error> {
|
|
|
+ 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 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 {
|
|
|
+ // let res_data_str = &res_data.data;
|
|
|
+ // let result = res_data_str.clone();
|
|
|
+ // Ok(result)
|
|
|
+ // } else {
|
|
|
+ // Err(Error::new(ErrorKind::Other, res_data.to_string()))
|
|
|
+ // }
|
|
|
+ }
|
|
|
+
|
|
|
+ async fn command_order(&mut self, order_command: &mut OrderCommand, trace_stack: &TraceStack) {
|
|
|
+ let mut handles = vec![];
|
|
|
+
|
|
|
+ // 下单指令
|
|
|
+ for item in order_command.limits_open.keys() {
|
|
|
+ let mut ts = trace_stack.clone();
|
|
|
+
|
|
|
+ let amount = Decimal::from_str(&*order_command.limits_open[item].get(0).unwrap().clone()).unwrap();
|
|
|
+ let side = order_command.limits_open[item].get(1).unwrap().clone();
|
|
|
+ let price = Decimal::from_str(&*order_command.limits_open[item].get(2).unwrap().clone()).unwrap();
|
|
|
+ let cid = order_command.limits_open[item].get(3).unwrap().clone();
|
|
|
+
|
|
|
+ // order_name: [数量，方向，价格，c_id]
|
|
|
+ let mut self_clone = self.clone();
|
|
|
+ let handle = spawn(async move {
|
|
|
+ // TraceStack::show_delay(&ts.ins);
|
|
|
+ ts.on_before_send();
|
|
|
+ let result = self_clone.take_order(cid.as_str(), side.as_str(), price, amount).await;
|
|
|
+ ts.on_after_send();
|
|
|
+
|
|
|
+ match result {
|
|
|
+ Ok(mut result) => {
|
|
|
+ result.trace_stack = ts;
|
|
|
+
|
|
|
+ self_clone.order_sender.send(result).await.unwrap();
|
|
|
+ }
|
|
|
+ Err(error) => {
|
|
|
+ info!(?error);
|
|
|
+ let mut err_order = Order::new();
|
|
|
+ err_order.custom_id = cid.clone();
|
|
|
+ err_order.status = "REMOVE".to_string();
|
|
|
+
|
|
|
+ self_clone.order_sender.send(err_order).await.unwrap();
|
|
|
+ self_clone.error_sender.send(error).await.unwrap();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ });
|
|
|
+ handles.push(handle)
|
|
|
+ }
|
|
|
+ let futures = FuturesUnordered::from_iter(handles);
|
|
|
+ // 等待所有任务完成
|
|
|
+ let _: Result<Vec<_>, _> = futures.try_collect().await;
|
|
|
+
|
|
|
+ // 撤销订单
|
|
|
+ let mut cancel_handlers = vec![];
|
|
|
+ for item in order_command.cancel.keys() {
|
|
|
+ let order_id = order_command.cancel[item].get(1).unwrap().clone();
|
|
|
+ let custom_id = order_command.cancel[item].get(0).unwrap().clone();
|
|
|
+
|
|
|
+ let mut self_clone = self.clone();
|
|
|
+ let handle = spawn(async move {
|
|
|
+ let result = self_clone.cancel_order(&order_id, &custom_id).await;
|
|
|
+ match result {
|
|
|
+ Ok(_) => {
|
|
|
+ // result_sd.send(result).await.unwrap();
|
|
|
+ }
|
|
|
+ Err(error) => {
|
|
|
+ // 取消失败去查订单。
|
|
|
+ let query_rst = self_clone.get_order_detail(&order_id, &custom_id).await;
|
|
|
+ match query_rst {
|
|
|
+ Ok(order) => {
|
|
|
+ self_clone.order_sender.send(order).await.unwrap();
|
|
|
+ }
|
|
|
+ Err(err) => {
|
|
|
+ error!("撤单失败，而且查单也失败了，bitget_swap，oid={}, cid={}, err={:?}。", order_id.clone(), custom_id.clone(), err);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ self_clone.error_sender.send(error).await.unwrap();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ });
|
|
|
+ cancel_handlers.push(handle)
|
|
|
+ }
|
|
|
+ let futures = FuturesUnordered::from_iter(cancel_handlers);
|
|
|
+ // 等待所有任务完成
|
|
|
+ let _: Result<Vec<_>, _> = futures.try_collect().await;
|
|
|
+
|
|
|
+ // 检查订单指令
|
|
|
+ let mut check_handlers = vec![];
|
|
|
+ for item in order_command.check.keys() {
|
|
|
+ let order_id = order_command.check[item].get(1).unwrap().clone();
|
|
|
+ let custom_id = order_command.check[item].get(0).unwrap().clone();
|
|
|
+
|
|
|
+ let mut self_clone = self.clone();
|
|
|
+ let handle = spawn(async move {
|
|
|
+ let result = self_clone.get_order_detail(order_id.as_str(), custom_id.as_str()).await;
|
|
|
+ match result {
|
|
|
+ Ok(result) => {
|
|
|
+ self_clone.order_sender.send(result).await.unwrap();
|
|
|
+ }
|
|
|
+ Err(error) => {
|
|
|
+ self_clone.error_sender.send(error).await.unwrap();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ });
|
|
|
+ check_handlers.push(handle)
|
|
|
+ }
|
|
|
+
|
|
|
+ let futures = FuturesUnordered::from_iter(check_handlers);
|
|
|
+ // 等待所有任务完成
|
|
|
+ let _: Result<Vec<_>, _> = futures.try_collect().await;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// 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();
|
|
|
+// let balance = available_balance + frozen_balance;
|
|
|
+//
|
|
|
+// Account {
|
|
|
+// coin: balance_coin,
|
|
|
+// balance,
|
|
|
+// available_balance,
|
|
|
+// frozen_balance,
|
|
|
+// stocks: Decimal::ZERO,
|
|
|
+// available_stocks: Decimal::ZERO,
|
|
|
+// frozen_stocks: Decimal::ZERO,
|
|
|
// }
|
|
|
// }
|
|
|
+
|
|
|
+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();
|
|
|
+ let base_volume = Decimal::from_str(order["quoteVolume"].as_str().unwrap()).unwrap();
|
|
|
+ let avg_price = if order["priceAvg"].is_null() || order["priceAvg"].as_str().unwrap().is_empty() {
|
|
|
+ Decimal::ZERO
|
|
|
+ } else {
|
|
|
+ Decimal::from_str(order["priceAvg"].as_str().unwrap().to_string().as_str()).unwrap()
|
|
|
+ };
|
|
|
+
|
|
|
+ let amount = size * multiplier;
|
|
|
+ let deal_amount = base_volume * multiplier;
|
|
|
+ let custom_status = if ["filled", "canceled"].contains(&status) {
|
|
|
+ "REMOVE".to_string()
|
|
|
+ } else if ["init", "live", "new", "partially_filled"].contains(&status) {
|
|
|
+ "NEW".to_string()
|
|
|
+ } else {
|
|
|
+ "NULL".to_string()
|
|
|
+ };
|
|
|
+ Order {
|
|
|
+ id: order["orderId"].as_str().unwrap().to_string(),
|
|
|
+ custom_id: order["clientOid"].as_str().unwrap().to_string(),
|
|
|
+ price,
|
|
|
+ amount,
|
|
|
+ deal_amount,
|
|
|
+ avg_price,
|
|
|
+ status: custom_status,
|
|
|
+ order_type: order["orderType"].as_str().unwrap().to_string(),
|
|
|
+ trace_stack: TraceStack::new(0, Instant::now()).on_special("700 bitget_swap".to_string()),
|
|
|
+ }
|
|
|
+}
|
gepangpang