1use std::sync::Arc;
2
3use crate::{
4 Error,
5 client::Inner,
6 common::response::ResponseStream,
7 transport::endpoint::Endpoint,
8 transport::pagination::{collect_all, stream_pages},
9};
10
11use super::{
12 BarsRequest, BarsResponse, LatestBarsRequest, LatestBarsResponse, LatestOrderbooksRequest,
13 LatestOrderbooksResponse, LatestQuotesRequest, LatestQuotesResponse, LatestTradesRequest,
14 LatestTradesResponse, QuotesRequest, QuotesResponse, SnapshotsRequest, SnapshotsResponse,
15 TradesRequest, TradesResponse,
16};
17
18#[derive(Clone, Debug)]
19pub struct CryptoClient {
20 inner: Arc<Inner>,
21}
22
23impl CryptoClient {
24 pub(crate) fn new(inner: Arc<Inner>) -> Self {
25 Self { inner }
26 }
27
28 pub async fn bars(&self, request: BarsRequest) -> Result<BarsResponse, Error> {
29 let endpoint = Endpoint::crypto_bars(request.loc.unwrap_or_default());
30 self.inner
31 .http
32 .get_json(
33 &self.inner.base_url,
34 endpoint,
35 &self.inner.auth,
36 request.to_query(),
37 )
38 .await
39 }
40
41 pub async fn bars_all(&self, request: BarsRequest) -> Result<BarsResponse, Error> {
42 let client = self.clone();
43
44 collect_all(request, move |request| {
45 let client = client.clone();
46 async move { client.bars(request).await }
47 })
48 .await
49 }
50
51 pub fn bars_stream(&self, request: BarsRequest) -> ResponseStream<Result<BarsResponse, Error>> {
52 let client = self.clone();
53 stream_pages(request, move |request| {
54 let client = client.clone();
55 async move { client.bars(request).await }
56 })
57 }
58
59 pub async fn quotes(&self, request: QuotesRequest) -> Result<QuotesResponse, Error> {
60 let endpoint = Endpoint::crypto_quotes(request.loc.unwrap_or_default());
61 self.inner
62 .http
63 .get_json(
64 &self.inner.base_url,
65 endpoint,
66 &self.inner.auth,
67 request.to_query(),
68 )
69 .await
70 }
71
72 pub async fn quotes_all(&self, request: QuotesRequest) -> Result<QuotesResponse, Error> {
73 let client = self.clone();
74
75 collect_all(request, move |request| {
76 let client = client.clone();
77 async move { client.quotes(request).await }
78 })
79 .await
80 }
81
82 pub fn quotes_stream(
83 &self,
84 request: QuotesRequest,
85 ) -> ResponseStream<Result<QuotesResponse, Error>> {
86 let client = self.clone();
87 stream_pages(request, move |request| {
88 let client = client.clone();
89 async move { client.quotes(request).await }
90 })
91 }
92
93 pub async fn trades(&self, request: TradesRequest) -> Result<TradesResponse, Error> {
94 let endpoint = Endpoint::crypto_trades(request.loc.unwrap_or_default());
95 self.inner
96 .http
97 .get_json(
98 &self.inner.base_url,
99 endpoint,
100 &self.inner.auth,
101 request.to_query(),
102 )
103 .await
104 }
105
106 pub async fn trades_all(&self, request: TradesRequest) -> Result<TradesResponse, Error> {
107 let client = self.clone();
108
109 collect_all(request, move |request| {
110 let client = client.clone();
111 async move { client.trades(request).await }
112 })
113 .await
114 }
115
116 pub fn trades_stream(
117 &self,
118 request: TradesRequest,
119 ) -> ResponseStream<Result<TradesResponse, Error>> {
120 let client = self.clone();
121 stream_pages(request, move |request| {
122 let client = client.clone();
123 async move { client.trades(request).await }
124 })
125 }
126
127 pub async fn latest_bars(
128 &self,
129 request: LatestBarsRequest,
130 ) -> Result<LatestBarsResponse, Error> {
131 let endpoint = Endpoint::crypto_latest_bars(request.loc.unwrap_or_default());
132 self.inner
133 .http
134 .get_json(
135 &self.inner.base_url,
136 endpoint,
137 &self.inner.auth,
138 request.to_query(),
139 )
140 .await
141 }
142
143 pub async fn latest_quotes(
144 &self,
145 request: LatestQuotesRequest,
146 ) -> Result<LatestQuotesResponse, Error> {
147 let endpoint = Endpoint::crypto_latest_quotes(request.loc.unwrap_or_default());
148
149 self.inner
150 .http
151 .get_json(
152 &self.inner.base_url,
153 endpoint,
154 &self.inner.auth,
155 request.to_query(),
156 )
157 .await
158 }
159
160 pub async fn latest_trades(
161 &self,
162 request: LatestTradesRequest,
163 ) -> Result<LatestTradesResponse, Error> {
164 let endpoint = Endpoint::crypto_latest_trades(request.loc.unwrap_or_default());
165 self.inner
166 .http
167 .get_json(
168 &self.inner.base_url,
169 endpoint,
170 &self.inner.auth,
171 request.to_query(),
172 )
173 .await
174 }
175
176 pub async fn latest_orderbooks(
177 &self,
178 request: LatestOrderbooksRequest,
179 ) -> Result<LatestOrderbooksResponse, Error> {
180 let endpoint = Endpoint::crypto_latest_orderbooks(request.loc.unwrap_or_default());
181 self.inner
182 .http
183 .get_json(
184 &self.inner.base_url,
185 endpoint,
186 &self.inner.auth,
187 request.to_query(),
188 )
189 .await
190 }
191
192 pub async fn snapshots(&self, request: SnapshotsRequest) -> Result<SnapshotsResponse, Error> {
193 let endpoint = Endpoint::crypto_snapshots(request.loc.unwrap_or_default());
194 self.inner
195 .http
196 .get_json(
197 &self.inner.base_url,
198 endpoint,
199 &self.inner.auth,
200 request.to_query(),
201 )
202 .await
203 }
204}