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

1// @generated
2/// Generated client implementations.
3#[cfg(feature = "grpc")]
4pub mod service_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 ServiceClient<T> {
16        inner: tonic::client::Grpc<T>,
17    }
18    #[cfg(feature = "grpc-transport")]
19    impl ServiceClient<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> ServiceClient<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        ) -> ServiceClient<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            ServiceClient::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 simulate(
95            &mut self,
96            request: impl tonic::IntoRequest<super::SimulateRequest>,
97        ) -> core::result::Result<tonic::Response<super::SimulateResponse>, tonic::Status> {
98            self.inner.ready().await.map_err(|e| {
99                tonic::Status::unknown(alloc::format!("Service was not ready: {}", e.into()))
100            })?;
101            let codec = tonic::codec::ProstCodec::default();
102            let path = http::uri::PathAndQuery::from_static("/cosmos.tx.v1beta1.Service/Simulate");
103            let mut req = request.into_request();
104            req.extensions_mut()
105                .insert(GrpcMethod::new("cosmos.tx.v1beta1.Service", "Simulate"));
106            self.inner.unary(req, path, codec).await
107        }
108        pub async fn get_tx(
109            &mut self,
110            request: impl tonic::IntoRequest<super::GetTxRequest>,
111        ) -> core::result::Result<tonic::Response<super::GetTxResponse>, tonic::Status> {
112            self.inner.ready().await.map_err(|e| {
113                tonic::Status::unknown(alloc::format!("Service was not ready: {}", e.into()))
114            })?;
115            let codec = tonic::codec::ProstCodec::default();
116            let path = http::uri::PathAndQuery::from_static("/cosmos.tx.v1beta1.Service/GetTx");
117            let mut req = request.into_request();
118            req.extensions_mut()
119                .insert(GrpcMethod::new("cosmos.tx.v1beta1.Service", "GetTx"));
120            self.inner.unary(req, path, codec).await
121        }
122        pub async fn broadcast_tx(
123            &mut self,
124            request: impl tonic::IntoRequest<super::BroadcastTxRequest>,
125        ) -> core::result::Result<tonic::Response<super::BroadcastTxResponse>, tonic::Status>
126        {
127            self.inner.ready().await.map_err(|e| {
128                tonic::Status::unknown(alloc::format!("Service was not ready: {}", e.into()))
129            })?;
130            let codec = tonic::codec::ProstCodec::default();
131            let path =
132                http::uri::PathAndQuery::from_static("/cosmos.tx.v1beta1.Service/BroadcastTx");
133            let mut req = request.into_request();
134            req.extensions_mut()
135                .insert(GrpcMethod::new("cosmos.tx.v1beta1.Service", "BroadcastTx"));
136            self.inner.unary(req, path, codec).await
137        }
138        pub async fn get_txs_event(
139            &mut self,
140            request: impl tonic::IntoRequest<super::GetTxsEventRequest>,
141        ) -> core::result::Result<tonic::Response<super::GetTxsEventResponse>, tonic::Status>
142        {
143            self.inner.ready().await.map_err(|e| {
144                tonic::Status::unknown(alloc::format!("Service was not ready: {}", e.into()))
145            })?;
146            let codec = tonic::codec::ProstCodec::default();
147            let path =
148                http::uri::PathAndQuery::from_static("/cosmos.tx.v1beta1.Service/GetTxsEvent");
149            let mut req = request.into_request();
150            req.extensions_mut()
151                .insert(GrpcMethod::new("cosmos.tx.v1beta1.Service", "GetTxsEvent"));
152            self.inner.unary(req, path, codec).await
153        }
154        pub async fn get_block_with_txs(
155            &mut self,
156            request: impl tonic::IntoRequest<super::GetBlockWithTxsRequest>,
157        ) -> core::result::Result<tonic::Response<super::GetBlockWithTxsResponse>, tonic::Status>
158        {
159            self.inner.ready().await.map_err(|e| {
160                tonic::Status::unknown(alloc::format!("Service was not ready: {}", e.into()))
161            })?;
162            let codec = tonic::codec::ProstCodec::default();
163            let path =
164                http::uri::PathAndQuery::from_static("/cosmos.tx.v1beta1.Service/GetBlockWithTxs");
165            let mut req = request.into_request();
166            req.extensions_mut().insert(GrpcMethod::new(
167                "cosmos.tx.v1beta1.Service",
168                "GetBlockWithTxs",
169            ));
170            self.inner.unary(req, path, codec).await
171        }
172        pub async fn tx_decode(
173            &mut self,
174            request: impl tonic::IntoRequest<super::TxDecodeRequest>,
175        ) -> core::result::Result<tonic::Response<super::TxDecodeResponse>, tonic::Status> {
176            self.inner.ready().await.map_err(|e| {
177                tonic::Status::unknown(alloc::format!("Service was not ready: {}", e.into()))
178            })?;
179            let codec = tonic::codec::ProstCodec::default();
180            let path = http::uri::PathAndQuery::from_static("/cosmos.tx.v1beta1.Service/TxDecode");
181            let mut req = request.into_request();
182            req.extensions_mut()
183                .insert(GrpcMethod::new("cosmos.tx.v1beta1.Service", "TxDecode"));
184            self.inner.unary(req, path, codec).await
185        }
186        pub async fn tx_encode(
187            &mut self,
188            request: impl tonic::IntoRequest<super::TxEncodeRequest>,
189        ) -> core::result::Result<tonic::Response<super::TxEncodeResponse>, tonic::Status> {
190            self.inner.ready().await.map_err(|e| {
191                tonic::Status::unknown(alloc::format!("Service was not ready: {}", e.into()))
192            })?;
193            let codec = tonic::codec::ProstCodec::default();
194            let path = http::uri::PathAndQuery::from_static("/cosmos.tx.v1beta1.Service/TxEncode");
195            let mut req = request.into_request();
196            req.extensions_mut()
197                .insert(GrpcMethod::new("cosmos.tx.v1beta1.Service", "TxEncode"));
198            self.inner.unary(req, path, codec).await
199        }
200        pub async fn tx_encode_amino(
201            &mut self,
202            request: impl tonic::IntoRequest<super::TxEncodeAminoRequest>,
203        ) -> core::result::Result<tonic::Response<super::TxEncodeAminoResponse>, tonic::Status>
204        {
205            self.inner.ready().await.map_err(|e| {
206                tonic::Status::unknown(alloc::format!("Service was not ready: {}", e.into()))
207            })?;
208            let codec = tonic::codec::ProstCodec::default();
209            let path =
210                http::uri::PathAndQuery::from_static("/cosmos.tx.v1beta1.Service/TxEncodeAmino");
211            let mut req = request.into_request();
212            req.extensions_mut().insert(GrpcMethod::new(
213                "cosmos.tx.v1beta1.Service",
214                "TxEncodeAmino",
215            ));
216            self.inner.unary(req, path, codec).await
217        }
218        pub async fn tx_decode_amino(
219            &mut self,
220            request: impl tonic::IntoRequest<super::TxDecodeAminoRequest>,
221        ) -> core::result::Result<tonic::Response<super::TxDecodeAminoResponse>, tonic::Status>
222        {
223            self.inner.ready().await.map_err(|e| {
224                tonic::Status::unknown(alloc::format!("Service was not ready: {}", e.into()))
225            })?;
226            let codec = tonic::codec::ProstCodec::default();
227            let path =
228                http::uri::PathAndQuery::from_static("/cosmos.tx.v1beta1.Service/TxDecodeAmino");
229            let mut req = request.into_request();
230            req.extensions_mut().insert(GrpcMethod::new(
231                "cosmos.tx.v1beta1.Service",
232                "TxDecodeAmino",
233            ));
234            self.inner.unary(req, path, codec).await
235        }
236    }
237}
238/// Generated server implementations.
239#[cfg(feature = "grpc")]
240pub mod service_server {
241    #![allow(
242        unused_variables,
243        dead_code,
244        missing_docs,
245        clippy::wildcard_imports,
246        clippy::let_unit_value
247    )]
248    use tonic::codegen::*;
249    /// Generated trait containing gRPC methods that should be implemented for use with ServiceServer.
250    #[async_trait]
251    pub trait Service: std::marker::Send + std::marker::Sync + 'static {
252        async fn simulate(
253            &self,
254            request: tonic::Request<super::SimulateRequest>,
255        ) -> core::result::Result<tonic::Response<super::SimulateResponse>, tonic::Status>;
256        async fn get_tx(
257            &self,
258            request: tonic::Request<super::GetTxRequest>,
259        ) -> core::result::Result<tonic::Response<super::GetTxResponse>, tonic::Status>;
260        async fn broadcast_tx(
261            &self,
262            request: tonic::Request<super::BroadcastTxRequest>,
263        ) -> core::result::Result<tonic::Response<super::BroadcastTxResponse>, tonic::Status>;
264        async fn get_txs_event(
265            &self,
266            request: tonic::Request<super::GetTxsEventRequest>,
267        ) -> core::result::Result<tonic::Response<super::GetTxsEventResponse>, tonic::Status>;
268        async fn get_block_with_txs(
269            &self,
270            request: tonic::Request<super::GetBlockWithTxsRequest>,
271        ) -> core::result::Result<tonic::Response<super::GetBlockWithTxsResponse>, tonic::Status>;
272        async fn tx_decode(
273            &self,
274            request: tonic::Request<super::TxDecodeRequest>,
275        ) -> core::result::Result<tonic::Response<super::TxDecodeResponse>, tonic::Status>;
276        async fn tx_encode(
277            &self,
278            request: tonic::Request<super::TxEncodeRequest>,
279        ) -> core::result::Result<tonic::Response<super::TxEncodeResponse>, tonic::Status>;
280        async fn tx_encode_amino(
281            &self,
282            request: tonic::Request<super::TxEncodeAminoRequest>,
283        ) -> core::result::Result<tonic::Response<super::TxEncodeAminoResponse>, tonic::Status>;
284        async fn tx_decode_amino(
285            &self,
286            request: tonic::Request<super::TxDecodeAminoRequest>,
287        ) -> core::result::Result<tonic::Response<super::TxDecodeAminoResponse>, tonic::Status>;
288    }
289    #[derive(Debug)]
290    pub struct ServiceServer<T> {
291        inner: Arc<T>,
292        accept_compression_encodings: EnabledCompressionEncodings,
293        send_compression_encodings: EnabledCompressionEncodings,
294        max_decoding_message_size: Option<usize>,
295        max_encoding_message_size: Option<usize>,
296    }
297    impl<T> ServiceServer<T> {
298        pub fn new(inner: T) -> Self {
299            Self::from_arc(Arc::new(inner))
300        }
301        pub fn from_arc(inner: Arc<T>) -> Self {
302            Self {
303                inner,
304                accept_compression_encodings: Default::default(),
305                send_compression_encodings: Default::default(),
306                max_decoding_message_size: None,
307                max_encoding_message_size: None,
308            }
309        }
310        pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
311        where
312            F: tonic::service::Interceptor,
313        {
314            InterceptedService::new(Self::new(inner), interceptor)
315        }
316        /// Enable decompressing requests with the given encoding.
317        #[must_use]
318        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
319            self.accept_compression_encodings.enable(encoding);
320            self
321        }
322        /// Compress responses with the given encoding, if the client supports it.
323        #[must_use]
324        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
325            self.send_compression_encodings.enable(encoding);
326            self
327        }
328        /// Limits the maximum size of a decoded message.
329        ///
330        /// Default: `4MB`
331        #[must_use]
332        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
333            self.max_decoding_message_size = Some(limit);
334            self
335        }
336        /// Limits the maximum size of an encoded message.
337        ///
338        /// Default: `usize::MAX`
339        #[must_use]
340        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
341            self.max_encoding_message_size = Some(limit);
342            self
343        }
344    }
345    impl<T, B> tonic::codegen::Service<http::Request<B>> for ServiceServer<T>
346    where
347        T: Service,
348        B: Body + std::marker::Send + 'static,
349        B::Error: Into<StdError> + std::marker::Send + 'static,
350    {
351        type Response = http::Response<tonic::body::Body>;
352        type Error = std::convert::Infallible;
353        type Future = BoxFuture<Self::Response, Self::Error>;
354        fn poll_ready(
355            &mut self,
356            _cx: &mut Context<'_>,
357        ) -> Poll<core::result::Result<(), Self::Error>> {
358            Poll::Ready(Ok(()))
359        }
360        fn call(&mut self, req: http::Request<B>) -> Self::Future {
361            match req.uri().path() {
362                "/cosmos.tx.v1beta1.Service/Simulate" => {
363                    #[allow(non_camel_case_types)]
364                    struct SimulateSvc<T: Service>(pub Arc<T>);
365                    impl<T: Service> tonic::server::UnaryService<super::SimulateRequest> for SimulateSvc<T> {
366                        type Response = super::SimulateResponse;
367                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
368                        fn call(
369                            &mut self,
370                            request: tonic::Request<super::SimulateRequest>,
371                        ) -> Self::Future {
372                            let inner = Arc::clone(&self.0);
373                            let fut =
374                                async move { <T as Service>::simulate(&inner, request).await };
375                            Box::pin(fut)
376                        }
377                    }
378                    let accept_compression_encodings = self.accept_compression_encodings;
379                    let send_compression_encodings = self.send_compression_encodings;
380                    let max_decoding_message_size = self.max_decoding_message_size;
381                    let max_encoding_message_size = self.max_encoding_message_size;
382                    let inner = self.inner.clone();
383                    let fut = async move {
384                        let method = SimulateSvc(inner);
385                        let codec = tonic::codec::ProstCodec::default();
386                        let mut grpc = tonic::server::Grpc::new(codec)
387                            .apply_compression_config(
388                                accept_compression_encodings,
389                                send_compression_encodings,
390                            )
391                            .apply_max_message_size_config(
392                                max_decoding_message_size,
393                                max_encoding_message_size,
394                            );
395                        let res = grpc.unary(method, req).await;
396                        Ok(res)
397                    };
398                    Box::pin(fut)
399                }
400                "/cosmos.tx.v1beta1.Service/GetTx" => {
401                    #[allow(non_camel_case_types)]
402                    struct GetTxSvc<T: Service>(pub Arc<T>);
403                    impl<T: Service> tonic::server::UnaryService<super::GetTxRequest> for GetTxSvc<T> {
404                        type Response = super::GetTxResponse;
405                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
406                        fn call(
407                            &mut self,
408                            request: tonic::Request<super::GetTxRequest>,
409                        ) -> Self::Future {
410                            let inner = Arc::clone(&self.0);
411                            let fut = async move { <T as Service>::get_tx(&inner, request).await };
412                            Box::pin(fut)
413                        }
414                    }
415                    let accept_compression_encodings = self.accept_compression_encodings;
416                    let send_compression_encodings = self.send_compression_encodings;
417                    let max_decoding_message_size = self.max_decoding_message_size;
418                    let max_encoding_message_size = self.max_encoding_message_size;
419                    let inner = self.inner.clone();
420                    let fut = async move {
421                        let method = GetTxSvc(inner);
422                        let codec = tonic::codec::ProstCodec::default();
423                        let mut grpc = tonic::server::Grpc::new(codec)
424                            .apply_compression_config(
425                                accept_compression_encodings,
426                                send_compression_encodings,
427                            )
428                            .apply_max_message_size_config(
429                                max_decoding_message_size,
430                                max_encoding_message_size,
431                            );
432                        let res = grpc.unary(method, req).await;
433                        Ok(res)
434                    };
435                    Box::pin(fut)
436                }
437                "/cosmos.tx.v1beta1.Service/BroadcastTx" => {
438                    #[allow(non_camel_case_types)]
439                    struct BroadcastTxSvc<T: Service>(pub Arc<T>);
440                    impl<T: Service> tonic::server::UnaryService<super::BroadcastTxRequest> for BroadcastTxSvc<T> {
441                        type Response = super::BroadcastTxResponse;
442                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
443                        fn call(
444                            &mut self,
445                            request: tonic::Request<super::BroadcastTxRequest>,
446                        ) -> Self::Future {
447                            let inner = Arc::clone(&self.0);
448                            let fut =
449                                async move { <T as Service>::broadcast_tx(&inner, request).await };
450                            Box::pin(fut)
451                        }
452                    }
453                    let accept_compression_encodings = self.accept_compression_encodings;
454                    let send_compression_encodings = self.send_compression_encodings;
455                    let max_decoding_message_size = self.max_decoding_message_size;
456                    let max_encoding_message_size = self.max_encoding_message_size;
457                    let inner = self.inner.clone();
458                    let fut = async move {
459                        let method = BroadcastTxSvc(inner);
460                        let codec = tonic::codec::ProstCodec::default();
461                        let mut grpc = tonic::server::Grpc::new(codec)
462                            .apply_compression_config(
463                                accept_compression_encodings,
464                                send_compression_encodings,
465                            )
466                            .apply_max_message_size_config(
467                                max_decoding_message_size,
468                                max_encoding_message_size,
469                            );
470                        let res = grpc.unary(method, req).await;
471                        Ok(res)
472                    };
473                    Box::pin(fut)
474                }
475                "/cosmos.tx.v1beta1.Service/GetTxsEvent" => {
476                    #[allow(non_camel_case_types)]
477                    struct GetTxsEventSvc<T: Service>(pub Arc<T>);
478                    impl<T: Service> tonic::server::UnaryService<super::GetTxsEventRequest> for GetTxsEventSvc<T> {
479                        type Response = super::GetTxsEventResponse;
480                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
481                        fn call(
482                            &mut self,
483                            request: tonic::Request<super::GetTxsEventRequest>,
484                        ) -> Self::Future {
485                            let inner = Arc::clone(&self.0);
486                            let fut =
487                                async move { <T as Service>::get_txs_event(&inner, request).await };
488                            Box::pin(fut)
489                        }
490                    }
491                    let accept_compression_encodings = self.accept_compression_encodings;
492                    let send_compression_encodings = self.send_compression_encodings;
493                    let max_decoding_message_size = self.max_decoding_message_size;
494                    let max_encoding_message_size = self.max_encoding_message_size;
495                    let inner = self.inner.clone();
496                    let fut = async move {
497                        let method = GetTxsEventSvc(inner);
498                        let codec = tonic::codec::ProstCodec::default();
499                        let mut grpc = tonic::server::Grpc::new(codec)
500                            .apply_compression_config(
501                                accept_compression_encodings,
502                                send_compression_encodings,
503                            )
504                            .apply_max_message_size_config(
505                                max_decoding_message_size,
506                                max_encoding_message_size,
507                            );
508                        let res = grpc.unary(method, req).await;
509                        Ok(res)
510                    };
511                    Box::pin(fut)
512                }
513                "/cosmos.tx.v1beta1.Service/GetBlockWithTxs" => {
514                    #[allow(non_camel_case_types)]
515                    struct GetBlockWithTxsSvc<T: Service>(pub Arc<T>);
516                    impl<T: Service> tonic::server::UnaryService<super::GetBlockWithTxsRequest>
517                        for GetBlockWithTxsSvc<T>
518                    {
519                        type Response = super::GetBlockWithTxsResponse;
520                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
521                        fn call(
522                            &mut self,
523                            request: tonic::Request<super::GetBlockWithTxsRequest>,
524                        ) -> Self::Future {
525                            let inner = Arc::clone(&self.0);
526                            let fut = async move {
527                                <T as Service>::get_block_with_txs(&inner, request).await
528                            };
529                            Box::pin(fut)
530                        }
531                    }
532                    let accept_compression_encodings = self.accept_compression_encodings;
533                    let send_compression_encodings = self.send_compression_encodings;
534                    let max_decoding_message_size = self.max_decoding_message_size;
535                    let max_encoding_message_size = self.max_encoding_message_size;
536                    let inner = self.inner.clone();
537                    let fut = async move {
538                        let method = GetBlockWithTxsSvc(inner);
539                        let codec = tonic::codec::ProstCodec::default();
540                        let mut grpc = tonic::server::Grpc::new(codec)
541                            .apply_compression_config(
542                                accept_compression_encodings,
543                                send_compression_encodings,
544                            )
545                            .apply_max_message_size_config(
546                                max_decoding_message_size,
547                                max_encoding_message_size,
548                            );
549                        let res = grpc.unary(method, req).await;
550                        Ok(res)
551                    };
552                    Box::pin(fut)
553                }
554                "/cosmos.tx.v1beta1.Service/TxDecode" => {
555                    #[allow(non_camel_case_types)]
556                    struct TxDecodeSvc<T: Service>(pub Arc<T>);
557                    impl<T: Service> tonic::server::UnaryService<super::TxDecodeRequest> for TxDecodeSvc<T> {
558                        type Response = super::TxDecodeResponse;
559                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
560                        fn call(
561                            &mut self,
562                            request: tonic::Request<super::TxDecodeRequest>,
563                        ) -> Self::Future {
564                            let inner = Arc::clone(&self.0);
565                            let fut =
566                                async move { <T as Service>::tx_decode(&inner, request).await };
567                            Box::pin(fut)
568                        }
569                    }
570                    let accept_compression_encodings = self.accept_compression_encodings;
571                    let send_compression_encodings = self.send_compression_encodings;
572                    let max_decoding_message_size = self.max_decoding_message_size;
573                    let max_encoding_message_size = self.max_encoding_message_size;
574                    let inner = self.inner.clone();
575                    let fut = async move {
576                        let method = TxDecodeSvc(inner);
577                        let codec = tonic::codec::ProstCodec::default();
578                        let mut grpc = tonic::server::Grpc::new(codec)
579                            .apply_compression_config(
580                                accept_compression_encodings,
581                                send_compression_encodings,
582                            )
583                            .apply_max_message_size_config(
584                                max_decoding_message_size,
585                                max_encoding_message_size,
586                            );
587                        let res = grpc.unary(method, req).await;
588                        Ok(res)
589                    };
590                    Box::pin(fut)
591                }
592                "/cosmos.tx.v1beta1.Service/TxEncode" => {
593                    #[allow(non_camel_case_types)]
594                    struct TxEncodeSvc<T: Service>(pub Arc<T>);
595                    impl<T: Service> tonic::server::UnaryService<super::TxEncodeRequest> for TxEncodeSvc<T> {
596                        type Response = super::TxEncodeResponse;
597                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
598                        fn call(
599                            &mut self,
600                            request: tonic::Request<super::TxEncodeRequest>,
601                        ) -> Self::Future {
602                            let inner = Arc::clone(&self.0);
603                            let fut =
604                                async move { <T as Service>::tx_encode(&inner, request).await };
605                            Box::pin(fut)
606                        }
607                    }
608                    let accept_compression_encodings = self.accept_compression_encodings;
609                    let send_compression_encodings = self.send_compression_encodings;
610                    let max_decoding_message_size = self.max_decoding_message_size;
611                    let max_encoding_message_size = self.max_encoding_message_size;
612                    let inner = self.inner.clone();
613                    let fut = async move {
614                        let method = TxEncodeSvc(inner);
615                        let codec = tonic::codec::ProstCodec::default();
616                        let mut grpc = tonic::server::Grpc::new(codec)
617                            .apply_compression_config(
618                                accept_compression_encodings,
619                                send_compression_encodings,
620                            )
621                            .apply_max_message_size_config(
622                                max_decoding_message_size,
623                                max_encoding_message_size,
624                            );
625                        let res = grpc.unary(method, req).await;
626                        Ok(res)
627                    };
628                    Box::pin(fut)
629                }
630                "/cosmos.tx.v1beta1.Service/TxEncodeAmino" => {
631                    #[allow(non_camel_case_types)]
632                    struct TxEncodeAminoSvc<T: Service>(pub Arc<T>);
633                    impl<T: Service> tonic::server::UnaryService<super::TxEncodeAminoRequest> for TxEncodeAminoSvc<T> {
634                        type Response = super::TxEncodeAminoResponse;
635                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
636                        fn call(
637                            &mut self,
638                            request: tonic::Request<super::TxEncodeAminoRequest>,
639                        ) -> Self::Future {
640                            let inner = Arc::clone(&self.0);
641                            let fut = async move {
642                                <T as Service>::tx_encode_amino(&inner, request).await
643                            };
644                            Box::pin(fut)
645                        }
646                    }
647                    let accept_compression_encodings = self.accept_compression_encodings;
648                    let send_compression_encodings = self.send_compression_encodings;
649                    let max_decoding_message_size = self.max_decoding_message_size;
650                    let max_encoding_message_size = self.max_encoding_message_size;
651                    let inner = self.inner.clone();
652                    let fut = async move {
653                        let method = TxEncodeAminoSvc(inner);
654                        let codec = tonic::codec::ProstCodec::default();
655                        let mut grpc = tonic::server::Grpc::new(codec)
656                            .apply_compression_config(
657                                accept_compression_encodings,
658                                send_compression_encodings,
659                            )
660                            .apply_max_message_size_config(
661                                max_decoding_message_size,
662                                max_encoding_message_size,
663                            );
664                        let res = grpc.unary(method, req).await;
665                        Ok(res)
666                    };
667                    Box::pin(fut)
668                }
669                "/cosmos.tx.v1beta1.Service/TxDecodeAmino" => {
670                    #[allow(non_camel_case_types)]
671                    struct TxDecodeAminoSvc<T: Service>(pub Arc<T>);
672                    impl<T: Service> tonic::server::UnaryService<super::TxDecodeAminoRequest> for TxDecodeAminoSvc<T> {
673                        type Response = super::TxDecodeAminoResponse;
674                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
675                        fn call(
676                            &mut self,
677                            request: tonic::Request<super::TxDecodeAminoRequest>,
678                        ) -> Self::Future {
679                            let inner = Arc::clone(&self.0);
680                            let fut = async move {
681                                <T as Service>::tx_decode_amino(&inner, request).await
682                            };
683                            Box::pin(fut)
684                        }
685                    }
686                    let accept_compression_encodings = self.accept_compression_encodings;
687                    let send_compression_encodings = self.send_compression_encodings;
688                    let max_decoding_message_size = self.max_decoding_message_size;
689                    let max_encoding_message_size = self.max_encoding_message_size;
690                    let inner = self.inner.clone();
691                    let fut = async move {
692                        let method = TxDecodeAminoSvc(inner);
693                        let codec = tonic::codec::ProstCodec::default();
694                        let mut grpc = tonic::server::Grpc::new(codec)
695                            .apply_compression_config(
696                                accept_compression_encodings,
697                                send_compression_encodings,
698                            )
699                            .apply_max_message_size_config(
700                                max_decoding_message_size,
701                                max_encoding_message_size,
702                            );
703                        let res = grpc.unary(method, req).await;
704                        Ok(res)
705                    };
706                    Box::pin(fut)
707                }
708                _ => Box::pin(async move {
709                    let mut response = http::Response::new(tonic::body::Body::default());
710                    let headers = response.headers_mut();
711                    headers.insert(
712                        tonic::Status::GRPC_STATUS,
713                        (tonic::Code::Unimplemented as i32).into(),
714                    );
715                    headers.insert(
716                        http::header::CONTENT_TYPE,
717                        tonic::metadata::GRPC_CONTENT_TYPE,
718                    );
719                    Ok(response)
720                }),
721            }
722        }
723    }
724    impl<T> Clone for ServiceServer<T> {
725        fn clone(&self) -> Self {
726            let inner = self.inner.clone();
727            Self {
728                inner,
729                accept_compression_encodings: self.accept_compression_encodings,
730                send_compression_encodings: self.send_compression_encodings,
731                max_decoding_message_size: self.max_decoding_message_size,
732                max_encoding_message_size: self.max_encoding_message_size,
733            }
734        }
735    }
736    /// Generated gRPC service name
737    pub const SERVICE_NAME: &str = "cosmos.tx.v1beta1.Service";
738    impl<T> tonic::server::NamedService for ServiceServer<T> {
739        const NAME: &'static str = SERVICE_NAME;
740    }
741}
cosmos_sdk_proto/prost/cosmos-sdk/cosmos.tx.v1beta1.tonic.rs

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