cosmos_sdk_proto_althea/prost/
ibc.applications.transfer.v1.rs

1// This file is @generated by prost-build.
2/// DenomTrace contains the base denomination for ICS20 fungible tokens and the
3/// source tracing information path.
4#[derive(Clone, PartialEq, ::prost::Message)]
5pub struct DenomTrace {
6    /// path defines the chain of port/channel identifiers used for tracing the
7    /// source of the fungible token.
8    #[prost(string, tag = "1")]
9    pub path: ::prost::alloc::string::String,
10    /// base denomination of the relayed fungible token.
11    #[prost(string, tag = "2")]
12    pub base_denom: ::prost::alloc::string::String,
13}
14/// Params defines the set of IBC transfer parameters.
15/// NOTE: To prevent a single token from being transferred, set the
16/// TransfersEnabled parameter to true and then set the bank module's SendEnabled
17/// parameter for the denomination to false.
18#[derive(Clone, Copy, PartialEq, ::prost::Message)]
19pub struct Params {
20    /// send_enabled enables or disables all cross-chain token transfers from this
21    /// chain.
22    #[prost(bool, tag = "1")]
23    pub send_enabled: bool,
24    /// receive_enabled enables or disables all cross-chain token transfers to this
25    /// chain.
26    #[prost(bool, tag = "2")]
27    pub receive_enabled: bool,
28}
29/// GenesisState defines the ibc-transfer genesis state
30#[derive(Clone, PartialEq, ::prost::Message)]
31pub struct GenesisState {
32    #[prost(string, tag = "1")]
33    pub port_id: ::prost::alloc::string::String,
34    #[prost(message, repeated, tag = "2")]
35    pub denom_traces: ::prost::alloc::vec::Vec<DenomTrace>,
36    #[prost(message, optional, tag = "3")]
37    pub params: ::core::option::Option<Params>,
38}
39/// QueryDenomTraceRequest is the request type for the Query/DenomTrace RPC
40/// method
41#[derive(Clone, PartialEq, ::prost::Message)]
42pub struct QueryDenomTraceRequest {
43    /// hash (in hex format) or denom (full denom with ibc prefix) of the denomination trace information.
44    #[prost(string, tag = "1")]
45    pub hash: ::prost::alloc::string::String,
46}
47/// QueryDenomTraceResponse is the response type for the Query/DenomTrace RPC
48/// method.
49#[derive(Clone, PartialEq, ::prost::Message)]
50pub struct QueryDenomTraceResponse {
51    /// denom_trace returns the requested denomination trace information.
52    #[prost(message, optional, tag = "1")]
53    pub denom_trace: ::core::option::Option<DenomTrace>,
54}
55/// QueryConnectionsRequest is the request type for the Query/DenomTraces RPC
56/// method
57#[derive(Clone, PartialEq, ::prost::Message)]
58pub struct QueryDenomTracesRequest {
59    /// pagination defines an optional pagination for the request.
60    #[prost(message, optional, tag = "1")]
61    pub pagination: ::core::option::Option<
62        crate::cosmos::base::query::v1beta1::PageRequest,
63    >,
64}
65/// QueryConnectionsResponse is the response type for the Query/DenomTraces RPC
66/// method.
67#[derive(Clone, PartialEq, ::prost::Message)]
68pub struct QueryDenomTracesResponse {
69    /// denom_traces returns all denominations trace information.
70    #[prost(message, repeated, tag = "1")]
71    pub denom_traces: ::prost::alloc::vec::Vec<DenomTrace>,
72    /// pagination defines the pagination in the response.
73    #[prost(message, optional, tag = "2")]
74    pub pagination: ::core::option::Option<
75        crate::cosmos::base::query::v1beta1::PageResponse,
76    >,
77}
78/// QueryParamsRequest is the request type for the Query/Params RPC method.
79#[derive(Clone, Copy, PartialEq, ::prost::Message)]
80pub struct QueryParamsRequest {}
81/// QueryParamsResponse is the response type for the Query/Params RPC method.
82#[derive(Clone, Copy, PartialEq, ::prost::Message)]
83pub struct QueryParamsResponse {
84    /// params defines the parameters of the module.
85    #[prost(message, optional, tag = "1")]
86    pub params: ::core::option::Option<Params>,
87}
88/// QueryDenomHashRequest is the request type for the Query/DenomHash RPC
89/// method
90#[derive(Clone, PartialEq, ::prost::Message)]
91pub struct QueryDenomHashRequest {
92    /// The denomination trace (\[port_id\]/[channel_id])+/\[denom\]
93    #[prost(string, tag = "1")]
94    pub trace: ::prost::alloc::string::String,
95}
96/// QueryDenomHashResponse is the response type for the Query/DenomHash RPC
97/// method.
98#[derive(Clone, PartialEq, ::prost::Message)]
99pub struct QueryDenomHashResponse {
100    /// hash (in hex format) of the denomination trace information.
101    #[prost(string, tag = "1")]
102    pub hash: ::prost::alloc::string::String,
103}
104/// QueryEscrowAddressRequest is the request type for the EscrowAddress RPC method.
105#[derive(Clone, PartialEq, ::prost::Message)]
106pub struct QueryEscrowAddressRequest {
107    /// unique port identifier
108    #[prost(string, tag = "1")]
109    pub port_id: ::prost::alloc::string::String,
110    /// unique channel identifier
111    #[prost(string, tag = "2")]
112    pub channel_id: ::prost::alloc::string::String,
113}
114/// QueryEscrowAddressResponse is the response type of the EscrowAddress RPC method.
115#[derive(Clone, PartialEq, ::prost::Message)]
116pub struct QueryEscrowAddressResponse {
117    /// the escrow account address
118    #[prost(string, tag = "1")]
119    pub escrow_address: ::prost::alloc::string::String,
120}
121/// Generated client implementations.
122pub mod query_client {
123    #![allow(
124        unused_variables,
125        dead_code,
126        missing_docs,
127        clippy::wildcard_imports,
128        clippy::let_unit_value,
129    )]
130    use tonic::codegen::*;
131    use tonic::codegen::http::Uri;
132    /// Query provides defines the gRPC querier service.
133    #[derive(Debug, Clone)]
134    pub struct QueryClient<T> {
135        inner: tonic::client::Grpc<T>,
136    }
137    impl QueryClient<tonic::transport::Channel> {
138        /// Attempt to create a new client by connecting to a given endpoint.
139        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
140        where
141            D: TryInto<tonic::transport::Endpoint>,
142            D::Error: Into<StdError>,
143        {
144            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
145            Ok(Self::new(conn))
146        }
147    }
148    impl<T> QueryClient<T>
149    where
150        T: tonic::client::GrpcService<tonic::body::BoxBody>,
151        T::Error: Into<StdError>,
152        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
153        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
154    {
155        pub fn new(inner: T) -> Self {
156            let inner = tonic::client::Grpc::new(inner);
157            Self { inner }
158        }
159        pub fn with_origin(inner: T, origin: Uri) -> Self {
160            let inner = tonic::client::Grpc::with_origin(inner, origin);
161            Self { inner }
162        }
163        pub fn with_interceptor<F>(
164            inner: T,
165            interceptor: F,
166        ) -> QueryClient<InterceptedService<T, F>>
167        where
168            F: tonic::service::Interceptor,
169            T::ResponseBody: Default,
170            T: tonic::codegen::Service<
171                http::Request<tonic::body::BoxBody>,
172                Response = http::Response<
173                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
174                >,
175            >,
176            <T as tonic::codegen::Service<
177                http::Request<tonic::body::BoxBody>,
178            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
179        {
180            QueryClient::new(InterceptedService::new(inner, interceptor))
181        }
182        /// Compress requests with the given encoding.
183        ///
184        /// This requires the server to support it otherwise it might respond with an
185        /// error.
186        #[must_use]
187        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
188            self.inner = self.inner.send_compressed(encoding);
189            self
190        }
191        /// Enable decompressing responses.
192        #[must_use]
193        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
194            self.inner = self.inner.accept_compressed(encoding);
195            self
196        }
197        /// Limits the maximum size of a decoded message.
198        ///
199        /// Default: `4MB`
200        #[must_use]
201        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
202            self.inner = self.inner.max_decoding_message_size(limit);
203            self
204        }
205        /// Limits the maximum size of an encoded message.
206        ///
207        /// Default: `usize::MAX`
208        #[must_use]
209        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
210            self.inner = self.inner.max_encoding_message_size(limit);
211            self
212        }
213        /// DenomTrace queries a denomination trace information.
214        pub async fn denom_trace(
215            &mut self,
216            request: impl tonic::IntoRequest<super::QueryDenomTraceRequest>,
217        ) -> std::result::Result<
218            tonic::Response<super::QueryDenomTraceResponse>,
219            tonic::Status,
220        > {
221            self.inner
222                .ready()
223                .await
224                .map_err(|e| {
225                    tonic::Status::unknown(
226                        format!("Service was not ready: {}", e.into()),
227                    )
228                })?;
229            let codec = tonic::codec::ProstCodec::default();
230            let path = http::uri::PathAndQuery::from_static(
231                "/ibc.applications.transfer.v1.Query/DenomTrace",
232            );
233            let mut req = request.into_request();
234            req.extensions_mut()
235                .insert(
236                    GrpcMethod::new("ibc.applications.transfer.v1.Query", "DenomTrace"),
237                );
238            self.inner.unary(req, path, codec).await
239        }
240        /// DenomTraces queries all denomination traces.
241        pub async fn denom_traces(
242            &mut self,
243            request: impl tonic::IntoRequest<super::QueryDenomTracesRequest>,
244        ) -> std::result::Result<
245            tonic::Response<super::QueryDenomTracesResponse>,
246            tonic::Status,
247        > {
248            self.inner
249                .ready()
250                .await
251                .map_err(|e| {
252                    tonic::Status::unknown(
253                        format!("Service was not ready: {}", e.into()),
254                    )
255                })?;
256            let codec = tonic::codec::ProstCodec::default();
257            let path = http::uri::PathAndQuery::from_static(
258                "/ibc.applications.transfer.v1.Query/DenomTraces",
259            );
260            let mut req = request.into_request();
261            req.extensions_mut()
262                .insert(
263                    GrpcMethod::new("ibc.applications.transfer.v1.Query", "DenomTraces"),
264                );
265            self.inner.unary(req, path, codec).await
266        }
267        /// Params queries all parameters of the ibc-transfer module.
268        pub async fn params(
269            &mut self,
270            request: impl tonic::IntoRequest<super::QueryParamsRequest>,
271        ) -> std::result::Result<
272            tonic::Response<super::QueryParamsResponse>,
273            tonic::Status,
274        > {
275            self.inner
276                .ready()
277                .await
278                .map_err(|e| {
279                    tonic::Status::unknown(
280                        format!("Service was not ready: {}", e.into()),
281                    )
282                })?;
283            let codec = tonic::codec::ProstCodec::default();
284            let path = http::uri::PathAndQuery::from_static(
285                "/ibc.applications.transfer.v1.Query/Params",
286            );
287            let mut req = request.into_request();
288            req.extensions_mut()
289                .insert(GrpcMethod::new("ibc.applications.transfer.v1.Query", "Params"));
290            self.inner.unary(req, path, codec).await
291        }
292        /// DenomHash queries a denomination hash information.
293        pub async fn denom_hash(
294            &mut self,
295            request: impl tonic::IntoRequest<super::QueryDenomHashRequest>,
296        ) -> std::result::Result<
297            tonic::Response<super::QueryDenomHashResponse>,
298            tonic::Status,
299        > {
300            self.inner
301                .ready()
302                .await
303                .map_err(|e| {
304                    tonic::Status::unknown(
305                        format!("Service was not ready: {}", e.into()),
306                    )
307                })?;
308            let codec = tonic::codec::ProstCodec::default();
309            let path = http::uri::PathAndQuery::from_static(
310                "/ibc.applications.transfer.v1.Query/DenomHash",
311            );
312            let mut req = request.into_request();
313            req.extensions_mut()
314                .insert(
315                    GrpcMethod::new("ibc.applications.transfer.v1.Query", "DenomHash"),
316                );
317            self.inner.unary(req, path, codec).await
318        }
319        /// EscrowAddress returns the escrow address for a particular port and channel id.
320        pub async fn escrow_address(
321            &mut self,
322            request: impl tonic::IntoRequest<super::QueryEscrowAddressRequest>,
323        ) -> std::result::Result<
324            tonic::Response<super::QueryEscrowAddressResponse>,
325            tonic::Status,
326        > {
327            self.inner
328                .ready()
329                .await
330                .map_err(|e| {
331                    tonic::Status::unknown(
332                        format!("Service was not ready: {}", e.into()),
333                    )
334                })?;
335            let codec = tonic::codec::ProstCodec::default();
336            let path = http::uri::PathAndQuery::from_static(
337                "/ibc.applications.transfer.v1.Query/EscrowAddress",
338            );
339            let mut req = request.into_request();
340            req.extensions_mut()
341                .insert(
342                    GrpcMethod::new(
343                        "ibc.applications.transfer.v1.Query",
344                        "EscrowAddress",
345                    ),
346                );
347            self.inner.unary(req, path, codec).await
348        }
349    }
350}
351/// MsgTransfer defines a msg to transfer fungible tokens (i.e Coins) between
352/// ICS20 enabled chains. See ICS Spec here:
353/// <https://github.com/cosmos/ibc/tree/master/spec/app/ics-020-fungible-token-transfer#data-structures>
354#[derive(Clone, PartialEq, ::prost::Message)]
355pub struct MsgTransfer {
356    /// the port on which the packet will be sent
357    #[prost(string, tag = "1")]
358    pub source_port: ::prost::alloc::string::String,
359    /// the channel by which the packet will be sent
360    #[prost(string, tag = "2")]
361    pub source_channel: ::prost::alloc::string::String,
362    /// the tokens to be transferred
363    #[prost(message, optional, tag = "3")]
364    pub token: ::core::option::Option<
365        crate::cosmos::base::v1beta1::Coin,
366    >,
367    /// the sender address
368    #[prost(string, tag = "4")]
369    pub sender: ::prost::alloc::string::String,
370    /// the recipient address on the destination chain
371    #[prost(string, tag = "5")]
372    pub receiver: ::prost::alloc::string::String,
373    /// Timeout height relative to the current block height.
374    /// The timeout is disabled when set to 0.
375    #[prost(message, optional, tag = "6")]
376    pub timeout_height: ::core::option::Option<
377        super::super::super::core::client::v1::Height,
378    >,
379    /// Timeout timestamp in absolute nanoseconds since unix epoch.
380    /// The timeout is disabled when set to 0.
381    #[prost(uint64, tag = "7")]
382    pub timeout_timestamp: u64,
383    /// optional memo
384    #[prost(string, tag = "8")]
385    pub memo: ::prost::alloc::string::String,
386}
387/// MsgTransferResponse defines the Msg/Transfer response type.
388#[derive(Clone, Copy, PartialEq, ::prost::Message)]
389pub struct MsgTransferResponse {
390    /// sequence number of the transfer packet sent
391    #[prost(uint64, tag = "1")]
392    pub sequence: u64,
393}
394/// Generated client implementations.
395pub mod msg_client {
396    #![allow(
397        unused_variables,
398        dead_code,
399        missing_docs,
400        clippy::wildcard_imports,
401        clippy::let_unit_value,
402    )]
403    use tonic::codegen::*;
404    use tonic::codegen::http::Uri;
405    /// Msg defines the ibc/transfer Msg service.
406    #[derive(Debug, Clone)]
407    pub struct MsgClient<T> {
408        inner: tonic::client::Grpc<T>,
409    }
410    impl MsgClient<tonic::transport::Channel> {
411        /// Attempt to create a new client by connecting to a given endpoint.
412        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
413        where
414            D: TryInto<tonic::transport::Endpoint>,
415            D::Error: Into<StdError>,
416        {
417            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
418            Ok(Self::new(conn))
419        }
420    }
421    impl<T> MsgClient<T>
422    where
423        T: tonic::client::GrpcService<tonic::body::BoxBody>,
424        T::Error: Into<StdError>,
425        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
426        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
427    {
428        pub fn new(inner: T) -> Self {
429            let inner = tonic::client::Grpc::new(inner);
430            Self { inner }
431        }
432        pub fn with_origin(inner: T, origin: Uri) -> Self {
433            let inner = tonic::client::Grpc::with_origin(inner, origin);
434            Self { inner }
435        }
436        pub fn with_interceptor<F>(
437            inner: T,
438            interceptor: F,
439        ) -> MsgClient<InterceptedService<T, F>>
440        where
441            F: tonic::service::Interceptor,
442            T::ResponseBody: Default,
443            T: tonic::codegen::Service<
444                http::Request<tonic::body::BoxBody>,
445                Response = http::Response<
446                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
447                >,
448            >,
449            <T as tonic::codegen::Service<
450                http::Request<tonic::body::BoxBody>,
451            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
452        {
453            MsgClient::new(InterceptedService::new(inner, interceptor))
454        }
455        /// Compress requests with the given encoding.
456        ///
457        /// This requires the server to support it otherwise it might respond with an
458        /// error.
459        #[must_use]
460        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
461            self.inner = self.inner.send_compressed(encoding);
462            self
463        }
464        /// Enable decompressing responses.
465        #[must_use]
466        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
467            self.inner = self.inner.accept_compressed(encoding);
468            self
469        }
470        /// Limits the maximum size of a decoded message.
471        ///
472        /// Default: `4MB`
473        #[must_use]
474        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
475            self.inner = self.inner.max_decoding_message_size(limit);
476            self
477        }
478        /// Limits the maximum size of an encoded message.
479        ///
480        /// Default: `usize::MAX`
481        #[must_use]
482        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
483            self.inner = self.inner.max_encoding_message_size(limit);
484            self
485        }
486        /// Transfer defines a rpc handler method for MsgTransfer.
487        pub async fn transfer(
488            &mut self,
489            request: impl tonic::IntoRequest<super::MsgTransfer>,
490        ) -> std::result::Result<
491            tonic::Response<super::MsgTransferResponse>,
492            tonic::Status,
493        > {
494            self.inner
495                .ready()
496                .await
497                .map_err(|e| {
498                    tonic::Status::unknown(
499                        format!("Service was not ready: {}", e.into()),
500                    )
501                })?;
502            let codec = tonic::codec::ProstCodec::default();
503            let path = http::uri::PathAndQuery::from_static(
504                "/ibc.applications.transfer.v1.Msg/Transfer",
505            );
506            let mut req = request.into_request();
507            req.extensions_mut()
508                .insert(GrpcMethod::new("ibc.applications.transfer.v1.Msg", "Transfer"));
509            self.inner.unary(req, path, codec).await
510        }
511    }
512}
cosmos_sdk_proto_althea/prost/ibc.applications.transfer.v1.rs

cosmos_sdk_proto_althea/prost/
ibc.applications.transfer.v1.rs
