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}