xmtp_proto/api_client/
impls.rs

1use super::*;
2
3#[xmtp_common::async_trait]
4impl<T: XmtpBackendClient + ?Sized> XmtpBackendClient for Box<T> {
5    type Error = T::Error;
6    fn register_client_event_writer(&self, writer: &Arc<dyn xmtp_events::EventWriter<()>>) {
7        (**self).register_client_event_writer(writer);
8    }
9    fn unregister_client_event_writer(&self, writer: &Arc<dyn xmtp_events::EventWriter<()>>) {
10        (**self).unregister_client_event_writer(writer);
11    }
12    async fn publish(&self, request: PublishRequest) -> Result<PublishResponse, Self::Error> {
13        (**self).publish(request).await
14    }
15    async fn create_upload(
16        &self,
17        request: CreateUploadRequest,
18    ) -> Result<CreateUploadResponse, Self::Error> {
19        (**self).create_upload(request).await
20    }
21    async fn query(&self, request: QueryRequest) -> Result<QueryResponse, Self::Error> {
22        (**self).query(request).await
23    }
24    async fn query_newest(
25        &self,
26        request: QueryNewestRequest,
27    ) -> Result<QueryNewestResponse, Self::Error> {
28        (**self).query_newest(request).await
29    }
30    async fn get_inbox_ids(
31        &self,
32        request: GetInboxIdsRequest,
33    ) -> Result<GetInboxIdsResponse, Self::Error> {
34        (**self).get_inbox_ids(request).await
35    }
36    async fn get_configuration(
37        &self,
38        request: GetConfigurationRequest,
39    ) -> Result<GetConfigurationResponse, Self::Error> {
40        (**self).get_configuration(request).await
41    }
42    fn backend_url(&self) -> Option<&str> {
43        (**self).backend_url()
44    }
45
46    fn has_credential_source(&self) -> bool {
47        (**self).has_credential_source()
48    }
49
50    fn set_limits(&self, limits: std::sync::Arc<xmtp_configuration::LimitsConfiguration>) {
51        (**self).set_limits(limits)
52    }
53    async fn verify_smart_contract_wallet_signatures(
54        &self,
55        request: VerifySmartContractWalletSignaturesRequest,
56    ) -> Result<VerifySmartContractWalletSignaturesResponse, Self::Error> {
57        (**self)
58            .verify_smart_contract_wallet_signatures(request)
59            .await
60    }
61    async fn register(&self, request: RegisterRequest) -> Result<RecipientState, Self::Error> {
62        (**self).register(request).await
63    }
64    async fn unregister(
65        &self,
66        request: UnregisterRequest,
67    ) -> Result<UnregisterResponse, Self::Error> {
68        (**self).unregister(request).await
69    }
70    async fn update_subscriptions(
71        &self,
72        request: UpdateSubscriptionsRequest,
73    ) -> Result<RecipientState, Self::Error> {
74        (**self).update_subscriptions(request).await
75    }
76}
77
78#[xmtp_common::async_trait]
79impl<T: XmtpMlsStreams + ?Sized> XmtpMlsStreams for Box<T> {
80    type Error = T::Error;
81    type GroupMessageStream = T::GroupMessageStream;
82    type WelcomeMessageStream = T::WelcomeMessageStream;
83    async fn subscribe_envelopes_with_cursors(
84        &self,
85        cursors: &TopicCursor,
86        limits: IncomingBatchLimits,
87    ) -> Result<IncomingSubscription<Self::Error>, Self::Error> {
88        (**self)
89            .subscribe_envelopes_with_cursors(cursors, limits)
90            .await
91    }
92    async fn subscribe_group_messages(
93        &self,
94        group_ids: &[&GroupId],
95    ) -> Result<Self::GroupMessageStream, Self::Error> {
96        (**self).subscribe_group_messages(group_ids).await
97    }
98    async fn subscribe_group_messages_with_cursors(
99        &self,
100        cursors: &TopicCursor,
101    ) -> Result<Self::GroupMessageStream, Self::Error> {
102        (**self)
103            .subscribe_group_messages_with_cursors(cursors)
104            .await
105    }
106    async fn subscribe_welcome_messages(
107        &self,
108        installations: &[&InstallationId],
109    ) -> Result<Self::WelcomeMessageStream, Self::Error> {
110        (**self).subscribe_welcome_messages(installations).await
111    }
112    async fn subscribe_welcome_messages_with_cursors(
113        &self,
114        cursors: &TopicCursor,
115    ) -> Result<Self::WelcomeMessageStream, Self::Error> {
116        (**self)
117            .subscribe_welcome_messages_with_cursors(cursors)
118            .await
119    }
120}
121
122#[xmtp_common::async_trait]
123impl<T: XmtpBackendClient + ?Sized> XmtpBackendClient for Arc<T> {
124    type Error = T::Error;
125    fn register_client_event_writer(&self, writer: &Arc<dyn xmtp_events::EventWriter<()>>) {
126        (**self).register_client_event_writer(writer);
127    }
128    fn unregister_client_event_writer(&self, writer: &Arc<dyn xmtp_events::EventWriter<()>>) {
129        (**self).unregister_client_event_writer(writer);
130    }
131    async fn publish(&self, request: PublishRequest) -> Result<PublishResponse, Self::Error> {
132        (**self).publish(request).await
133    }
134    async fn create_upload(
135        &self,
136        request: CreateUploadRequest,
137    ) -> Result<CreateUploadResponse, Self::Error> {
138        (**self).create_upload(request).await
139    }
140    async fn query(&self, request: QueryRequest) -> Result<QueryResponse, Self::Error> {
141        (**self).query(request).await
142    }
143    async fn query_newest(
144        &self,
145        request: QueryNewestRequest,
146    ) -> Result<QueryNewestResponse, Self::Error> {
147        (**self).query_newest(request).await
148    }
149    async fn get_inbox_ids(
150        &self,
151        request: GetInboxIdsRequest,
152    ) -> Result<GetInboxIdsResponse, Self::Error> {
153        (**self).get_inbox_ids(request).await
154    }
155    async fn get_configuration(
156        &self,
157        request: GetConfigurationRequest,
158    ) -> Result<GetConfigurationResponse, Self::Error> {
159        (**self).get_configuration(request).await
160    }
161    fn backend_url(&self) -> Option<&str> {
162        (**self).backend_url()
163    }
164
165    fn has_credential_source(&self) -> bool {
166        (**self).has_credential_source()
167    }
168
169    fn set_limits(&self, limits: std::sync::Arc<xmtp_configuration::LimitsConfiguration>) {
170        (**self).set_limits(limits)
171    }
172    async fn verify_smart_contract_wallet_signatures(
173        &self,
174        request: VerifySmartContractWalletSignaturesRequest,
175    ) -> Result<VerifySmartContractWalletSignaturesResponse, Self::Error> {
176        (**self)
177            .verify_smart_contract_wallet_signatures(request)
178            .await
179    }
180    async fn register(&self, request: RegisterRequest) -> Result<RecipientState, Self::Error> {
181        (**self).register(request).await
182    }
183    async fn unregister(
184        &self,
185        request: UnregisterRequest,
186    ) -> Result<UnregisterResponse, Self::Error> {
187        (**self).unregister(request).await
188    }
189    async fn update_subscriptions(
190        &self,
191        request: UpdateSubscriptionsRequest,
192    ) -> Result<RecipientState, Self::Error> {
193        (**self).update_subscriptions(request).await
194    }
195}
196
197#[xmtp_common::async_trait]
198impl<T: XmtpMlsStreams + ?Sized> XmtpMlsStreams for Arc<T> {
199    type Error = T::Error;
200    type GroupMessageStream = T::GroupMessageStream;
201    type WelcomeMessageStream = T::WelcomeMessageStream;
202    async fn subscribe_envelopes_with_cursors(
203        &self,
204        cursors: &TopicCursor,
205        limits: IncomingBatchLimits,
206    ) -> Result<IncomingSubscription<Self::Error>, Self::Error> {
207        (**self)
208            .subscribe_envelopes_with_cursors(cursors, limits)
209            .await
210    }
211    async fn subscribe_group_messages(
212        &self,
213        group_ids: &[&GroupId],
214    ) -> Result<Self::GroupMessageStream, Self::Error> {
215        (**self).subscribe_group_messages(group_ids).await
216    }
217    async fn subscribe_group_messages_with_cursors(
218        &self,
219        cursors: &TopicCursor,
220    ) -> Result<Self::GroupMessageStream, Self::Error> {
221        (**self)
222            .subscribe_group_messages_with_cursors(cursors)
223            .await
224    }
225    async fn subscribe_welcome_messages(
226        &self,
227        installations: &[&InstallationId],
228    ) -> Result<Self::WelcomeMessageStream, Self::Error> {
229        (**self).subscribe_welcome_messages(installations).await
230    }
231    async fn subscribe_welcome_messages_with_cursors(
232        &self,
233        cursors: &TopicCursor,
234    ) -> Result<Self::WelcomeMessageStream, Self::Error> {
235        (**self)
236            .subscribe_welcome_messages_with_cursors(cursors)
237            .await
238    }
239}
240
241#[xmtp_common::async_trait]
242impl<T: XmtpBackendClient + ?Sized> XmtpBackendClient for &T {
243    type Error = T::Error;
244    fn register_client_event_writer(&self, writer: &Arc<dyn xmtp_events::EventWriter<()>>) {
245        (**self).register_client_event_writer(writer);
246    }
247    fn unregister_client_event_writer(&self, writer: &Arc<dyn xmtp_events::EventWriter<()>>) {
248        (**self).unregister_client_event_writer(writer);
249    }
250    async fn publish(&self, request: PublishRequest) -> Result<PublishResponse, Self::Error> {
251        (**self).publish(request).await
252    }
253    async fn create_upload(
254        &self,
255        request: CreateUploadRequest,
256    ) -> Result<CreateUploadResponse, Self::Error> {
257        (**self).create_upload(request).await
258    }
259    async fn query(&self, request: QueryRequest) -> Result<QueryResponse, Self::Error> {
260        (**self).query(request).await
261    }
262    async fn query_newest(
263        &self,
264        request: QueryNewestRequest,
265    ) -> Result<QueryNewestResponse, Self::Error> {
266        (**self).query_newest(request).await
267    }
268    async fn get_inbox_ids(
269        &self,
270        request: GetInboxIdsRequest,
271    ) -> Result<GetInboxIdsResponse, Self::Error> {
272        (**self).get_inbox_ids(request).await
273    }
274    async fn get_configuration(
275        &self,
276        request: GetConfigurationRequest,
277    ) -> Result<GetConfigurationResponse, Self::Error> {
278        (**self).get_configuration(request).await
279    }
280    fn backend_url(&self) -> Option<&str> {
281        (**self).backend_url()
282    }
283
284    fn has_credential_source(&self) -> bool {
285        (**self).has_credential_source()
286    }
287
288    fn set_limits(&self, limits: std::sync::Arc<xmtp_configuration::LimitsConfiguration>) {
289        (**self).set_limits(limits)
290    }
291    async fn verify_smart_contract_wallet_signatures(
292        &self,
293        request: VerifySmartContractWalletSignaturesRequest,
294    ) -> Result<VerifySmartContractWalletSignaturesResponse, Self::Error> {
295        (**self)
296            .verify_smart_contract_wallet_signatures(request)
297            .await
298    }
299    async fn register(&self, request: RegisterRequest) -> Result<RecipientState, Self::Error> {
300        (**self).register(request).await
301    }
302    async fn unregister(
303        &self,
304        request: UnregisterRequest,
305    ) -> Result<UnregisterResponse, Self::Error> {
306        (**self).unregister(request).await
307    }
308    async fn update_subscriptions(
309        &self,
310        request: UpdateSubscriptionsRequest,
311    ) -> Result<RecipientState, Self::Error> {
312        (**self).update_subscriptions(request).await
313    }
314}
315
316#[xmtp_common::async_trait]
317impl<T: XmtpMlsStreams + ?Sized> XmtpMlsStreams for &T {
318    type Error = T::Error;
319    type GroupMessageStream = T::GroupMessageStream;
320    type WelcomeMessageStream = T::WelcomeMessageStream;
321    async fn subscribe_envelopes_with_cursors(
322        &self,
323        cursors: &TopicCursor,
324        limits: IncomingBatchLimits,
325    ) -> Result<IncomingSubscription<Self::Error>, Self::Error> {
326        (**self)
327            .subscribe_envelopes_with_cursors(cursors, limits)
328            .await
329    }
330    async fn subscribe_group_messages(
331        &self,
332        group_ids: &[&GroupId],
333    ) -> Result<Self::GroupMessageStream, Self::Error> {
334        (**self).subscribe_group_messages(group_ids).await
335    }
336    async fn subscribe_group_messages_with_cursors(
337        &self,
338        cursors: &TopicCursor,
339    ) -> Result<Self::GroupMessageStream, Self::Error> {
340        (**self)
341            .subscribe_group_messages_with_cursors(cursors)
342            .await
343    }
344    async fn subscribe_welcome_messages(
345        &self,
346        installations: &[&InstallationId],
347    ) -> Result<Self::WelcomeMessageStream, Self::Error> {
348        (**self).subscribe_welcome_messages(installations).await
349    }
350    async fn subscribe_welcome_messages_with_cursors(
351        &self,
352        cursors: &TopicCursor,
353    ) -> Result<Self::WelcomeMessageStream, Self::Error> {
354        (**self)
355            .subscribe_welcome_messages_with_cursors(cursors)
356            .await
357    }
358}
359
360xmtp_common::if_native! {
361    // `XmtpMlsBidiStreams` is native-only (see `api_client.rs`), so its boxed /
362    // arced forwarders are gated the same way. Without these, erasing a client
363    // into `Box<dyn XmtpMlsBidiStreams>` / `Arc<dyn XmtpMlsBidiStreams>` would
364    // fail to compile on `subscribe_bidi`, unlike every other client trait here.
365    #[xmtp_common::async_trait]
366    impl<T> XmtpMlsBidiStreams for Box<T>
367    where
368        T: XmtpMlsBidiStreams + Sync + ?Sized,
369    {
370        type Error = <T as XmtpMlsBidiStreams>::Error;
371        type SubscribeStream = <T as XmtpMlsBidiStreams>::SubscribeStream;
372
373        fn host(&self) -> &str {
374            (**self).host()
375        }
376
377        fn bidi_limits(&self) -> std::sync::Arc<xmtp_configuration::LimitsConfiguration> {
378            (**self).bidi_limits()
379        }
380
381        async fn subscribe_bidi(
382            &self,
383            requests: futures::stream::BoxStream<'static, crate::backend_v1::SubscribeRequest>,
384        ) -> Result<Self::SubscribeStream, Self::Error> {
385            (**self).subscribe_bidi(requests).await
386        }
387    }
388
389    #[xmtp_common::async_trait]
390    impl<T> XmtpMlsBidiStreams for Arc<T>
391    where
392        T: XmtpMlsBidiStreams + ?Sized,
393    {
394        type Error = <T as XmtpMlsBidiStreams>::Error;
395        type SubscribeStream = <T as XmtpMlsBidiStreams>::SubscribeStream;
396
397        fn host(&self) -> &str {
398            (**self).host()
399        }
400
401        fn bidi_limits(&self) -> std::sync::Arc<xmtp_configuration::LimitsConfiguration> {
402            (**self).bidi_limits()
403        }
404
405        async fn subscribe_bidi(
406            &self,
407            requests: futures::stream::BoxStream<'static, crate::backend_v1::SubscribeRequest>,
408        ) -> Result<Self::SubscribeStream, Self::Error> {
409            (**self).subscribe_bidi(requests).await
410        }
411    }
412}
xmtp_proto/api_client/impls.rs

xmtp_proto/api_client/
impls.rs
