ibc_proto/prost/
interchain_security.ccv.consumer.v1.rs

1// This file is @generated by prost-build.
2/// MsgUpdateParams is the Msg/UpdateParams request type
3#[derive(Clone, PartialEq, ::prost::Message)]
4pub struct MsgUpdateParams {
5    /// signer is the address of the governance account.
6    #[prost(string, tag = "1")]
7    pub authority: ::prost::alloc::string::String,
8    /// params defines the x/provider parameters to update.
9    #[prost(message, optional, tag = "2")]
10    pub params: ::core::option::Option<super::super::v1::ConsumerParams>,
11}
12impl ::prost::Name for MsgUpdateParams {
13    const NAME: &'static str = "MsgUpdateParams";
14    const PACKAGE: &'static str = "interchain_security.ccv.consumer.v1";
15    fn full_name() -> ::prost::alloc::string::String {
16        "interchain_security.ccv.consumer.v1.MsgUpdateParams".into()
17    }
18    fn type_url() -> ::prost::alloc::string::String {
19        "/interchain_security.ccv.consumer.v1.MsgUpdateParams".into()
20    }
21}
22#[derive(Clone, Copy, PartialEq, ::prost::Message)]
23pub struct MsgUpdateParamsResponse {}
24impl ::prost::Name for MsgUpdateParamsResponse {
25    const NAME: &'static str = "MsgUpdateParamsResponse";
26    const PACKAGE: &'static str = "interchain_security.ccv.consumer.v1";
27    fn full_name() -> ::prost::alloc::string::String {
28        "interchain_security.ccv.consumer.v1.MsgUpdateParamsResponse".into()
29    }
30    fn type_url() -> ::prost::alloc::string::String {
31        "/interchain_security.ccv.consumer.v1.MsgUpdateParamsResponse".into()
32    }
33}
34/// Generated client implementations.
35#[cfg(feature = "client")]
36pub mod msg_client {
37    #![allow(
38        unused_variables,
39        dead_code,
40        missing_docs,
41        clippy::wildcard_imports,
42        clippy::let_unit_value,
43    )]
44    use tonic::codegen::*;
45    use tonic::codegen::http::Uri;
46    /// Msg defines the Msg service.
47    #[derive(Debug, Clone)]
48    pub struct MsgClient<T> {
49        inner: tonic::client::Grpc<T>,
50    }
51    #[cfg(feature = "transport")]
52    impl MsgClient<tonic::transport::Channel> {
53        /// Attempt to create a new client by connecting to a given endpoint.
54        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
55        where
56            D: TryInto<tonic::transport::Endpoint>,
57            D::Error: Into<StdError>,
58        {
59            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
60            Ok(Self::new(conn))
61        }
62    }
63    impl<T> MsgClient<T>
64    where
65        T: tonic::client::GrpcService<tonic::body::Body>,
66        T::Error: Into<StdError>,
67        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
68        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
69    {
70        pub fn new(inner: T) -> Self {
71            let inner = tonic::client::Grpc::new(inner);
72            Self { inner }
73        }
74        pub fn with_origin(inner: T, origin: Uri) -> Self {
75            let inner = tonic::client::Grpc::with_origin(inner, origin);
76            Self { inner }
77        }
78        pub fn with_interceptor<F>(
79            inner: T,
80            interceptor: F,
81        ) -> MsgClient<InterceptedService<T, F>>
82        where
83            F: tonic::service::Interceptor,
84            T::ResponseBody: Default,
85            T: tonic::codegen::Service<
86                http::Request<tonic::body::Body>,
87                Response = http::Response<
88                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
89                >,
90            >,
91            <T as tonic::codegen::Service<
92                http::Request<tonic::body::Body>,
93            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
94        {
95            MsgClient::new(InterceptedService::new(inner, interceptor))
96        }
97        /// Compress requests with the given encoding.
98        ///
99        /// This requires the server to support it otherwise it might respond with an
100        /// error.
101        #[must_use]
102        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
103            self.inner = self.inner.send_compressed(encoding);
104            self
105        }
106        /// Enable decompressing responses.
107        #[must_use]
108        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
109            self.inner = self.inner.accept_compressed(encoding);
110            self
111        }
112        /// Limits the maximum size of a decoded message.
113        ///
114        /// Default: `4MB`
115        #[must_use]
116        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
117            self.inner = self.inner.max_decoding_message_size(limit);
118            self
119        }
120        /// Limits the maximum size of an encoded message.
121        ///
122        /// Default: `usize::MAX`
123        #[must_use]
124        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
125            self.inner = self.inner.max_encoding_message_size(limit);
126            self
127        }
128        pub async fn update_params(
129            &mut self,
130            request: impl tonic::IntoRequest<super::MsgUpdateParams>,
131        ) -> std::result::Result<
132            tonic::Response<super::MsgUpdateParamsResponse>,
133            tonic::Status,
134        > {
135            self.inner
136                .ready()
137                .await
138                .map_err(|e| {
139                    tonic::Status::unknown(
140                        format!("Service was not ready: {}", e.into()),
141                    )
142                })?;
143            let codec = tonic::codec::ProstCodec::default();
144            let path = http::uri::PathAndQuery::from_static(
145                "/interchain_security.ccv.consumer.v1.Msg/UpdateParams",
146            );
147            let mut req = request.into_request();
148            req.extensions_mut()
149                .insert(
150                    GrpcMethod::new(
151                        "interchain_security.ccv.consumer.v1.Msg",
152                        "UpdateParams",
153                    ),
154                );
155            self.inner.unary(req, path, codec).await
156        }
157    }
158}
159/// Generated server implementations.
160#[cfg(feature = "server")]
161pub mod msg_server {
162    #![allow(
163        unused_variables,
164        dead_code,
165        missing_docs,
166        clippy::wildcard_imports,
167        clippy::let_unit_value,
168    )]
169    use tonic::codegen::*;
170    /// Generated trait containing gRPC methods that should be implemented for use with MsgServer.
171    #[async_trait]
172    pub trait Msg: std::marker::Send + std::marker::Sync + 'static {
173        async fn update_params(
174            &self,
175            request: tonic::Request<super::MsgUpdateParams>,
176        ) -> std::result::Result<
177            tonic::Response<super::MsgUpdateParamsResponse>,
178            tonic::Status,
179        >;
180    }
181    /// Msg defines the Msg service.
182    #[derive(Debug)]
183    pub struct MsgServer<T> {
184        inner: Arc<T>,
185        accept_compression_encodings: EnabledCompressionEncodings,
186        send_compression_encodings: EnabledCompressionEncodings,
187        max_decoding_message_size: Option<usize>,
188        max_encoding_message_size: Option<usize>,
189    }
190    impl<T> MsgServer<T> {
191        pub fn new(inner: T) -> Self {
192            Self::from_arc(Arc::new(inner))
193        }
194        pub fn from_arc(inner: Arc<T>) -> Self {
195            Self {
196                inner,
197                accept_compression_encodings: Default::default(),
198                send_compression_encodings: Default::default(),
199                max_decoding_message_size: None,
200                max_encoding_message_size: None,
201            }
202        }
203        pub fn with_interceptor<F>(
204            inner: T,
205            interceptor: F,
206        ) -> InterceptedService<Self, F>
207        where
208            F: tonic::service::Interceptor,
209        {
210            InterceptedService::new(Self::new(inner), interceptor)
211        }
212        /// Enable decompressing requests with the given encoding.
213        #[must_use]
214        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
215            self.accept_compression_encodings.enable(encoding);
216            self
217        }
218        /// Compress responses with the given encoding, if the client supports it.
219        #[must_use]
220        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
221            self.send_compression_encodings.enable(encoding);
222            self
223        }
224        /// Limits the maximum size of a decoded message.
225        ///
226        /// Default: `4MB`
227        #[must_use]
228        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
229            self.max_decoding_message_size = Some(limit);
230            self
231        }
232        /// Limits the maximum size of an encoded message.
233        ///
234        /// Default: `usize::MAX`
235        #[must_use]
236        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
237            self.max_encoding_message_size = Some(limit);
238            self
239        }
240    }
241    impl<T, B> tonic::codegen::Service<http::Request<B>> for MsgServer<T>
242    where
243        T: Msg,
244        B: Body + std::marker::Send + 'static,
245        B::Error: Into<StdError> + std::marker::Send + 'static,
246    {
247        type Response = http::Response<tonic::body::Body>;
248        type Error = std::convert::Infallible;
249        type Future = BoxFuture<Self::Response, Self::Error>;
250        fn poll_ready(
251            &mut self,
252            _cx: &mut Context<'_>,
253        ) -> Poll<std::result::Result<(), Self::Error>> {
254            Poll::Ready(Ok(()))
255        }
256        fn call(&mut self, req: http::Request<B>) -> Self::Future {
257            match req.uri().path() {
258                "/interchain_security.ccv.consumer.v1.Msg/UpdateParams" => {
259                    #[allow(non_camel_case_types)]
260                    struct UpdateParamsSvc<T: Msg>(pub Arc<T>);
261                    impl<T: Msg> tonic::server::UnaryService<super::MsgUpdateParams>
262                    for UpdateParamsSvc<T> {
263                        type Response = super::MsgUpdateParamsResponse;
264                        type Future = BoxFuture<
265                            tonic::Response<Self::Response>,
266                            tonic::Status,
267                        >;
268                        fn call(
269                            &mut self,
270                            request: tonic::Request<super::MsgUpdateParams>,
271                        ) -> Self::Future {
272                            let inner = Arc::clone(&self.0);
273                            let fut = async move {
274                                <T as Msg>::update_params(&inner, request).await
275                            };
276                            Box::pin(fut)
277                        }
278                    }
279                    let accept_compression_encodings = self.accept_compression_encodings;
280                    let send_compression_encodings = self.send_compression_encodings;
281                    let max_decoding_message_size = self.max_decoding_message_size;
282                    let max_encoding_message_size = self.max_encoding_message_size;
283                    let inner = self.inner.clone();
284                    let fut = async move {
285                        let method = UpdateParamsSvc(inner);
286                        let codec = tonic::codec::ProstCodec::default();
287                        let mut grpc = tonic::server::Grpc::new(codec)
288                            .apply_compression_config(
289                                accept_compression_encodings,
290                                send_compression_encodings,
291                            )
292                            .apply_max_message_size_config(
293                                max_decoding_message_size,
294                                max_encoding_message_size,
295                            );
296                        let res = grpc.unary(method, req).await;
297                        Ok(res)
298                    };
299                    Box::pin(fut)
300                }
301                _ => {
302                    Box::pin(async move {
303                        let mut response = http::Response::new(
304                            tonic::body::Body::default(),
305                        );
306                        let headers = response.headers_mut();
307                        headers
308                            .insert(
309                                tonic::Status::GRPC_STATUS,
310                                (tonic::Code::Unimplemented as i32).into(),
311                            );
312                        headers
313                            .insert(
314                                http::header::CONTENT_TYPE,
315                                tonic::metadata::GRPC_CONTENT_TYPE,
316                            );
317                        Ok(response)
318                    })
319                }
320            }
321        }
322    }
323    impl<T> Clone for MsgServer<T> {
324        fn clone(&self) -> Self {
325            let inner = self.inner.clone();
326            Self {
327                inner,
328                accept_compression_encodings: self.accept_compression_encodings,
329                send_compression_encodings: self.send_compression_encodings,
330                max_decoding_message_size: self.max_decoding_message_size,
331                max_encoding_message_size: self.max_encoding_message_size,
332            }
333        }
334    }
335    /// Generated gRPC service name
336    pub const SERVICE_NAME: &str = "interchain_security.ccv.consumer.v1.Msg";
337    impl<T> tonic::server::NamedService for MsgServer<T> {
338        const NAME: &'static str = SERVICE_NAME;
339    }
340}
341/// CrossChainValidator defines the type used to store validator information
342/// internal to the consumer CCV module.  Note one cross chain validator entry is
343/// persisted for each consumer validator, where incoming VSC packets update this
344/// data, which is eventually forwarded to comet for consumer chain consensus.
345///
346/// Note this type is only used internally to the consumer CCV module.
347#[derive(Clone, PartialEq, ::prost::Message)]
348pub struct CrossChainValidator {
349    #[prost(bytes = "vec", tag = "1")]
350    pub address: ::prost::alloc::vec::Vec<u8>,
351    #[prost(int64, tag = "2")]
352    pub power: i64,
353    /// pubkey is the consensus public key of the validator, as a Protobuf Any.
354    #[prost(message, optional, tag = "3")]
355    pub pubkey: ::core::option::Option<::tendermint_proto::google::protobuf::Any>,
356    /// !!! DEPRECATED !!! opted_out is deprecated because after the introduction of Partial Set Security (PSS)
357    /// we removed the soft opt-out feature.
358    #[deprecated]
359    #[prost(bool, tag = "4")]
360    pub opted_out: bool,
361}
362impl ::prost::Name for CrossChainValidator {
363    const NAME: &'static str = "CrossChainValidator";
364    const PACKAGE: &'static str = "interchain_security.ccv.consumer.v1";
365    fn full_name() -> ::prost::alloc::string::String {
366        "interchain_security.ccv.consumer.v1.CrossChainValidator".into()
367    }
368    fn type_url() -> ::prost::alloc::string::String {
369        "/interchain_security.ccv.consumer.v1.CrossChainValidator".into()
370    }
371}
372/// A record storing the state of a slash packet sent to the provider chain
373/// which may bounce back and forth until handled by the provider.
374///
375/// Note this type is only used internally to the consumer CCV module.
376#[derive(Clone, Copy, PartialEq, ::prost::Message)]
377pub struct SlashRecord {
378    #[prost(bool, tag = "1")]
379    pub waiting_on_reply: bool,
380    #[prost(message, optional, tag = "2")]
381    pub send_time: ::core::option::Option<
382        ::tendermint_proto::google::protobuf::Timestamp,
383    >,
384}
385impl ::prost::Name for SlashRecord {
386    const NAME: &'static str = "SlashRecord";
387    const PACKAGE: &'static str = "interchain_security.ccv.consumer.v1";
388    fn full_name() -> ::prost::alloc::string::String {
389        "interchain_security.ccv.consumer.v1.SlashRecord".into()
390    }
391    fn type_url() -> ::prost::alloc::string::String {
392        "/interchain_security.ccv.consumer.v1.SlashRecord".into()
393    }
394}
395/// NextFeeDistributionEstimate holds information about next fee distribution
396#[derive(Clone, PartialEq, ::prost::Message)]
397pub struct NextFeeDistributionEstimate {
398    /// current block height at the time of querying
399    #[prost(int64, tag = "1")]
400    pub current_height: i64,
401    /// block height at which last distribution took place
402    #[prost(int64, tag = "2")]
403    pub last_height: i64,
404    /// block height at which next distribution will take place
405    #[prost(int64, tag = "3")]
406    pub next_height: i64,
407    /// ratio between consumer and provider fee distribution
408    #[prost(string, tag = "4")]
409    pub distribution_fraction: ::prost::alloc::string::String,
410    /// total accruead fees at the time of querying
411    #[prost(string, tag = "5")]
412    pub total: ::prost::alloc::string::String,
413    /// amount distributed to provider chain
414    #[prost(string, tag = "6")]
415    pub to_provider: ::prost::alloc::string::String,
416    /// amount distributed (kept) by consumer chain
417    #[prost(string, tag = "7")]
418    pub to_consumer: ::prost::alloc::string::String,
419}
420impl ::prost::Name for NextFeeDistributionEstimate {
421    const NAME: &'static str = "NextFeeDistributionEstimate";
422    const PACKAGE: &'static str = "interchain_security.ccv.consumer.v1";
423    fn full_name() -> ::prost::alloc::string::String {
424        "interchain_security.ccv.consumer.v1.NextFeeDistributionEstimate".into()
425    }
426    fn type_url() -> ::prost::alloc::string::String {
427        "/interchain_security.ccv.consumer.v1.NextFeeDistributionEstimate".into()
428    }
429}
430#[derive(Clone, Copy, PartialEq, ::prost::Message)]
431pub struct QueryNextFeeDistributionEstimateRequest {}
432impl ::prost::Name for QueryNextFeeDistributionEstimateRequest {
433    const NAME: &'static str = "QueryNextFeeDistributionEstimateRequest";
434    const PACKAGE: &'static str = "interchain_security.ccv.consumer.v1";
435    fn full_name() -> ::prost::alloc::string::String {
436        "interchain_security.ccv.consumer.v1.QueryNextFeeDistributionEstimateRequest"
437            .into()
438    }
439    fn type_url() -> ::prost::alloc::string::String {
440        "/interchain_security.ccv.consumer.v1.QueryNextFeeDistributionEstimateRequest"
441            .into()
442    }
443}
444#[derive(Clone, PartialEq, ::prost::Message)]
445pub struct QueryNextFeeDistributionEstimateResponse {
446    #[prost(message, optional, tag = "1")]
447    pub data: ::core::option::Option<NextFeeDistributionEstimate>,
448}
449impl ::prost::Name for QueryNextFeeDistributionEstimateResponse {
450    const NAME: &'static str = "QueryNextFeeDistributionEstimateResponse";
451    const PACKAGE: &'static str = "interchain_security.ccv.consumer.v1";
452    fn full_name() -> ::prost::alloc::string::String {
453        "interchain_security.ccv.consumer.v1.QueryNextFeeDistributionEstimateResponse"
454            .into()
455    }
456    fn type_url() -> ::prost::alloc::string::String {
457        "/interchain_security.ccv.consumer.v1.QueryNextFeeDistributionEstimateResponse"
458            .into()
459    }
460}
461#[derive(Clone, Copy, PartialEq, ::prost::Message)]
462pub struct QueryParamsRequest {}
463impl ::prost::Name for QueryParamsRequest {
464    const NAME: &'static str = "QueryParamsRequest";
465    const PACKAGE: &'static str = "interchain_security.ccv.consumer.v1";
466    fn full_name() -> ::prost::alloc::string::String {
467        "interchain_security.ccv.consumer.v1.QueryParamsRequest".into()
468    }
469    fn type_url() -> ::prost::alloc::string::String {
470        "/interchain_security.ccv.consumer.v1.QueryParamsRequest".into()
471    }
472}
473/// QueryParamsResponse is response type for the Query/Params RPC method.
474#[derive(Clone, PartialEq, ::prost::Message)]
475pub struct QueryParamsResponse {
476    /// params holds all the parameters of this module.
477    #[prost(message, optional, tag = "1")]
478    pub params: ::core::option::Option<super::super::v1::ConsumerParams>,
479}
480impl ::prost::Name for QueryParamsResponse {
481    const NAME: &'static str = "QueryParamsResponse";
482    const PACKAGE: &'static str = "interchain_security.ccv.consumer.v1";
483    fn full_name() -> ::prost::alloc::string::String {
484        "interchain_security.ccv.consumer.v1.QueryParamsResponse".into()
485    }
486    fn type_url() -> ::prost::alloc::string::String {
487        "/interchain_security.ccv.consumer.v1.QueryParamsResponse".into()
488    }
489}
490#[derive(Clone, Copy, PartialEq, ::prost::Message)]
491pub struct QueryProviderInfoRequest {}
492impl ::prost::Name for QueryProviderInfoRequest {
493    const NAME: &'static str = "QueryProviderInfoRequest";
494    const PACKAGE: &'static str = "interchain_security.ccv.consumer.v1";
495    fn full_name() -> ::prost::alloc::string::String {
496        "interchain_security.ccv.consumer.v1.QueryProviderInfoRequest".into()
497    }
498    fn type_url() -> ::prost::alloc::string::String {
499        "/interchain_security.ccv.consumer.v1.QueryProviderInfoRequest".into()
500    }
501}
502#[derive(Clone, PartialEq, ::prost::Message)]
503pub struct QueryProviderInfoResponse {
504    #[prost(message, optional, tag = "1")]
505    pub consumer: ::core::option::Option<ChainInfo>,
506    #[prost(message, optional, tag = "2")]
507    pub provider: ::core::option::Option<ChainInfo>,
508}
509impl ::prost::Name for QueryProviderInfoResponse {
510    const NAME: &'static str = "QueryProviderInfoResponse";
511    const PACKAGE: &'static str = "interchain_security.ccv.consumer.v1";
512    fn full_name() -> ::prost::alloc::string::String {
513        "interchain_security.ccv.consumer.v1.QueryProviderInfoResponse".into()
514    }
515    fn type_url() -> ::prost::alloc::string::String {
516        "/interchain_security.ccv.consumer.v1.QueryProviderInfoResponse".into()
517    }
518}
519#[derive(Clone, Copy, PartialEq, ::prost::Message)]
520pub struct QueryThrottleStateRequest {}
521impl ::prost::Name for QueryThrottleStateRequest {
522    const NAME: &'static str = "QueryThrottleStateRequest";
523    const PACKAGE: &'static str = "interchain_security.ccv.consumer.v1";
524    fn full_name() -> ::prost::alloc::string::String {
525        "interchain_security.ccv.consumer.v1.QueryThrottleStateRequest".into()
526    }
527    fn type_url() -> ::prost::alloc::string::String {
528        "/interchain_security.ccv.consumer.v1.QueryThrottleStateRequest".into()
529    }
530}
531#[derive(Clone, PartialEq, ::prost::Message)]
532pub struct QueryThrottleStateResponse {
533    #[prost(message, optional, tag = "1")]
534    pub slash_record: ::core::option::Option<SlashRecord>,
535    #[prost(message, repeated, tag = "2")]
536    pub packet_data_queue: ::prost::alloc::vec::Vec<
537        super::super::v1::ConsumerPacketData,
538    >,
539}
540impl ::prost::Name for QueryThrottleStateResponse {
541    const NAME: &'static str = "QueryThrottleStateResponse";
542    const PACKAGE: &'static str = "interchain_security.ccv.consumer.v1";
543    fn full_name() -> ::prost::alloc::string::String {
544        "interchain_security.ccv.consumer.v1.QueryThrottleStateResponse".into()
545    }
546    fn type_url() -> ::prost::alloc::string::String {
547        "/interchain_security.ccv.consumer.v1.QueryThrottleStateResponse".into()
548    }
549}
550#[derive(Clone, PartialEq, ::prost::Message)]
551pub struct ChainInfo {
552    #[prost(string, tag = "1")]
553    pub chain_id: ::prost::alloc::string::String,
554    #[prost(string, tag = "2")]
555    pub client_id: ::prost::alloc::string::String,
556    #[prost(string, tag = "3")]
557    pub connection_id: ::prost::alloc::string::String,
558    #[prost(string, tag = "4")]
559    pub channel_id: ::prost::alloc::string::String,
560}
561impl ::prost::Name for ChainInfo {
562    const NAME: &'static str = "ChainInfo";
563    const PACKAGE: &'static str = "interchain_security.ccv.consumer.v1";
564    fn full_name() -> ::prost::alloc::string::String {
565        "interchain_security.ccv.consumer.v1.ChainInfo".into()
566    }
567    fn type_url() -> ::prost::alloc::string::String {
568        "/interchain_security.ccv.consumer.v1.ChainInfo".into()
569    }
570}
571/// Generated client implementations.
572#[cfg(feature = "client")]
573pub mod query_client {
574    #![allow(
575        unused_variables,
576        dead_code,
577        missing_docs,
578        clippy::wildcard_imports,
579        clippy::let_unit_value,
580    )]
581    use tonic::codegen::*;
582    use tonic::codegen::http::Uri;
583    #[derive(Debug, Clone)]
584    pub struct QueryClient<T> {
585        inner: tonic::client::Grpc<T>,
586    }
587    #[cfg(feature = "transport")]
588    impl QueryClient<tonic::transport::Channel> {
589        /// Attempt to create a new client by connecting to a given endpoint.
590        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
591        where
592            D: TryInto<tonic::transport::Endpoint>,
593            D::Error: Into<StdError>,
594        {
595            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
596            Ok(Self::new(conn))
597        }
598    }
599    impl<T> QueryClient<T>
600    where
601        T: tonic::client::GrpcService<tonic::body::Body>,
602        T::Error: Into<StdError>,
603        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
604        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
605    {
606        pub fn new(inner: T) -> Self {
607            let inner = tonic::client::Grpc::new(inner);
608            Self { inner }
609        }
610        pub fn with_origin(inner: T, origin: Uri) -> Self {
611            let inner = tonic::client::Grpc::with_origin(inner, origin);
612            Self { inner }
613        }
614        pub fn with_interceptor<F>(
615            inner: T,
616            interceptor: F,
617        ) -> QueryClient<InterceptedService<T, F>>
618        where
619            F: tonic::service::Interceptor,
620            T::ResponseBody: Default,
621            T: tonic::codegen::Service<
622                http::Request<tonic::body::Body>,
623                Response = http::Response<
624                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
625                >,
626            >,
627            <T as tonic::codegen::Service<
628                http::Request<tonic::body::Body>,
629            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
630        {
631            QueryClient::new(InterceptedService::new(inner, interceptor))
632        }
633        /// Compress requests with the given encoding.
634        ///
635        /// This requires the server to support it otherwise it might respond with an
636        /// error.
637        #[must_use]
638        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
639            self.inner = self.inner.send_compressed(encoding);
640            self
641        }
642        /// Enable decompressing responses.
643        #[must_use]
644        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
645            self.inner = self.inner.accept_compressed(encoding);
646            self
647        }
648        /// Limits the maximum size of a decoded message.
649        ///
650        /// Default: `4MB`
651        #[must_use]
652        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
653            self.inner = self.inner.max_decoding_message_size(limit);
654            self
655        }
656        /// Limits the maximum size of an encoded message.
657        ///
658        /// Default: `usize::MAX`
659        #[must_use]
660        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
661            self.inner = self.inner.max_encoding_message_size(limit);
662            self
663        }
664        /// ConsumerGenesis queries the genesis state needed to start a consumer chain
665        /// whose proposal has been accepted
666        pub async fn query_next_fee_distribution(
667            &mut self,
668            request: impl tonic::IntoRequest<
669                super::QueryNextFeeDistributionEstimateRequest,
670            >,
671        ) -> std::result::Result<
672            tonic::Response<super::QueryNextFeeDistributionEstimateResponse>,
673            tonic::Status,
674        > {
675            self.inner
676                .ready()
677                .await
678                .map_err(|e| {
679                    tonic::Status::unknown(
680                        format!("Service was not ready: {}", e.into()),
681                    )
682                })?;
683            let codec = tonic::codec::ProstCodec::default();
684            let path = http::uri::PathAndQuery::from_static(
685                "/interchain_security.ccv.consumer.v1.Query/QueryNextFeeDistribution",
686            );
687            let mut req = request.into_request();
688            req.extensions_mut()
689                .insert(
690                    GrpcMethod::new(
691                        "interchain_security.ccv.consumer.v1.Query",
692                        "QueryNextFeeDistribution",
693                    ),
694                );
695            self.inner.unary(req, path, codec).await
696        }
697        /// QueryParams queries the ccv/consumer module parameters.
698        pub async fn query_params(
699            &mut self,
700            request: impl tonic::IntoRequest<super::QueryParamsRequest>,
701        ) -> std::result::Result<
702            tonic::Response<super::QueryParamsResponse>,
703            tonic::Status,
704        > {
705            self.inner
706                .ready()
707                .await
708                .map_err(|e| {
709                    tonic::Status::unknown(
710                        format!("Service was not ready: {}", e.into()),
711                    )
712                })?;
713            let codec = tonic::codec::ProstCodec::default();
714            let path = http::uri::PathAndQuery::from_static(
715                "/interchain_security.ccv.consumer.v1.Query/QueryParams",
716            );
717            let mut req = request.into_request();
718            req.extensions_mut()
719                .insert(
720                    GrpcMethod::new(
721                        "interchain_security.ccv.consumer.v1.Query",
722                        "QueryParams",
723                    ),
724                );
725            self.inner.unary(req, path, codec).await
726        }
727        pub async fn query_provider_info(
728            &mut self,
729            request: impl tonic::IntoRequest<super::QueryProviderInfoRequest>,
730        ) -> std::result::Result<
731            tonic::Response<super::QueryProviderInfoResponse>,
732            tonic::Status,
733        > {
734            self.inner
735                .ready()
736                .await
737                .map_err(|e| {
738                    tonic::Status::unknown(
739                        format!("Service was not ready: {}", e.into()),
740                    )
741                })?;
742            let codec = tonic::codec::ProstCodec::default();
743            let path = http::uri::PathAndQuery::from_static(
744                "/interchain_security.ccv.consumer.v1.Query/QueryProviderInfo",
745            );
746            let mut req = request.into_request();
747            req.extensions_mut()
748                .insert(
749                    GrpcMethod::new(
750                        "interchain_security.ccv.consumer.v1.Query",
751                        "QueryProviderInfo",
752                    ),
753                );
754            self.inner.unary(req, path, codec).await
755        }
756        /// QueryThrottleState returns on-chain state relevant to throttled consumer packets
757        pub async fn query_throttle_state(
758            &mut self,
759            request: impl tonic::IntoRequest<super::QueryThrottleStateRequest>,
760        ) -> std::result::Result<
761            tonic::Response<super::QueryThrottleStateResponse>,
762            tonic::Status,
763        > {
764            self.inner
765                .ready()
766                .await
767                .map_err(|e| {
768                    tonic::Status::unknown(
769                        format!("Service was not ready: {}", e.into()),
770                    )
771                })?;
772            let codec = tonic::codec::ProstCodec::default();
773            let path = http::uri::PathAndQuery::from_static(
774                "/interchain_security.ccv.consumer.v1.Query/QueryThrottleState",
775            );
776            let mut req = request.into_request();
777            req.extensions_mut()
778                .insert(
779                    GrpcMethod::new(
780                        "interchain_security.ccv.consumer.v1.Query",
781                        "QueryThrottleState",
782                    ),
783                );
784            self.inner.unary(req, path, codec).await
785        }
786    }
787}
788/// Generated server implementations.
789#[cfg(feature = "server")]
790pub mod query_server {
791    #![allow(
792        unused_variables,
793        dead_code,
794        missing_docs,
795        clippy::wildcard_imports,
796        clippy::let_unit_value,
797    )]
798    use tonic::codegen::*;
799    /// Generated trait containing gRPC methods that should be implemented for use with QueryServer.
800    #[async_trait]
801    pub trait Query: std::marker::Send + std::marker::Sync + 'static {
802        /// ConsumerGenesis queries the genesis state needed to start a consumer chain
803        /// whose proposal has been accepted
804        async fn query_next_fee_distribution(
805            &self,
806            request: tonic::Request<super::QueryNextFeeDistributionEstimateRequest>,
807        ) -> std::result::Result<
808            tonic::Response<super::QueryNextFeeDistributionEstimateResponse>,
809            tonic::Status,
810        >;
811        /// QueryParams queries the ccv/consumer module parameters.
812        async fn query_params(
813            &self,
814            request: tonic::Request<super::QueryParamsRequest>,
815        ) -> std::result::Result<
816            tonic::Response<super::QueryParamsResponse>,
817            tonic::Status,
818        >;
819        async fn query_provider_info(
820            &self,
821            request: tonic::Request<super::QueryProviderInfoRequest>,
822        ) -> std::result::Result<
823            tonic::Response<super::QueryProviderInfoResponse>,
824            tonic::Status,
825        >;
826        /// QueryThrottleState returns on-chain state relevant to throttled consumer packets
827        async fn query_throttle_state(
828            &self,
829            request: tonic::Request<super::QueryThrottleStateRequest>,
830        ) -> std::result::Result<
831            tonic::Response<super::QueryThrottleStateResponse>,
832            tonic::Status,
833        >;
834    }
835    #[derive(Debug)]
836    pub struct QueryServer<T> {
837        inner: Arc<T>,
838        accept_compression_encodings: EnabledCompressionEncodings,
839        send_compression_encodings: EnabledCompressionEncodings,
840        max_decoding_message_size: Option<usize>,
841        max_encoding_message_size: Option<usize>,
842    }
843    impl<T> QueryServer<T> {
844        pub fn new(inner: T) -> Self {
845            Self::from_arc(Arc::new(inner))
846        }
847        pub fn from_arc(inner: Arc<T>) -> Self {
848            Self {
849                inner,
850                accept_compression_encodings: Default::default(),
851                send_compression_encodings: Default::default(),
852                max_decoding_message_size: None,
853                max_encoding_message_size: None,
854            }
855        }
856        pub fn with_interceptor<F>(
857            inner: T,
858            interceptor: F,
859        ) -> InterceptedService<Self, F>
860        where
861            F: tonic::service::Interceptor,
862        {
863            InterceptedService::new(Self::new(inner), interceptor)
864        }
865        /// Enable decompressing requests with the given encoding.
866        #[must_use]
867        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
868            self.accept_compression_encodings.enable(encoding);
869            self
870        }
871        /// Compress responses with the given encoding, if the client supports it.
872        #[must_use]
873        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
874            self.send_compression_encodings.enable(encoding);
875            self
876        }
877        /// Limits the maximum size of a decoded message.
878        ///
879        /// Default: `4MB`
880        #[must_use]
881        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
882            self.max_decoding_message_size = Some(limit);
883            self
884        }
885        /// Limits the maximum size of an encoded message.
886        ///
887        /// Default: `usize::MAX`
888        #[must_use]
889        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
890            self.max_encoding_message_size = Some(limit);
891            self
892        }
893    }
894    impl<T, B> tonic::codegen::Service<http::Request<B>> for QueryServer<T>
895    where
896        T: Query,
897        B: Body + std::marker::Send + 'static,
898        B::Error: Into<StdError> + std::marker::Send + 'static,
899    {
900        type Response = http::Response<tonic::body::Body>;
901        type Error = std::convert::Infallible;
902        type Future = BoxFuture<Self::Response, Self::Error>;
903        fn poll_ready(
904            &mut self,
905            _cx: &mut Context<'_>,
906        ) -> Poll<std::result::Result<(), Self::Error>> {
907            Poll::Ready(Ok(()))
908        }
909        fn call(&mut self, req: http::Request<B>) -> Self::Future {
910            match req.uri().path() {
911                "/interchain_security.ccv.consumer.v1.Query/QueryNextFeeDistribution" => {
912                    #[allow(non_camel_case_types)]
913                    struct QueryNextFeeDistributionSvc<T: Query>(pub Arc<T>);
914                    impl<
915                        T: Query,
916                    > tonic::server::UnaryService<
917                        super::QueryNextFeeDistributionEstimateRequest,
918                    > for QueryNextFeeDistributionSvc<T> {
919                        type Response = super::QueryNextFeeDistributionEstimateResponse;
920                        type Future = BoxFuture<
921                            tonic::Response<Self::Response>,
922                            tonic::Status,
923                        >;
924                        fn call(
925                            &mut self,
926                            request: tonic::Request<
927                                super::QueryNextFeeDistributionEstimateRequest,
928                            >,
929                        ) -> Self::Future {
930                            let inner = Arc::clone(&self.0);
931                            let fut = async move {
932                                <T as Query>::query_next_fee_distribution(&inner, request)
933                                    .await
934                            };
935                            Box::pin(fut)
936                        }
937                    }
938                    let accept_compression_encodings = self.accept_compression_encodings;
939                    let send_compression_encodings = self.send_compression_encodings;
940                    let max_decoding_message_size = self.max_decoding_message_size;
941                    let max_encoding_message_size = self.max_encoding_message_size;
942                    let inner = self.inner.clone();
943                    let fut = async move {
944                        let method = QueryNextFeeDistributionSvc(inner);
945                        let codec = tonic::codec::ProstCodec::default();
946                        let mut grpc = tonic::server::Grpc::new(codec)
947                            .apply_compression_config(
948                                accept_compression_encodings,
949                                send_compression_encodings,
950                            )
951                            .apply_max_message_size_config(
952                                max_decoding_message_size,
953                                max_encoding_message_size,
954                            );
955                        let res = grpc.unary(method, req).await;
956                        Ok(res)
957                    };
958                    Box::pin(fut)
959                }
960                "/interchain_security.ccv.consumer.v1.Query/QueryParams" => {
961                    #[allow(non_camel_case_types)]
962                    struct QueryParamsSvc<T: Query>(pub Arc<T>);
963                    impl<T: Query> tonic::server::UnaryService<super::QueryParamsRequest>
964                    for QueryParamsSvc<T> {
965                        type Response = super::QueryParamsResponse;
966                        type Future = BoxFuture<
967                            tonic::Response<Self::Response>,
968                            tonic::Status,
969                        >;
970                        fn call(
971                            &mut self,
972                            request: tonic::Request<super::QueryParamsRequest>,
973                        ) -> Self::Future {
974                            let inner = Arc::clone(&self.0);
975                            let fut = async move {
976                                <T as Query>::query_params(&inner, request).await
977                            };
978                            Box::pin(fut)
979                        }
980                    }
981                    let accept_compression_encodings = self.accept_compression_encodings;
982                    let send_compression_encodings = self.send_compression_encodings;
983                    let max_decoding_message_size = self.max_decoding_message_size;
984                    let max_encoding_message_size = self.max_encoding_message_size;
985                    let inner = self.inner.clone();
986                    let fut = async move {
987                        let method = QueryParamsSvc(inner);
988                        let codec = tonic::codec::ProstCodec::default();
989                        let mut grpc = tonic::server::Grpc::new(codec)
990                            .apply_compression_config(
991                                accept_compression_encodings,
992                                send_compression_encodings,
993                            )
994                            .apply_max_message_size_config(
995                                max_decoding_message_size,
996                                max_encoding_message_size,
997                            );
998                        let res = grpc.unary(method, req).await;
999                        Ok(res)
1000                    };
1001                    Box::pin(fut)
1002                }
1003                "/interchain_security.ccv.consumer.v1.Query/QueryProviderInfo" => {
1004                    #[allow(non_camel_case_types)]
1005                    struct QueryProviderInfoSvc<T: Query>(pub Arc<T>);
1006                    impl<
1007                        T: Query,
1008                    > tonic::server::UnaryService<super::QueryProviderInfoRequest>
1009                    for QueryProviderInfoSvc<T> {
1010                        type Response = super::QueryProviderInfoResponse;
1011                        type Future = BoxFuture<
1012                            tonic::Response<Self::Response>,
1013                            tonic::Status,
1014                        >;
1015                        fn call(
1016                            &mut self,
1017                            request: tonic::Request<super::QueryProviderInfoRequest>,
1018                        ) -> Self::Future {
1019                            let inner = Arc::clone(&self.0);
1020                            let fut = async move {
1021                                <T as Query>::query_provider_info(&inner, request).await
1022                            };
1023                            Box::pin(fut)
1024                        }
1025                    }
1026                    let accept_compression_encodings = self.accept_compression_encodings;
1027                    let send_compression_encodings = self.send_compression_encodings;
1028                    let max_decoding_message_size = self.max_decoding_message_size;
1029                    let max_encoding_message_size = self.max_encoding_message_size;
1030                    let inner = self.inner.clone();
1031                    let fut = async move {
1032                        let method = QueryProviderInfoSvc(inner);
1033                        let codec = tonic::codec::ProstCodec::default();
1034                        let mut grpc = tonic::server::Grpc::new(codec)
1035                            .apply_compression_config(
1036                                accept_compression_encodings,
1037                                send_compression_encodings,
1038                            )
1039                            .apply_max_message_size_config(
1040                                max_decoding_message_size,
1041                                max_encoding_message_size,
1042                            );
1043                        let res = grpc.unary(method, req).await;
1044                        Ok(res)
1045                    };
1046                    Box::pin(fut)
1047                }
1048                "/interchain_security.ccv.consumer.v1.Query/QueryThrottleState" => {
1049                    #[allow(non_camel_case_types)]
1050                    struct QueryThrottleStateSvc<T: Query>(pub Arc<T>);
1051                    impl<
1052                        T: Query,
1053                    > tonic::server::UnaryService<super::QueryThrottleStateRequest>
1054                    for QueryThrottleStateSvc<T> {
1055                        type Response = super::QueryThrottleStateResponse;
1056                        type Future = BoxFuture<
1057                            tonic::Response<Self::Response>,
1058                            tonic::Status,
1059                        >;
1060                        fn call(
1061                            &mut self,
1062                            request: tonic::Request<super::QueryThrottleStateRequest>,
1063                        ) -> Self::Future {
1064                            let inner = Arc::clone(&self.0);
1065                            let fut = async move {
1066                                <T as Query>::query_throttle_state(&inner, request).await
1067                            };
1068                            Box::pin(fut)
1069                        }
1070                    }
1071                    let accept_compression_encodings = self.accept_compression_encodings;
1072                    let send_compression_encodings = self.send_compression_encodings;
1073                    let max_decoding_message_size = self.max_decoding_message_size;
1074                    let max_encoding_message_size = self.max_encoding_message_size;
1075                    let inner = self.inner.clone();
1076                    let fut = async move {
1077                        let method = QueryThrottleStateSvc(inner);
1078                        let codec = tonic::codec::ProstCodec::default();
1079                        let mut grpc = tonic::server::Grpc::new(codec)
1080                            .apply_compression_config(
1081                                accept_compression_encodings,
1082                                send_compression_encodings,
1083                            )
1084                            .apply_max_message_size_config(
1085                                max_decoding_message_size,
1086                                max_encoding_message_size,
1087                            );
1088                        let res = grpc.unary(method, req).await;
1089                        Ok(res)
1090                    };
1091                    Box::pin(fut)
1092                }
1093                _ => {
1094                    Box::pin(async move {
1095                        let mut response = http::Response::new(
1096                            tonic::body::Body::default(),
1097                        );
1098                        let headers = response.headers_mut();
1099                        headers
1100                            .insert(
1101                                tonic::Status::GRPC_STATUS,
1102                                (tonic::Code::Unimplemented as i32).into(),
1103                            );
1104                        headers
1105                            .insert(
1106                                http::header::CONTENT_TYPE,
1107                                tonic::metadata::GRPC_CONTENT_TYPE,
1108                            );
1109                        Ok(response)
1110                    })
1111                }
1112            }
1113        }
1114    }
1115    impl<T> Clone for QueryServer<T> {
1116        fn clone(&self) -> Self {
1117            let inner = self.inner.clone();
1118            Self {
1119                inner,
1120                accept_compression_encodings: self.accept_compression_encodings,
1121                send_compression_encodings: self.send_compression_encodings,
1122                max_decoding_message_size: self.max_decoding_message_size,
1123                max_encoding_message_size: self.max_encoding_message_size,
1124            }
1125        }
1126    }
1127    /// Generated gRPC service name
1128    pub const SERVICE_NAME: &str = "interchain_security.ccv.consumer.v1.Query";
1129    impl<T> tonic::server::NamedService for QueryServer<T> {
1130        const NAME: &'static str = SERVICE_NAME;
1131    }
1132}
1133/// GenesisState defines the CCV consumer genesis state
1134///
1135/// Note: this type is only used on consumer side and references shared types with
1136/// provider
1137#[derive(Clone, PartialEq, ::prost::Message)]
1138pub struct GenesisState {
1139    /// ConsumerParams is a shared type with provider module
1140    #[prost(message, optional, tag = "1")]
1141    pub params: ::core::option::Option<super::super::v1::ConsumerParams>,
1142    /// Client ID of the provider. Empty for a new chain, filled in on restart.
1143    #[prost(string, tag = "2")]
1144    pub provider_client_id: ::prost::alloc::string::String,
1145    /// Channel ID of the provider. Empty for a new chain, filled in on restart.
1146    #[prost(string, tag = "3")]
1147    pub provider_channel_id: ::prost::alloc::string::String,
1148    /// true for new chain, false for chain restart.
1149    #[prost(bool, tag = "4")]
1150    pub new_chain: bool,
1151    /// !!! DEPRECATED !!! ProviderClientState is deprecated. Use provider.client_state instead
1152    #[deprecated]
1153    #[prost(message, optional, tag = "5")]
1154    pub provider_client_state: ::core::option::Option<
1155        super::super::super::super::ibc::lightclients::tendermint::v1::ClientState,
1156    >,
1157    /// !!! DEPRECATED !!! ProviderConsensusState is deprecated. Use provider.consensus_state instead
1158    #[deprecated]
1159    #[prost(message, optional, tag = "6")]
1160    pub provider_consensus_state: ::core::option::Option<
1161        super::super::super::super::ibc::lightclients::tendermint::v1::ConsensusState,
1162    >,
1163    /// MaturingPackets nil on new chain, filled in on restart.
1164    #[prost(message, repeated, tag = "7")]
1165    pub maturing_packets: ::prost::alloc::vec::Vec<MaturingVscPacket>,
1166    /// !!! DEPRECATED !!!! InitialValset is deprecated. Use provider.initial_val_set instead
1167    #[deprecated]
1168    #[prost(message, repeated, tag = "8")]
1169    pub initial_val_set: ::prost::alloc::vec::Vec<
1170        ::tendermint_proto::abci::ValidatorUpdate,
1171    >,
1172    /// HeightToValsetUpdateId nil on new chain, filled in on restart.
1173    #[prost(message, repeated, tag = "9")]
1174    pub height_to_valset_update_id: ::prost::alloc::vec::Vec<HeightToValsetUpdateId>,
1175    /// OutstandingDowntimes nil on new chain, filled  in on restart.
1176    #[prost(message, repeated, tag = "10")]
1177    pub outstanding_downtime_slashing: ::prost::alloc::vec::Vec<OutstandingDowntime>,
1178    /// PendingConsumerPackets nil on new chain, filled in on restart.
1179    #[prost(message, optional, tag = "11")]
1180    pub pending_consumer_packets: ::core::option::Option<ConsumerPacketDataList>,
1181    /// LastTransmissionBlockHeight nil on new chain, filled in on restart.
1182    #[prost(message, optional, tag = "12")]
1183    pub last_transmission_block_height: ::core::option::Option<
1184        LastTransmissionBlockHeight,
1185    >,
1186    /// flag indicating whether the consumer CCV module starts in pre-CCV state
1187    #[prost(bool, tag = "13")]
1188    pub pre_ccv: bool,
1189    #[prost(message, optional, tag = "14")]
1190    pub provider: ::core::option::Option<super::super::v1::ProviderInfo>,
1191}
1192impl ::prost::Name for GenesisState {
1193    const NAME: &'static str = "GenesisState";
1194    const PACKAGE: &'static str = "interchain_security.ccv.consumer.v1";
1195    fn full_name() -> ::prost::alloc::string::String {
1196        "interchain_security.ccv.consumer.v1.GenesisState".into()
1197    }
1198    fn type_url() -> ::prost::alloc::string::String {
1199        "/interchain_security.ccv.consumer.v1.GenesisState".into()
1200    }
1201}
1202/// HeightValsetUpdateID represents a mapping internal to the consumer CCV module
1203/// which links a block height to each recv valset update id.
1204#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1205pub struct HeightToValsetUpdateId {
1206    #[prost(uint64, tag = "1")]
1207    pub height: u64,
1208    #[prost(uint64, tag = "2")]
1209    pub valset_update_id: u64,
1210}
1211impl ::prost::Name for HeightToValsetUpdateId {
1212    const NAME: &'static str = "HeightToValsetUpdateID";
1213    const PACKAGE: &'static str = "interchain_security.ccv.consumer.v1";
1214    fn full_name() -> ::prost::alloc::string::String {
1215        "interchain_security.ccv.consumer.v1.HeightToValsetUpdateID".into()
1216    }
1217    fn type_url() -> ::prost::alloc::string::String {
1218        "/interchain_security.ccv.consumer.v1.HeightToValsetUpdateID".into()
1219    }
1220}
1221/// OutstandingDowntime defines the type used internally to the consumer CCV
1222/// module and is used in order to not send multiple slashing requests for
1223/// the same downtime infraction.
1224#[derive(Clone, PartialEq, ::prost::Message)]
1225pub struct OutstandingDowntime {
1226    #[prost(string, tag = "1")]
1227    pub validator_consensus_address: ::prost::alloc::string::String,
1228}
1229impl ::prost::Name for OutstandingDowntime {
1230    const NAME: &'static str = "OutstandingDowntime";
1231    const PACKAGE: &'static str = "interchain_security.ccv.consumer.v1";
1232    fn full_name() -> ::prost::alloc::string::String {
1233        "interchain_security.ccv.consumer.v1.OutstandingDowntime".into()
1234    }
1235    fn type_url() -> ::prost::alloc::string::String {
1236        "/interchain_security.ccv.consumer.v1.OutstandingDowntime".into()
1237    }
1238}
1239/// LastTransmissionBlockHeight is the last time validator holding
1240/// pools were transmitted to the provider chain. This type is used internally
1241/// to the consumer CCV module.
1242#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1243pub struct LastTransmissionBlockHeight {
1244    #[prost(int64, tag = "1")]
1245    pub height: i64,
1246}
1247impl ::prost::Name for LastTransmissionBlockHeight {
1248    const NAME: &'static str = "LastTransmissionBlockHeight";
1249    const PACKAGE: &'static str = "interchain_security.ccv.consumer.v1";
1250    fn full_name() -> ::prost::alloc::string::String {
1251        "interchain_security.ccv.consumer.v1.LastTransmissionBlockHeight".into()
1252    }
1253    fn type_url() -> ::prost::alloc::string::String {
1254        "/interchain_security.ccv.consumer.v1.LastTransmissionBlockHeight".into()
1255    }
1256}
1257/// MaturingVSCPacket represents a vsc packet that is maturing internal to the
1258/// consumer CCV module, where the consumer has not yet relayed a VSCMatured
1259/// packet back to the provider.
1260#[derive(Clone, Copy, PartialEq, ::prost::Message)]
1261pub struct MaturingVscPacket {
1262    #[prost(uint64, tag = "1")]
1263    pub vsc_id: u64,
1264    #[prost(message, optional, tag = "2")]
1265    pub maturity_time: ::core::option::Option<
1266        ::tendermint_proto::google::protobuf::Timestamp,
1267    >,
1268}
1269impl ::prost::Name for MaturingVscPacket {
1270    const NAME: &'static str = "MaturingVSCPacket";
1271    const PACKAGE: &'static str = "interchain_security.ccv.consumer.v1";
1272    fn full_name() -> ::prost::alloc::string::String {
1273        "interchain_security.ccv.consumer.v1.MaturingVSCPacket".into()
1274    }
1275    fn type_url() -> ::prost::alloc::string::String {
1276        "/interchain_security.ccv.consumer.v1.MaturingVSCPacket".into()
1277    }
1278}
1279/// ConsumerPacketDataList is a list of consumer packet data packets.
1280///
1281/// Note this type is used internally to the consumer CCV module
1282/// for exporting / importing state in InitGenesis and ExportGenesis.
1283#[derive(Clone, PartialEq, ::prost::Message)]
1284pub struct ConsumerPacketDataList {
1285    #[prost(message, repeated, tag = "1")]
1286    pub list: ::prost::alloc::vec::Vec<super::super::v1::ConsumerPacketData>,
1287}
1288impl ::prost::Name for ConsumerPacketDataList {
1289    const NAME: &'static str = "ConsumerPacketDataList";
1290    const PACKAGE: &'static str = "interchain_security.ccv.consumer.v1";
1291    fn full_name() -> ::prost::alloc::string::String {
1292        "interchain_security.ccv.consumer.v1.ConsumerPacketDataList".into()
1293    }
1294    fn type_url() -> ::prost::alloc::string::String {
1295        "/interchain_security.ccv.consumer.v1.ConsumerPacketDataList".into()
1296    }
1297}
ibc_proto/prost/interchain_security.ccv.consumer.v1.rs

ibc_proto/prost/
interchain_security.ccv.consumer.v1.rs
