1use crate::{
2 mls_v1::QueryGroupMessagesResponse,
3 types::{Cursor, GroupId, GroupMessageMetadata, TopicCursor, WelcomeMessage},
4 xmtp::xmtpv4::{envelopes::OriginatorEnvelope, message_api::QueryEnvelopesResponse},
5};
6
7use super::*;
8
9impl Paged for QueryGroupMessagesResponse {
10 type Message = ProtoGroupMessage;
11 fn info(&self) -> &Option<PagingInfo> {
12 &self.paging_info
13 }
14
15 fn messages(self) -> Vec<Self::Message> {
16 self.messages
17 }
18}
19
20impl Paged for QueryWelcomeMessagesResponse {
21 type Message = ProtoWelcomeMessage;
22 fn info(&self) -> &Option<PagingInfo> {
23 &self.paging_info
24 }
25
26 fn messages(self) -> Vec<Self::Message> {
27 self.messages
28 }
29}
30
31impl Paged for QueryEnvelopesResponse {
32 type Message = OriginatorEnvelope;
33
34 fn info(&self) -> &Option<PagingInfo> {
35 &None
36 }
37
38 fn messages(self) -> Vec<Self::Message> {
39 self.envelopes
40 }
41}
42
43impl std::fmt::Debug for AggregateStats {
44 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
45 writeln!(f, "============ Api Stats ============")?;
46 writeln!(f, "UploadKeyPackage {}", self.mls.upload_key_package)?;
47 writeln!(f, "FetchKeyPackage {}", self.mls.fetch_key_package)?;
48 writeln!(
49 f,
50 "SendGroupMessages {}",
51 self.mls.send_group_messages
52 )?;
53 writeln!(
54 f,
55 "SendWelcomeMessages {}",
56 self.mls.send_welcome_messages
57 )?;
58 writeln!(
59 f,
60 "QueryGroupMessages {}",
61 self.mls.query_group_messages
62 )?;
63 writeln!(
64 f,
65 "QueryWelcomeMessages {}",
66 self.mls.query_welcome_messages
67 )?;
68 writeln!(f, "SubscribeMessages {}", self.mls.subscribe_messages)?;
69 writeln!(f, "SubscribeWelcomes {}", self.mls.subscribe_welcomes)?;
70 writeln!(f, "============ Identity ============")?;
71 writeln!(
72 f,
73 "PublishIdentityUpdate {}",
74 self.identity.publish_identity_update
75 )?;
76 writeln!(
77 f,
78 "GetIdentityUpdatesV2 {}",
79 self.identity.get_identity_updates_v2
80 )?;
81 writeln!(f, "GetInboxIds {}", self.identity.get_inbox_ids)?;
82 writeln!(
83 f,
84 "VerifySCWSignatures {}",
85 self.identity.verify_smart_contract_wallet_signature
86 )?;
87 writeln!(f, "============ Stream ============")?;
88 writeln!(
89 f,
90 "SubscribeMessages {}",
91 self.mls.subscribe_messages
92 )?;
93 writeln!(f, "SubscribeWelcomes {}", self.mls.subscribe_welcomes)?;
94 writeln!(f, "============ Commit Log ============")?;
95 writeln!(
96 f,
97 "PublishCommitLog {}",
98 self.mls.publish_commit_log
99 )?;
100 writeln!(f, "QueryCommitLog {}", self.mls.query_commit_log)?;
101 Ok(())
102 }
103}
104
105#[xmtp_common::async_trait]
106impl<T> XmtpMlsClient for Box<T>
107where
108 T: XmtpMlsClient + ?Sized,
109{
110 type Error = <T as XmtpMlsClient>::Error;
111
112 async fn upload_key_package(
113 &self,
114 request: UploadKeyPackageRequest,
115 ) -> Result<(), Self::Error> {
116 (**self).upload_key_package(request).await
117 }
118
119 async fn fetch_key_packages(
120 &self,
121 request: FetchKeyPackagesRequest,
122 ) -> Result<FetchKeyPackagesResponse, Self::Error> {
123 (**self).fetch_key_packages(request).await
124 }
125
126 async fn send_group_messages(
127 &self,
128 request: SendGroupMessagesRequest,
129 ) -> Result<(), Self::Error> {
130 (**self).send_group_messages(request).await
131 }
132
133 async fn send_welcome_messages(
134 &self,
135 request: SendWelcomeMessagesRequest,
136 ) -> Result<(), Self::Error> {
137 (**self).send_welcome_messages(request).await
138 }
139
140 async fn query_group_messages(
141 &self,
142 group_id: crate::types::GroupId,
143 ) -> Result<Vec<GroupMessage>, Self::Error> {
144 (**self).query_group_messages(group_id).await
145 }
146
147 async fn query_latest_group_message(
148 &self,
149 group_id: crate::types::GroupId,
150 ) -> Result<Option<GroupMessage>, Self::Error> {
151 (**self).query_latest_group_message(group_id).await
152 }
153
154 async fn query_welcome_messages(
155 &self,
156 installation_key: InstallationId,
157 ) -> Result<Vec<WelcomeMessage>, Self::Error> {
158 (**self).query_welcome_messages(installation_key).await
159 }
160
161 async fn publish_commit_log(
162 &self,
163 request: BatchPublishCommitLogRequest,
164 ) -> Result<(), Self::Error> {
165 (**self).publish_commit_log(request).await
166 }
167
168 async fn query_commit_log(
169 &self,
170 request: BatchQueryCommitLogRequest,
171 ) -> Result<BatchQueryCommitLogResponse, Self::Error> {
172 (**self).query_commit_log(request).await
173 }
174
175 async fn get_newest_group_message(
176 &self,
177 request: GetNewestGroupMessageRequest,
178 ) -> Result<Vec<Option<GroupMessageMetadata>>, Self::Error> {
179 (**self).get_newest_group_message(request).await
180 }
181}
182
183#[xmtp_common::async_trait]
184impl<T> XmtpMlsClient for Arc<T>
185where
186 T: XmtpMlsClient + ?Sized,
187{
188 type Error = <T as XmtpMlsClient>::Error;
189
190 async fn upload_key_package(
191 &self,
192 request: UploadKeyPackageRequest,
193 ) -> Result<(), Self::Error> {
194 (**self).upload_key_package(request).await
195 }
196
197 async fn fetch_key_packages(
198 &self,
199 request: FetchKeyPackagesRequest,
200 ) -> Result<FetchKeyPackagesResponse, Self::Error> {
201 (**self).fetch_key_packages(request).await
202 }
203
204 async fn send_group_messages(
205 &self,
206 request: SendGroupMessagesRequest,
207 ) -> Result<(), Self::Error> {
208 (**self).send_group_messages(request).await
209 }
210
211 async fn send_welcome_messages(
212 &self,
213 request: SendWelcomeMessagesRequest,
214 ) -> Result<(), Self::Error> {
215 (**self).send_welcome_messages(request).await
216 }
217
218 async fn query_group_messages(
219 &self,
220 group_id: crate::types::GroupId,
221 ) -> Result<Vec<GroupMessage>, Self::Error> {
222 (**self).query_group_messages(group_id).await
223 }
224
225 async fn query_latest_group_message(
226 &self,
227 group_id: crate::types::GroupId,
228 ) -> Result<Option<GroupMessage>, Self::Error> {
229 (**self).query_latest_group_message(group_id).await
230 }
231
232 async fn query_welcome_messages(
233 &self,
234 installation_key: InstallationId,
235 ) -> Result<Vec<WelcomeMessage>, Self::Error> {
236 (**self).query_welcome_messages(installation_key).await
237 }
238
239 async fn publish_commit_log(
240 &self,
241 request: BatchPublishCommitLogRequest,
242 ) -> Result<(), Self::Error> {
243 (**self).publish_commit_log(request).await
244 }
245
246 async fn query_commit_log(
247 &self,
248 request: BatchQueryCommitLogRequest,
249 ) -> Result<BatchQueryCommitLogResponse, Self::Error> {
250 (**self).query_commit_log(request).await
251 }
252
253 async fn get_newest_group_message(
254 &self,
255 request: GetNewestGroupMessageRequest,
256 ) -> Result<Vec<Option<GroupMessageMetadata>>, Self::Error> {
257 (**self).get_newest_group_message(request).await
258 }
259}
260
261#[xmtp_common::async_trait]
262impl<T> XmtpMlsStreams for Box<T>
263where
264 T: XmtpMlsStreams + Sync + ?Sized,
265{
266 type Error = <T as XmtpMlsStreams>::Error;
267
268 type GroupMessageStream = <T as XmtpMlsStreams>::GroupMessageStream;
269
270 type WelcomeMessageStream = <T as XmtpMlsStreams>::WelcomeMessageStream;
271
272 async fn subscribe_group_messages(
273 &self,
274 group_ids: &[&GroupId],
275 ) -> Result<Self::GroupMessageStream, Self::Error> {
276 (**self).subscribe_group_messages(group_ids).await
277 }
278
279 async fn subscribe_group_messages_with_cursors(
280 &self,
281 groups_with_cursors: &TopicCursor,
282 ) -> Result<Self::GroupMessageStream, Self::Error> {
283 (**self)
284 .subscribe_group_messages_with_cursors(groups_with_cursors)
285 .await
286 }
287
288 async fn subscribe_welcome_messages(
289 &self,
290 installations: &[&InstallationId],
291 ) -> Result<Self::WelcomeMessageStream, Self::Error> {
292 (**self).subscribe_welcome_messages(installations).await
293 }
294}
295
296#[xmtp_common::async_trait]
297impl<T> XmtpMlsStreams for Arc<T>
298where
299 T: XmtpMlsStreams + ?Sized,
300{
301 type Error = <T as XmtpMlsStreams>::Error;
302
303 type GroupMessageStream = <T as XmtpMlsStreams>::GroupMessageStream;
304
305 type WelcomeMessageStream = <T as XmtpMlsStreams>::WelcomeMessageStream;
306
307 async fn subscribe_group_messages(
308 &self,
309 group_ids: &[&GroupId],
310 ) -> Result<Self::GroupMessageStream, Self::Error> {
311 (**self).subscribe_group_messages(group_ids).await
312 }
313
314 async fn subscribe_group_messages_with_cursors(
315 &self,
316 groups_with_cursors: &TopicCursor,
317 ) -> Result<Self::GroupMessageStream, Self::Error> {
318 (**self)
319 .subscribe_group_messages_with_cursors(groups_with_cursors)
320 .await
321 }
322
323 async fn subscribe_welcome_messages(
324 &self,
325 installations: &[&InstallationId],
326 ) -> Result<Self::WelcomeMessageStream, Self::Error> {
327 (**self).subscribe_welcome_messages(installations).await
328 }
329}
330
331#[xmtp_common::async_trait]
332impl<T> XmtpIdentityClient for Box<T>
333where
334 T: XmtpIdentityClient + ?Sized,
335{
336 type Error = <T as XmtpIdentityClient>::Error;
337
338 async fn publish_identity_update(
339 &self,
340 request: PublishIdentityUpdateRequest,
341 ) -> Result<Option<Cursor>, Self::Error> {
342 (**self).publish_identity_update(request).await
343 }
344
345 async fn get_identity_updates_v2(
346 &self,
347 request: GetIdentityUpdatesV2Request,
348 ) -> Result<GetIdentityUpdatesV2Response, Self::Error> {
349 (**self).get_identity_updates_v2(request).await
350 }
351
352 async fn get_inbox_ids(
353 &self,
354 request: GetInboxIdsRequest,
355 ) -> Result<GetInboxIdsResponse, Self::Error> {
356 (**self).get_inbox_ids(request).await
357 }
358
359 async fn verify_smart_contract_wallet_signatures(
360 &self,
361 request: VerifySmartContractWalletSignaturesRequest,
362 ) -> Result<VerifySmartContractWalletSignaturesResponse, Self::Error> {
363 (**self)
364 .verify_smart_contract_wallet_signatures(request)
365 .await
366 }
367}
368
369#[xmtp_common::async_trait]
370impl<T> XmtpIdentityClient for Arc<T>
371where
372 T: XmtpIdentityClient + ?Sized,
373{
374 type Error = <T as XmtpIdentityClient>::Error;
375
376 async fn publish_identity_update(
377 &self,
378 request: PublishIdentityUpdateRequest,
379 ) -> Result<Option<Cursor>, Self::Error> {
380 (**self).publish_identity_update(request).await
381 }
382
383 async fn get_identity_updates_v2(
384 &self,
385 request: GetIdentityUpdatesV2Request,
386 ) -> Result<GetIdentityUpdatesV2Response, Self::Error> {
387 (**self).get_identity_updates_v2(request).await
388 }
389
390 async fn get_inbox_ids(
391 &self,
392 request: GetInboxIdsRequest,
393 ) -> Result<GetInboxIdsResponse, Self::Error> {
394 (**self).get_inbox_ids(request).await
395 }
396
397 async fn verify_smart_contract_wallet_signatures(
398 &self,
399 request: VerifySmartContractWalletSignaturesRequest,
400 ) -> Result<VerifySmartContractWalletSignaturesResponse, Self::Error> {
401 (**self)
402 .verify_smart_contract_wallet_signatures(request)
403 .await
404 }
405}
406
407xmtp_common::if_native! {
408 #[xmtp_common::async_trait]
413 impl<T> XmtpMlsBidiStreams for Box<T>
414 where
415 T: XmtpMlsBidiStreams + Sync + ?Sized,
416 {
417 type Error = <T as XmtpMlsBidiStreams>::Error;
418 type SubscribeStream = <T as XmtpMlsBidiStreams>::SubscribeStream;
419
420 async fn subscribe_bidi(
421 &self,
422 requests: futures::stream::BoxStream<'static, crate::mls_v1::SubscribeRequest>,
423 ) -> Result<Self::SubscribeStream, Self::Error> {
424 (**self).subscribe_bidi(requests).await
425 }
426 }
427
428 #[xmtp_common::async_trait]
429 impl<T> XmtpMlsBidiStreams for Arc<T>
430 where
431 T: XmtpMlsBidiStreams + ?Sized,
432 {
433 type Error = <T as XmtpMlsBidiStreams>::Error;
434 type SubscribeStream = <T as XmtpMlsBidiStreams>::SubscribeStream;
435
436 async fn subscribe_bidi(
437 &self,
438 requests: futures::stream::BoxStream<'static, crate::mls_v1::SubscribeRequest>,
439 ) -> Result<Self::SubscribeStream, Self::Error> {
440 (**self).subscribe_bidi(requests).await
441 }
442 }
443}