xmtp_proto/gen/
xmtp.identity.api.v1.rs

1// This file is @generated by prost-build.
2#[derive(Clone, PartialEq, ::prost::Message)]
3pub struct VerifySmartContractWalletSignaturesRequest {
4    #[prost(message, repeated, tag = "1")]
5    pub signatures: ::prost::alloc::vec::Vec<
6        VerifySmartContractWalletSignatureRequestSignature,
7    >,
8}
9impl ::prost::Name for VerifySmartContractWalletSignaturesRequest {
10    const NAME: &'static str = "VerifySmartContractWalletSignaturesRequest";
11    const PACKAGE: &'static str = "xmtp.identity.api.v1";
12    fn full_name() -> ::prost::alloc::string::String {
13        "xmtp.identity.api.v1.VerifySmartContractWalletSignaturesRequest".into()
14    }
15    fn type_url() -> ::prost::alloc::string::String {
16        "/xmtp.identity.api.v1.VerifySmartContractWalletSignaturesRequest".into()
17    }
18}
19#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
20pub struct VerifySmartContractWalletSignatureRequestSignature {
21    /// CAIP-10 string
22    /// <https://github.com/ChainAgnostic/CAIPs/blob/main/CAIPs/caip-10.md>
23    #[prost(string, tag = "1")]
24    pub account_id: ::prost::alloc::string::String,
25    /// Specify the block number to verify the signature against
26    #[prost(uint64, optional, tag = "2")]
27    pub block_number: ::core::option::Option<u64>,
28    /// The signature bytes
29    #[prost(bytes = "vec", tag = "3")]
30    pub signature: ::prost::alloc::vec::Vec<u8>,
31    #[prost(bytes = "vec", tag = "4")]
32    pub hash: ::prost::alloc::vec::Vec<u8>,
33}
34impl ::prost::Name for VerifySmartContractWalletSignatureRequestSignature {
35    const NAME: &'static str = "VerifySmartContractWalletSignatureRequestSignature";
36    const PACKAGE: &'static str = "xmtp.identity.api.v1";
37    fn full_name() -> ::prost::alloc::string::String {
38        "xmtp.identity.api.v1.VerifySmartContractWalletSignatureRequestSignature".into()
39    }
40    fn type_url() -> ::prost::alloc::string::String {
41        "/xmtp.identity.api.v1.VerifySmartContractWalletSignatureRequestSignature".into()
42    }
43}
44#[derive(Clone, PartialEq, ::prost::Message)]
45pub struct VerifySmartContractWalletSignaturesResponse {
46    #[prost(message, repeated, tag = "1")]
47    pub responses: ::prost::alloc::vec::Vec<
48        verify_smart_contract_wallet_signatures_response::ValidationResponse,
49    >,
50}
51/// Nested message and enum types in `VerifySmartContractWalletSignaturesResponse`.
52pub mod verify_smart_contract_wallet_signatures_response {
53    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
54    pub struct ValidationResponse {
55        #[prost(bool, tag = "1")]
56        pub is_valid: bool,
57        #[prost(uint64, optional, tag = "2")]
58        pub block_number: ::core::option::Option<u64>,
59        #[prost(string, optional, tag = "3")]
60        pub error: ::core::option::Option<::prost::alloc::string::String>,
61    }
62    impl ::prost::Name for ValidationResponse {
63        const NAME: &'static str = "ValidationResponse";
64        const PACKAGE: &'static str = "xmtp.identity.api.v1";
65        fn full_name() -> ::prost::alloc::string::String {
66            "xmtp.identity.api.v1.VerifySmartContractWalletSignaturesResponse.ValidationResponse"
67                .into()
68        }
69        fn type_url() -> ::prost::alloc::string::String {
70            "/xmtp.identity.api.v1.VerifySmartContractWalletSignaturesResponse.ValidationResponse"
71                .into()
72        }
73    }
74}
75impl ::prost::Name for VerifySmartContractWalletSignaturesResponse {
76    const NAME: &'static str = "VerifySmartContractWalletSignaturesResponse";
77    const PACKAGE: &'static str = "xmtp.identity.api.v1";
78    fn full_name() -> ::prost::alloc::string::String {
79        "xmtp.identity.api.v1.VerifySmartContractWalletSignaturesResponse".into()
80    }
81    fn type_url() -> ::prost::alloc::string::String {
82        "/xmtp.identity.api.v1.VerifySmartContractWalletSignaturesResponse".into()
83    }
84}
85/// Publishes an identity update to the network
86#[derive(Clone, PartialEq, ::prost::Message)]
87pub struct PublishIdentityUpdateRequest {
88    #[prost(message, optional, tag = "1")]
89    pub identity_update: ::core::option::Option<
90        super::super::associations::IdentityUpdate,
91    >,
92}
93impl ::prost::Name for PublishIdentityUpdateRequest {
94    const NAME: &'static str = "PublishIdentityUpdateRequest";
95    const PACKAGE: &'static str = "xmtp.identity.api.v1";
96    fn full_name() -> ::prost::alloc::string::String {
97        "xmtp.identity.api.v1.PublishIdentityUpdateRequest".into()
98    }
99    fn type_url() -> ::prost::alloc::string::String {
100        "/xmtp.identity.api.v1.PublishIdentityUpdateRequest".into()
101    }
102}
103/// The response when an identity update is published
104#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
105pub struct PublishIdentityUpdateResponse {}
106impl ::prost::Name for PublishIdentityUpdateResponse {
107    const NAME: &'static str = "PublishIdentityUpdateResponse";
108    const PACKAGE: &'static str = "xmtp.identity.api.v1";
109    fn full_name() -> ::prost::alloc::string::String {
110        "xmtp.identity.api.v1.PublishIdentityUpdateResponse".into()
111    }
112    fn type_url() -> ::prost::alloc::string::String {
113        "/xmtp.identity.api.v1.PublishIdentityUpdateResponse".into()
114    }
115}
116/// Get all updates for an identity since the specified time
117#[derive(Clone, PartialEq, ::prost::Message)]
118pub struct GetIdentityUpdatesRequest {
119    #[prost(message, repeated, tag = "1")]
120    pub requests: ::prost::alloc::vec::Vec<get_identity_updates_request::Request>,
121}
122/// Nested message and enum types in `GetIdentityUpdatesRequest`.
123pub mod get_identity_updates_request {
124    /// Points to the last entry the client has received. The sequence_id should be
125    /// set to 0 if the client has not received anything.
126    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
127    pub struct Request {
128        #[prost(string, tag = "1")]
129        pub inbox_id: ::prost::alloc::string::String,
130        #[prost(uint64, tag = "2")]
131        pub sequence_id: u64,
132    }
133    impl ::prost::Name for Request {
134        const NAME: &'static str = "Request";
135        const PACKAGE: &'static str = "xmtp.identity.api.v1";
136        fn full_name() -> ::prost::alloc::string::String {
137            "xmtp.identity.api.v1.GetIdentityUpdatesRequest.Request".into()
138        }
139        fn type_url() -> ::prost::alloc::string::String {
140            "/xmtp.identity.api.v1.GetIdentityUpdatesRequest.Request".into()
141        }
142    }
143}
144impl ::prost::Name for GetIdentityUpdatesRequest {
145    const NAME: &'static str = "GetIdentityUpdatesRequest";
146    const PACKAGE: &'static str = "xmtp.identity.api.v1";
147    fn full_name() -> ::prost::alloc::string::String {
148        "xmtp.identity.api.v1.GetIdentityUpdatesRequest".into()
149    }
150    fn type_url() -> ::prost::alloc::string::String {
151        "/xmtp.identity.api.v1.GetIdentityUpdatesRequest".into()
152    }
153}
154/// Returns all log entries for the requested identities
155#[derive(Clone, PartialEq, ::prost::Message)]
156pub struct GetIdentityUpdatesResponse {
157    #[prost(message, repeated, tag = "1")]
158    pub responses: ::prost::alloc::vec::Vec<get_identity_updates_response::Response>,
159}
160/// Nested message and enum types in `GetIdentityUpdatesResponse`.
161pub mod get_identity_updates_response {
162    /// A single entry in the XID log on the server.
163    #[derive(Clone, PartialEq, ::prost::Message)]
164    pub struct IdentityUpdateLog {
165        #[prost(uint64, tag = "1")]
166        pub sequence_id: u64,
167        #[prost(uint64, tag = "2")]
168        pub server_timestamp_ns: u64,
169        #[prost(message, optional, tag = "3")]
170        pub update: ::core::option::Option<
171            super::super::super::associations::IdentityUpdate,
172        >,
173    }
174    impl ::prost::Name for IdentityUpdateLog {
175        const NAME: &'static str = "IdentityUpdateLog";
176        const PACKAGE: &'static str = "xmtp.identity.api.v1";
177        fn full_name() -> ::prost::alloc::string::String {
178            "xmtp.identity.api.v1.GetIdentityUpdatesResponse.IdentityUpdateLog".into()
179        }
180        fn type_url() -> ::prost::alloc::string::String {
181            "/xmtp.identity.api.v1.GetIdentityUpdatesResponse.IdentityUpdateLog".into()
182        }
183    }
184    /// The update log for a single identity, starting after the last cursor
185    #[derive(Clone, PartialEq, ::prost::Message)]
186    pub struct Response {
187        #[prost(string, tag = "1")]
188        pub inbox_id: ::prost::alloc::string::String,
189        #[prost(message, repeated, tag = "2")]
190        pub updates: ::prost::alloc::vec::Vec<IdentityUpdateLog>,
191    }
192    impl ::prost::Name for Response {
193        const NAME: &'static str = "Response";
194        const PACKAGE: &'static str = "xmtp.identity.api.v1";
195        fn full_name() -> ::prost::alloc::string::String {
196            "xmtp.identity.api.v1.GetIdentityUpdatesResponse.Response".into()
197        }
198        fn type_url() -> ::prost::alloc::string::String {
199            "/xmtp.identity.api.v1.GetIdentityUpdatesResponse.Response".into()
200        }
201    }
202}
203impl ::prost::Name for GetIdentityUpdatesResponse {
204    const NAME: &'static str = "GetIdentityUpdatesResponse";
205    const PACKAGE: &'static str = "xmtp.identity.api.v1";
206    fn full_name() -> ::prost::alloc::string::String {
207        "xmtp.identity.api.v1.GetIdentityUpdatesResponse".into()
208    }
209    fn type_url() -> ::prost::alloc::string::String {
210        "/xmtp.identity.api.v1.GetIdentityUpdatesResponse".into()
211    }
212}
213/// Request to retrieve the XIDs for the given addresses
214#[derive(Clone, PartialEq, ::prost::Message)]
215pub struct GetInboxIdsRequest {
216    #[prost(message, repeated, tag = "1")]
217    pub requests: ::prost::alloc::vec::Vec<get_inbox_ids_request::Request>,
218}
219/// Nested message and enum types in `GetInboxIdsRequest`.
220pub mod get_inbox_ids_request {
221    /// A single request for a given address
222    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
223    pub struct Request {
224        #[prost(string, tag = "1")]
225        pub identifier: ::prost::alloc::string::String,
226        #[prost(
227            enumeration = "super::super::super::associations::IdentifierKind",
228            tag = "2"
229        )]
230        pub identifier_kind: i32,
231    }
232    impl ::prost::Name for Request {
233        const NAME: &'static str = "Request";
234        const PACKAGE: &'static str = "xmtp.identity.api.v1";
235        fn full_name() -> ::prost::alloc::string::String {
236            "xmtp.identity.api.v1.GetInboxIdsRequest.Request".into()
237        }
238        fn type_url() -> ::prost::alloc::string::String {
239            "/xmtp.identity.api.v1.GetInboxIdsRequest.Request".into()
240        }
241    }
242}
243impl ::prost::Name for GetInboxIdsRequest {
244    const NAME: &'static str = "GetInboxIdsRequest";
245    const PACKAGE: &'static str = "xmtp.identity.api.v1";
246    fn full_name() -> ::prost::alloc::string::String {
247        "xmtp.identity.api.v1.GetInboxIdsRequest".into()
248    }
249    fn type_url() -> ::prost::alloc::string::String {
250        "/xmtp.identity.api.v1.GetInboxIdsRequest".into()
251    }
252}
253/// Response with the XIDs for the requested addresses
254#[derive(Clone, PartialEq, ::prost::Message)]
255pub struct GetInboxIdsResponse {
256    #[prost(message, repeated, tag = "1")]
257    pub responses: ::prost::alloc::vec::Vec<get_inbox_ids_response::Response>,
258}
259/// Nested message and enum types in `GetInboxIdsResponse`.
260pub mod get_inbox_ids_response {
261    /// A single response for a given address
262    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
263    pub struct Response {
264        #[prost(string, tag = "1")]
265        pub identifier: ::prost::alloc::string::String,
266        #[prost(string, optional, tag = "2")]
267        pub inbox_id: ::core::option::Option<::prost::alloc::string::String>,
268        #[prost(
269            enumeration = "super::super::super::associations::IdentifierKind",
270            tag = "3"
271        )]
272        pub identifier_kind: i32,
273    }
274    impl ::prost::Name for Response {
275        const NAME: &'static str = "Response";
276        const PACKAGE: &'static str = "xmtp.identity.api.v1";
277        fn full_name() -> ::prost::alloc::string::String {
278            "xmtp.identity.api.v1.GetInboxIdsResponse.Response".into()
279        }
280        fn type_url() -> ::prost::alloc::string::String {
281            "/xmtp.identity.api.v1.GetInboxIdsResponse.Response".into()
282        }
283    }
284}
285impl ::prost::Name for GetInboxIdsResponse {
286    const NAME: &'static str = "GetInboxIdsResponse";
287    const PACKAGE: &'static str = "xmtp.identity.api.v1";
288    fn full_name() -> ::prost::alloc::string::String {
289        "xmtp.identity.api.v1.GetInboxIdsResponse".into()
290    }
291    fn type_url() -> ::prost::alloc::string::String {
292        "/xmtp.identity.api.v1.GetInboxIdsResponse".into()
293    }
294}
295/// Generated server implementations.
296#[cfg(any(not(target_arch = "wasm32"), feature = "grpc_server_impls"))]
297pub mod identity_api_server {
298    #![allow(
299        unused_variables,
300        dead_code,
301        missing_docs,
302        clippy::wildcard_imports,
303        clippy::let_unit_value,
304    )]
305    use tonic::codegen::*;
306    /// Generated trait containing gRPC methods that should be implemented for use with IdentityApiServer.
307    #[async_trait]
308    pub trait IdentityApi: std::marker::Send + std::marker::Sync + 'static {
309        /// Publishes an identity update for an XID or wallet. An identity update may
310        /// consist of multiple identity actions that have been batch signed.
311        async fn publish_identity_update(
312            &self,
313            request: tonic::Request<super::PublishIdentityUpdateRequest>,
314        ) -> std::result::Result<
315            tonic::Response<super::PublishIdentityUpdateResponse>,
316            tonic::Status,
317        >;
318        /// Used to check for changes related to members of a group.
319        /// Would return an array of any new installations associated with the wallet
320        /// address, and any revocations that have happened.
321        async fn get_identity_updates(
322            &self,
323            request: tonic::Request<super::GetIdentityUpdatesRequest>,
324        ) -> std::result::Result<
325            tonic::Response<super::GetIdentityUpdatesResponse>,
326            tonic::Status,
327        >;
328        /// Retrieve the XIDs for the given addresses
329        async fn get_inbox_ids(
330            &self,
331            request: tonic::Request<super::GetInboxIdsRequest>,
332        ) -> std::result::Result<
333            tonic::Response<super::GetInboxIdsResponse>,
334            tonic::Status,
335        >;
336        /// Verify an unverified smart contract wallet signature
337        async fn verify_smart_contract_wallet_signatures(
338            &self,
339            request: tonic::Request<super::VerifySmartContractWalletSignaturesRequest>,
340        ) -> std::result::Result<
341            tonic::Response<super::VerifySmartContractWalletSignaturesResponse>,
342            tonic::Status,
343        >;
344    }
345    /// RPCs for the new MLS API
346    #[derive(Debug)]
347    pub struct IdentityApiServer<T> {
348        inner: Arc<T>,
349        accept_compression_encodings: EnabledCompressionEncodings,
350        send_compression_encodings: EnabledCompressionEncodings,
351        max_decoding_message_size: Option<usize>,
352        max_encoding_message_size: Option<usize>,
353    }
354    impl<T> IdentityApiServer<T> {
355        pub fn new(inner: T) -> Self {
356            Self::from_arc(Arc::new(inner))
357        }
358        pub fn from_arc(inner: Arc<T>) -> Self {
359            Self {
360                inner,
361                accept_compression_encodings: Default::default(),
362                send_compression_encodings: Default::default(),
363                max_decoding_message_size: None,
364                max_encoding_message_size: None,
365            }
366        }
367        pub fn with_interceptor<F>(
368            inner: T,
369            interceptor: F,
370        ) -> InterceptedService<Self, F>
371        where
372            F: tonic::service::Interceptor,
373        {
374            InterceptedService::new(Self::new(inner), interceptor)
375        }
376        /// Enable decompressing requests with the given encoding.
377        #[must_use]
378        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
379            self.accept_compression_encodings.enable(encoding);
380            self
381        }
382        /// Compress responses with the given encoding, if the client supports it.
383        #[must_use]
384        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
385            self.send_compression_encodings.enable(encoding);
386            self
387        }
388        /// Limits the maximum size of a decoded message.
389        ///
390        /// Default: `4MB`
391        #[must_use]
392        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
393            self.max_decoding_message_size = Some(limit);
394            self
395        }
396        /// Limits the maximum size of an encoded message.
397        ///
398        /// Default: `usize::MAX`
399        #[must_use]
400        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
401            self.max_encoding_message_size = Some(limit);
402            self
403        }
404    }
405    impl<T, B> tonic::codegen::Service<http::Request<B>> for IdentityApiServer<T>
406    where
407        T: IdentityApi,
408        B: Body + std::marker::Send + 'static,
409        B::Error: Into<StdError> + std::marker::Send + 'static,
410    {
411        type Response = http::Response<tonic::body::Body>;
412        type Error = std::convert::Infallible;
413        type Future = BoxFuture<Self::Response, Self::Error>;
414        fn poll_ready(
415            &mut self,
416            _cx: &mut Context<'_>,
417        ) -> Poll<std::result::Result<(), Self::Error>> {
418            Poll::Ready(Ok(()))
419        }
420        fn call(&mut self, req: http::Request<B>) -> Self::Future {
421            match req.uri().path() {
422                "/xmtp.identity.api.v1.IdentityApi/PublishIdentityUpdate" => {
423                    #[allow(non_camel_case_types)]
424                    struct PublishIdentityUpdateSvc<T: IdentityApi>(pub Arc<T>);
425                    impl<
426                        T: IdentityApi,
427                    > tonic::server::UnaryService<super::PublishIdentityUpdateRequest>
428                    for PublishIdentityUpdateSvc<T> {
429                        type Response = super::PublishIdentityUpdateResponse;
430                        type Future = BoxFuture<
431                            tonic::Response<Self::Response>,
432                            tonic::Status,
433                        >;
434                        fn call(
435                            &mut self,
436                            request: tonic::Request<super::PublishIdentityUpdateRequest>,
437                        ) -> Self::Future {
438                            let inner = Arc::clone(&self.0);
439                            let fut = async move {
440                                <T as IdentityApi>::publish_identity_update(&inner, request)
441                                    .await
442                            };
443                            Box::pin(fut)
444                        }
445                    }
446                    let accept_compression_encodings = self.accept_compression_encodings;
447                    let send_compression_encodings = self.send_compression_encodings;
448                    let max_decoding_message_size = self.max_decoding_message_size;
449                    let max_encoding_message_size = self.max_encoding_message_size;
450                    let inner = self.inner.clone();
451                    let fut = async move {
452                        let method = PublishIdentityUpdateSvc(inner);
453                        let codec = tonic_prost::ProstCodec::default();
454                        let mut grpc = tonic::server::Grpc::new(codec)
455                            .apply_compression_config(
456                                accept_compression_encodings,
457                                send_compression_encodings,
458                            )
459                            .apply_max_message_size_config(
460                                max_decoding_message_size,
461                                max_encoding_message_size,
462                            );
463                        let res = grpc.unary(method, req).await;
464                        Ok(res)
465                    };
466                    Box::pin(fut)
467                }
468                "/xmtp.identity.api.v1.IdentityApi/GetIdentityUpdates" => {
469                    #[allow(non_camel_case_types)]
470                    struct GetIdentityUpdatesSvc<T: IdentityApi>(pub Arc<T>);
471                    impl<
472                        T: IdentityApi,
473                    > tonic::server::UnaryService<super::GetIdentityUpdatesRequest>
474                    for GetIdentityUpdatesSvc<T> {
475                        type Response = super::GetIdentityUpdatesResponse;
476                        type Future = BoxFuture<
477                            tonic::Response<Self::Response>,
478                            tonic::Status,
479                        >;
480                        fn call(
481                            &mut self,
482                            request: tonic::Request<super::GetIdentityUpdatesRequest>,
483                        ) -> Self::Future {
484                            let inner = Arc::clone(&self.0);
485                            let fut = async move {
486                                <T as IdentityApi>::get_identity_updates(&inner, request)
487                                    .await
488                            };
489                            Box::pin(fut)
490                        }
491                    }
492                    let accept_compression_encodings = self.accept_compression_encodings;
493                    let send_compression_encodings = self.send_compression_encodings;
494                    let max_decoding_message_size = self.max_decoding_message_size;
495                    let max_encoding_message_size = self.max_encoding_message_size;
496                    let inner = self.inner.clone();
497                    let fut = async move {
498                        let method = GetIdentityUpdatesSvc(inner);
499                        let codec = tonic_prost::ProstCodec::default();
500                        let mut grpc = tonic::server::Grpc::new(codec)
501                            .apply_compression_config(
502                                accept_compression_encodings,
503                                send_compression_encodings,
504                            )
505                            .apply_max_message_size_config(
506                                max_decoding_message_size,
507                                max_encoding_message_size,
508                            );
509                        let res = grpc.unary(method, req).await;
510                        Ok(res)
511                    };
512                    Box::pin(fut)
513                }
514                "/xmtp.identity.api.v1.IdentityApi/GetInboxIds" => {
515                    #[allow(non_camel_case_types)]
516                    struct GetInboxIdsSvc<T: IdentityApi>(pub Arc<T>);
517                    impl<
518                        T: IdentityApi,
519                    > tonic::server::UnaryService<super::GetInboxIdsRequest>
520                    for GetInboxIdsSvc<T> {
521                        type Response = super::GetInboxIdsResponse;
522                        type Future = BoxFuture<
523                            tonic::Response<Self::Response>,
524                            tonic::Status,
525                        >;
526                        fn call(
527                            &mut self,
528                            request: tonic::Request<super::GetInboxIdsRequest>,
529                        ) -> Self::Future {
530                            let inner = Arc::clone(&self.0);
531                            let fut = async move {
532                                <T as IdentityApi>::get_inbox_ids(&inner, request).await
533                            };
534                            Box::pin(fut)
535                        }
536                    }
537                    let accept_compression_encodings = self.accept_compression_encodings;
538                    let send_compression_encodings = self.send_compression_encodings;
539                    let max_decoding_message_size = self.max_decoding_message_size;
540                    let max_encoding_message_size = self.max_encoding_message_size;
541                    let inner = self.inner.clone();
542                    let fut = async move {
543                        let method = GetInboxIdsSvc(inner);
544                        let codec = tonic_prost::ProstCodec::default();
545                        let mut grpc = tonic::server::Grpc::new(codec)
546                            .apply_compression_config(
547                                accept_compression_encodings,
548                                send_compression_encodings,
549                            )
550                            .apply_max_message_size_config(
551                                max_decoding_message_size,
552                                max_encoding_message_size,
553                            );
554                        let res = grpc.unary(method, req).await;
555                        Ok(res)
556                    };
557                    Box::pin(fut)
558                }
559                "/xmtp.identity.api.v1.IdentityApi/VerifySmartContractWalletSignatures" => {
560                    #[allow(non_camel_case_types)]
561                    struct VerifySmartContractWalletSignaturesSvc<T: IdentityApi>(
562                        pub Arc<T>,
563                    );
564                    impl<
565                        T: IdentityApi,
566                    > tonic::server::UnaryService<
567                        super::VerifySmartContractWalletSignaturesRequest,
568                    > for VerifySmartContractWalletSignaturesSvc<T> {
569                        type Response = super::VerifySmartContractWalletSignaturesResponse;
570                        type Future = BoxFuture<
571                            tonic::Response<Self::Response>,
572                            tonic::Status,
573                        >;
574                        fn call(
575                            &mut self,
576                            request: tonic::Request<
577                                super::VerifySmartContractWalletSignaturesRequest,
578                            >,
579                        ) -> Self::Future {
580                            let inner = Arc::clone(&self.0);
581                            let fut = async move {
582                                <T as IdentityApi>::verify_smart_contract_wallet_signatures(
583                                        &inner,
584                                        request,
585                                    )
586                                    .await
587                            };
588                            Box::pin(fut)
589                        }
590                    }
591                    let accept_compression_encodings = self.accept_compression_encodings;
592                    let send_compression_encodings = self.send_compression_encodings;
593                    let max_decoding_message_size = self.max_decoding_message_size;
594                    let max_encoding_message_size = self.max_encoding_message_size;
595                    let inner = self.inner.clone();
596                    let fut = async move {
597                        let method = VerifySmartContractWalletSignaturesSvc(inner);
598                        let codec = tonic_prost::ProstCodec::default();
599                        let mut grpc = tonic::server::Grpc::new(codec)
600                            .apply_compression_config(
601                                accept_compression_encodings,
602                                send_compression_encodings,
603                            )
604                            .apply_max_message_size_config(
605                                max_decoding_message_size,
606                                max_encoding_message_size,
607                            );
608                        let res = grpc.unary(method, req).await;
609                        Ok(res)
610                    };
611                    Box::pin(fut)
612                }
613                _ => {
614                    Box::pin(async move {
615                        let mut response = http::Response::new(
616                            tonic::body::Body::default(),
617                        );
618                        let headers = response.headers_mut();
619                        headers
620                            .insert(
621                                tonic::Status::GRPC_STATUS,
622                                (tonic::Code::Unimplemented as i32).into(),
623                            );
624                        headers
625                            .insert(
626                                http::header::CONTENT_TYPE,
627                                tonic::metadata::GRPC_CONTENT_TYPE,
628                            );
629                        Ok(response)
630                    })
631                }
632            }
633        }
634    }
635    impl<T> Clone for IdentityApiServer<T> {
636        fn clone(&self) -> Self {
637            let inner = self.inner.clone();
638            Self {
639                inner,
640                accept_compression_encodings: self.accept_compression_encodings,
641                send_compression_encodings: self.send_compression_encodings,
642                max_decoding_message_size: self.max_decoding_message_size,
643                max_encoding_message_size: self.max_encoding_message_size,
644            }
645        }
646    }
647    /// Generated gRPC service name
648    pub const SERVICE_NAME: &str = "xmtp.identity.api.v1.IdentityApi";
649    impl<T> tonic::server::NamedService for IdentityApiServer<T> {
650        const NAME: &'static str = SERVICE_NAME;
651    }
652}
xmtp_proto/gen/xmtp.identity.api.v1.rs

xmtp_proto/gen/
xmtp.identity.api.v1.rs
