cosmos_sdk_proto/prost/cosmos-sdk/
cosmos.upgrade.v1beta1.tonic.rs

1// @generated
2/// Generated client implementations.
3#[cfg(feature = "grpc")]
4pub mod query_client {
5    #![allow(
6        unused_variables,
7        dead_code,
8        missing_docs,
9        clippy::wildcard_imports,
10        clippy::let_unit_value
11    )]
12    use tonic::codegen::http::Uri;
13    use tonic::codegen::*;
14    #[derive(Debug, Clone)]
15    pub struct QueryClient<T> {
16        inner: tonic::client::Grpc<T>,
17    }
18    #[cfg(feature = "grpc-transport")]
19    impl QueryClient<tonic::transport::Channel> {
20        /// Attempt to create a new client by connecting to a given endpoint.
21        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
22        where
23            D: TryInto<tonic::transport::Endpoint>,
24            D::Error: Into<StdError>,
25        {
26            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
27            Ok(Self::new(conn))
28        }
29    }
30    impl<T> QueryClient<T>
31    where
32        T: tonic::client::GrpcService<tonic::body::Body>,
33        T::Error: Into<StdError>,
34        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
35        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
36    {
37        pub fn new(inner: T) -> Self {
38            let inner = tonic::client::Grpc::new(inner);
39            Self { inner }
40        }
41        pub fn with_origin(inner: T, origin: Uri) -> Self {
42            let inner = tonic::client::Grpc::with_origin(inner, origin);
43            Self { inner }
44        }
45        pub fn with_interceptor<F>(
46            inner: T,
47            interceptor: F,
48        ) -> QueryClient<InterceptedService<T, F>>
49        where
50            F: tonic::service::Interceptor,
51            T::ResponseBody: Default,
52            T: tonic::codegen::Service<
53                http::Request<tonic::body::Body>,
54                Response = http::Response<
55                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
56                >,
57            >,
58            <T as tonic::codegen::Service<http::Request<tonic::body::Body>>>::Error:
59                Into<StdError> + std::marker::Send + std::marker::Sync,
60        {
61            QueryClient::new(InterceptedService::new(inner, interceptor))
62        }
63        /// Compress requests with the given encoding.
64        ///
65        /// This requires the server to support it otherwise it might respond with an
66        /// error.
67        #[must_use]
68        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
69            self.inner = self.inner.send_compressed(encoding);
70            self
71        }
72        /// Enable decompressing responses.
73        #[must_use]
74        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
75            self.inner = self.inner.accept_compressed(encoding);
76            self
77        }
78        /// Limits the maximum size of a decoded message.
79        ///
80        /// Default: `4MB`
81        #[must_use]
82        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
83            self.inner = self.inner.max_decoding_message_size(limit);
84            self
85        }
86        /// Limits the maximum size of an encoded message.
87        ///
88        /// Default: `usize::MAX`
89        #[must_use]
90        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
91            self.inner = self.inner.max_encoding_message_size(limit);
92            self
93        }
94        pub async fn current_plan(
95            &mut self,
96            request: impl tonic::IntoRequest<super::QueryCurrentPlanRequest>,
97        ) -> core::result::Result<tonic::Response<super::QueryCurrentPlanResponse>, tonic::Status>
98        {
99            self.inner.ready().await.map_err(|e| {
100                tonic::Status::unknown(alloc::format!("Service was not ready: {}", e.into()))
101            })?;
102            let codec = tonic::codec::ProstCodec::default();
103            let path =
104                http::uri::PathAndQuery::from_static("/cosmos.upgrade.v1beta1.Query/CurrentPlan");
105            let mut req = request.into_request();
106            req.extensions_mut().insert(GrpcMethod::new(
107                "cosmos.upgrade.v1beta1.Query",
108                "CurrentPlan",
109            ));
110            self.inner.unary(req, path, codec).await
111        }
112        pub async fn applied_plan(
113            &mut self,
114            request: impl tonic::IntoRequest<super::QueryAppliedPlanRequest>,
115        ) -> core::result::Result<tonic::Response<super::QueryAppliedPlanResponse>, tonic::Status>
116        {
117            self.inner.ready().await.map_err(|e| {
118                tonic::Status::unknown(alloc::format!("Service was not ready: {}", e.into()))
119            })?;
120            let codec = tonic::codec::ProstCodec::default();
121            let path =
122                http::uri::PathAndQuery::from_static("/cosmos.upgrade.v1beta1.Query/AppliedPlan");
123            let mut req = request.into_request();
124            req.extensions_mut().insert(GrpcMethod::new(
125                "cosmos.upgrade.v1beta1.Query",
126                "AppliedPlan",
127            ));
128            self.inner.unary(req, path, codec).await
129        }
130        pub async fn upgraded_consensus_state(
131            &mut self,
132            request: impl tonic::IntoRequest<super::QueryUpgradedConsensusStateRequest>,
133        ) -> core::result::Result<
134            tonic::Response<super::QueryUpgradedConsensusStateResponse>,
135            tonic::Status,
136        > {
137            self.inner.ready().await.map_err(|e| {
138                tonic::Status::unknown(alloc::format!("Service was not ready: {}", e.into()))
139            })?;
140            let codec = tonic::codec::ProstCodec::default();
141            let path = http::uri::PathAndQuery::from_static(
142                "/cosmos.upgrade.v1beta1.Query/UpgradedConsensusState",
143            );
144            let mut req = request.into_request();
145            req.extensions_mut().insert(GrpcMethod::new(
146                "cosmos.upgrade.v1beta1.Query",
147                "UpgradedConsensusState",
148            ));
149            self.inner.unary(req, path, codec).await
150        }
151        pub async fn module_versions(
152            &mut self,
153            request: impl tonic::IntoRequest<super::QueryModuleVersionsRequest>,
154        ) -> core::result::Result<tonic::Response<super::QueryModuleVersionsResponse>, tonic::Status>
155        {
156            self.inner.ready().await.map_err(|e| {
157                tonic::Status::unknown(alloc::format!("Service was not ready: {}", e.into()))
158            })?;
159            let codec = tonic::codec::ProstCodec::default();
160            let path = http::uri::PathAndQuery::from_static(
161                "/cosmos.upgrade.v1beta1.Query/ModuleVersions",
162            );
163            let mut req = request.into_request();
164            req.extensions_mut().insert(GrpcMethod::new(
165                "cosmos.upgrade.v1beta1.Query",
166                "ModuleVersions",
167            ));
168            self.inner.unary(req, path, codec).await
169        }
170        pub async fn authority(
171            &mut self,
172            request: impl tonic::IntoRequest<super::QueryAuthorityRequest>,
173        ) -> core::result::Result<tonic::Response<super::QueryAuthorityResponse>, tonic::Status>
174        {
175            self.inner.ready().await.map_err(|e| {
176                tonic::Status::unknown(alloc::format!("Service was not ready: {}", e.into()))
177            })?;
178            let codec = tonic::codec::ProstCodec::default();
179            let path =
180                http::uri::PathAndQuery::from_static("/cosmos.upgrade.v1beta1.Query/Authority");
181            let mut req = request.into_request();
182            req.extensions_mut()
183                .insert(GrpcMethod::new("cosmos.upgrade.v1beta1.Query", "Authority"));
184            self.inner.unary(req, path, codec).await
185        }
186    }
187}
188/// Generated server implementations.
189#[cfg(feature = "grpc")]
190pub mod query_server {
191    #![allow(
192        unused_variables,
193        dead_code,
194        missing_docs,
195        clippy::wildcard_imports,
196        clippy::let_unit_value
197    )]
198    use tonic::codegen::*;
199    /// Generated trait containing gRPC methods that should be implemented for use with QueryServer.
200    #[async_trait]
201    pub trait Query: std::marker::Send + std::marker::Sync + 'static {
202        async fn current_plan(
203            &self,
204            request: tonic::Request<super::QueryCurrentPlanRequest>,
205        ) -> core::result::Result<tonic::Response<super::QueryCurrentPlanResponse>, tonic::Status>;
206        async fn applied_plan(
207            &self,
208            request: tonic::Request<super::QueryAppliedPlanRequest>,
209        ) -> core::result::Result<tonic::Response<super::QueryAppliedPlanResponse>, tonic::Status>;
210        async fn upgraded_consensus_state(
211            &self,
212            request: tonic::Request<super::QueryUpgradedConsensusStateRequest>,
213        ) -> core::result::Result<
214            tonic::Response<super::QueryUpgradedConsensusStateResponse>,
215            tonic::Status,
216        >;
217        async fn module_versions(
218            &self,
219            request: tonic::Request<super::QueryModuleVersionsRequest>,
220        ) -> core::result::Result<tonic::Response<super::QueryModuleVersionsResponse>, tonic::Status>;
221        async fn authority(
222            &self,
223            request: tonic::Request<super::QueryAuthorityRequest>,
224        ) -> core::result::Result<tonic::Response<super::QueryAuthorityResponse>, tonic::Status>;
225    }
226    #[derive(Debug)]
227    pub struct QueryServer<T> {
228        inner: Arc<T>,
229        accept_compression_encodings: EnabledCompressionEncodings,
230        send_compression_encodings: EnabledCompressionEncodings,
231        max_decoding_message_size: Option<usize>,
232        max_encoding_message_size: Option<usize>,
233    }
234    impl<T> QueryServer<T> {
235        pub fn new(inner: T) -> Self {
236            Self::from_arc(Arc::new(inner))
237        }
238        pub fn from_arc(inner: Arc<T>) -> Self {
239            Self {
240                inner,
241                accept_compression_encodings: Default::default(),
242                send_compression_encodings: Default::default(),
243                max_decoding_message_size: None,
244                max_encoding_message_size: None,
245            }
246        }
247        pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
248        where
249            F: tonic::service::Interceptor,
250        {
251            InterceptedService::new(Self::new(inner), interceptor)
252        }
253        /// Enable decompressing requests with the given encoding.
254        #[must_use]
255        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
256            self.accept_compression_encodings.enable(encoding);
257            self
258        }
259        /// Compress responses with the given encoding, if the client supports it.
260        #[must_use]
261        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
262            self.send_compression_encodings.enable(encoding);
263            self
264        }
265        /// Limits the maximum size of a decoded message.
266        ///
267        /// Default: `4MB`
268        #[must_use]
269        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
270            self.max_decoding_message_size = Some(limit);
271            self
272        }
273        /// Limits the maximum size of an encoded message.
274        ///
275        /// Default: `usize::MAX`
276        #[must_use]
277        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
278            self.max_encoding_message_size = Some(limit);
279            self
280        }
281    }
282    impl<T, B> tonic::codegen::Service<http::Request<B>> for QueryServer<T>
283    where
284        T: Query,
285        B: Body + std::marker::Send + 'static,
286        B::Error: Into<StdError> + std::marker::Send + 'static,
287    {
288        type Response = http::Response<tonic::body::Body>;
289        type Error = std::convert::Infallible;
290        type Future = BoxFuture<Self::Response, Self::Error>;
291        fn poll_ready(
292            &mut self,
293            _cx: &mut Context<'_>,
294        ) -> Poll<core::result::Result<(), Self::Error>> {
295            Poll::Ready(Ok(()))
296        }
297        fn call(&mut self, req: http::Request<B>) -> Self::Future {
298            match req.uri().path() {
299                "/cosmos.upgrade.v1beta1.Query/CurrentPlan" => {
300                    #[allow(non_camel_case_types)]
301                    struct CurrentPlanSvc<T: Query>(pub Arc<T>);
302                    impl<T: Query> tonic::server::UnaryService<super::QueryCurrentPlanRequest> for CurrentPlanSvc<T> {
303                        type Response = super::QueryCurrentPlanResponse;
304                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
305                        fn call(
306                            &mut self,
307                            request: tonic::Request<super::QueryCurrentPlanRequest>,
308                        ) -> Self::Future {
309                            let inner = Arc::clone(&self.0);
310                            let fut =
311                                async move { <T as Query>::current_plan(&inner, request).await };
312                            Box::pin(fut)
313                        }
314                    }
315                    let accept_compression_encodings = self.accept_compression_encodings;
316                    let send_compression_encodings = self.send_compression_encodings;
317                    let max_decoding_message_size = self.max_decoding_message_size;
318                    let max_encoding_message_size = self.max_encoding_message_size;
319                    let inner = self.inner.clone();
320                    let fut = async move {
321                        let method = CurrentPlanSvc(inner);
322                        let codec = tonic::codec::ProstCodec::default();
323                        let mut grpc = tonic::server::Grpc::new(codec)
324                            .apply_compression_config(
325                                accept_compression_encodings,
326                                send_compression_encodings,
327                            )
328                            .apply_max_message_size_config(
329                                max_decoding_message_size,
330                                max_encoding_message_size,
331                            );
332                        let res = grpc.unary(method, req).await;
333                        Ok(res)
334                    };
335                    Box::pin(fut)
336                }
337                "/cosmos.upgrade.v1beta1.Query/AppliedPlan" => {
338                    #[allow(non_camel_case_types)]
339                    struct AppliedPlanSvc<T: Query>(pub Arc<T>);
340                    impl<T: Query> tonic::server::UnaryService<super::QueryAppliedPlanRequest> for AppliedPlanSvc<T> {
341                        type Response = super::QueryAppliedPlanResponse;
342                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
343                        fn call(
344                            &mut self,
345                            request: tonic::Request<super::QueryAppliedPlanRequest>,
346                        ) -> Self::Future {
347                            let inner = Arc::clone(&self.0);
348                            let fut =
349                                async move { <T as Query>::applied_plan(&inner, request).await };
350                            Box::pin(fut)
351                        }
352                    }
353                    let accept_compression_encodings = self.accept_compression_encodings;
354                    let send_compression_encodings = self.send_compression_encodings;
355                    let max_decoding_message_size = self.max_decoding_message_size;
356                    let max_encoding_message_size = self.max_encoding_message_size;
357                    let inner = self.inner.clone();
358                    let fut = async move {
359                        let method = AppliedPlanSvc(inner);
360                        let codec = tonic::codec::ProstCodec::default();
361                        let mut grpc = tonic::server::Grpc::new(codec)
362                            .apply_compression_config(
363                                accept_compression_encodings,
364                                send_compression_encodings,
365                            )
366                            .apply_max_message_size_config(
367                                max_decoding_message_size,
368                                max_encoding_message_size,
369                            );
370                        let res = grpc.unary(method, req).await;
371                        Ok(res)
372                    };
373                    Box::pin(fut)
374                }
375                "/cosmos.upgrade.v1beta1.Query/UpgradedConsensusState" => {
376                    #[allow(non_camel_case_types)]
377                    struct UpgradedConsensusStateSvc<T: Query>(pub Arc<T>);
378                    impl<T: Query>
379                        tonic::server::UnaryService<super::QueryUpgradedConsensusStateRequest>
380                        for UpgradedConsensusStateSvc<T>
381                    {
382                        type Response = super::QueryUpgradedConsensusStateResponse;
383                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
384                        fn call(
385                            &mut self,
386                            request: tonic::Request<super::QueryUpgradedConsensusStateRequest>,
387                        ) -> Self::Future {
388                            let inner = Arc::clone(&self.0);
389                            let fut = async move {
390                                <T as Query>::upgraded_consensus_state(&inner, request).await
391                            };
392                            Box::pin(fut)
393                        }
394                    }
395                    let accept_compression_encodings = self.accept_compression_encodings;
396                    let send_compression_encodings = self.send_compression_encodings;
397                    let max_decoding_message_size = self.max_decoding_message_size;
398                    let max_encoding_message_size = self.max_encoding_message_size;
399                    let inner = self.inner.clone();
400                    let fut = async move {
401                        let method = UpgradedConsensusStateSvc(inner);
402                        let codec = tonic::codec::ProstCodec::default();
403                        let mut grpc = tonic::server::Grpc::new(codec)
404                            .apply_compression_config(
405                                accept_compression_encodings,
406                                send_compression_encodings,
407                            )
408                            .apply_max_message_size_config(
409                                max_decoding_message_size,
410                                max_encoding_message_size,
411                            );
412                        let res = grpc.unary(method, req).await;
413                        Ok(res)
414                    };
415                    Box::pin(fut)
416                }
417                "/cosmos.upgrade.v1beta1.Query/ModuleVersions" => {
418                    #[allow(non_camel_case_types)]
419                    struct ModuleVersionsSvc<T: Query>(pub Arc<T>);
420                    impl<T: Query> tonic::server::UnaryService<super::QueryModuleVersionsRequest>
421                        for ModuleVersionsSvc<T>
422                    {
423                        type Response = super::QueryModuleVersionsResponse;
424                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
425                        fn call(
426                            &mut self,
427                            request: tonic::Request<super::QueryModuleVersionsRequest>,
428                        ) -> Self::Future {
429                            let inner = Arc::clone(&self.0);
430                            let fut =
431                                async move { <T as Query>::module_versions(&inner, request).await };
432                            Box::pin(fut)
433                        }
434                    }
435                    let accept_compression_encodings = self.accept_compression_encodings;
436                    let send_compression_encodings = self.send_compression_encodings;
437                    let max_decoding_message_size = self.max_decoding_message_size;
438                    let max_encoding_message_size = self.max_encoding_message_size;
439                    let inner = self.inner.clone();
440                    let fut = async move {
441                        let method = ModuleVersionsSvc(inner);
442                        let codec = tonic::codec::ProstCodec::default();
443                        let mut grpc = tonic::server::Grpc::new(codec)
444                            .apply_compression_config(
445                                accept_compression_encodings,
446                                send_compression_encodings,
447                            )
448                            .apply_max_message_size_config(
449                                max_decoding_message_size,
450                                max_encoding_message_size,
451                            );
452                        let res = grpc.unary(method, req).await;
453                        Ok(res)
454                    };
455                    Box::pin(fut)
456                }
457                "/cosmos.upgrade.v1beta1.Query/Authority" => {
458                    #[allow(non_camel_case_types)]
459                    struct AuthoritySvc<T: Query>(pub Arc<T>);
460                    impl<T: Query> tonic::server::UnaryService<super::QueryAuthorityRequest> for AuthoritySvc<T> {
461                        type Response = super::QueryAuthorityResponse;
462                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
463                        fn call(
464                            &mut self,
465                            request: tonic::Request<super::QueryAuthorityRequest>,
466                        ) -> Self::Future {
467                            let inner = Arc::clone(&self.0);
468                            let fut = async move { <T as Query>::authority(&inner, request).await };
469                            Box::pin(fut)
470                        }
471                    }
472                    let accept_compression_encodings = self.accept_compression_encodings;
473                    let send_compression_encodings = self.send_compression_encodings;
474                    let max_decoding_message_size = self.max_decoding_message_size;
475                    let max_encoding_message_size = self.max_encoding_message_size;
476                    let inner = self.inner.clone();
477                    let fut = async move {
478                        let method = AuthoritySvc(inner);
479                        let codec = tonic::codec::ProstCodec::default();
480                        let mut grpc = tonic::server::Grpc::new(codec)
481                            .apply_compression_config(
482                                accept_compression_encodings,
483                                send_compression_encodings,
484                            )
485                            .apply_max_message_size_config(
486                                max_decoding_message_size,
487                                max_encoding_message_size,
488                            );
489                        let res = grpc.unary(method, req).await;
490                        Ok(res)
491                    };
492                    Box::pin(fut)
493                }
494                _ => Box::pin(async move {
495                    let mut response = http::Response::new(tonic::body::Body::default());
496                    let headers = response.headers_mut();
497                    headers.insert(
498                        tonic::Status::GRPC_STATUS,
499                        (tonic::Code::Unimplemented as i32).into(),
500                    );
501                    headers.insert(
502                        http::header::CONTENT_TYPE,
503                        tonic::metadata::GRPC_CONTENT_TYPE,
504                    );
505                    Ok(response)
506                }),
507            }
508        }
509    }
510    impl<T> Clone for QueryServer<T> {
511        fn clone(&self) -> Self {
512            let inner = self.inner.clone();
513            Self {
514                inner,
515                accept_compression_encodings: self.accept_compression_encodings,
516                send_compression_encodings: self.send_compression_encodings,
517                max_decoding_message_size: self.max_decoding_message_size,
518                max_encoding_message_size: self.max_encoding_message_size,
519            }
520        }
521    }
522    /// Generated gRPC service name
523    pub const SERVICE_NAME: &str = "cosmos.upgrade.v1beta1.Query";
524    impl<T> tonic::server::NamedService for QueryServer<T> {
525        const NAME: &'static str = SERVICE_NAME;
526    }
527}
528/// Generated client implementations.
529#[cfg(feature = "grpc")]
530pub mod msg_client {
531    #![allow(
532        unused_variables,
533        dead_code,
534        missing_docs,
535        clippy::wildcard_imports,
536        clippy::let_unit_value
537    )]
538    use tonic::codegen::http::Uri;
539    use tonic::codegen::*;
540    #[derive(Debug, Clone)]
541    pub struct MsgClient<T> {
542        inner: tonic::client::Grpc<T>,
543    }
544    #[cfg(feature = "grpc-transport")]
545    impl MsgClient<tonic::transport::Channel> {
546        /// Attempt to create a new client by connecting to a given endpoint.
547        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
548        where
549            D: TryInto<tonic::transport::Endpoint>,
550            D::Error: Into<StdError>,
551        {
552            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
553            Ok(Self::new(conn))
554        }
555    }
556    impl<T> MsgClient<T>
557    where
558        T: tonic::client::GrpcService<tonic::body::Body>,
559        T::Error: Into<StdError>,
560        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
561        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
562    {
563        pub fn new(inner: T) -> Self {
564            let inner = tonic::client::Grpc::new(inner);
565            Self { inner }
566        }
567        pub fn with_origin(inner: T, origin: Uri) -> Self {
568            let inner = tonic::client::Grpc::with_origin(inner, origin);
569            Self { inner }
570        }
571        pub fn with_interceptor<F>(inner: T, interceptor: F) -> MsgClient<InterceptedService<T, F>>
572        where
573            F: tonic::service::Interceptor,
574            T::ResponseBody: Default,
575            T: tonic::codegen::Service<
576                http::Request<tonic::body::Body>,
577                Response = http::Response<
578                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
579                >,
580            >,
581            <T as tonic::codegen::Service<http::Request<tonic::body::Body>>>::Error:
582                Into<StdError> + std::marker::Send + std::marker::Sync,
583        {
584            MsgClient::new(InterceptedService::new(inner, interceptor))
585        }
586        /// Compress requests with the given encoding.
587        ///
588        /// This requires the server to support it otherwise it might respond with an
589        /// error.
590        #[must_use]
591        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
592            self.inner = self.inner.send_compressed(encoding);
593            self
594        }
595        /// Enable decompressing responses.
596        #[must_use]
597        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
598            self.inner = self.inner.accept_compressed(encoding);
599            self
600        }
601        /// Limits the maximum size of a decoded message.
602        ///
603        /// Default: `4MB`
604        #[must_use]
605        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
606            self.inner = self.inner.max_decoding_message_size(limit);
607            self
608        }
609        /// Limits the maximum size of an encoded message.
610        ///
611        /// Default: `usize::MAX`
612        #[must_use]
613        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
614            self.inner = self.inner.max_encoding_message_size(limit);
615            self
616        }
617        pub async fn software_upgrade(
618            &mut self,
619            request: impl tonic::IntoRequest<super::MsgSoftwareUpgrade>,
620        ) -> core::result::Result<tonic::Response<super::MsgSoftwareUpgradeResponse>, tonic::Status>
621        {
622            self.inner.ready().await.map_err(|e| {
623                tonic::Status::unknown(alloc::format!("Service was not ready: {}", e.into()))
624            })?;
625            let codec = tonic::codec::ProstCodec::default();
626            let path =
627                http::uri::PathAndQuery::from_static("/cosmos.upgrade.v1beta1.Msg/SoftwareUpgrade");
628            let mut req = request.into_request();
629            req.extensions_mut().insert(GrpcMethod::new(
630                "cosmos.upgrade.v1beta1.Msg",
631                "SoftwareUpgrade",
632            ));
633            self.inner.unary(req, path, codec).await
634        }
635        pub async fn cancel_upgrade(
636            &mut self,
637            request: impl tonic::IntoRequest<super::MsgCancelUpgrade>,
638        ) -> core::result::Result<tonic::Response<super::MsgCancelUpgradeResponse>, tonic::Status>
639        {
640            self.inner.ready().await.map_err(|e| {
641                tonic::Status::unknown(alloc::format!("Service was not ready: {}", e.into()))
642            })?;
643            let codec = tonic::codec::ProstCodec::default();
644            let path =
645                http::uri::PathAndQuery::from_static("/cosmos.upgrade.v1beta1.Msg/CancelUpgrade");
646            let mut req = request.into_request();
647            req.extensions_mut().insert(GrpcMethod::new(
648                "cosmos.upgrade.v1beta1.Msg",
649                "CancelUpgrade",
650            ));
651            self.inner.unary(req, path, codec).await
652        }
653    }
654}
655/// Generated server implementations.
656#[cfg(feature = "grpc")]
657pub mod msg_server {
658    #![allow(
659        unused_variables,
660        dead_code,
661        missing_docs,
662        clippy::wildcard_imports,
663        clippy::let_unit_value
664    )]
665    use tonic::codegen::*;
666    /// Generated trait containing gRPC methods that should be implemented for use with MsgServer.
667    #[async_trait]
668    pub trait Msg: std::marker::Send + std::marker::Sync + 'static {
669        async fn software_upgrade(
670            &self,
671            request: tonic::Request<super::MsgSoftwareUpgrade>,
672        ) -> core::result::Result<tonic::Response<super::MsgSoftwareUpgradeResponse>, tonic::Status>;
673        async fn cancel_upgrade(
674            &self,
675            request: tonic::Request<super::MsgCancelUpgrade>,
676        ) -> core::result::Result<tonic::Response<super::MsgCancelUpgradeResponse>, tonic::Status>;
677    }
678    #[derive(Debug)]
679    pub struct MsgServer<T> {
680        inner: Arc<T>,
681        accept_compression_encodings: EnabledCompressionEncodings,
682        send_compression_encodings: EnabledCompressionEncodings,
683        max_decoding_message_size: Option<usize>,
684        max_encoding_message_size: Option<usize>,
685    }
686    impl<T> MsgServer<T> {
687        pub fn new(inner: T) -> Self {
688            Self::from_arc(Arc::new(inner))
689        }
690        pub fn from_arc(inner: Arc<T>) -> Self {
691            Self {
692                inner,
693                accept_compression_encodings: Default::default(),
694                send_compression_encodings: Default::default(),
695                max_decoding_message_size: None,
696                max_encoding_message_size: None,
697            }
698        }
699        pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
700        where
701            F: tonic::service::Interceptor,
702        {
703            InterceptedService::new(Self::new(inner), interceptor)
704        }
705        /// Enable decompressing requests with the given encoding.
706        #[must_use]
707        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
708            self.accept_compression_encodings.enable(encoding);
709            self
710        }
711        /// Compress responses with the given encoding, if the client supports it.
712        #[must_use]
713        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
714            self.send_compression_encodings.enable(encoding);
715            self
716        }
717        /// Limits the maximum size of a decoded message.
718        ///
719        /// Default: `4MB`
720        #[must_use]
721        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
722            self.max_decoding_message_size = Some(limit);
723            self
724        }
725        /// Limits the maximum size of an encoded message.
726        ///
727        /// Default: `usize::MAX`
728        #[must_use]
729        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
730            self.max_encoding_message_size = Some(limit);
731            self
732        }
733    }
734    impl<T, B> tonic::codegen::Service<http::Request<B>> for MsgServer<T>
735    where
736        T: Msg,
737        B: Body + std::marker::Send + 'static,
738        B::Error: Into<StdError> + std::marker::Send + 'static,
739    {
740        type Response = http::Response<tonic::body::Body>;
741        type Error = std::convert::Infallible;
742        type Future = BoxFuture<Self::Response, Self::Error>;
743        fn poll_ready(
744            &mut self,
745            _cx: &mut Context<'_>,
746        ) -> Poll<core::result::Result<(), Self::Error>> {
747            Poll::Ready(Ok(()))
748        }
749        fn call(&mut self, req: http::Request<B>) -> Self::Future {
750            match req.uri().path() {
751                "/cosmos.upgrade.v1beta1.Msg/SoftwareUpgrade" => {
752                    #[allow(non_camel_case_types)]
753                    struct SoftwareUpgradeSvc<T: Msg>(pub Arc<T>);
754                    impl<T: Msg> tonic::server::UnaryService<super::MsgSoftwareUpgrade> for SoftwareUpgradeSvc<T> {
755                        type Response = super::MsgSoftwareUpgradeResponse;
756                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
757                        fn call(
758                            &mut self,
759                            request: tonic::Request<super::MsgSoftwareUpgrade>,
760                        ) -> Self::Future {
761                            let inner = Arc::clone(&self.0);
762                            let fut =
763                                async move { <T as Msg>::software_upgrade(&inner, request).await };
764                            Box::pin(fut)
765                        }
766                    }
767                    let accept_compression_encodings = self.accept_compression_encodings;
768                    let send_compression_encodings = self.send_compression_encodings;
769                    let max_decoding_message_size = self.max_decoding_message_size;
770                    let max_encoding_message_size = self.max_encoding_message_size;
771                    let inner = self.inner.clone();
772                    let fut = async move {
773                        let method = SoftwareUpgradeSvc(inner);
774                        let codec = tonic::codec::ProstCodec::default();
775                        let mut grpc = tonic::server::Grpc::new(codec)
776                            .apply_compression_config(
777                                accept_compression_encodings,
778                                send_compression_encodings,
779                            )
780                            .apply_max_message_size_config(
781                                max_decoding_message_size,
782                                max_encoding_message_size,
783                            );
784                        let res = grpc.unary(method, req).await;
785                        Ok(res)
786                    };
787                    Box::pin(fut)
788                }
789                "/cosmos.upgrade.v1beta1.Msg/CancelUpgrade" => {
790                    #[allow(non_camel_case_types)]
791                    struct CancelUpgradeSvc<T: Msg>(pub Arc<T>);
792                    impl<T: Msg> tonic::server::UnaryService<super::MsgCancelUpgrade> for CancelUpgradeSvc<T> {
793                        type Response = super::MsgCancelUpgradeResponse;
794                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
795                        fn call(
796                            &mut self,
797                            request: tonic::Request<super::MsgCancelUpgrade>,
798                        ) -> Self::Future {
799                            let inner = Arc::clone(&self.0);
800                            let fut =
801                                async move { <T as Msg>::cancel_upgrade(&inner, request).await };
802                            Box::pin(fut)
803                        }
804                    }
805                    let accept_compression_encodings = self.accept_compression_encodings;
806                    let send_compression_encodings = self.send_compression_encodings;
807                    let max_decoding_message_size = self.max_decoding_message_size;
808                    let max_encoding_message_size = self.max_encoding_message_size;
809                    let inner = self.inner.clone();
810                    let fut = async move {
811                        let method = CancelUpgradeSvc(inner);
812                        let codec = tonic::codec::ProstCodec::default();
813                        let mut grpc = tonic::server::Grpc::new(codec)
814                            .apply_compression_config(
815                                accept_compression_encodings,
816                                send_compression_encodings,
817                            )
818                            .apply_max_message_size_config(
819                                max_decoding_message_size,
820                                max_encoding_message_size,
821                            );
822                        let res = grpc.unary(method, req).await;
823                        Ok(res)
824                    };
825                    Box::pin(fut)
826                }
827                _ => Box::pin(async move {
828                    let mut response = http::Response::new(tonic::body::Body::default());
829                    let headers = response.headers_mut();
830                    headers.insert(
831                        tonic::Status::GRPC_STATUS,
832                        (tonic::Code::Unimplemented as i32).into(),
833                    );
834                    headers.insert(
835                        http::header::CONTENT_TYPE,
836                        tonic::metadata::GRPC_CONTENT_TYPE,
837                    );
838                    Ok(response)
839                }),
840            }
841        }
842    }
843    impl<T> Clone for MsgServer<T> {
844        fn clone(&self) -> Self {
845            let inner = self.inner.clone();
846            Self {
847                inner,
848                accept_compression_encodings: self.accept_compression_encodings,
849                send_compression_encodings: self.send_compression_encodings,
850                max_decoding_message_size: self.max_decoding_message_size,
851                max_encoding_message_size: self.max_encoding_message_size,
852            }
853        }
854    }
855    /// Generated gRPC service name
856    pub const SERVICE_NAME: &str = "cosmos.upgrade.v1beta1.Msg";
857    impl<T> tonic::server::NamedService for MsgServer<T> {
858        const NAME: &'static str = SERVICE_NAME;
859    }
860}
cosmos_sdk_proto/prost/cosmos-sdk/cosmos.upgrade.v1beta1.tonic.rs

cosmos_sdk_proto/prost/cosmos-sdk/
cosmos.upgrade.v1beta1.tonic.rs
