添加获取自定义币对行情

添加获取自定义币对市场信息

standard/src/binance_spot.rs

@@ -77,10 +77,14 @@ impl Platform for BinanceSpot {
         todo!()
     }
 
+    async fn get_ticker_symbol(&mut self, _symbol: String) -> Result<Ticker, Error> { todo!() }
+
     async fn get_market(&mut self) -> Result<Market, Error> {
         todo!()
     }
 
+    async fn get_market_symbol(&mut self, _symbol: String) -> Result<Market, Error> { todo!() }
+
     async fn get_order_detail(&mut self, _order_id: &str, _custom_id: &str) -> Result<Order, Error> { todo!() }
 
     async fn get_orders_list(&mut self, _status: &str) -> Result<Vec<Order>, Error> {
@@ -89,7 +93,7 @@ impl Platform for BinanceSpot {
 
     async fn take_order(&mut self, _custom_id: &str, _origin_side: &str, _price: Decimal, _amount: Decimal) -> Result<Order, Error> { todo!() }
 
-    async fn take_order_symbol(&mut self, _symbol: String, _custom_id: &str, _origin_side: &str, _price: Decimal, _amount: Decimal) -> Result<Order, Error> { todo!()}
+    async fn take_order_symbol(&mut self, _symbol: String, _custom_id: &str, _origin_side: &str, _price: Decimal, _amount: Decimal) -> Result<Order, Error> { todo!() }
 
     async fn cancel_order(&mut self, _order_id: &str, _custom_id: &str) -> Result<Order, Error> { todo!() }
 

standard/src/binance_swap.rs

@@ -164,6 +164,27 @@ impl Platform for BinanceSwap {
         }
     }
 
+    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_book_ticker(symbol_format).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 = Ticker {
+                time: res_data_json["time"].as_i64().unwrap(),
+                high: Decimal::from_str(res_data_json["askPrice"].as_str().unwrap()).unwrap(),
+                low: Decimal::from_str(res_data_json["bidPrice"].as_str().unwrap()).unwrap(),
+                sell: Decimal::from_str(res_data_json["askPrice"].as_str().unwrap()).unwrap(),
+                buy: Decimal::from_str(res_data_json["bidPrice"].as_str().unwrap()).unwrap(),
+                last: dec!(-1),
+                volume: dec!(-1),
+            };
+            Ok(result)
+        } else {
+            Err(Error::new(ErrorKind::Other, res_data.to_string()))
+        }
+    }
+
     async fn get_market(&mut self) -> Result<Market, Error> {
         let symbol_format = utils::format_symbol(self.symbol.clone(), "");
         let res_data = self.request.get_exchange_info().await;
@@ -207,6 +228,49 @@ impl Platform for BinanceSwap {
         }
     }
 
