tokio_binance/client/
user_data.rs

1use reqwest::{Url, Client};
2use crate::param::Parameters;
3use crate::builder::ParamBuilder;
4use crate::types::*;
5
6/// Client for dealing with the user data stream.
7#[derive(Clone)]
8pub struct UserDataClient {
9    api_key: String,
10    url: Url,
11    client: Client
12}
13
14impl UserDataClient {
15    /// Creates new client instance
16    /// # Example
17    ///
18    /// ```no_run
19    /// use tokio_binance::{UserDataClient, BINANCE_US_URL};
20    /// 
21    /// #[tokio::main]
22    /// async fn main() -> Result<(), Box<dyn std::error::Error>> {
23    ///     let client = UserDataClient::connect("<api-key>", BINANCE_US_URL)?;
24    ///     Ok(())
25    /// }
26    /// ```
27    pub fn connect<A, U>(api_key: A, url: U) -> crate::error::Result<Self> 
28    where
29        A: Into<String>,
30        U: Into<String>
31    {
32        Ok(Self {
33            api_key: api_key.into(), 
34            url: url.into().parse::<Url>()?,
35            client: Client::new()
36        })
37    }
38    /// Start a new user data stream. 
39    /// The stream will close after 60 minutes unless a keepalive is sent.
40    /// # Example
41    ///
42    /// ```no_run
43    /// # use tokio_binance::{UserDataClient, BINANCE_US_URL};
44    /// use serde_json::Value;
45    /// 
46    /// # #[tokio::main]
47    /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
48    /// # let client = UserDataClient::connect("<api-key>", BINANCE_US_URL)?;
49    /// let response = client
50    ///     .start_stream()
51    ///     .json::<Value>()
52    ///     .await?;
53    /// # Ok(())
54    /// # }
55    /// ```
56    pub fn start_stream(&self) -> ParamBuilder<'_, '_, StartStreamParams>{
57        let Self { api_key, url, client } = self;
58        let url = url.join("/api/v3/userDataStream").unwrap();
59
60        ParamBuilder::new(
61            Parameters::default(),
62            client.post(url),
63            Some(api_key),
64            None
65        )
66    }
67    /// Keepalive a user data stream to prevent a time out. 
68    /// User data streams will close after 60 minutes. 
69    /// It's recommended to send a ping about every 30 minutes.
70    /// # Example
71    ///
72    /// ```no_run
73    /// # use tokio_binance::{UserDataClient, BINANCE_US_URL};
74    /// use serde_json::Value;
75    /// 
76    /// # #[tokio::main]
77    /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
78    /// # let client = UserDataClient::connect("<api-key>", BINANCE_US_URL)?;
79    /// let response = client
80    ///     .keep_alive("<listen-key>")
81    ///     .json::<Value>()
82    ///     .await?;
83    /// # Ok(())
84    /// # }
85    /// ```
86    pub fn keep_alive<'a>(&self, listen_key: &'a str) -> ParamBuilder<'a, '_, KeepAliveStreamParams>{
87        let Self { api_key,  url, client } = self;
88        let url = url.join("/api/v3/userDataStream").unwrap();
89
90        ParamBuilder::new(
91            Parameters { listen_key: Some(listen_key), ..Parameters::default() },
92            client.put(url),
93            Some(api_key),
94            None
95        )
96    }
97    /// Close out a user data stream.
98    /// # Example
99    ///
100    /// ```no_run
101    /// # use tokio_binance::{UserDataClient, BINANCE_US_URL};
102    /// use serde_json::Value;
103    /// 
104    /// # #[tokio::main]
105    /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
106    /// # let client = UserDataClient::connect("<api-key>", BINANCE_US_URL)?;
107    /// let response = client
108    ///     .close_stream("<listen-key>")
109    ///     .json::<Value>()
110    ///     .await?;
111    /// # Ok(())
112    /// # }
113    /// ```
114    pub fn close_stream<'a>(&self, listen_key: &'a str) -> ParamBuilder<'a, '_, CloseStreamParams>{
115        let Self { api_key, url, client } = self;
116        let url = url.join("/api/v3/userDataStream").unwrap();
117
118        ParamBuilder::new(
119            Parameters { listen_key: Some(listen_key), ..Parameters::default() },
120            client.delete(url),
121            Some(api_key),
122            None
123        )
124    }
125}