rest的基本接口接通了。

Cargo.toml

@@ -77,6 +77,10 @@ backtrace = "0.3.74"
 prost = "0.11"
 hex = "0.4.3"
 
+##代替f64避免精度丢失
+rust_decimal = "1.32.0"
+rust_decimal_macros = "1.32.0"
+
 # =======================================================
 # 以下是一些在开发过程中可能会用到的devDependencies，只用于开发和测试，不包含在最终发布版本中
 [dev-dependencies]

src/exchange/mexc_spot_client.rs

@@ -0,0 +1,302 @@
+use std::collections::BTreeMap;
+use chrono::Utc;
+use reqwest::header::HeaderMap;
+use reqwest::{Client};
+use rust_decimal::Decimal;
+use rust_decimal::prelude::FromPrimitive;
+use rust_decimal_macros::dec;
+use tracing::{error, info, trace};
+use ring::hmac;
+use serde_json::Value;
+use crate::exchange::response_base::Response;
+use crate::utils::rest_utils::RestUtils;
+
+#[derive(Clone, Debug)]
+pub struct MexcSpotClient {
+    pub tag: String,
+    base_url: String,
+    client: Client,
+    login_param: Option<BTreeMap<String, String>>,
+    delays: Vec<i64>,
+    max_delay: i64,
+    avg_delay: Decimal,
+}
+
+impl MexcSpotClient {
+    // 构造函数
+    pub fn new_with_tag(tag: String, login_param: Option<BTreeMap<String, String>>) -> MexcSpotClient {
+        let base_url = "https://api.mexc.com".to_string();
+
+        MexcSpotClient {
+            tag,
+            base_url,
+            client: Client::new(),
+            login_param,
+            delays: vec![],
+            max_delay: 0,
+            avg_delay: dec!(0.0),
+        }
+    }
+
+    // ping
+    pub async fn ping(&mut self) -> Response {
+        let data = self.request("GET".to_string(),
+                                "/api/v3".to_string(),
+                                "/ping".to_string(),
+                                false,
+                                Value::Null,
+        ).await;
+
+        data
+    }
+
+    // time
+    pub async fn time(&mut self) -> Response {
+        let data = self.request("GET".to_string(),
+                                "/api/v3".to_string(),
+                                "/time".to_string(),
+                                false,
+                                Value::Null,
+        ).await;
+
+        data
+    }
+
+    // 一些工具函数
+    pub fn get_delays(&self) -> Vec<i64> {
+        self.delays.clone()
+    }
+    pub fn get_avg_delay(&self) -> Decimal {
+        self.avg_delay.clone()
+    }
+    pub fn get_max_delay(&self) -> i64 {
+        self.max_delay.clone()
+    }
+    fn get_delay_info(&mut self) {
+        let last_100 = if self.delays.len() > 100 {
+            self.delays[self.delays.len() - 100..].to_vec()
+        } else {
+            self.delays.clone()
+        };
+
+        let max_value = last_100.iter().max().unwrap();
+        if max_value.clone().to_owned() > self.max_delay {
+            self.max_delay = max_value.clone().to_owned();
+        }
+
+        let sum: i64 = last_100.iter().sum();
+        let sum_v = Decimal::from_i64(sum).unwrap();
+        let len_v = Decimal::from_u64(last_100.len() as u64).unwrap();
+        self.avg_delay = (sum_v / len_v).round_dp(1);
+        self.delays = last_100.clone().into_iter().collect();
+    }
+
+    //调用请求
+    pub async fn request(&mut self,
+                         method: String,
+                         prefix_url: String,
+                         request_url: String,
+                         is_login: bool,
+                         mut params: Value) -> Response
+    {
+        // trace!("login_param:{:?}", self.login_param);
+        //解析账号信息
+        let mut access_key = "".to_string();
+        let mut secret_key = "".to_string();
+        let mut passphrase = "".to_string();
+        let mut is_login_param = false; // 默认未成功解析
+
+        // 通过模式匹配引用来避免所有权移动
+        // 如果 login_param 是 Some，并且能成功获取所有 key，则设置 is_login_param 为 true
+        if let Some(login_param_map) = &self.login_param {
+            // 使用 get 方法安全地获取 key 对应的引用
+            if let Some(ak) = login_param_map.get("access_key") {
+                access_key = ak.clone(); // 克隆字符串
+            }
+            if let Some(sk) = login_param_map.get("secret_key") {
+                secret_key = sk.clone(); // 克隆字符串
+            }
+            if let Some(pph) = login_param_map.get("pass_key") { // 注意：这里假设您想检查 "passphrase"，而不是 "pass_key"
+                passphrase = pph.clone(); // 克隆字符串
+            }
+
+            // 检查是否所有 key 都成功获取并非空
+            if !access_key.is_empty() && !secret_key.is_empty() && !passphrase.is_empty() {
+                is_login_param = true;
+            }
+        }
+
+        //每个接口都有的参数
+        let timestamp = Utc::now().timestamp_millis();
+        let recv_window = 3000;
+        params["timestamp"] = serde_json::json!(timestamp);
+        params["recvWindow"] = serde_json::json!(recv_window);
+
+
+        //请求类型不同，可能请求头body 不同
+        let mut body = "{}".to_string();
+        let mut headers = HeaderMap::new();
+        if method == "POST" {
+            headers.insert("Content-Type", "application/json".parse().unwrap());
+            body = params.to_string();
+        }
+
+        //是否需要登录-- 组装sing
+        if is_login {
+            if !is_login_param {
+                let e = Response::error(self.tag.clone(), "登录参数错误！".to_string());
+                return e;
+            } else {
+                // //需要登录-且登录参数齐全
+                // trace!("param:{}", params);
+                // trace!("body:{}", body);
+                // //组装sing
+                // let sing = Self::sign(secret_key.clone(),
+                //                       method.clone(),
+                //                       prefix_url.clone(),
+                //                       request_url.clone(),
+                //                       params.clone(),
+                //                       body.clone(),
+                //                       timestamp.clone(),
+                // );
+                // //组装header
+                // headers.extend(Self::headers(sing, timestamp, passphrase, access_key));
+            }
+        }
+
+        let start_time = chrono::Utc::now().timestamp_millis();
+        let response = self.http_tool(
+            format!("{}{}", prefix_url.clone(), request_url.clone()),
+            method.to_string(),
+            params.to_string(),
+            body,
+            headers,
+        ).await;
+
+        let time_array = chrono::Utc::now().timestamp_millis() - start_time;
+        self.delays.push(time_array);
+        self.get_delay_info();
+
+        response
+    }
+
+    pub fn sign(secret_key: String,
+                method: String, prefix_url: String, request_url: String,
+                params: String, body: String, timestamp: String) -> String
+    {
+        /*签名生成*/
+        let url_param_str = RestUtils::parse_params_to_str(params);
+        let base_url = if method == "GET" {
+            format!("{}{}?{}", prefix_url, request_url, url_param_str)
+        } else {
+            format!("{}{}", prefix_url, request_url)
+        };
+
+        // 时间戳 + 请求类型+ 请求参数字符串
+        let message = format!("{}{}{}{}", timestamp, method, base_url, body);
+        trace!("message:{}",message);
+
+        // 做签名
+        let hmac_key = ring::hmac::Key::new(hmac::HMAC_SHA256, secret_key.as_bytes());
+        let result = ring::hmac::sign(&hmac_key, &message.as_bytes());
+        let sign = base64::encode(result);
+        sign
+    }
+
+    async fn http_tool(&mut self, request_path: String,
+                       request_type: String,
+                       params: String,
+                       body: String,
+                       headers: HeaderMap) -> Response {
+        let url = format!("{}{}", self.base_url.to_string(), request_path);
+        let request_type = request_type.clone().to_uppercase();
+        let addrs_url: String = if RestUtils::parse_params_to_str(params.clone()) == "" {
+            url.clone()
+        } else {
+            format!("{}?{}", url.clone(), RestUtils::parse_params_to_str(params.clone()))
+        };
+
+        // trace!("url-----:???{}", url.clone());
+        // trace!("addrs_url-----:???{}", addrs_url.clone());
+        // trace!("params-----:???{}", params.clone());
+        // trace!("body-----:???{}", body.clone());
+
+        let request_builder = match request_type.as_str() {
+            "GET" => self.client.get(addrs_url.clone()).headers(headers),
+            "POST" => self.client.post(url.clone()).body(body).headers(headers),
+            // "DELETE" => self.client.delete(addrs_url.clone()).headers(headers),
+            // "PUT" => self.client.put(url.clone()).json(&params),
+            _ => {
+                panic!("{}", format!("错误的请求类型:{}", request_type.clone()))
+            }
+        };
+
+        // 读取响应的内容
+        let response = request_builder.send().await.unwrap();
+        // 先检查状态码
+        let is_success = response.status().is_success();
+        let text = response.text().await.unwrap();
+
+        // trace!("text:???{:?}",text);
+
+        if is_success {
+            self.on_success_data(&text)
+        } else {
+            self.on_error_data(&text, &addrs_url, &params)
+        }
+    }
+
+    pub fn on_success_data(&mut self, text: &String) -> Response {
+        let json_value = serde_json::from_str::<Value>(&text).unwrap();
+        Response::new(self.tag.clone(), 200, "success".to_string(), json_value)
+    }
+
+    pub fn on_error_data(&mut self, text: &String, base_url: &String, params: &String) -> Response {
+        let json_value = serde_json::from_str::<Value>(&text);
+
+        match json_value {
+            Ok(data) => {
+                let message;
+
+                if !data["message"].is_null() {
+                    message = format!("{}:{}", data["tag"].as_str().unwrap(), data["message"].as_str().unwrap());
+                } else {
+                    message = data["tag"].to_string();
+                }
+
+                let mut error = Response::error(self.tag.clone(), message);
+                error.message = format!("请求地址：{}, 请求参数：{}, 报错内容：{}。", base_url, params, error.message);
+                error
+            }
+            Err(e) => {
+                error!("解析错误：{:?}", e);
+                let error = Response::error("".to_string(),
+                                                format!("json 解析失败:{}，相关参数:{}", e, text));
+                error
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use tracing::info;
+    use crate::exchange::mexc_spot_client::MexcSpotClient;
+    use crate::utils::log_setup::setup_logging;
+
+    #[tokio::test]
+    async fn test_mexc_spot_time() {
+        let guard = setup_logging().unwrap();
+        let mut client = MexcSpotClient::new_with_tag("MexcSpot".to_string(), None);
+
+        info!("{}", serde_json::to_string_pretty(&client.time().await.data).unwrap());
+    }
+
+    #[tokio::test]
+    async fn test_mexc_spot_ping() {
+        let guard = setup_logging().unwrap();
+        let mut client = MexcSpotClient::new_with_tag("MexcSpot".to_string(), None);
+
+        info!("{}", serde_json::to_string_pretty(&client.ping().await.data).unwrap());
+    }
+}

src/exchange/mexc_spot_ws.rs

@@ -272,7 +272,7 @@ impl MexcSpotWs {
                         let response_data = Response::new(
                             kline_message.topic_info.clone(), // 使用解析到的 Topic 信息
                             200,
-                            "OK".to_string(),
+                            "success".to_string(),
                         json!({
                                 "interval": kline_data.interval,
                                 "windowStart": kline_data.window_start, //注意 snake_case
@@ -331,11 +331,12 @@ impl MexcSpotWs {
                         // 填充 Response 并返回
                         let response_data = Response::new(
                             depth_message.topic_info.clone(), // 使用解析到的 Topic
-                            200, "OK".to_string(),
-                            serde_json::json!({
+                            200,
+                            "success".to_string(),
+                            json!({
                                  // 嵌套消息内部的字段
-                                "asks": depth_data_content.asks.into_iter().map(|item| serde_json::json!({"price": item.price, "quantity": item.quantity})).collect::<Vec<_>>(),
-                                "bids": depth_data_content.bids.into_iter().map(|item| serde_json::json!({"price": item.price, "quantity": item.quantity})).collect::<Vec<_>>(),
+                                "asks": depth_data_content.asks.into_iter().map(|item| json!({"price": item.price, "quantity": item.quantity})).collect::<Vec<_>>(),
+                                "bids": depth_data_content.bids.into_iter().map(|item| json!({"price": item.price, "quantity": item.quantity})).collect::<Vec<_>>(),
                                 "eventType": depth_data_content.event_type,
                                 "version": depth_data_content.version,
                                 "lastUpdateId": depth_data_content.last_update_id, // 新增字段

src/exchange/mod.rs

@@ -1,7 +1,8 @@
+pub mod response_base;
+
 mod types;
 mod ws_manager;
 mod mexc_spot_client;
 mod mexc_spot_ws;
-mod response_base;
 mod socket_tool;
 mod proxy;

src/utils/mod.rs

@@ -1,2 +1,3 @@
 mod error;
-pub mod log_setup;
+pub mod log_setup;
+pub mod rest_utils;

src/utils/rest_utils.rs

@@ -0,0 +1,65 @@
+use tracing::trace;
+use crate::exchange::response_base::Response;
+
+#[derive(Clone)]
+pub struct RestUtils {
+    pub base_url: String
+}
+
+impl RestUtils {
+    pub fn new(base_url: String) -> RestUtils {
+        RestUtils { base_url }
+    }
+
+    //map数据转 get请求参数
+    pub fn parse_params_to_str(parameters: String) -> String {
+        let mut params_str = String::from("");
+        let parsed_json: serde_json::Value = serde_json::from_str(&parameters).unwrap();
+
+        if let Some(json_obj) = parsed_json.as_object() {
+            for (key, value) in json_obj.iter() {
+                let formatted_value = match value {
+                    serde_json::Value::String(s) => s.clone(),
+                    _ => value.to_string()
+                };
+                // trace!("Key: {}", key);
+                // trace!("Value: {}", formatted_value);
+                // let formatted_value = match value {
+                //     Value::String(s) => s.clone(),
+                //     _ => value.to_string()
+                // };
+                let str = format!("{}={}", key, formatted_value);
+                let format_str = format!("{}{}{}", params_str, (if params_str.len() > 0 { "&" } else { "" }), str);
+                params_str = format_str;
+            }
+        }
+        trace!("---json-转字符串拼接:{}",params_str);
+        params_str.to_string()
+    }
+    //res_data 解析
+    pub fn res_data_analysis(result: Result<Response, reqwest::Error>) -> Response {
+        match result {
+            Ok(res_data) => {
+                if res_data.code != 0 {
+                    res_data
+                } else {
+                    let json_value= res_data.data;
+
+                    let code = json_value["code"].as_str().unwrap();
+                    let data = serde_json::to_string(&json_value["data"]).unwrap();
+                    let msg = json_value["msg"].as_str().unwrap();
+                    
+                    let success = Response::new("".to_string(),
+                                                    code.parse().unwrap(),
+                                                    msg.parse().unwrap(),
+                                                    data.parse().unwrap());
+                    success
+                }
+            }
+            Err(err) => {
+                let error = Response::error("".to_string(),format!("json 解析失败:{}", err));
+                error
+            }
+        }
+    }
+}