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