side_proto/prost/side/
side.tss.tonic.rs

1// @generated
2/// Generated client implementations.
3#[cfg(feature = "grpc")]
4pub mod query_client {
5    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
6    use tonic::codegen::http::Uri;
7    use tonic::codegen::*;
8    #[derive(Debug, Clone)]
9    pub struct QueryClient<T> {
10        inner: tonic::client::Grpc<T>,
11    }
12    #[cfg(feature = "grpc-transport")]
13    impl QueryClient<tonic::transport::Channel> {
14        /// Attempt to create a new client by connecting to a given endpoint.
15        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
16        where
17            D: TryInto<tonic::transport::Endpoint>,
18            D::Error: Into<StdError>,
19        {
20            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
21            Ok(Self::new(conn))
22        }
23    }
24    impl<T> QueryClient<T>
25    where
26        T: tonic::client::GrpcService<tonic::body::BoxBody>,
27        T::Error: Into<StdError>,
28        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
29        <T::ResponseBody as Body>::Error: Into<StdError> + Send,
30    {
31        pub fn new(inner: T) -> Self {
32            let inner = tonic::client::Grpc::new(inner);
33            Self { inner }
34        }
35        pub fn with_origin(inner: T, origin: Uri) -> Self {
36            let inner = tonic::client::Grpc::with_origin(inner, origin);
37            Self { inner }
38        }
39        pub fn with_interceptor<F>(
40            inner: T,
41            interceptor: F,
42        ) -> QueryClient<InterceptedService<T, F>>
43        where
44            F: tonic::service::Interceptor,
45            T::ResponseBody: Default,
46            T: tonic::codegen::Service<
47                http::Request<tonic::body::BoxBody>,
48                Response = http::Response<
49                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
50                >,
51            >,
52            <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
53                Into<StdError> + Send + Sync,
54        {
55            QueryClient::new(InterceptedService::new(inner, interceptor))
56        }
57        /// Compress requests with the given encoding.
58        ///
59        /// This requires the server to support it otherwise it might respond with an
60        /// error.
61        #[must_use]
62        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
63            self.inner = self.inner.send_compressed(encoding);
64            self
65        }
66        /// Enable decompressing responses.
67        #[must_use]
68        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
69            self.inner = self.inner.accept_compressed(encoding);
70            self
71        }
72        /// Limits the maximum size of a decoded message.
73        ///
74        /// Default: `4MB`
75        #[must_use]
76        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
77            self.inner = self.inner.max_decoding_message_size(limit);
78            self
79        }
80        /// Limits the maximum size of an encoded message.
81        ///
82        /// Default: `usize::MAX`
83        #[must_use]
84        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
85            self.inner = self.inner.max_encoding_message_size(limit);
86            self
87        }
88        pub async fn params(
89            &mut self,
90            request: impl tonic::IntoRequest<super::QueryParamsRequest>,
91        ) -> core::result::Result<tonic::Response<super::QueryParamsResponse>, tonic::Status>
92        {
93            self.inner.ready().await.map_err(|e| {
94                tonic::Status::new(
95                    tonic::Code::Unknown,
96                    alloc::format!("Service was not ready: {}", e.into()),
97                )
98            })?;
99            let codec = tonic::codec::ProstCodec::default();
100            let path = http::uri::PathAndQuery::from_static("/side.tss.Query/Params");
101            let mut req = request.into_request();
102            req.extensions_mut()
103                .insert(GrpcMethod::new("side.tss.Query", "Params"));
104            self.inner.unary(req, path, codec).await
105        }
106        pub async fn dkg_request(
107            &mut self,
108            request: impl tonic::IntoRequest<super::QueryDkgRequestRequest>,
109        ) -> core::result::Result<tonic::Response<super::QueryDkgRequestResponse>, tonic::Status>
110        {
111            self.inner.ready().await.map_err(|e| {
112                tonic::Status::new(
113                    tonic::Code::Unknown,
114                    alloc::format!("Service was not ready: {}", e.into()),
115                )
116            })?;
117            let codec = tonic::codec::ProstCodec::default();
118            let path = http::uri::PathAndQuery::from_static("/side.tss.Query/DKGRequest");
119            let mut req = request.into_request();
120            req.extensions_mut()
121                .insert(GrpcMethod::new("side.tss.Query", "DKGRequest"));
122            self.inner.unary(req, path, codec).await
123        }
124        pub async fn dkg_requests(
125            &mut self,
126            request: impl tonic::IntoRequest<super::QueryDkgRequestsRequest>,
127        ) -> core::result::Result<tonic::Response<super::QueryDkgRequestsResponse>, tonic::Status>
128        {
129            self.inner.ready().await.map_err(|e| {
130                tonic::Status::new(
131                    tonic::Code::Unknown,
132                    alloc::format!("Service was not ready: {}", e.into()),
133                )
134            })?;
135            let codec = tonic::codec::ProstCodec::default();
136            let path = http::uri::PathAndQuery::from_static("/side.tss.Query/DKGRequests");
137            let mut req = request.into_request();
138            req.extensions_mut()
139                .insert(GrpcMethod::new("side.tss.Query", "DKGRequests"));
140            self.inner.unary(req, path, codec).await
141        }
142        pub async fn dkg_completions(
143            &mut self,
144            request: impl tonic::IntoRequest<super::QueryDkgCompletionsRequest>,
145        ) -> core::result::Result<tonic::Response<super::QueryDkgCompletionsResponse>, tonic::Status>
146        {
147            self.inner.ready().await.map_err(|e| {
148                tonic::Status::new(
149                    tonic::Code::Unknown,
150                    alloc::format!("Service was not ready: {}", e.into()),
151                )
152            })?;
153            let codec = tonic::codec::ProstCodec::default();
154            let path = http::uri::PathAndQuery::from_static("/side.tss.Query/DKGCompletions");
155            let mut req = request.into_request();
156            req.extensions_mut()
157                .insert(GrpcMethod::new("side.tss.Query", "DKGCompletions"));
158            self.inner.unary(req, path, codec).await
159        }
160        pub async fn signing_request(
161            &mut self,
162            request: impl tonic::IntoRequest<super::QuerySigningRequestRequest>,
163        ) -> core::result::Result<tonic::Response<super::QuerySigningRequestResponse>, tonic::Status>
164        {
165            self.inner.ready().await.map_err(|e| {
166                tonic::Status::new(
167                    tonic::Code::Unknown,
168                    alloc::format!("Service was not ready: {}", e.into()),
169                )
170            })?;
171            let codec = tonic::codec::ProstCodec::default();
172            let path = http::uri::PathAndQuery::from_static("/side.tss.Query/SigningRequest");
173            let mut req = request.into_request();
174            req.extensions_mut()
175                .insert(GrpcMethod::new("side.tss.Query", "SigningRequest"));
176            self.inner.unary(req, path, codec).await
177        }
178        pub async fn signing_requests(
179            &mut self,
180            request: impl tonic::IntoRequest<super::QuerySigningRequestsRequest>,
181        ) -> core::result::Result<tonic::Response<super::QuerySigningRequestsResponse>, tonic::Status>
182        {
183            self.inner.ready().await.map_err(|e| {
184                tonic::Status::new(
185                    tonic::Code::Unknown,
186                    alloc::format!("Service was not ready: {}", e.into()),
187                )
188            })?;
189            let codec = tonic::codec::ProstCodec::default();
190            let path = http::uri::PathAndQuery::from_static("/side.tss.Query/SigningRequests");
191            let mut req = request.into_request();
192            req.extensions_mut()
193                .insert(GrpcMethod::new("side.tss.Query", "SigningRequests"));
194            self.inner.unary(req, path, codec).await
195        }
196        pub async fn refreshing_request(
197            &mut self,
198            request: impl tonic::IntoRequest<super::QueryRefreshingRequestRequest>,
199        ) -> core::result::Result<
200            tonic::Response<super::QueryRefreshingRequestResponse>,
201            tonic::Status,
202        > {
203            self.inner.ready().await.map_err(|e| {
204                tonic::Status::new(
205                    tonic::Code::Unknown,
206                    alloc::format!("Service was not ready: {}", e.into()),
207                )
208            })?;
209            let codec = tonic::codec::ProstCodec::default();
210            let path = http::uri::PathAndQuery::from_static("/side.tss.Query/RefreshingRequest");
211            let mut req = request.into_request();
212            req.extensions_mut()
213                .insert(GrpcMethod::new("side.tss.Query", "RefreshingRequest"));
214            self.inner.unary(req, path, codec).await
215        }
216        pub async fn refreshing_requests(
217            &mut self,
218            request: impl tonic::IntoRequest<super::QueryRefreshingRequestsRequest>,
219        ) -> core::result::Result<
220            tonic::Response<super::QueryRefreshingRequestsResponse>,
221            tonic::Status,
222        > {
223            self.inner.ready().await.map_err(|e| {
224                tonic::Status::new(
225                    tonic::Code::Unknown,
226                    alloc::format!("Service was not ready: {}", e.into()),
227                )
228            })?;
229            let codec = tonic::codec::ProstCodec::default();
230            let path = http::uri::PathAndQuery::from_static("/side.tss.Query/RefreshingRequests");
231            let mut req = request.into_request();
232            req.extensions_mut()
233                .insert(GrpcMethod::new("side.tss.Query", "RefreshingRequests"));
234            self.inner.unary(req, path, codec).await
235        }
236        pub async fn refreshing_completions(
237            &mut self,
238            request: impl tonic::IntoRequest<super::QueryRefreshingCompletionsRequest>,
239        ) -> core::result::Result<
240            tonic::Response<super::QueryRefreshingCompletionsResponse>,
241            tonic::Status,
242        > {
243            self.inner.ready().await.map_err(|e| {
244                tonic::Status::new(
245                    tonic::Code::Unknown,
246                    alloc::format!("Service was not ready: {}", e.into()),
247                )
248            })?;
249            let codec = tonic::codec::ProstCodec::default();
250            let path =
251                http::uri::PathAndQuery::from_static("/side.tss.Query/RefreshingCompletions");
252            let mut req = request.into_request();
253            req.extensions_mut()
254                .insert(GrpcMethod::new("side.tss.Query", "RefreshingCompletions"));
255            self.inner.unary(req, path, codec).await
256        }
257    }
258}
259/// Generated server implementations.
260#[cfg(feature = "grpc")]
261pub mod query_server {
262    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
263    use tonic::codegen::*;
264    /// Generated trait containing gRPC methods that should be implemented for use with QueryServer.
265    #[async_trait]
266    pub trait Query: Send + Sync + 'static {
267        async fn params(
268            &self,
269            request: tonic::Request<super::QueryParamsRequest>,
270        ) -> core::result::Result<tonic::Response<super::QueryParamsResponse>, tonic::Status>;
271        async fn dkg_request(
272            &self,
273            request: tonic::Request<super::QueryDkgRequestRequest>,
274        ) -> core::result::Result<tonic::Response<super::QueryDkgRequestResponse>, tonic::Status>;
275        async fn dkg_requests(
276            &self,
277            request: tonic::Request<super::QueryDkgRequestsRequest>,
278        ) -> core::result::Result<tonic::Response<super::QueryDkgRequestsResponse>, tonic::Status>;
279        async fn dkg_completions(
280            &self,
281            request: tonic::Request<super::QueryDkgCompletionsRequest>,
282        ) -> core::result::Result<tonic::Response<super::QueryDkgCompletionsResponse>, tonic::Status>;
283        async fn signing_request(
284            &self,
285            request: tonic::Request<super::QuerySigningRequestRequest>,
286        ) -> core::result::Result<tonic::Response<super::QuerySigningRequestResponse>, tonic::Status>;
287        async fn signing_requests(
288            &self,
289            request: tonic::Request<super::QuerySigningRequestsRequest>,
290        ) -> core::result::Result<tonic::Response<super::QuerySigningRequestsResponse>, tonic::Status>;
291        async fn refreshing_request(
292            &self,
293            request: tonic::Request<super::QueryRefreshingRequestRequest>,
294        ) -> core::result::Result<
295            tonic::Response<super::QueryRefreshingRequestResponse>,
296            tonic::Status,
297        >;
298        async fn refreshing_requests(
299            &self,
300            request: tonic::Request<super::QueryRefreshingRequestsRequest>,
301        ) -> core::result::Result<
302            tonic::Response<super::QueryRefreshingRequestsResponse>,
303            tonic::Status,
304        >;
305        async fn refreshing_completions(
306            &self,
307            request: tonic::Request<super::QueryRefreshingCompletionsRequest>,
308        ) -> core::result::Result<
309            tonic::Response<super::QueryRefreshingCompletionsResponse>,
310            tonic::Status,
311        >;
312    }
313    #[derive(Debug)]
314    pub struct QueryServer<T: Query> {
315        inner: _Inner<T>,
316        accept_compression_encodings: EnabledCompressionEncodings,
317        send_compression_encodings: EnabledCompressionEncodings,
318        max_decoding_message_size: Option<usize>,
319        max_encoding_message_size: Option<usize>,
320    }
321    struct _Inner<T>(Arc<T>);
322    impl<T: Query> QueryServer<T> {
323        pub fn new(inner: T) -> Self {
324            Self::from_arc(Arc::new(inner))
325        }
326        pub fn from_arc(inner: Arc<T>) -> Self {
327            let inner = _Inner(inner);
328            Self {
329                inner,
330                accept_compression_encodings: Default::default(),
331                send_compression_encodings: Default::default(),
332                max_decoding_message_size: None,
333                max_encoding_message_size: None,
334            }
335        }
336        pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
337        where
338            F: tonic::service::Interceptor,
339        {
340            InterceptedService::new(Self::new(inner), interceptor)
341        }
342        /// Enable decompressing requests with the given encoding.
343        #[must_use]
344        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
345            self.accept_compression_encodings.enable(encoding);
346            self
347        }
348        /// Compress responses with the given encoding, if the client supports it.
349        #[must_use]
350        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
351            self.send_compression_encodings.enable(encoding);
352            self
353        }
354        /// Limits the maximum size of a decoded message.
355        ///
356        /// Default: `4MB`
357        #[must_use]
358        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
359            self.max_decoding_message_size = Some(limit);
360            self
361        }
362        /// Limits the maximum size of an encoded message.
363        ///
364        /// Default: `usize::MAX`
365        #[must_use]
366        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
367            self.max_encoding_message_size = Some(limit);
368            self
369        }
370    }
371    impl<T, B> tonic::codegen::Service<http::Request<B>> for QueryServer<T>
372    where
373        T: Query,
374        B: Body + Send + 'static,
375        B::Error: Into<StdError> + Send + 'static,
376    {
377        type Response = http::Response<tonic::body::BoxBody>;
378        type Error = std::convert::Infallible;
379        type Future = BoxFuture<Self::Response, Self::Error>;
380        fn poll_ready(
381            &mut self,
382            _cx: &mut Context<'_>,
383        ) -> Poll<core::result::Result<(), Self::Error>> {
384            Poll::Ready(Ok(()))
385        }
386        fn call(&mut self, req: http::Request<B>) -> Self::Future {
387            let inner = self.inner.clone();
388            match req.uri().path() {
389                "/side.tss.Query/Params" => {
390                    #[allow(non_camel_case_types)]
391                    struct ParamsSvc<T: Query>(pub Arc<T>);
392                    impl<T: Query> tonic::server::UnaryService<super::QueryParamsRequest> for ParamsSvc<T> {
393                        type Response = super::QueryParamsResponse;
394                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
395                        fn call(
396                            &mut self,
397                            request: tonic::Request<super::QueryParamsRequest>,
398                        ) -> Self::Future {
399                            let inner = Arc::clone(&self.0);
400                            let fut = async move { (*inner).params(request).await };
401                            Box::pin(fut)
402                        }
403                    }
404                    let accept_compression_encodings = self.accept_compression_encodings;
405                    let send_compression_encodings = self.send_compression_encodings;
406                    let max_decoding_message_size = self.max_decoding_message_size;
407                    let max_encoding_message_size = self.max_encoding_message_size;
408                    let inner = self.inner.clone();
409                    let fut = async move {
410                        let inner = inner.0;
411                        let method = ParamsSvc(inner);
412                        let codec = tonic::codec::ProstCodec::default();
413                        let mut grpc = tonic::server::Grpc::new(codec)
414                            .apply_compression_config(
415                                accept_compression_encodings,
416                                send_compression_encodings,
417                            )
418                            .apply_max_message_size_config(
419                                max_decoding_message_size,
420                                max_encoding_message_size,
421                            );
422                        let res = grpc.unary(method, req).await;
423                        Ok(res)
424                    };
425                    Box::pin(fut)
426                }
427                "/side.tss.Query/DKGRequest" => {
428                    #[allow(non_camel_case_types)]
429                    struct DKGRequestSvc<T: Query>(pub Arc<T>);
430                    impl<T: Query> tonic::server::UnaryService<super::QueryDkgRequestRequest> for DKGRequestSvc<T> {
431                        type Response = super::QueryDkgRequestResponse;
432                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
433                        fn call(
434                            &mut self,
435                            request: tonic::Request<super::QueryDkgRequestRequest>,
436                        ) -> Self::Future {
437                            let inner = Arc::clone(&self.0);
438                            let fut = async move { (*inner).dkg_request(request).await };
439                            Box::pin(fut)
440                        }
441                    }
442                    let accept_compression_encodings = self.accept_compression_encodings;
443                    let send_compression_encodings = self.send_compression_encodings;
444                    let max_decoding_message_size = self.max_decoding_message_size;
445                    let max_encoding_message_size = self.max_encoding_message_size;
446                    let inner = self.inner.clone();
447                    let fut = async move {
448                        let inner = inner.0;
449                        let method = DKGRequestSvc(inner);
450                        let codec = tonic::codec::ProstCodec::default();
451                        let mut grpc = tonic::server::Grpc::new(codec)
452                            .apply_compression_config(
453                                accept_compression_encodings,
454                                send_compression_encodings,
455                            )
456                            .apply_max_message_size_config(
457                                max_decoding_message_size,
458                                max_encoding_message_size,
459                            );
460                        let res = grpc.unary(method, req).await;
461                        Ok(res)
462                    };
463                    Box::pin(fut)
464                }
465                "/side.tss.Query/DKGRequests" => {
466                    #[allow(non_camel_case_types)]
467                    struct DKGRequestsSvc<T: Query>(pub Arc<T>);
468                    impl<T: Query> tonic::server::UnaryService<super::QueryDkgRequestsRequest> for DKGRequestsSvc<T> {
469                        type Response = super::QueryDkgRequestsResponse;
470                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
471                        fn call(
472                            &mut self,
473                            request: tonic::Request<super::QueryDkgRequestsRequest>,
474                        ) -> Self::Future {
475                            let inner = Arc::clone(&self.0);
476                            let fut = async move { (*inner).dkg_requests(request).await };
477                            Box::pin(fut)
478                        }
479                    }
480                    let accept_compression_encodings = self.accept_compression_encodings;
481                    let send_compression_encodings = self.send_compression_encodings;
482                    let max_decoding_message_size = self.max_decoding_message_size;
483                    let max_encoding_message_size = self.max_encoding_message_size;
484                    let inner = self.inner.clone();
485                    let fut = async move {
486                        let inner = inner.0;
487                        let method = DKGRequestsSvc(inner);
488                        let codec = tonic::codec::ProstCodec::default();
489                        let mut grpc = tonic::server::Grpc::new(codec)
490                            .apply_compression_config(
491                                accept_compression_encodings,
492                                send_compression_encodings,
493                            )
494                            .apply_max_message_size_config(
495                                max_decoding_message_size,
496                                max_encoding_message_size,
497                            );
498                        let res = grpc.unary(method, req).await;
499                        Ok(res)
500                    };
501                    Box::pin(fut)
502                }
503                "/side.tss.Query/DKGCompletions" => {
504                    #[allow(non_camel_case_types)]
505                    struct DKGCompletionsSvc<T: Query>(pub Arc<T>);
506                    impl<T: Query> tonic::server::UnaryService<super::QueryDkgCompletionsRequest>
507                        for DKGCompletionsSvc<T>
508                    {
509                        type Response = super::QueryDkgCompletionsResponse;
510                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
511                        fn call(
512                            &mut self,
513                            request: tonic::Request<super::QueryDkgCompletionsRequest>,
514                        ) -> Self::Future {
515                            let inner = Arc::clone(&self.0);
516                            let fut = async move { (*inner).dkg_completions(request).await };
517                            Box::pin(fut)
518                        }
519                    }
520                    let accept_compression_encodings = self.accept_compression_encodings;
521                    let send_compression_encodings = self.send_compression_encodings;
522                    let max_decoding_message_size = self.max_decoding_message_size;
523                    let max_encoding_message_size = self.max_encoding_message_size;
524                    let inner = self.inner.clone();
525                    let fut = async move {
526                        let inner = inner.0;
527                        let method = DKGCompletionsSvc(inner);
528                        let codec = tonic::codec::ProstCodec::default();
529                        let mut grpc = tonic::server::Grpc::new(codec)
530                            .apply_compression_config(
531                                accept_compression_encodings,
532                                send_compression_encodings,
533                            )
534                            .apply_max_message_size_config(
535                                max_decoding_message_size,
536                                max_encoding_message_size,
537                            );
538                        let res = grpc.unary(method, req).await;
539                        Ok(res)
540                    };
541                    Box::pin(fut)
542                }
543                "/side.tss.Query/SigningRequest" => {
544                    #[allow(non_camel_case_types)]
545                    struct SigningRequestSvc<T: Query>(pub Arc<T>);
546                    impl<T: Query> tonic::server::UnaryService<super::QuerySigningRequestRequest>
547                        for SigningRequestSvc<T>
548                    {
549                        type Response = super::QuerySigningRequestResponse;
550                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
551                        fn call(
552                            &mut self,
553                            request: tonic::Request<super::QuerySigningRequestRequest>,
554                        ) -> Self::Future {
555                            let inner = Arc::clone(&self.0);
556                            let fut = async move { (*inner).signing_request(request).await };
557                            Box::pin(fut)
558                        }
559                    }
560                    let accept_compression_encodings = self.accept_compression_encodings;
561                    let send_compression_encodings = self.send_compression_encodings;
562                    let max_decoding_message_size = self.max_decoding_message_size;
563                    let max_encoding_message_size = self.max_encoding_message_size;
564                    let inner = self.inner.clone();
565                    let fut = async move {
566                        let inner = inner.0;
567                        let method = SigningRequestSvc(inner);
568                        let codec = tonic::codec::ProstCodec::default();
569                        let mut grpc = tonic::server::Grpc::new(codec)
570                            .apply_compression_config(
571                                accept_compression_encodings,
572                                send_compression_encodings,
573                            )
574                            .apply_max_message_size_config(
575                                max_decoding_message_size,
576                                max_encoding_message_size,
577                            );
578                        let res = grpc.unary(method, req).await;
579                        Ok(res)
580                    };
581                    Box::pin(fut)
582                }
583                "/side.tss.Query/SigningRequests" => {
584                    #[allow(non_camel_case_types)]
585                    struct SigningRequestsSvc<T: Query>(pub Arc<T>);
586                    impl<T: Query> tonic::server::UnaryService<super::QuerySigningRequestsRequest>
587                        for SigningRequestsSvc<T>
588                    {
589                        type Response = super::QuerySigningRequestsResponse;
590                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
591                        fn call(
592                            &mut self,
593                            request: tonic::Request<super::QuerySigningRequestsRequest>,
594                        ) -> Self::Future {
595                            let inner = Arc::clone(&self.0);
596                            let fut = async move { (*inner).signing_requests(request).await };
597                            Box::pin(fut)
598                        }
599                    }
600                    let accept_compression_encodings = self.accept_compression_encodings;
601                    let send_compression_encodings = self.send_compression_encodings;
602                    let max_decoding_message_size = self.max_decoding_message_size;
603                    let max_encoding_message_size = self.max_encoding_message_size;
604                    let inner = self.inner.clone();
605                    let fut = async move {
606                        let inner = inner.0;
607                        let method = SigningRequestsSvc(inner);
608                        let codec = tonic::codec::ProstCodec::default();
609                        let mut grpc = tonic::server::Grpc::new(codec)
610                            .apply_compression_config(
611                                accept_compression_encodings,
612                                send_compression_encodings,
613                            )
614                            .apply_max_message_size_config(
615                                max_decoding_message_size,
616                                max_encoding_message_size,
617                            );
618                        let res = grpc.unary(method, req).await;
619                        Ok(res)
620                    };
621                    Box::pin(fut)
622                }
623                "/side.tss.Query/RefreshingRequest" => {
624                    #[allow(non_camel_case_types)]
625                    struct RefreshingRequestSvc<T: Query>(pub Arc<T>);
626                    impl<T: Query> tonic::server::UnaryService<super::QueryRefreshingRequestRequest>
627                        for RefreshingRequestSvc<T>
628                    {
629                        type Response = super::QueryRefreshingRequestResponse;
630                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
631                        fn call(
632                            &mut self,
633                            request: tonic::Request<super::QueryRefreshingRequestRequest>,
634                        ) -> Self::Future {
635                            let inner = Arc::clone(&self.0);
636                            let fut = async move { (*inner).refreshing_request(request).await };
637                            Box::pin(fut)
638                        }
639                    }
640                    let accept_compression_encodings = self.accept_compression_encodings;
641                    let send_compression_encodings = self.send_compression_encodings;
642                    let max_decoding_message_size = self.max_decoding_message_size;
643                    let max_encoding_message_size = self.max_encoding_message_size;
644                    let inner = self.inner.clone();
645                    let fut = async move {
646                        let inner = inner.0;
647                        let method = RefreshingRequestSvc(inner);
648                        let codec = tonic::codec::ProstCodec::default();
649                        let mut grpc = tonic::server::Grpc::new(codec)
650                            .apply_compression_config(
651                                accept_compression_encodings,
652                                send_compression_encodings,
653                            )
654                            .apply_max_message_size_config(
655                                max_decoding_message_size,
656                                max_encoding_message_size,
657                            );
658                        let res = grpc.unary(method, req).await;
659                        Ok(res)
660                    };
661                    Box::pin(fut)
662                }
663                "/side.tss.Query/RefreshingRequests" => {
664                    #[allow(non_camel_case_types)]
665                    struct RefreshingRequestsSvc<T: Query>(pub Arc<T>);
666                    impl<T: Query>
667                        tonic::server::UnaryService<super::QueryRefreshingRequestsRequest>
668                        for RefreshingRequestsSvc<T>
669                    {
670                        type Response = super::QueryRefreshingRequestsResponse;
671                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
672                        fn call(
673                            &mut self,
674                            request: tonic::Request<super::QueryRefreshingRequestsRequest>,
675                        ) -> Self::Future {
676                            let inner = Arc::clone(&self.0);
677                            let fut = async move { (*inner).refreshing_requests(request).await };
678                            Box::pin(fut)
679                        }
680                    }
681                    let accept_compression_encodings = self.accept_compression_encodings;
682                    let send_compression_encodings = self.send_compression_encodings;
683                    let max_decoding_message_size = self.max_decoding_message_size;
684                    let max_encoding_message_size = self.max_encoding_message_size;
685                    let inner = self.inner.clone();
686                    let fut = async move {
687                        let inner = inner.0;
688                        let method = RefreshingRequestsSvc(inner);
689                        let codec = tonic::codec::ProstCodec::default();
690                        let mut grpc = tonic::server::Grpc::new(codec)
691                            .apply_compression_config(
692                                accept_compression_encodings,
693                                send_compression_encodings,
694                            )
695                            .apply_max_message_size_config(
696                                max_decoding_message_size,
697                                max_encoding_message_size,
698                            );
699                        let res = grpc.unary(method, req).await;
700                        Ok(res)
701                    };
702                    Box::pin(fut)
703                }
704                "/side.tss.Query/RefreshingCompletions" => {
705                    #[allow(non_camel_case_types)]
706                    struct RefreshingCompletionsSvc<T: Query>(pub Arc<T>);
707                    impl<T: Query>
708                        tonic::server::UnaryService<super::QueryRefreshingCompletionsRequest>
709                        for RefreshingCompletionsSvc<T>
710                    {
711                        type Response = super::QueryRefreshingCompletionsResponse;
712                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
713                        fn call(
714                            &mut self,
715                            request: tonic::Request<super::QueryRefreshingCompletionsRequest>,
716                        ) -> Self::Future {
717                            let inner = Arc::clone(&self.0);
718                            let fut = async move { (*inner).refreshing_completions(request).await };
719                            Box::pin(fut)
720                        }
721                    }
722                    let accept_compression_encodings = self.accept_compression_encodings;
723                    let send_compression_encodings = self.send_compression_encodings;
724                    let max_decoding_message_size = self.max_decoding_message_size;
725                    let max_encoding_message_size = self.max_encoding_message_size;
726                    let inner = self.inner.clone();
727                    let fut = async move {
728                        let inner = inner.0;
729                        let method = RefreshingCompletionsSvc(inner);
730                        let codec = tonic::codec::ProstCodec::default();
731                        let mut grpc = tonic::server::Grpc::new(codec)
732                            .apply_compression_config(
733                                accept_compression_encodings,
734                                send_compression_encodings,
735                            )
736                            .apply_max_message_size_config(
737                                max_decoding_message_size,
738                                max_encoding_message_size,
739                            );
740                        let res = grpc.unary(method, req).await;
741                        Ok(res)
742                    };
743                    Box::pin(fut)
744                }
745                _ => Box::pin(async move {
746                    Ok(http::Response::builder()
747                        .status(200)
748                        .header("grpc-status", "12")
749                        .header("content-type", "application/grpc")
750                        .body(empty_body())
751                        .unwrap())
752                }),
753            }
754        }
755    }
756    impl<T: Query> Clone for QueryServer<T> {
757        fn clone(&self) -> Self {
758            let inner = self.inner.clone();
759            Self {
760                inner,
761                accept_compression_encodings: self.accept_compression_encodings,
762                send_compression_encodings: self.send_compression_encodings,
763                max_decoding_message_size: self.max_decoding_message_size,
764                max_encoding_message_size: self.max_encoding_message_size,
765            }
766        }
767    }
768    impl<T: Query> Clone for _Inner<T> {
769        fn clone(&self) -> Self {
770            Self(Arc::clone(&self.0))
771        }
772    }
773    impl<T: core::fmt::Debug> core::fmt::Debug for _Inner<T> {
774        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
775            write!(f, "{:?}", self.0)
776        }
777    }
778    impl<T: Query> tonic::server::NamedService for QueryServer<T> {
779        const NAME: &'static str = "side.tss.Query";
780    }
781}
782/// Generated client implementations.
783#[cfg(feature = "grpc")]
784pub mod msg_client {
785    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
786    use tonic::codegen::http::Uri;
787    use tonic::codegen::*;
788    #[derive(Debug, Clone)]
789    pub struct MsgClient<T> {
790        inner: tonic::client::Grpc<T>,
791    }
792    #[cfg(feature = "grpc-transport")]
793    impl MsgClient<tonic::transport::Channel> {
794        /// Attempt to create a new client by connecting to a given endpoint.
795        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
796        where
797            D: TryInto<tonic::transport::Endpoint>,
798            D::Error: Into<StdError>,
799        {
800            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
801            Ok(Self::new(conn))
802        }
803    }
804    impl<T> MsgClient<T>
805    where
806        T: tonic::client::GrpcService<tonic::body::BoxBody>,
807        T::Error: Into<StdError>,
808        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
809        <T::ResponseBody as Body>::Error: Into<StdError> + Send,
810    {
811        pub fn new(inner: T) -> Self {
812            let inner = tonic::client::Grpc::new(inner);
813            Self { inner }
814        }
815        pub fn with_origin(inner: T, origin: Uri) -> Self {
816            let inner = tonic::client::Grpc::with_origin(inner, origin);
817            Self { inner }
818        }
819        pub fn with_interceptor<F>(inner: T, interceptor: F) -> MsgClient<InterceptedService<T, F>>
820        where
821            F: tonic::service::Interceptor,
822            T::ResponseBody: Default,
823            T: tonic::codegen::Service<
824                http::Request<tonic::body::BoxBody>,
825                Response = http::Response<
826                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
827                >,
828            >,
829            <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
830                Into<StdError> + Send + Sync,
831        {
832            MsgClient::new(InterceptedService::new(inner, interceptor))
833        }
834        /// Compress requests with the given encoding.
835        ///
836        /// This requires the server to support it otherwise it might respond with an
837        /// error.
838        #[must_use]
839        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
840            self.inner = self.inner.send_compressed(encoding);
841            self
842        }
843        /// Enable decompressing responses.
844        #[must_use]
845        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
846            self.inner = self.inner.accept_compressed(encoding);
847            self
848        }
849        /// Limits the maximum size of a decoded message.
850        ///
851        /// Default: `4MB`
852        #[must_use]
853        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
854            self.inner = self.inner.max_decoding_message_size(limit);
855            self
856        }
857        /// Limits the maximum size of an encoded message.
858        ///
859        /// Default: `usize::MAX`
860        #[must_use]
861        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
862            self.inner = self.inner.max_encoding_message_size(limit);
863            self
864        }
865        pub async fn complete_dkg(
866            &mut self,
867            request: impl tonic::IntoRequest<super::MsgCompleteDkg>,
868        ) -> core::result::Result<tonic::Response<super::MsgCompleteDkgResponse>, tonic::Status>
869        {
870            self.inner.ready().await.map_err(|e| {
871                tonic::Status::new(
872                    tonic::Code::Unknown,
873                    alloc::format!("Service was not ready: {}", e.into()),
874                )
875            })?;
876            let codec = tonic::codec::ProstCodec::default();
877            let path = http::uri::PathAndQuery::from_static("/side.tss.Msg/CompleteDKG");
878            let mut req = request.into_request();
879            req.extensions_mut()
880                .insert(GrpcMethod::new("side.tss.Msg", "CompleteDKG"));
881            self.inner.unary(req, path, codec).await
882        }
883        pub async fn submit_signatures(
884            &mut self,
885            request: impl tonic::IntoRequest<super::MsgSubmitSignatures>,
886        ) -> core::result::Result<tonic::Response<super::MsgSubmitSignaturesResponse>, tonic::Status>
887        {
888            self.inner.ready().await.map_err(|e| {
889                tonic::Status::new(
890                    tonic::Code::Unknown,
891                    alloc::format!("Service was not ready: {}", e.into()),
892                )
893            })?;
894            let codec = tonic::codec::ProstCodec::default();
895            let path = http::uri::PathAndQuery::from_static("/side.tss.Msg/SubmitSignatures");
896            let mut req = request.into_request();
897            req.extensions_mut()
898                .insert(GrpcMethod::new("side.tss.Msg", "SubmitSignatures"));
899            self.inner.unary(req, path, codec).await
900        }
901        pub async fn refresh(
902            &mut self,
903            request: impl tonic::IntoRequest<super::MsgRefresh>,
904        ) -> core::result::Result<tonic::Response<super::MsgRefreshResponse>, tonic::Status>
905        {
906            self.inner.ready().await.map_err(|e| {
907                tonic::Status::new(
908                    tonic::Code::Unknown,
909                    alloc::format!("Service was not ready: {}", e.into()),
910                )
911            })?;
912            let codec = tonic::codec::ProstCodec::default();
913            let path = http::uri::PathAndQuery::from_static("/side.tss.Msg/Refresh");
914            let mut req = request.into_request();
915            req.extensions_mut()
916                .insert(GrpcMethod::new("side.tss.Msg", "Refresh"));
917            self.inner.unary(req, path, codec).await
918        }
919        pub async fn complete_refreshing(
920            &mut self,
921            request: impl tonic::IntoRequest<super::MsgCompleteRefreshing>,
922        ) -> core::result::Result<
923            tonic::Response<super::MsgCompleteRefreshingResponse>,
924            tonic::Status,
925        > {
926            self.inner.ready().await.map_err(|e| {
927                tonic::Status::new(
928                    tonic::Code::Unknown,
929                    alloc::format!("Service was not ready: {}", e.into()),
930                )
931            })?;
932            let codec = tonic::codec::ProstCodec::default();
933            let path = http::uri::PathAndQuery::from_static("/side.tss.Msg/CompleteRefreshing");
934            let mut req = request.into_request();
935            req.extensions_mut()
936                .insert(GrpcMethod::new("side.tss.Msg", "CompleteRefreshing"));
937            self.inner.unary(req, path, codec).await
938        }
939        pub async fn update_params(
940            &mut self,
941            request: impl tonic::IntoRequest<super::MsgUpdateParams>,
942        ) -> core::result::Result<tonic::Response<super::MsgUpdateParamsResponse>, tonic::Status>
943        {
944            self.inner.ready().await.map_err(|e| {
945                tonic::Status::new(
946                    tonic::Code::Unknown,
947                    alloc::format!("Service was not ready: {}", e.into()),
948                )
949            })?;
950            let codec = tonic::codec::ProstCodec::default();
951            let path = http::uri::PathAndQuery::from_static("/side.tss.Msg/UpdateParams");
952            let mut req = request.into_request();
953            req.extensions_mut()
954                .insert(GrpcMethod::new("side.tss.Msg", "UpdateParams"));
955            self.inner.unary(req, path, codec).await
956        }
957    }
958}
959/// Generated server implementations.
960#[cfg(feature = "grpc")]
961pub mod msg_server {
962    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
963    use tonic::codegen::*;
964    /// Generated trait containing gRPC methods that should be implemented for use with MsgServer.
965    #[async_trait]
966    pub trait Msg: Send + Sync + 'static {
967        async fn complete_dkg(
968            &self,
969            request: tonic::Request<super::MsgCompleteDkg>,
970        ) -> core::result::Result<tonic::Response<super::MsgCompleteDkgResponse>, tonic::Status>;
971        async fn submit_signatures(
972            &self,
973            request: tonic::Request<super::MsgSubmitSignatures>,
974        ) -> core::result::Result<tonic::Response<super::MsgSubmitSignaturesResponse>, tonic::Status>;
975        async fn refresh(
976            &self,
977            request: tonic::Request<super::MsgRefresh>,
978        ) -> core::result::Result<tonic::Response<super::MsgRefreshResponse>, tonic::Status>;
979        async fn complete_refreshing(
980            &self,
981            request: tonic::Request<super::MsgCompleteRefreshing>,
982        ) -> core::result::Result<
983            tonic::Response<super::MsgCompleteRefreshingResponse>,
984            tonic::Status,
985        >;
986        async fn update_params(
987            &self,
988            request: tonic::Request<super::MsgUpdateParams>,
989        ) -> core::result::Result<tonic::Response<super::MsgUpdateParamsResponse>, tonic::Status>;
990    }
991    #[derive(Debug)]
992    pub struct MsgServer<T: Msg> {
993        inner: _Inner<T>,
994        accept_compression_encodings: EnabledCompressionEncodings,
995        send_compression_encodings: EnabledCompressionEncodings,
996        max_decoding_message_size: Option<usize>,
997        max_encoding_message_size: Option<usize>,
998    }
999    struct _Inner<T>(Arc<T>);
1000    impl<T: Msg> MsgServer<T> {
1001        pub fn new(inner: T) -> Self {
1002            Self::from_arc(Arc::new(inner))
1003        }
1004        pub fn from_arc(inner: Arc<T>) -> Self {
1005            let inner = _Inner(inner);
1006            Self {
1007                inner,
1008                accept_compression_encodings: Default::default(),
1009                send_compression_encodings: Default::default(),
1010                max_decoding_message_size: None,
1011                max_encoding_message_size: None,
1012            }
1013        }
1014        pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
1015        where
1016            F: tonic::service::Interceptor,
1017        {
1018            InterceptedService::new(Self::new(inner), interceptor)
1019        }
1020        /// Enable decompressing requests with the given encoding.
1021        #[must_use]
1022        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
1023            self.accept_compression_encodings.enable(encoding);
1024            self
1025        }
1026        /// Compress responses with the given encoding, if the client supports it.
1027        #[must_use]
1028        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
1029            self.send_compression_encodings.enable(encoding);
1030            self
1031        }
1032        /// Limits the maximum size of a decoded message.
1033        ///
1034        /// Default: `4MB`
1035        #[must_use]
1036        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
1037            self.max_decoding_message_size = Some(limit);
1038            self
1039        }
1040        /// Limits the maximum size of an encoded message.
1041        ///
1042        /// Default: `usize::MAX`
1043        #[must_use]
1044        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
1045            self.max_encoding_message_size = Some(limit);
1046            self
1047        }
1048    }
1049    impl<T, B> tonic::codegen::Service<http::Request<B>> for MsgServer<T>
1050    where
1051        T: Msg,
1052        B: Body + Send + 'static,
1053        B::Error: Into<StdError> + Send + 'static,
1054    {
1055        type Response = http::Response<tonic::body::BoxBody>;
1056        type Error = std::convert::Infallible;
1057        type Future = BoxFuture<Self::Response, Self::Error>;
1058        fn poll_ready(
1059            &mut self,
1060            _cx: &mut Context<'_>,
1061        ) -> Poll<core::result::Result<(), Self::Error>> {
1062            Poll::Ready(Ok(()))
1063        }
1064        fn call(&mut self, req: http::Request<B>) -> Self::Future {
1065            let inner = self.inner.clone();
1066            match req.uri().path() {
1067                "/side.tss.Msg/CompleteDKG" => {
1068                    #[allow(non_camel_case_types)]
1069                    struct CompleteDKGSvc<T: Msg>(pub Arc<T>);
1070                    impl<T: Msg> tonic::server::UnaryService<super::MsgCompleteDkg> for CompleteDKGSvc<T> {
1071                        type Response = super::MsgCompleteDkgResponse;
1072                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1073                        fn call(
1074                            &mut self,
1075                            request: tonic::Request<super::MsgCompleteDkg>,
1076                        ) -> Self::Future {
1077                            let inner = Arc::clone(&self.0);
1078                            let fut = async move { (*inner).complete_dkg(request).await };
1079                            Box::pin(fut)
1080                        }
1081                    }
1082                    let accept_compression_encodings = self.accept_compression_encodings;
1083                    let send_compression_encodings = self.send_compression_encodings;
1084                    let max_decoding_message_size = self.max_decoding_message_size;
1085                    let max_encoding_message_size = self.max_encoding_message_size;
1086                    let inner = self.inner.clone();
1087                    let fut = async move {
1088                        let inner = inner.0;
1089                        let method = CompleteDKGSvc(inner);
1090                        let codec = tonic::codec::ProstCodec::default();
1091                        let mut grpc = tonic::server::Grpc::new(codec)
1092                            .apply_compression_config(
1093                                accept_compression_encodings,
1094                                send_compression_encodings,
1095                            )
1096                            .apply_max_message_size_config(
1097                                max_decoding_message_size,
1098                                max_encoding_message_size,
1099                            );
1100                        let res = grpc.unary(method, req).await;
1101                        Ok(res)
1102                    };
1103                    Box::pin(fut)
1104                }
1105                "/side.tss.Msg/SubmitSignatures" => {
1106                    #[allow(non_camel_case_types)]
1107                    struct SubmitSignaturesSvc<T: Msg>(pub Arc<T>);
1108                    impl<T: Msg> tonic::server::UnaryService<super::MsgSubmitSignatures> for SubmitSignaturesSvc<T> {
1109                        type Response = super::MsgSubmitSignaturesResponse;
1110                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1111                        fn call(
1112                            &mut self,
1113                            request: tonic::Request<super::MsgSubmitSignatures>,
1114                        ) -> Self::Future {
1115                            let inner = Arc::clone(&self.0);
1116                            let fut = async move { (*inner).submit_signatures(request).await };
1117                            Box::pin(fut)
1118                        }
1119                    }
1120                    let accept_compression_encodings = self.accept_compression_encodings;
1121                    let send_compression_encodings = self.send_compression_encodings;
1122                    let max_decoding_message_size = self.max_decoding_message_size;
1123                    let max_encoding_message_size = self.max_encoding_message_size;
1124                    let inner = self.inner.clone();
1125                    let fut = async move {
1126                        let inner = inner.0;
1127                        let method = SubmitSignaturesSvc(inner);
1128                        let codec = tonic::codec::ProstCodec::default();
1129                        let mut grpc = tonic::server::Grpc::new(codec)
1130                            .apply_compression_config(
1131                                accept_compression_encodings,
1132                                send_compression_encodings,
1133                            )
1134                            .apply_max_message_size_config(
1135                                max_decoding_message_size,
1136                                max_encoding_message_size,
1137                            );
1138                        let res = grpc.unary(method, req).await;
1139                        Ok(res)
1140                    };
1141                    Box::pin(fut)
1142                }
1143                "/side.tss.Msg/Refresh" => {
1144                    #[allow(non_camel_case_types)]
1145                    struct RefreshSvc<T: Msg>(pub Arc<T>);
1146                    impl<T: Msg> tonic::server::UnaryService<super::MsgRefresh> for RefreshSvc<T> {
1147                        type Response = super::MsgRefreshResponse;
1148                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1149                        fn call(
1150                            &mut self,
1151                            request: tonic::Request<super::MsgRefresh>,
1152                        ) -> Self::Future {
1153                            let inner = Arc::clone(&self.0);
1154                            let fut = async move { (*inner).refresh(request).await };
1155                            Box::pin(fut)
1156                        }
1157                    }
1158                    let accept_compression_encodings = self.accept_compression_encodings;
1159                    let send_compression_encodings = self.send_compression_encodings;
1160                    let max_decoding_message_size = self.max_decoding_message_size;
1161                    let max_encoding_message_size = self.max_encoding_message_size;
1162                    let inner = self.inner.clone();
1163                    let fut = async move {
1164                        let inner = inner.0;
1165                        let method = RefreshSvc(inner);
1166                        let codec = tonic::codec::ProstCodec::default();
1167                        let mut grpc = tonic::server::Grpc::new(codec)
1168                            .apply_compression_config(
1169                                accept_compression_encodings,
1170                                send_compression_encodings,
1171                            )
1172                            .apply_max_message_size_config(
1173                                max_decoding_message_size,
1174                                max_encoding_message_size,
1175                            );
1176                        let res = grpc.unary(method, req).await;
1177                        Ok(res)
1178                    };
1179                    Box::pin(fut)
1180                }
1181                "/side.tss.Msg/CompleteRefreshing" => {
1182                    #[allow(non_camel_case_types)]
1183                    struct CompleteRefreshingSvc<T: Msg>(pub Arc<T>);
1184                    impl<T: Msg> tonic::server::UnaryService<super::MsgCompleteRefreshing>
1185                        for CompleteRefreshingSvc<T>
1186                    {
1187                        type Response = super::MsgCompleteRefreshingResponse;
1188                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1189                        fn call(
1190                            &mut self,
1191                            request: tonic::Request<super::MsgCompleteRefreshing>,
1192                        ) -> Self::Future {
1193                            let inner = Arc::clone(&self.0);
1194                            let fut = async move { (*inner).complete_refreshing(request).await };
1195                            Box::pin(fut)
1196                        }
1197                    }
1198                    let accept_compression_encodings = self.accept_compression_encodings;
1199                    let send_compression_encodings = self.send_compression_encodings;
1200                    let max_decoding_message_size = self.max_decoding_message_size;
1201                    let max_encoding_message_size = self.max_encoding_message_size;
1202                    let inner = self.inner.clone();
1203                    let fut = async move {
1204                        let inner = inner.0;
1205                        let method = CompleteRefreshingSvc(inner);
1206                        let codec = tonic::codec::ProstCodec::default();
1207                        let mut grpc = tonic::server::Grpc::new(codec)
1208                            .apply_compression_config(
1209                                accept_compression_encodings,
1210                                send_compression_encodings,
1211                            )
1212                            .apply_max_message_size_config(
1213                                max_decoding_message_size,
1214                                max_encoding_message_size,
1215                            );
1216                        let res = grpc.unary(method, req).await;
1217                        Ok(res)
1218                    };
1219                    Box::pin(fut)
1220                }
1221                "/side.tss.Msg/UpdateParams" => {
1222                    #[allow(non_camel_case_types)]
1223                    struct UpdateParamsSvc<T: Msg>(pub Arc<T>);
1224                    impl<T: Msg> tonic::server::UnaryService<super::MsgUpdateParams> for UpdateParamsSvc<T> {
1225                        type Response = super::MsgUpdateParamsResponse;
1226                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1227                        fn call(
1228                            &mut self,
1229                            request: tonic::Request<super::MsgUpdateParams>,
1230                        ) -> Self::Future {
1231                            let inner = Arc::clone(&self.0);
1232                            let fut = async move { (*inner).update_params(request).await };
1233                            Box::pin(fut)
1234                        }
1235                    }
1236                    let accept_compression_encodings = self.accept_compression_encodings;
1237                    let send_compression_encodings = self.send_compression_encodings;
1238                    let max_decoding_message_size = self.max_decoding_message_size;
1239                    let max_encoding_message_size = self.max_encoding_message_size;
1240                    let inner = self.inner.clone();
1241                    let fut = async move {
1242                        let inner = inner.0;
1243                        let method = UpdateParamsSvc(inner);
1244                        let codec = tonic::codec::ProstCodec::default();
1245                        let mut grpc = tonic::server::Grpc::new(codec)
1246                            .apply_compression_config(
1247                                accept_compression_encodings,
1248                                send_compression_encodings,
1249                            )
1250                            .apply_max_message_size_config(
1251                                max_decoding_message_size,
1252                                max_encoding_message_size,
1253                            );
1254                        let res = grpc.unary(method, req).await;
1255                        Ok(res)
1256                    };
1257                    Box::pin(fut)
1258                }
1259                _ => Box::pin(async move {
1260                    Ok(http::Response::builder()
1261                        .status(200)
1262                        .header("grpc-status", "12")
1263                        .header("content-type", "application/grpc")
1264                        .body(empty_body())
1265                        .unwrap())
1266                }),
1267            }
1268        }
1269    }
1270    impl<T: Msg> Clone for MsgServer<T> {
1271        fn clone(&self) -> Self {
1272            let inner = self.inner.clone();
1273            Self {
1274                inner,
1275                accept_compression_encodings: self.accept_compression_encodings,
1276                send_compression_encodings: self.send_compression_encodings,
1277                max_decoding_message_size: self.max_decoding_message_size,
1278                max_encoding_message_size: self.max_encoding_message_size,
1279            }
1280        }
1281    }
1282    impl<T: Msg> Clone for _Inner<T> {
1283        fn clone(&self) -> Self {
1284            Self(Arc::clone(&self.0))
1285        }
1286    }
1287    impl<T: core::fmt::Debug> core::fmt::Debug for _Inner<T> {
1288        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1289            write!(f, "{:?}", self.0)
1290        }
1291    }
1292    impl<T: Msg> tonic::server::NamedService for MsgServer<T> {
1293        const NAME: &'static str = "side.tss.Msg";
1294    }
1295}
side_proto/prost/side/side.tss.tonic.rs

side_proto/prost/side/
side.tss.tonic.rs
