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

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