+    async fn get_market_symbol(&mut self, symbol: String) -> Result<Market, Error> {
+        let symbol_format = utils::format_symbol(symbol.clone(), "");
+        let res_data = self.request.get_exchange_info().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 symbols: Vec<serde_json::Value> = res_data_json["symbols"].as_array().unwrap().clone();
+            let market_info = symbols.iter().find(|&item| item["symbol"].as_str().unwrap() == symbol_format);
+            match market_info {
+                None => {
+                    error!("Binance：获取Market信息错误!\nget_market:res_data={:?}", res_data_str);
+                    panic!("Binance：获取Market信息错误!\nget_market:res_data={:?}", res_data_str)
+                }
+                Some(value) => {
+                    let base_asset = value["baseAsset"].as_str().unwrap_or("").to_string();
+                    let quote_asset = value["quoteAsset"].as_str().unwrap_or("").to_string();
+
+                    let filter_array = value["filters"].as_array().unwrap().clone();
+                    let price_filter = filter_array.iter().find(|&item| item["filterType"].as_str().unwrap() == "PRICE_FILTER").unwrap();
+                    let lot_size_filter = filter_array.iter().find(|&item| item["filterType"].as_str().unwrap() == "LOT_SIZE").unwrap();
+
+                    let result = Market {
+                        symbol: format!("{}_{}", base_asset, quote_asset),
+                        base_asset,
+                        quote_asset,
+                        tick_size: Decimal::from_str(&price_filter["tickSize"].as_str().unwrap()).unwrap(),
+                        amount_size: dec!(1),
+                        price_precision: Decimal::from_str(&value["pricePrecision"].to_string()).unwrap(),
+                        amount_precision: Decimal::from_str(&value["quantityPrecision"].to_string()).unwrap(),
+                        min_qty: Decimal::from_str(lot_size_filter["minQty"].as_str().unwrap()).unwrap(),
+                        max_qty: Decimal::from_str(lot_size_filter["maxQty"].as_str().unwrap()).unwrap(),
+                        min_notional: Decimal::from_str(price_filter["minPrice"].as_str().unwrap()).unwrap(),
+                        max_notional: Decimal::from_str(price_filter["maxPrice"].as_str().unwrap()).unwrap(),
+                        ct_val: Default::default(),
+                    };
+                    Ok(result)
+                }
+            }
+        } else {
+            Err(Error::new(ErrorKind::Other, res_data.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 res_data = self.request.get_order(symbol_format, order_id.parse().unwrap_or(-1), custom_id.to_string()).await;

standard/src/gate_spot.rs

@@ -77,10 +77,14 @@ impl Platform for GateSpot {
         todo!()
     }
 
+    async fn get_ticker_symbol(&mut self, _symbol: String) -> Result<Ticker, Error> { todo!() }
+
     async fn get_market(&mut self) -> Result<Market, Error> {
         todo!()
     }
 
+    async fn get_market_symbol(&mut self, _symbol: String) -> Result<Market, Error> { todo!() }
+
     async fn get_order_detail(&mut self, _order_id: &str, _custom_id: &str) -> Result<Order, Error> { todo!() }
 
     async fn get_orders_list(&mut self, _status: &str) -> Result<Vec<Order>, Error> {

standard/src/gate_swap.rs

@@ -179,6 +179,36 @@ impl Platform for GateSwap {
         }
     }
 
+    async fn get_ticker_symbol(&mut self, symbol: String) -> Result<Ticker, Error> {
+        let symbol_array: Vec<&str> = symbol.split("_").collect();
+        let res_data = self.request.get_ticker(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 ticker_info = res_data_json.iter().find(|item| item["contract"].as_str().unwrap() == symbol);
+            match ticker_info {
+                None => {
+                    error!("Gate：获取Ticker信息错误!\nget_ticker:res_data={:?}", res_data_str);
+                    panic!("Gate：获取Ticker信息错误!\nget_ticker:res_data={:?}", res_data_str)
+                }
+                Some(value) => {
+                    let result = Ticker {
+                        time: chrono::Utc::now().timestamp_millis(),
+                        high: Decimal::from_str(value["high_24h"].as_str().unwrap()).unwrap(),
+                        low: Decimal::from_str(value["low_24h"].as_str().unwrap()).unwrap(),
+                        sell: Decimal::from_str(value["lowest_ask"].as_str().unwrap()).unwrap(),
+                        buy: Decimal::from_str(value["highest_bid"].as_str().unwrap()).unwrap(),
+                        last: Decimal::from_str(value["last"].as_str().unwrap()).unwrap(),
+                        volume: Decimal::from_str(value["volume_24h"].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> {
         let symbol_array: Vec<&str> = self.symbol.split("_").collect();
         let res_data = self.request.get_market_details(symbol_array[1].to_string().to_lowercase()).await;
@@ -220,6 +250,49 @@ impl Platform for GateSwap {
             Err(Error::new(ErrorKind::Other, res_data.to_string()))
         }
     }
+
+    async fn get_market_symbol(&mut self, symbol: String) -> Result<Market, Error> {
+        let symbol_array: Vec<&str> = symbol.split("_").collect();
+        let res_data = self.request.get_market_details(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 market_info = res_data_json.iter().find(|item| item["name"].as_str().unwrap() == symbol);
+            match market_info {
+                None => {
+                    error!("Gate：获取Market信息错误!\nget_market:market_info={:?}", market_info);
+                    panic!("Gate：获取Market信息错误!\nget_market:market_info={:?}", market_info)
+                }
+                Some(value) => {
+                    let name = value["name"].as_str().unwrap();
+                    let name_array: Vec<&str> = name.split("_").collect();
+                    let tick_size = Decimal::from_str(value["order_price_round"].as_str().unwrap()).unwrap();
+                    let amount_size = Decimal::from_str(value["quanto_multiplier"].as_str().unwrap()).unwrap();
+                    let price_precision = Decimal::from_u32(tick_size.scale()).unwrap();
+                    let amount_precision = Decimal::from_u32(amount_size.scale()).unwrap();
+
+                    let result = Market {
+                        symbol: name.to_string(),
+                        base_asset: name_array[0].to_string(),
+                        quote_asset: name_array[1].to_string(),
+                        tick_size,
+                        amount_size,
+                        price_precision,
+                        amount_precision,
+                        min_qty: Decimal::from_str(&value["order_size_min"].to_string()).unwrap(),
+                        max_qty: Decimal::from_str(&value["order_size_max"].to_string()).unwrap(),
+                        min_notional: Default::default(),
+                        max_notional: Default::default(),
+                        ct_val: Default::default(),
+                    };
+                    Ok(result)
+                }
+            }
+        } else {
+            Err(Error::new(ErrorKind::Other, res_data.to_string()))
+        }
+    }
+
     // 获取订单详情
     async fn get_order_detail(&mut self, order_id: &str, custom_id: &str) -> Result<Order, Error> {
         let symbol_array: Vec<&str> = self.symbol.split("_").collect();

standard/src/kucoin_swap.rs

@@ -163,6 +163,29 @@ impl Platform for KucoinSwap {
         }
     }
 
+    async fn get_ticker_symbol(&mut self, symbol: String) -> Result<Ticker, Error> {
+        let symbol_format = format!("{}M", utils::format_symbol(symbol.clone(), ""));
+        let res_data = self.request.get_ticker(symbol_format).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 ticker_info = res_data_json;
+            let time = (Decimal::from_str(&*ticker_info["ts"].to_string()).unwrap() / dec!(1000000)).floor().to_i64().unwrap();
+            let result = Ticker {
+                time,
+                high: Decimal::from_str(&ticker_info["bestAskPrice"].to_string()).unwrap(),
+                low: Decimal::from_str(&ticker_info["bestBidPrice"].to_string()).unwrap(),
+                sell: Decimal::from_str(&ticker_info["bestAskPrice"].to_string()).unwrap(),
+                buy: Decimal::from_str(&ticker_info["bestBidPrice"].to_string()).unwrap(),
+                last: Decimal::from_str(&ticker_info["price"].to_string()).unwrap(),
+                volume: Decimal::from_str(&ticker_info["size"].to_string()).unwrap(),
+            };
+            Ok(result)
+        } else {
+            Err(Error::new(ErrorKind::Other, res_data.to_string()))
+        }
+    }
+
     async fn get_market(&mut self) -> Result<Market, Error> {
         let symbol_format = format!("{}M", utils::format_symbol(self.symbol.clone(), ""));
         let res_data = self.request.get_market_details().await;
@@ -208,6 +231,51 @@ impl Platform for KucoinSwap {
         }
     }
 
+    async fn get_market_symbol(&mut self, symbol: String) -> Result<Market, Error> {
+        let symbol_format = format!("{}M", utils::format_symbol(symbol.clone(), ""));
+        let res_data = self.request.get_market_details().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 market_info = res_data_json.iter().find(|item| item["symbol"].as_str().unwrap() == symbol_format);
+            match market_info {
+                None => {
+                    error!("Kucoin：获取Market信息错误!\nget_market:res_data={:?}", res_data_str);
+                    panic!("Kucoin：获取Market信息错误!\nget_market:res_data={:?}", res_data_str)
+                }
+                Some(value) => {
+                    let base_asset = value["baseCurrency"].as_str().unwrap_or("").to_string();
+                    let quote_asset = value["quoteCurrency"].as_str().unwrap_or("").to_string();
+                    let tick_size = Decimal::from_str(&value["tickSize"].to_string()).unwrap();
+                    let amount_size = Decimal::from_str(&value["multiplier"].to_string()).unwrap();
+                    let min_qty = Decimal::from_str(&value["lotSize"].to_string()).unwrap();
+
+                    let price_precision = Decimal::from_u32(tick_size.scale()).unwrap();
+                    let amount_precision = Decimal::from_u32(amount_size.scale()).unwrap();
+                    let min_notional = min_qty * amount_size;
+
+                    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: Decimal::from_str(&value["maxOrderQty"].to_string()).unwrap(),
+                        min_notional,
+                        max_notional: Decimal::from_str(&value["maxPrice"].to_string()).unwrap(),
+                        ct_val: Default::default(),
+                    };
+                    Ok(result)
+                }
+            }
+        } else {
+            Err(Error::new(ErrorKind::Other, res_data.to_string()))
+        }
+    }
+
     async fn get_order_detail(&mut self, order_id: &str, custom_id: &str) -> Result<Order, Error> {
         let amount_size = self.market.amount_size;
         let res_data = self.request.get_orders_details(order_id.to_string(), custom_id.to_string()).await;

standard/src/lib.rs

@@ -508,8 +508,12 @@ pub trait Platform {
     async fn get_positions(&mut self) -> Result<Vec<Position>, Error>;
     // 获取市场行情
     async fn get_ticker(&mut self) -> Result<Ticker, Error>;
-    // 查询所有的合约信息
+    // 获取市场行情自定义交易对
+    async fn get_ticker_symbol(&mut self, symbol: String) -> Result<Ticker, Error>;
+    // 查询所有的市场信息
     async fn get_market(&mut self) -> Result<Market, Error>;
+    // 查询所有的市场信息自定义交易对
+    async fn get_market_symbol(&mut self, symbol: String) -> Result<Market, Error>;
     // 查询订单详情
     async fn get_order_detail(&mut self, order_id: &str, custom_id: &str) -> Result<Order, Error>;
     // 获取订单列表