side_proto/prost/side/
side.dlc.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.dlc.Query/Params");
101            let mut req = request.into_request();
102            req.extensions_mut()
103                .insert(GrpcMethod::new("side.dlc.Query", "Params"));
104            self.inner.unary(req, path, codec).await
105        }
106        pub async fn event(
107            &mut self,
108            request: impl tonic::IntoRequest<super::QueryEventRequest>,
109        ) -> core::result::Result<tonic::Response<super::QueryEventResponse>, 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.dlc.Query/Event");
119            let mut req = request.into_request();
120            req.extensions_mut()
121                .insert(GrpcMethod::new("side.dlc.Query", "Event"));
122            self.inner.unary(req, path, codec).await
123        }
124        pub async fn events(
125            &mut self,
126            request: impl tonic::IntoRequest<super::QueryEventsRequest>,
127        ) -> core::result::Result<tonic::Response<super::QueryEventsResponse>, 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.dlc.Query/Events");
137            let mut req = request.into_request();
138            req.extensions_mut()
139                .insert(GrpcMethod::new("side.dlc.Query", "Events"));
140            self.inner.unary(req, path, codec).await
141        }
142        pub async fn attestation(
143            &mut self,
144            request: impl tonic::IntoRequest<super::QueryAttestationRequest>,
145        ) -> core::result::Result<tonic::Response<super::QueryAttestationResponse>, 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.dlc.Query/Attestation");
155            let mut req = request.into_request();
156            req.extensions_mut()
157                .insert(GrpcMethod::new("side.dlc.Query", "Attestation"));
158            self.inner.unary(req, path, codec).await
159        }
160        pub async fn attestation_by_event(
161            &mut self,
162            request: impl tonic::IntoRequest<super::QueryAttestationByEventRequest>,
163        ) -> core::result::Result<
164            tonic::Response<super::QueryAttestationByEventResponse>,
165            tonic::Status,
166        > {
167            self.inner.ready().await.map_err(|e| {
168                tonic::Status::new(
169                    tonic::Code::Unknown,
170                    alloc::format!("Service was not ready: {}", e.into()),
171                )
172            })?;
173            let codec = tonic::codec::ProstCodec::default();
174            let path = http::uri::PathAndQuery::from_static("/side.dlc.Query/AttestationByEvent");
175            let mut req = request.into_request();
176            req.extensions_mut()
177                .insert(GrpcMethod::new("side.dlc.Query", "AttestationByEvent"));
178            self.inner.unary(req, path, codec).await
179        }
180        pub async fn attestations(
181            &mut self,
182            request: impl tonic::IntoRequest<super::QueryAttestationsRequest>,
183        ) -> core::result::Result<tonic::Response<super::QueryAttestationsResponse>, tonic::Status>
184        {
185            self.inner.ready().await.map_err(|e| {
186                tonic::Status::new(
187                    tonic::Code::Unknown,
188                    alloc::format!("Service was not ready: {}", e.into()),
189                )
190            })?;
191            let codec = tonic::codec::ProstCodec::default();
192            let path = http::uri::PathAndQuery::from_static("/side.dlc.Query/Attestations");
193            let mut req = request.into_request();
194            req.extensions_mut()
195                .insert(GrpcMethod::new("side.dlc.Query", "Attestations"));
196            self.inner.unary(req, path, codec).await
197        }
198        pub async fn nonce(
199            &mut self,
200            request: impl tonic::IntoRequest<super::QueryNonceRequest>,
201        ) -> core::result::Result<tonic::Response<super::QueryNonceResponse>, 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.dlc.Query/Nonce");
211            let mut req = request.into_request();
212            req.extensions_mut()
213                .insert(GrpcMethod::new("side.dlc.Query", "Nonce"));
214            self.inner.unary(req, path, codec).await
215        }
216        pub async fn nonces(
217            &mut self,
218            request: impl tonic::IntoRequest<super::QueryNoncesRequest>,
219        ) -> core::result::Result<tonic::Response<super::QueryNoncesResponse>, tonic::Status>
220        {
221            self.inner.ready().await.map_err(|e| {
222                tonic::Status::new(
223                    tonic::Code::Unknown,
224                    alloc::format!("Service was not ready: {}", e.into()),
225                )
226            })?;
227            let codec = tonic::codec::ProstCodec::default();
228            let path = http::uri::PathAndQuery::from_static("/side.dlc.Query/Nonces");
229            let mut req = request.into_request();
230            req.extensions_mut()
231                .insert(GrpcMethod::new("side.dlc.Query", "Nonces"));
232            self.inner.unary(req, path, codec).await
233        }
234        pub async fn count_nonces(
235            &mut self,
236            request: impl tonic::IntoRequest<super::QueryCountNoncesRequest>,
237        ) -> core::result::Result<tonic::Response<super::QueryCountNoncesResponse>, tonic::Status>
238        {
239            self.inner.ready().await.map_err(|e| {
240                tonic::Status::new(
241                    tonic::Code::Unknown,
242                    alloc::format!("Service was not ready: {}", e.into()),
243                )
244            })?;
245            let codec = tonic::codec::ProstCodec::default();
246            let path = http::uri::PathAndQuery::from_static("/side.dlc.Query/CountNonces");
247            let mut req = request.into_request();
248            req.extensions_mut()
249                .insert(GrpcMethod::new("side.dlc.Query", "CountNonces"));
250            self.inner.unary(req, path, codec).await
251        }
252        pub async fn dcm(
253            &mut self,
254            request: impl tonic::IntoRequest<super::QueryDcmRequest>,
255        ) -> core::result::Result<tonic::Response<super::QueryDcmResponse>, tonic::Status> {
256            self.inner.ready().await.map_err(|e| {
257                tonic::Status::new(
258                    tonic::Code::Unknown,
259                    alloc::format!("Service was not ready: {}", e.into()),
260                )
261            })?;
262            let codec = tonic::codec::ProstCodec::default();
263            let path = http::uri::PathAndQuery::from_static("/side.dlc.Query/DCM");
264            let mut req = request.into_request();
265            req.extensions_mut()
266                .insert(GrpcMethod::new("side.dlc.Query", "DCM"));
267            self.inner.unary(req, path, codec).await
268        }
269        pub async fn dc_ms(
270            &mut self,
271            request: impl tonic::IntoRequest<super::QueryDcMsRequest>,
272        ) -> core::result::Result<tonic::Response<super::QueryDcMsResponse>, tonic::Status>
273        {
274            self.inner.ready().await.map_err(|e| {
275                tonic::Status::new(
276                    tonic::Code::Unknown,
277                    alloc::format!("Service was not ready: {}", e.into()),
278                )
279            })?;
280            let codec = tonic::codec::ProstCodec::default();
281            let path = http::uri::PathAndQuery::from_static("/side.dlc.Query/DCMs");
282            let mut req = request.into_request();
283            req.extensions_mut()
284                .insert(GrpcMethod::new("side.dlc.Query", "DCMs"));
285            self.inner.unary(req, path, codec).await
286        }
287        pub async fn oracle(
288            &mut self,
289            request: impl tonic::IntoRequest<super::QueryOracleRequest>,
290        ) -> core::result::Result<tonic::Response<super::QueryOracleResponse>, tonic::Status>
291        {
292            self.inner.ready().await.map_err(|e| {
293                tonic::Status::new(
294                    tonic::Code::Unknown,
295                    alloc::format!("Service was not ready: {}", e.into()),
296                )
297            })?;
298            let codec = tonic::codec::ProstCodec::default();
299            let path = http::uri::PathAndQuery::from_static("/side.dlc.Query/Oracle");
300            let mut req = request.into_request();
301            req.extensions_mut()
302                .insert(GrpcMethod::new("side.dlc.Query", "Oracle"));
303            self.inner.unary(req, path, codec).await
304        }
305        pub async fn oracles(
306            &mut self,
307            request: impl tonic::IntoRequest<super::QueryOraclesRequest>,
308        ) -> core::result::Result<tonic::Response<super::QueryOraclesResponse>, tonic::Status>
309        {
310            self.inner.ready().await.map_err(|e| {
311                tonic::Status::new(
312                    tonic::Code::Unknown,
313                    alloc::format!("Service was not ready: {}", e.into()),
314                )
315            })?;
316            let codec = tonic::codec::ProstCodec::default();
317            let path = http::uri::PathAndQuery::from_static("/side.dlc.Query/Oracles");
318            let mut req = request.into_request();
319            req.extensions_mut()
320                .insert(GrpcMethod::new("side.dlc.Query", "Oracles"));
321            self.inner.unary(req, path, codec).await
322        }
323        pub async fn oracle_participant_liveness(
324            &mut self,
325            request: impl tonic::IntoRequest<super::QueryOracleParticipantLivenessRequest>,
326        ) -> core::result::Result<
327            tonic::Response<super::QueryOracleParticipantLivenessResponse>,
328            tonic::Status,
329        > {
330            self.inner.ready().await.map_err(|e| {
331                tonic::Status::new(
332                    tonic::Code::Unknown,
333                    alloc::format!("Service was not ready: {}", e.into()),
334                )
335            })?;
336            let codec = tonic::codec::ProstCodec::default();
337            let path =
338                http::uri::PathAndQuery::from_static("/side.dlc.Query/OracleParticipantLiveness");
339            let mut req = request.into_request();
340            req.extensions_mut().insert(GrpcMethod::new(
341                "side.dlc.Query",
342                "OracleParticipantLiveness",
343            ));
344            self.inner.unary(req, path, codec).await
345        }
346    }
347}
348/// Generated server implementations.
349#[cfg(feature = "grpc")]
350pub mod query_server {
351    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
352    use tonic::codegen::*;
353    /// Generated trait containing gRPC methods that should be implemented for use with QueryServer.
354    #[async_trait]
355    pub trait Query: Send + Sync + 'static {
356        async fn params(
357            &self,
358            request: tonic::Request<super::QueryParamsRequest>,
359        ) -> core::result::Result<tonic::Response<super::QueryParamsResponse>, tonic::Status>;
360        async fn event(
361            &self,
362            request: tonic::Request<super::QueryEventRequest>,
363        ) -> core::result::Result<tonic::Response<super::QueryEventResponse>, tonic::Status>;
364        async fn events(
365            &self,
366            request: tonic::Request<super::QueryEventsRequest>,
367        ) -> core::result::Result<tonic::Response<super::QueryEventsResponse>, tonic::Status>;
368        async fn attestation(
369            &self,
370            request: tonic::Request<super::QueryAttestationRequest>,
371        ) -> core::result::Result<tonic::Response<super::QueryAttestationResponse>, tonic::Status>;
372        async fn attestation_by_event(
373            &self,
374            request: tonic::Request<super::QueryAttestationByEventRequest>,
375        ) -> core::result::Result<
376            tonic::Response<super::QueryAttestationByEventResponse>,
377            tonic::Status,
378        >;
379        async fn attestations(
380            &self,
381            request: tonic::Request<super::QueryAttestationsRequest>,
382        ) -> core::result::Result<tonic::Response<super::QueryAttestationsResponse>, tonic::Status>;
383        async fn nonce(
384            &self,
385            request: tonic::Request<super::QueryNonceRequest>,
386        ) -> core::result::Result<tonic::Response<super::QueryNonceResponse>, tonic::Status>;
387        async fn nonces(
388            &self,
389            request: tonic::Request<super::QueryNoncesRequest>,
390        ) -> core::result::Result<tonic::Response<super::QueryNoncesResponse>, tonic::Status>;
391        async fn count_nonces(
392            &self,
393            request: tonic::Request<super::QueryCountNoncesRequest>,
394        ) -> core::result::Result<tonic::Response<super::QueryCountNoncesResponse>, tonic::Status>;
395        async fn dcm(
396            &self,
397            request: tonic::Request<super::QueryDcmRequest>,
398        ) -> core::result::Result<tonic::Response<super::QueryDcmResponse>, tonic::Status>;
399        async fn dc_ms(
400            &self,
401            request: tonic::Request<super::QueryDcMsRequest>,
402        ) -> core::result::Result<tonic::Response<super::QueryDcMsResponse>, tonic::Status>;
403        async fn oracle(
404            &self,
405            request: tonic::Request<super::QueryOracleRequest>,
406        ) -> core::result::Result<tonic::Response<super::QueryOracleResponse>, tonic::Status>;
407        async fn oracles(
408            &self,
409            request: tonic::Request<super::QueryOraclesRequest>,
410        ) -> core::result::Result<tonic::Response<super::QueryOraclesResponse>, tonic::Status>;
411        async fn oracle_participant_liveness(
412            &self,
413            request: tonic::Request<super::QueryOracleParticipantLivenessRequest>,
414        ) -> core::result::Result<
415            tonic::Response<super::QueryOracleParticipantLivenessResponse>,
416            tonic::Status,
417        >;
418    }
419    #[derive(Debug)]
420    pub struct QueryServer<T: Query> {
421        inner: _Inner<T>,
422        accept_compression_encodings: EnabledCompressionEncodings,
423        send_compression_encodings: EnabledCompressionEncodings,
424        max_decoding_message_size: Option<usize>,
425        max_encoding_message_size: Option<usize>,
426    }
427    struct _Inner<T>(Arc<T>);
428    impl<T: Query> QueryServer<T> {
429        pub fn new(inner: T) -> Self {
430            Self::from_arc(Arc::new(inner))
431        }
432        pub fn from_arc(inner: Arc<T>) -> Self {
433            let inner = _Inner(inner);
434            Self {
435                inner,
436                accept_compression_encodings: Default::default(),
437                send_compression_encodings: Default::default(),
438                max_decoding_message_size: None,
439                max_encoding_message_size: None,
440            }
441        }
442        pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
443        where
444            F: tonic::service::Interceptor,
445        {
446            InterceptedService::new(Self::new(inner), interceptor)
447        }
448        /// Enable decompressing requests with the given encoding.
449        #[must_use]
450        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
451            self.accept_compression_encodings.enable(encoding);
452            self
453        }
454        /// Compress responses with the given encoding, if the client supports it.
455        #[must_use]
456        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
457            self.send_compression_encodings.enable(encoding);
458            self
459        }
460        /// Limits the maximum size of a decoded message.
461        ///
462        /// Default: `4MB`
463        #[must_use]
464        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
465            self.max_decoding_message_size = Some(limit);
466            self
467        }
468        /// Limits the maximum size of an encoded message.
469        ///
470        /// Default: `usize::MAX`
471        #[must_use]
472        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
473            self.max_encoding_message_size = Some(limit);
474            self
475        }
476    }
477    impl<T, B> tonic::codegen::Service<http::Request<B>> for QueryServer<T>
478    where
479        T: Query,
480        B: Body + Send + 'static,
481        B::Error: Into<StdError> + Send + 'static,
482    {
483        type Response = http::Response<tonic::body::BoxBody>;
484        type Error = std::convert::Infallible;
485        type Future = BoxFuture<Self::Response, Self::Error>;
486        fn poll_ready(
487            &mut self,
488            _cx: &mut Context<'_>,
489        ) -> Poll<core::result::Result<(), Self::Error>> {
490            Poll::Ready(Ok(()))
491        }
492        fn call(&mut self, req: http::Request<B>) -> Self::Future {
493            let inner = self.inner.clone();
494            match req.uri().path() {
495                "/side.dlc.Query/Params" => {
496                    #[allow(non_camel_case_types)]
497                    struct ParamsSvc<T: Query>(pub Arc<T>);
498                    impl<T: Query> tonic::server::UnaryService<super::QueryParamsRequest> for ParamsSvc<T> {
499                        type Response = super::QueryParamsResponse;
500                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
501                        fn call(
502                            &mut self,
503                            request: tonic::Request<super::QueryParamsRequest>,
504                        ) -> Self::Future {
505                            let inner = Arc::clone(&self.0);
506                            let fut = async move { (*inner).params(request).await };
507                            Box::pin(fut)
508                        }
509                    }
510                    let accept_compression_encodings = self.accept_compression_encodings;
511                    let send_compression_encodings = self.send_compression_encodings;
512                    let max_decoding_message_size = self.max_decoding_message_size;
513                    let max_encoding_message_size = self.max_encoding_message_size;
514                    let inner = self.inner.clone();
515                    let fut = async move {
516                        let inner = inner.0;
517                        let method = ParamsSvc(inner);
518                        let codec = tonic::codec::ProstCodec::default();
519                        let mut grpc = tonic::server::Grpc::new(codec)
520                            .apply_compression_config(
521                                accept_compression_encodings,
522                                send_compression_encodings,
523                            )
524                            .apply_max_message_size_config(
525                                max_decoding_message_size,
526                                max_encoding_message_size,
527                            );
528                        let res = grpc.unary(method, req).await;
529                        Ok(res)
530                    };
531                    Box::pin(fut)
532                }
533                "/side.dlc.Query/Event" => {
534                    #[allow(non_camel_case_types)]
535                    struct EventSvc<T: Query>(pub Arc<T>);
536                    impl<T: Query> tonic::server::UnaryService<super::QueryEventRequest> for EventSvc<T> {
537                        type Response = super::QueryEventResponse;
538                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
539                        fn call(
540                            &mut self,
541                            request: tonic::Request<super::QueryEventRequest>,
542                        ) -> Self::Future {
543                            let inner = Arc::clone(&self.0);
544                            let fut = async move { (*inner).event(request).await };
545                            Box::pin(fut)
546                        }
547                    }
548                    let accept_compression_encodings = self.accept_compression_encodings;
549                    let send_compression_encodings = self.send_compression_encodings;
550                    let max_decoding_message_size = self.max_decoding_message_size;
551                    let max_encoding_message_size = self.max_encoding_message_size;
552                    let inner = self.inner.clone();
553                    let fut = async move {
554                        let inner = inner.0;
555                        let method = EventSvc(inner);
556                        let codec = tonic::codec::ProstCodec::default();
557                        let mut grpc = tonic::server::Grpc::new(codec)
558                            .apply_compression_config(
559                                accept_compression_encodings,
560                                send_compression_encodings,
561                            )
562                            .apply_max_message_size_config(
563                                max_decoding_message_size,
564                                max_encoding_message_size,
565                            );
566                        let res = grpc.unary(method, req).await;
567                        Ok(res)
568                    };
569                    Box::pin(fut)
570                }
571                "/side.dlc.Query/Events" => {
572                    #[allow(non_camel_case_types)]
573                    struct EventsSvc<T: Query>(pub Arc<T>);
574                    impl<T: Query> tonic::server::UnaryService<super::QueryEventsRequest> for EventsSvc<T> {
575                        type Response = super::QueryEventsResponse;
576                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
577                        fn call(
578                            &mut self,
579                            request: tonic::Request<super::QueryEventsRequest>,
580                        ) -> Self::Future {
581                            let inner = Arc::clone(&self.0);
582                            let fut = async move { (*inner).events(request).await };
583                            Box::pin(fut)
584                        }
585                    }
586                    let accept_compression_encodings = self.accept_compression_encodings;
587                    let send_compression_encodings = self.send_compression_encodings;
588                    let max_decoding_message_size = self.max_decoding_message_size;
589                    let max_encoding_message_size = self.max_encoding_message_size;
590                    let inner = self.inner.clone();
591                    let fut = async move {
592                        let inner = inner.0;
593                        let method = EventsSvc(inner);
594                        let codec = tonic::codec::ProstCodec::default();
595                        let mut grpc = tonic::server::Grpc::new(codec)
596                            .apply_compression_config(
597                                accept_compression_encodings,
598                                send_compression_encodings,
599                            )
600                            .apply_max_message_size_config(
601                                max_decoding_message_size,
602                                max_encoding_message_size,
603                            );
604                        let res = grpc.unary(method, req).await;
605                        Ok(res)
606                    };
607                    Box::pin(fut)
608                }
609                "/side.dlc.Query/Attestation" => {
610                    #[allow(non_camel_case_types)]
611                    struct AttestationSvc<T: Query>(pub Arc<T>);
612                    impl<T: Query> tonic::server::UnaryService<super::QueryAttestationRequest> for AttestationSvc<T> {
613                        type Response = super::QueryAttestationResponse;
614                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
615                        fn call(
616                            &mut self,
617                            request: tonic::Request<super::QueryAttestationRequest>,
618                        ) -> Self::Future {
619                            let inner = Arc::clone(&self.0);
620                            let fut = async move { (*inner).attestation(request).await };
621                            Box::pin(fut)
622                        }
623                    }
624                    let accept_compression_encodings = self.accept_compression_encodings;
625                    let send_compression_encodings = self.send_compression_encodings;
626                    let max_decoding_message_size = self.max_decoding_message_size;
627                    let max_encoding_message_size = self.max_encoding_message_size;
628                    let inner = self.inner.clone();
629                    let fut = async move {
630                        let inner = inner.0;
631                        let method = AttestationSvc(inner);
632                        let codec = tonic::codec::ProstCodec::default();
633                        let mut grpc = tonic::server::Grpc::new(codec)
634                            .apply_compression_config(
635                                accept_compression_encodings,
636                                send_compression_encodings,
637                            )
638                            .apply_max_message_size_config(
639                                max_decoding_message_size,
640                                max_encoding_message_size,
641                            );
642                        let res = grpc.unary(method, req).await;
643                        Ok(res)
644                    };
645                    Box::pin(fut)
646                }
647                "/side.dlc.Query/AttestationByEvent" => {
648                    #[allow(non_camel_case_types)]
649                    struct AttestationByEventSvc<T: Query>(pub Arc<T>);
650                    impl<T: Query>
651                        tonic::server::UnaryService<super::QueryAttestationByEventRequest>
652                        for AttestationByEventSvc<T>
653                    {
654                        type Response = super::QueryAttestationByEventResponse;
655                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
656                        fn call(
657                            &mut self,
658                            request: tonic::Request<super::QueryAttestationByEventRequest>,
659                        ) -> Self::Future {
660                            let inner = Arc::clone(&self.0);
661                            let fut = async move { (*inner).attestation_by_event(request).await };
662                            Box::pin(fut)
663                        }
664                    }
665                    let accept_compression_encodings = self.accept_compression_encodings;
666                    let send_compression_encodings = self.send_compression_encodings;
667                    let max_decoding_message_size = self.max_decoding_message_size;
668                    let max_encoding_message_size = self.max_encoding_message_size;
669                    let inner = self.inner.clone();
670                    let fut = async move {
671                        let inner = inner.0;
672                        let method = AttestationByEventSvc(inner);
673                        let codec = tonic::codec::ProstCodec::default();
674                        let mut grpc = tonic::server::Grpc::new(codec)
675                            .apply_compression_config(
676                                accept_compression_encodings,
677                                send_compression_encodings,
678                            )
679                            .apply_max_message_size_config(
680                                max_decoding_message_size,
681                                max_encoding_message_size,
682                            );
683                        let res = grpc.unary(method, req).await;
684                        Ok(res)
685                    };
686                    Box::pin(fut)
687                }
688                "/side.dlc.Query/Attestations" => {
689                    #[allow(non_camel_case_types)]
690                    struct AttestationsSvc<T: Query>(pub Arc<T>);
691                    impl<T: Query> tonic::server::UnaryService<super::QueryAttestationsRequest> for AttestationsSvc<T> {
692                        type Response = super::QueryAttestationsResponse;
693                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
694                        fn call(
695                            &mut self,
696                            request: tonic::Request<super::QueryAttestationsRequest>,
697                        ) -> Self::Future {
698                            let inner = Arc::clone(&self.0);
699                            let fut = async move { (*inner).attestations(request).await };
700                            Box::pin(fut)
701                        }
702                    }
703                    let accept_compression_encodings = self.accept_compression_encodings;
704                    let send_compression_encodings = self.send_compression_encodings;
705                    let max_decoding_message_size = self.max_decoding_message_size;
706                    let max_encoding_message_size = self.max_encoding_message_size;
707                    let inner = self.inner.clone();
708                    let fut = async move {
709                        let inner = inner.0;
710                        let method = AttestationsSvc(inner);
711                        let codec = tonic::codec::ProstCodec::default();
712                        let mut grpc = tonic::server::Grpc::new(codec)
713                            .apply_compression_config(
714                                accept_compression_encodings,
715                                send_compression_encodings,
716                            )
717                            .apply_max_message_size_config(
718                                max_decoding_message_size,
719                                max_encoding_message_size,
720                            );
721                        let res = grpc.unary(method, req).await;
722                        Ok(res)
723                    };
724                    Box::pin(fut)
725                }
726                "/side.dlc.Query/Nonce" => {
727                    #[allow(non_camel_case_types)]
728                    struct NonceSvc<T: Query>(pub Arc<T>);
729                    impl<T: Query> tonic::server::UnaryService<super::QueryNonceRequest> for NonceSvc<T> {
730                        type Response = super::QueryNonceResponse;
731                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
732                        fn call(
733                            &mut self,
734                            request: tonic::Request<super::QueryNonceRequest>,
735                        ) -> Self::Future {
736                            let inner = Arc::clone(&self.0);
737                            let fut = async move { (*inner).nonce(request).await };
738                            Box::pin(fut)
739                        }
740                    }
741                    let accept_compression_encodings = self.accept_compression_encodings;
742                    let send_compression_encodings = self.send_compression_encodings;
743                    let max_decoding_message_size = self.max_decoding_message_size;
744                    let max_encoding_message_size = self.max_encoding_message_size;
745                    let inner = self.inner.clone();
746                    let fut = async move {
747                        let inner = inner.0;
748                        let method = NonceSvc(inner);
749                        let codec = tonic::codec::ProstCodec::default();
750                        let mut grpc = tonic::server::Grpc::new(codec)
751                            .apply_compression_config(
752                                accept_compression_encodings,
753                                send_compression_encodings,
754                            )
755                            .apply_max_message_size_config(
756                                max_decoding_message_size,
757                                max_encoding_message_size,
758                            );
759                        let res = grpc.unary(method, req).await;
760                        Ok(res)
761                    };
762                    Box::pin(fut)
763                }
764                "/side.dlc.Query/Nonces" => {
765                    #[allow(non_camel_case_types)]
766                    struct NoncesSvc<T: Query>(pub Arc<T>);
767                    impl<T: Query> tonic::server::UnaryService<super::QueryNoncesRequest> for NoncesSvc<T> {
768                        type Response = super::QueryNoncesResponse;
769                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
770                        fn call(
771                            &mut self,
772                            request: tonic::Request<super::QueryNoncesRequest>,
773                        ) -> Self::Future {
774                            let inner = Arc::clone(&self.0);
775                            let fut = async move { (*inner).nonces(request).await };
776                            Box::pin(fut)
777                        }
778                    }
779                    let accept_compression_encodings = self.accept_compression_encodings;
780                    let send_compression_encodings = self.send_compression_encodings;
781                    let max_decoding_message_size = self.max_decoding_message_size;
782                    let max_encoding_message_size = self.max_encoding_message_size;
783                    let inner = self.inner.clone();
784                    let fut = async move {
785                        let inner = inner.0;
786                        let method = NoncesSvc(inner);
787                        let codec = tonic::codec::ProstCodec::default();
788                        let mut grpc = tonic::server::Grpc::new(codec)
789                            .apply_compression_config(
790                                accept_compression_encodings,
791                                send_compression_encodings,
792                            )
793                            .apply_max_message_size_config(
794                                max_decoding_message_size,
795                                max_encoding_message_size,
796                            );
797                        let res = grpc.unary(method, req).await;
798                        Ok(res)
799                    };
800                    Box::pin(fut)
801                }
802                "/side.dlc.Query/CountNonces" => {
803                    #[allow(non_camel_case_types)]
804                    struct CountNoncesSvc<T: Query>(pub Arc<T>);
805                    impl<T: Query> tonic::server::UnaryService<super::QueryCountNoncesRequest> for CountNoncesSvc<T> {
806                        type Response = super::QueryCountNoncesResponse;
807                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
808                        fn call(
809                            &mut self,
810                            request: tonic::Request<super::QueryCountNoncesRequest>,
811                        ) -> Self::Future {
812                            let inner = Arc::clone(&self.0);
813                            let fut = async move { (*inner).count_nonces(request).await };
814                            Box::pin(fut)
815                        }
816                    }
817                    let accept_compression_encodings = self.accept_compression_encodings;
818                    let send_compression_encodings = self.send_compression_encodings;
819                    let max_decoding_message_size = self.max_decoding_message_size;
820                    let max_encoding_message_size = self.max_encoding_message_size;
821                    let inner = self.inner.clone();
822                    let fut = async move {
823                        let inner = inner.0;
824                        let method = CountNoncesSvc(inner);
825                        let codec = tonic::codec::ProstCodec::default();
826                        let mut grpc = tonic::server::Grpc::new(codec)
827                            .apply_compression_config(
828                                accept_compression_encodings,
829                                send_compression_encodings,
830                            )
831                            .apply_max_message_size_config(
832                                max_decoding_message_size,
833                                max_encoding_message_size,
834                            );
835                        let res = grpc.unary(method, req).await;
836                        Ok(res)
837                    };
838                    Box::pin(fut)
839                }
840                "/side.dlc.Query/DCM" => {
841                    #[allow(non_camel_case_types)]
842                    struct DCMSvc<T: Query>(pub Arc<T>);
843                    impl<T: Query> tonic::server::UnaryService<super::QueryDcmRequest> for DCMSvc<T> {
844                        type Response = super::QueryDcmResponse;
845                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
846                        fn call(
847                            &mut self,
848                            request: tonic::Request<super::QueryDcmRequest>,
849                        ) -> Self::Future {
850                            let inner = Arc::clone(&self.0);
851                            let fut = async move { (*inner).dcm(request).await };
852                            Box::pin(fut)
853                        }
854                    }
855                    let accept_compression_encodings = self.accept_compression_encodings;
856                    let send_compression_encodings = self.send_compression_encodings;
857                    let max_decoding_message_size = self.max_decoding_message_size;
858                    let max_encoding_message_size = self.max_encoding_message_size;
859                    let inner = self.inner.clone();
860                    let fut = async move {
861                        let inner = inner.0;
862                        let method = DCMSvc(inner);
863                        let codec = tonic::codec::ProstCodec::default();
864                        let mut grpc = tonic::server::Grpc::new(codec)
865                            .apply_compression_config(
866                                accept_compression_encodings,
867                                send_compression_encodings,
868                            )
869                            .apply_max_message_size_config(
870                                max_decoding_message_size,
871                                max_encoding_message_size,
872                            );
873                        let res = grpc.unary(method, req).await;
874                        Ok(res)
875                    };
876                    Box::pin(fut)
877                }
878                "/side.dlc.Query/DCMs" => {
879                    #[allow(non_camel_case_types)]
880                    struct DCMsSvc<T: Query>(pub Arc<T>);
881                    impl<T: Query> tonic::server::UnaryService<super::QueryDcMsRequest> for DCMsSvc<T> {
882                        type Response = super::QueryDcMsResponse;
883                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
884                        fn call(
885                            &mut self,
886                            request: tonic::Request<super::QueryDcMsRequest>,
887                        ) -> Self::Future {
888                            let inner = Arc::clone(&self.0);
889                            let fut = async move { (*inner).dc_ms(request).await };
890                            Box::pin(fut)
891                        }
892                    }
893                    let accept_compression_encodings = self.accept_compression_encodings;
894                    let send_compression_encodings = self.send_compression_encodings;
895                    let max_decoding_message_size = self.max_decoding_message_size;
896                    let max_encoding_message_size = self.max_encoding_message_size;
897                    let inner = self.inner.clone();
898                    let fut = async move {
899                        let inner = inner.0;
900                        let method = DCMsSvc(inner);
901                        let codec = tonic::codec::ProstCodec::default();
902                        let mut grpc = tonic::server::Grpc::new(codec)
903                            .apply_compression_config(
904                                accept_compression_encodings,
905                                send_compression_encodings,
906                            )
907                            .apply_max_message_size_config(
908                                max_decoding_message_size,
909                                max_encoding_message_size,
910                            );
911                        let res = grpc.unary(method, req).await;
912                        Ok(res)
913                    };
914                    Box::pin(fut)
915                }
916                "/side.dlc.Query/Oracle" => {
917                    #[allow(non_camel_case_types)]
918                    struct OracleSvc<T: Query>(pub Arc<T>);
919                    impl<T: Query> tonic::server::UnaryService<super::QueryOracleRequest> for OracleSvc<T> {
920                        type Response = super::QueryOracleResponse;
921                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
922                        fn call(
923                            &mut self,
924                            request: tonic::Request<super::QueryOracleRequest>,
925                        ) -> Self::Future {
926                            let inner = Arc::clone(&self.0);
927                            let fut = async move { (*inner).oracle(request).await };
928                            Box::pin(fut)
929                        }
930                    }
931                    let accept_compression_encodings = self.accept_compression_encodings;
932                    let send_compression_encodings = self.send_compression_encodings;
933                    let max_decoding_message_size = self.max_decoding_message_size;
934                    let max_encoding_message_size = self.max_encoding_message_size;
935                    let inner = self.inner.clone();
936                    let fut = async move {
937                        let inner = inner.0;
938                        let method = OracleSvc(inner);
939                        let codec = tonic::codec::ProstCodec::default();
940                        let mut grpc = tonic::server::Grpc::new(codec)
941                            .apply_compression_config(
942                                accept_compression_encodings,
943                                send_compression_encodings,
944                            )
945                            .apply_max_message_size_config(
946                                max_decoding_message_size,
947                                max_encoding_message_size,
948                            );
949                        let res = grpc.unary(method, req).await;
950                        Ok(res)
951                    };
952                    Box::pin(fut)
953                }
954                "/side.dlc.Query/Oracles" => {
955                    #[allow(non_camel_case_types)]
956                    struct OraclesSvc<T: Query>(pub Arc<T>);
957                    impl<T: Query> tonic::server::UnaryService<super::QueryOraclesRequest> for OraclesSvc<T> {
958                        type Response = super::QueryOraclesResponse;
959                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
960                        fn call(
961                            &mut self,
962                            request: tonic::Request<super::QueryOraclesRequest>,
963                        ) -> Self::Future {
964                            let inner = Arc::clone(&self.0);
965                            let fut = async move { (*inner).oracles(request).await };
966                            Box::pin(fut)
967                        }
968                    }
969                    let accept_compression_encodings = self.accept_compression_encodings;
970                    let send_compression_encodings = self.send_compression_encodings;
971                    let max_decoding_message_size = self.max_decoding_message_size;
972                    let max_encoding_message_size = self.max_encoding_message_size;
973                    let inner = self.inner.clone();
974                    let fut = async move {
975                        let inner = inner.0;
976                        let method = OraclesSvc(inner);
977                        let codec = tonic::codec::ProstCodec::default();
978                        let mut grpc = tonic::server::Grpc::new(codec)
979                            .apply_compression_config(
980                                accept_compression_encodings,
981                                send_compression_encodings,
982                            )
983                            .apply_max_message_size_config(
984                                max_decoding_message_size,
985                                max_encoding_message_size,
986                            );
987                        let res = grpc.unary(method, req).await;
988                        Ok(res)
989                    };
990                    Box::pin(fut)
991                }
992                "/side.dlc.Query/OracleParticipantLiveness" => {
993                    #[allow(non_camel_case_types)]
994                    struct OracleParticipantLivenessSvc<T: Query>(pub Arc<T>);
995                    impl<T: Query>
996                        tonic::server::UnaryService<super::QueryOracleParticipantLivenessRequest>
997                        for OracleParticipantLivenessSvc<T>
998                    {
999                        type Response = super::QueryOracleParticipantLivenessResponse;
1000                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1001                        fn call(
1002                            &mut self,
1003                            request: tonic::Request<super::QueryOracleParticipantLivenessRequest>,
1004                        ) -> Self::Future {
1005                            let inner = Arc::clone(&self.0);
1006                            let fut =
1007                                async move { (*inner).oracle_participant_liveness(request).await };
1008                            Box::pin(fut)
1009                        }
1010                    }
1011                    let accept_compression_encodings = self.accept_compression_encodings;
1012                    let send_compression_encodings = self.send_compression_encodings;
1013                    let max_decoding_message_size = self.max_decoding_message_size;
1014                    let max_encoding_message_size = self.max_encoding_message_size;
1015                    let inner = self.inner.clone();
1016                    let fut = async move {
1017                        let inner = inner.0;
1018                        let method = OracleParticipantLivenessSvc(inner);
1019                        let codec = tonic::codec::ProstCodec::default();
1020                        let mut grpc = tonic::server::Grpc::new(codec)
1021                            .apply_compression_config(
1022                                accept_compression_encodings,
1023                                send_compression_encodings,
1024                            )
1025                            .apply_max_message_size_config(
1026                                max_decoding_message_size,
1027                                max_encoding_message_size,
1028                            );
1029                        let res = grpc.unary(method, req).await;
1030                        Ok(res)
1031                    };
1032                    Box::pin(fut)
1033                }
1034                _ => Box::pin(async move {
1035                    Ok(http::Response::builder()
1036                        .status(200)
1037                        .header("grpc-status", "12")
1038                        .header("content-type", "application/grpc")
1039                        .body(empty_body())
1040                        .unwrap())
1041                }),
1042            }
1043        }
1044    }
1045    impl<T: Query> Clone for QueryServer<T> {
1046        fn clone(&self) -> Self {
1047            let inner = self.inner.clone();
1048            Self {
1049                inner,
1050                accept_compression_encodings: self.accept_compression_encodings,
1051                send_compression_encodings: self.send_compression_encodings,
1052                max_decoding_message_size: self.max_decoding_message_size,
1053                max_encoding_message_size: self.max_encoding_message_size,
1054            }
1055        }
1056    }
1057    impl<T: Query> Clone for _Inner<T> {
1058        fn clone(&self) -> Self {
1059            Self(Arc::clone(&self.0))
1060        }
1061    }
1062    impl<T: core::fmt::Debug> core::fmt::Debug for _Inner<T> {
1063        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1064            write!(f, "{:?}", self.0)
1065        }
1066    }
1067    impl<T: Query> tonic::server::NamedService for QueryServer<T> {
1068        const NAME: &'static str = "side.dlc.Query";
1069    }
1070}
1071/// Generated client implementations.
1072#[cfg(feature = "grpc")]
1073pub mod msg_client {
1074    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
1075    use tonic::codegen::http::Uri;
1076    use tonic::codegen::*;
1077    #[derive(Debug, Clone)]
1078    pub struct MsgClient<T> {
1079        inner: tonic::client::Grpc<T>,
1080    }
1081    #[cfg(feature = "grpc-transport")]
1082    impl MsgClient<tonic::transport::Channel> {
1083        /// Attempt to create a new client by connecting to a given endpoint.
1084        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
1085        where
1086            D: TryInto<tonic::transport::Endpoint>,
1087            D::Error: Into<StdError>,
1088        {
1089            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
1090            Ok(Self::new(conn))
1091        }
1092    }
1093    impl<T> MsgClient<T>
1094    where
1095        T: tonic::client::GrpcService<tonic::body::BoxBody>,
1096        T::Error: Into<StdError>,
1097        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
1098        <T::ResponseBody as Body>::Error: Into<StdError> + Send,
1099    {
1100        pub fn new(inner: T) -> Self {
1101            let inner = tonic::client::Grpc::new(inner);
1102            Self { inner }
1103        }
1104        pub fn with_origin(inner: T, origin: Uri) -> Self {
1105            let inner = tonic::client::Grpc::with_origin(inner, origin);
1106            Self { inner }
1107        }
1108        pub fn with_interceptor<F>(inner: T, interceptor: F) -> MsgClient<InterceptedService<T, F>>
1109        where
1110            F: tonic::service::Interceptor,
1111            T::ResponseBody: Default,
1112            T: tonic::codegen::Service<
1113                http::Request<tonic::body::BoxBody>,
1114                Response = http::Response<
1115                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
1116                >,
1117            >,
1118            <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
1119                Into<StdError> + Send + Sync,
1120        {
1121            MsgClient::new(InterceptedService::new(inner, interceptor))
1122        }
1123        /// Compress requests with the given encoding.
1124        ///
1125        /// This requires the server to support it otherwise it might respond with an
1126        /// error.
1127        #[must_use]
1128        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
1129            self.inner = self.inner.send_compressed(encoding);
1130            self
1131        }
1132        /// Enable decompressing responses.
1133        #[must_use]
1134        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
1135            self.inner = self.inner.accept_compressed(encoding);
1136            self
1137        }
1138        /// Limits the maximum size of a decoded message.
1139        ///
1140        /// Default: `4MB`
1141        #[must_use]
1142        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
1143            self.inner = self.inner.max_decoding_message_size(limit);
1144            self
1145        }
1146        /// Limits the maximum size of an encoded message.
1147        ///
1148        /// Default: `usize::MAX`
1149        #[must_use]
1150        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
1151            self.inner = self.inner.max_encoding_message_size(limit);
1152            self
1153        }
1154        pub async fn create_dcm(
1155            &mut self,
1156            request: impl tonic::IntoRequest<super::MsgCreateDcm>,
1157        ) -> core::result::Result<tonic::Response<super::MsgCreateDcmResponse>, tonic::Status>
1158        {
1159            self.inner.ready().await.map_err(|e| {
1160                tonic::Status::new(
1161                    tonic::Code::Unknown,
1162                    alloc::format!("Service was not ready: {}", e.into()),
1163                )
1164            })?;
1165            let codec = tonic::codec::ProstCodec::default();
1166            let path = http::uri::PathAndQuery::from_static("/side.dlc.Msg/CreateDCM");
1167            let mut req = request.into_request();
1168            req.extensions_mut()
1169                .insert(GrpcMethod::new("side.dlc.Msg", "CreateDCM"));
1170            self.inner.unary(req, path, codec).await
1171        }
1172        pub async fn update_params(
1173            &mut self,
1174            request: impl tonic::IntoRequest<super::MsgUpdateParams>,
1175        ) -> core::result::Result<tonic::Response<super::MsgUpdateParamsResponse>, tonic::Status>
1176        {
1177            self.inner.ready().await.map_err(|e| {
1178                tonic::Status::new(
1179                    tonic::Code::Unknown,
1180                    alloc::format!("Service was not ready: {}", e.into()),
1181                )
1182            })?;
1183            let codec = tonic::codec::ProstCodec::default();
1184            let path = http::uri::PathAndQuery::from_static("/side.dlc.Msg/UpdateParams");
1185            let mut req = request.into_request();
1186            req.extensions_mut()
1187                .insert(GrpcMethod::new("side.dlc.Msg", "UpdateParams"));
1188            self.inner.unary(req, path, codec).await
1189        }
1190    }
1191}
1192/// Generated server implementations.
1193#[cfg(feature = "grpc")]
1194pub mod msg_server {
1195    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
1196    use tonic::codegen::*;
1197    /// Generated trait containing gRPC methods that should be implemented for use with MsgServer.
1198    #[async_trait]
1199    pub trait Msg: Send + Sync + 'static {
1200        async fn create_dcm(
1201            &self,
1202            request: tonic::Request<super::MsgCreateDcm>,
1203        ) -> core::result::Result<tonic::Response<super::MsgCreateDcmResponse>, tonic::Status>;
1204        async fn update_params(
1205            &self,
1206            request: tonic::Request<super::MsgUpdateParams>,
1207        ) -> core::result::Result<tonic::Response<super::MsgUpdateParamsResponse>, tonic::Status>;
1208    }
1209    #[derive(Debug)]
1210    pub struct MsgServer<T: Msg> {
1211        inner: _Inner<T>,
1212        accept_compression_encodings: EnabledCompressionEncodings,
1213        send_compression_encodings: EnabledCompressionEncodings,
1214        max_decoding_message_size: Option<usize>,
1215        max_encoding_message_size: Option<usize>,
1216    }
1217    struct _Inner<T>(Arc<T>);
1218    impl<T: Msg> MsgServer<T> {
1219        pub fn new(inner: T) -> Self {
1220            Self::from_arc(Arc::new(inner))
1221        }
1222        pub fn from_arc(inner: Arc<T>) -> Self {
1223            let inner = _Inner(inner);
1224            Self {
1225                inner,
1226                accept_compression_encodings: Default::default(),
1227                send_compression_encodings: Default::default(),
1228                max_decoding_message_size: None,
1229                max_encoding_message_size: None,
1230            }
1231        }
1232        pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
1233        where
1234            F: tonic::service::Interceptor,
1235        {
1236            InterceptedService::new(Self::new(inner), interceptor)
1237        }
1238        /// Enable decompressing requests with the given encoding.
1239        #[must_use]
1240        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
1241            self.accept_compression_encodings.enable(encoding);
1242            self
1243        }
1244        /// Compress responses with the given encoding, if the client supports it.
1245        #[must_use]
1246        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
1247            self.send_compression_encodings.enable(encoding);
1248            self
1249        }
1250        /// Limits the maximum size of a decoded message.
1251        ///
1252        /// Default: `4MB`
1253        #[must_use]
1254        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
1255            self.max_decoding_message_size = Some(limit);
1256            self
1257        }
1258        /// Limits the maximum size of an encoded message.
1259        ///
1260        /// Default: `usize::MAX`
1261        #[must_use]
1262        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
1263            self.max_encoding_message_size = Some(limit);
1264            self
1265        }
1266    }
1267    impl<T, B> tonic::codegen::Service<http::Request<B>> for MsgServer<T>
1268    where
1269        T: Msg,
1270        B: Body + Send + 'static,
1271        B::Error: Into<StdError> + Send + 'static,
1272    {
1273        type Response = http::Response<tonic::body::BoxBody>;
1274        type Error = std::convert::Infallible;
1275        type Future = BoxFuture<Self::Response, Self::Error>;
1276        fn poll_ready(
1277            &mut self,
1278            _cx: &mut Context<'_>,
1279        ) -> Poll<core::result::Result<(), Self::Error>> {
1280            Poll::Ready(Ok(()))
1281        }
1282        fn call(&mut self, req: http::Request<B>) -> Self::Future {
1283            let inner = self.inner.clone();
1284            match req.uri().path() {
1285                "/side.dlc.Msg/CreateDCM" => {
1286                    #[allow(non_camel_case_types)]
1287                    struct CreateDCMSvc<T: Msg>(pub Arc<T>);
1288                    impl<T: Msg> tonic::server::UnaryService<super::MsgCreateDcm> for CreateDCMSvc<T> {
1289                        type Response = super::MsgCreateDcmResponse;
1290                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1291                        fn call(
1292                            &mut self,
1293                            request: tonic::Request<super::MsgCreateDcm>,
1294                        ) -> Self::Future {
1295                            let inner = Arc::clone(&self.0);
1296                            let fut = async move { (*inner).create_dcm(request).await };
1297                            Box::pin(fut)
1298                        }
1299                    }
1300                    let accept_compression_encodings = self.accept_compression_encodings;
1301                    let send_compression_encodings = self.send_compression_encodings;
1302                    let max_decoding_message_size = self.max_decoding_message_size;
1303                    let max_encoding_message_size = self.max_encoding_message_size;
1304                    let inner = self.inner.clone();
1305                    let fut = async move {
1306                        let inner = inner.0;
1307                        let method = CreateDCMSvc(inner);
1308                        let codec = tonic::codec::ProstCodec::default();
1309                        let mut grpc = tonic::server::Grpc::new(codec)
1310                            .apply_compression_config(
1311                                accept_compression_encodings,
1312                                send_compression_encodings,
1313                            )
1314                            .apply_max_message_size_config(
1315                                max_decoding_message_size,
1316                                max_encoding_message_size,
1317                            );
1318                        let res = grpc.unary(method, req).await;
1319                        Ok(res)
1320                    };
1321                    Box::pin(fut)
1322                }
1323                "/side.dlc.Msg/UpdateParams" => {
1324                    #[allow(non_camel_case_types)]
1325                    struct UpdateParamsSvc<T: Msg>(pub Arc<T>);
1326                    impl<T: Msg> tonic::server::UnaryService<super::MsgUpdateParams> for UpdateParamsSvc<T> {
1327                        type Response = super::MsgUpdateParamsResponse;
1328                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1329                        fn call(
1330                            &mut self,
1331                            request: tonic::Request<super::MsgUpdateParams>,
1332                        ) -> Self::Future {
1333                            let inner = Arc::clone(&self.0);
1334                            let fut = async move { (*inner).update_params(request).await };
1335                            Box::pin(fut)
1336                        }
1337                    }
1338                    let accept_compression_encodings = self.accept_compression_encodings;
1339                    let send_compression_encodings = self.send_compression_encodings;
1340                    let max_decoding_message_size = self.max_decoding_message_size;
1341                    let max_encoding_message_size = self.max_encoding_message_size;
1342                    let inner = self.inner.clone();
1343                    let fut = async move {
1344                        let inner = inner.0;
1345                        let method = UpdateParamsSvc(inner);
1346                        let codec = tonic::codec::ProstCodec::default();
1347                        let mut grpc = tonic::server::Grpc::new(codec)
1348                            .apply_compression_config(
1349                                accept_compression_encodings,
1350                                send_compression_encodings,
1351                            )
1352                            .apply_max_message_size_config(
1353                                max_decoding_message_size,
1354                                max_encoding_message_size,
1355                            );
1356                        let res = grpc.unary(method, req).await;
1357                        Ok(res)
1358                    };
1359                    Box::pin(fut)
1360                }
1361                _ => Box::pin(async move {
1362                    Ok(http::Response::builder()
1363                        .status(200)
1364                        .header("grpc-status", "12")
1365                        .header("content-type", "application/grpc")
1366                        .body(empty_body())
1367                        .unwrap())
1368                }),
1369            }
1370        }
1371    }
1372    impl<T: Msg> Clone for MsgServer<T> {
1373        fn clone(&self) -> Self {
1374            let inner = self.inner.clone();
1375            Self {
1376                inner,
1377                accept_compression_encodings: self.accept_compression_encodings,
1378                send_compression_encodings: self.send_compression_encodings,
1379                max_decoding_message_size: self.max_decoding_message_size,
1380                max_encoding_message_size: self.max_encoding_message_size,
1381            }
1382        }
1383    }
1384    impl<T: Msg> Clone for _Inner<T> {
1385        fn clone(&self) -> Self {
1386            Self(Arc::clone(&self.0))
1387        }
1388    }
1389    impl<T: core::fmt::Debug> core::fmt::Debug for _Inner<T> {
1390        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1391            write!(f, "{:?}", self.0)
1392        }
1393    }
1394    impl<T: Msg> tonic::server::NamedService for MsgServer<T> {
1395        const NAME: &'static str = "side.dlc.Msg";
1396    }
1397}
side_proto/prost/side/side.dlc.tonic.rs

side_proto/prost/side/
side.dlc.tonic.rs
