juno_rust_proto/prost/cosmos-sdk/
cosmos.distribution.v1beta1.rs

1/// MsgSetWithdrawAddress sets the withdraw address for
2/// a delegator (or validator self-delegation).
3#[allow(clippy::derive_partial_eq_without_eq)]
4#[derive(Clone, PartialEq, ::prost::Message)]
5pub struct MsgSetWithdrawAddress {
6    #[prost(string, tag = "1")]
7    pub delegator_address: ::prost::alloc::string::String,
8    #[prost(string, tag = "2")]
9    pub withdraw_address: ::prost::alloc::string::String,
10}
11/// MsgSetWithdrawAddressResponse defines the Msg/SetWithdrawAddress response type.
12#[allow(clippy::derive_partial_eq_without_eq)]
13#[derive(Clone, PartialEq, ::prost::Message)]
14pub struct MsgSetWithdrawAddressResponse {}
15/// MsgWithdrawDelegatorReward represents delegation withdrawal to a delegator
16/// from a single validator.
17#[allow(clippy::derive_partial_eq_without_eq)]
18#[derive(Clone, PartialEq, ::prost::Message)]
19pub struct MsgWithdrawDelegatorReward {
20    #[prost(string, tag = "1")]
21    pub delegator_address: ::prost::alloc::string::String,
22    #[prost(string, tag = "2")]
23    pub validator_address: ::prost::alloc::string::String,
24}
25/// MsgWithdrawDelegatorRewardResponse defines the Msg/WithdrawDelegatorReward response type.
26#[allow(clippy::derive_partial_eq_without_eq)]
27#[derive(Clone, PartialEq, ::prost::Message)]
28pub struct MsgWithdrawDelegatorRewardResponse {}
29/// MsgWithdrawValidatorCommission withdraws the full commission to the validator
30/// address.
31#[allow(clippy::derive_partial_eq_without_eq)]
32#[derive(Clone, PartialEq, ::prost::Message)]
33pub struct MsgWithdrawValidatorCommission {
34    #[prost(string, tag = "1")]
35    pub validator_address: ::prost::alloc::string::String,
36}
37/// MsgWithdrawValidatorCommissionResponse defines the Msg/WithdrawValidatorCommission response type.
38#[allow(clippy::derive_partial_eq_without_eq)]
39#[derive(Clone, PartialEq, ::prost::Message)]
40pub struct MsgWithdrawValidatorCommissionResponse {}
41/// MsgFundCommunityPool allows an account to directly
42/// fund the community pool.
43#[allow(clippy::derive_partial_eq_without_eq)]
44#[derive(Clone, PartialEq, ::prost::Message)]
45pub struct MsgFundCommunityPool {
46    #[prost(message, repeated, tag = "1")]
47    pub amount: ::prost::alloc::vec::Vec<super::super::base::v1beta1::Coin>,
48    #[prost(string, tag = "2")]
49    pub depositor: ::prost::alloc::string::String,
50}
51/// MsgFundCommunityPoolResponse defines the Msg/FundCommunityPool response type.
52#[allow(clippy::derive_partial_eq_without_eq)]
53#[derive(Clone, PartialEq, ::prost::Message)]
54pub struct MsgFundCommunityPoolResponse {}
55/// Generated client implementations.
56#[cfg(feature = "grpc")]
57#[cfg_attr(docsrs, doc(cfg(feature = "grpc")))]
58pub mod msg_client {
59    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
60    use tonic::codegen::http::Uri;
61    use tonic::codegen::*;
62    /// Msg defines the distribution Msg service.
63    #[derive(Debug, Clone)]
64    pub struct MsgClient<T> {
65        inner: tonic::client::Grpc<T>,
66    }
67    #[cfg(feature = "grpc-transport")]
68    #[cfg_attr(docsrs, doc(cfg(feature = "grpc-transport")))]
69    impl MsgClient<tonic::transport::Channel> {
70        /// Attempt to create a new client by connecting to a given endpoint.
71        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
72        where
73            D: std::convert::TryInto<tonic::transport::Endpoint>,
74            D::Error: Into<StdError>,
75        {
76            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
77            Ok(Self::new(conn))
78        }
79    }
80    impl<T> MsgClient<T>
81    where
82        T: tonic::client::GrpcService<tonic::body::BoxBody>,
83        T::Error: Into<StdError>,
84        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
85        <T::ResponseBody as Body>::Error: Into<StdError> + Send,
86    {
87        pub fn new(inner: T) -> Self {
88            let inner = tonic::client::Grpc::new(inner);
89            Self { inner }
90        }
91        pub fn with_origin(inner: T, origin: Uri) -> Self {
92            let inner = tonic::client::Grpc::with_origin(inner, origin);
93            Self { inner }
94        }
95        pub fn with_interceptor<F>(inner: T, interceptor: F) -> MsgClient<InterceptedService<T, F>>
96        where
97            F: tonic::service::Interceptor,
98            T::ResponseBody: Default,
99            T: tonic::codegen::Service<
100                http::Request<tonic::body::BoxBody>,
101                Response = http::Response<
102                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
103                >,
104            >,
105            <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
106                Into<StdError> + Send + Sync,
107        {
108            MsgClient::new(InterceptedService::new(inner, interceptor))
109        }
110        /// Compress requests with the given encoding.
111        ///
112        /// This requires the server to support it otherwise it might respond with an
113        /// error.
114        #[must_use]
115        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
116            self.inner = self.inner.send_compressed(encoding);
117            self
118        }
119        /// Enable decompressing responses.
120        #[must_use]
121        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
122            self.inner = self.inner.accept_compressed(encoding);
123            self
124        }
125        /// SetWithdrawAddress defines a method to change the withdraw address
126        /// for a delegator (or validator self-delegation).
127        pub async fn set_withdraw_address(
128            &mut self,
129            request: impl tonic::IntoRequest<super::MsgSetWithdrawAddress>,
130        ) -> Result<tonic::Response<super::MsgSetWithdrawAddressResponse>, tonic::Status> {
131            self.inner.ready().await.map_err(|e| {
132                tonic::Status::new(
133                    tonic::Code::Unknown,
134                    format!("Service was not ready: {}", e.into()),
135                )
136            })?;
137            let codec = tonic::codec::ProstCodec::default();
138            let path = http::uri::PathAndQuery::from_static(
139                "/cosmos.distribution.v1beta1.Msg/SetWithdrawAddress",
140            );
141            self.inner.unary(request.into_request(), path, codec).await
142        }
143        /// WithdrawDelegatorReward defines a method to withdraw rewards of delegator
144        /// from a single validator.
145        pub async fn withdraw_delegator_reward(
146            &mut self,
147            request: impl tonic::IntoRequest<super::MsgWithdrawDelegatorReward>,
148        ) -> Result<tonic::Response<super::MsgWithdrawDelegatorRewardResponse>, tonic::Status>
149        {
150            self.inner.ready().await.map_err(|e| {
151                tonic::Status::new(
152                    tonic::Code::Unknown,
153                    format!("Service was not ready: {}", e.into()),
154                )
155            })?;
156            let codec = tonic::codec::ProstCodec::default();
157            let path = http::uri::PathAndQuery::from_static(
158                "/cosmos.distribution.v1beta1.Msg/WithdrawDelegatorReward",
159            );
160            self.inner.unary(request.into_request(), path, codec).await
161        }
162        /// WithdrawValidatorCommission defines a method to withdraw the
163        /// full commission to the validator address.
164        pub async fn withdraw_validator_commission(
165            &mut self,
166            request: impl tonic::IntoRequest<super::MsgWithdrawValidatorCommission>,
167        ) -> Result<tonic::Response<super::MsgWithdrawValidatorCommissionResponse>, tonic::Status>
168        {
169            self.inner.ready().await.map_err(|e| {
170                tonic::Status::new(
171                    tonic::Code::Unknown,
172                    format!("Service was not ready: {}", e.into()),
173                )
174            })?;
175            let codec = tonic::codec::ProstCodec::default();
176            let path = http::uri::PathAndQuery::from_static(
177                "/cosmos.distribution.v1beta1.Msg/WithdrawValidatorCommission",
178            );
179            self.inner.unary(request.into_request(), path, codec).await
180        }
181        /// FundCommunityPool defines a method to allow an account to directly
182        /// fund the community pool.
183        pub async fn fund_community_pool(
184            &mut self,
185            request: impl tonic::IntoRequest<super::MsgFundCommunityPool>,
186        ) -> Result<tonic::Response<super::MsgFundCommunityPoolResponse>, tonic::Status> {
187            self.inner.ready().await.map_err(|e| {
188                tonic::Status::new(
189                    tonic::Code::Unknown,
190                    format!("Service was not ready: {}", e.into()),
191                )
192            })?;
193            let codec = tonic::codec::ProstCodec::default();
194            let path = http::uri::PathAndQuery::from_static(
195                "/cosmos.distribution.v1beta1.Msg/FundCommunityPool",
196            );
197            self.inner.unary(request.into_request(), path, codec).await
198        }
199    }
200}
201/// Generated server implementations.
202#[cfg(feature = "grpc")]
203#[cfg_attr(docsrs, doc(cfg(feature = "grpc")))]
204pub mod msg_server {
205    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
206    use tonic::codegen::*;
207    /// Generated trait containing gRPC methods that should be implemented for use with MsgServer.
208    #[async_trait]
209    pub trait Msg: Send + Sync + 'static {
210        /// SetWithdrawAddress defines a method to change the withdraw address
211        /// for a delegator (or validator self-delegation).
212        async fn set_withdraw_address(
213            &self,
214            request: tonic::Request<super::MsgSetWithdrawAddress>,
215        ) -> Result<tonic::Response<super::MsgSetWithdrawAddressResponse>, tonic::Status>;
216        /// WithdrawDelegatorReward defines a method to withdraw rewards of delegator
217        /// from a single validator.
218        async fn withdraw_delegator_reward(
219            &self,
220            request: tonic::Request<super::MsgWithdrawDelegatorReward>,
221        ) -> Result<tonic::Response<super::MsgWithdrawDelegatorRewardResponse>, tonic::Status>;
222        /// WithdrawValidatorCommission defines a method to withdraw the
223        /// full commission to the validator address.
224        async fn withdraw_validator_commission(
225            &self,
226            request: tonic::Request<super::MsgWithdrawValidatorCommission>,
227        ) -> Result<tonic::Response<super::MsgWithdrawValidatorCommissionResponse>, tonic::Status>;
228        /// FundCommunityPool defines a method to allow an account to directly
229        /// fund the community pool.
230        async fn fund_community_pool(
231            &self,
232            request: tonic::Request<super::MsgFundCommunityPool>,
233        ) -> Result<tonic::Response<super::MsgFundCommunityPoolResponse>, tonic::Status>;
234    }
235    /// Msg defines the distribution Msg service.
236    #[derive(Debug)]
237    pub struct MsgServer<T: Msg> {
238        inner: _Inner<T>,
239        accept_compression_encodings: EnabledCompressionEncodings,
240        send_compression_encodings: EnabledCompressionEncodings,
241    }
242    struct _Inner<T>(Arc<T>);
243    impl<T: Msg> MsgServer<T> {
244        pub fn new(inner: T) -> Self {
245            Self::from_arc(Arc::new(inner))
246        }
247        pub fn from_arc(inner: Arc<T>) -> Self {
248            let inner = _Inner(inner);
249            Self {
250                inner,
251                accept_compression_encodings: Default::default(),
252                send_compression_encodings: Default::default(),
253            }
254        }
255        pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
256        where
257            F: tonic::service::Interceptor,
258        {
259            InterceptedService::new(Self::new(inner), interceptor)
260        }
261        /// Enable decompressing requests with the given encoding.
262        #[must_use]
263        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
264            self.accept_compression_encodings.enable(encoding);
265            self
266        }
267        /// Compress responses with the given encoding, if the client supports it.
268        #[must_use]
269        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
270            self.send_compression_encodings.enable(encoding);
271            self
272        }
273    }
274    impl<T, B> tonic::codegen::Service<http::Request<B>> for MsgServer<T>
275    where
276        T: Msg,
277        B: Body + Send + 'static,
278        B::Error: Into<StdError> + Send + 'static,
279    {
280        type Response = http::Response<tonic::body::BoxBody>;
281        type Error = std::convert::Infallible;
282        type Future = BoxFuture<Self::Response, Self::Error>;
283        fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
284            Poll::Ready(Ok(()))
285        }
286        fn call(&mut self, req: http::Request<B>) -> Self::Future {
287            let inner = self.inner.clone();
288            match req.uri().path() {
289                "/cosmos.distribution.v1beta1.Msg/SetWithdrawAddress" => {
290                    #[allow(non_camel_case_types)]
291                    struct SetWithdrawAddressSvc<T: Msg>(pub Arc<T>);
292                    impl<T: Msg> tonic::server::UnaryService<super::MsgSetWithdrawAddress>
293                        for SetWithdrawAddressSvc<T>
294                    {
295                        type Response = super::MsgSetWithdrawAddressResponse;
296                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
297                        fn call(
298                            &mut self,
299                            request: tonic::Request<super::MsgSetWithdrawAddress>,
300                        ) -> Self::Future {
301                            let inner = self.0.clone();
302                            let fut = async move { (*inner).set_withdraw_address(request).await };
303                            Box::pin(fut)
304                        }
305                    }
306                    let accept_compression_encodings = self.accept_compression_encodings;
307                    let send_compression_encodings = self.send_compression_encodings;
308                    let inner = self.inner.clone();
309                    let fut = async move {
310                        let inner = inner.0;
311                        let method = SetWithdrawAddressSvc(inner);
312                        let codec = tonic::codec::ProstCodec::default();
313                        let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config(
314                            accept_compression_encodings,
315                            send_compression_encodings,
316                        );
317                        let res = grpc.unary(method, req).await;
318                        Ok(res)
319                    };
320                    Box::pin(fut)
321                }
322                "/cosmos.distribution.v1beta1.Msg/WithdrawDelegatorReward" => {
323                    #[allow(non_camel_case_types)]
324                    struct WithdrawDelegatorRewardSvc<T: Msg>(pub Arc<T>);
325                    impl<T: Msg> tonic::server::UnaryService<super::MsgWithdrawDelegatorReward>
326                        for WithdrawDelegatorRewardSvc<T>
327                    {
328                        type Response = super::MsgWithdrawDelegatorRewardResponse;
329                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
330                        fn call(
331                            &mut self,
332                            request: tonic::Request<super::MsgWithdrawDelegatorReward>,
333                        ) -> Self::Future {
334                            let inner = self.0.clone();
335                            let fut =
336                                async move { (*inner).withdraw_delegator_reward(request).await };
337                            Box::pin(fut)
338                        }
339                    }
340                    let accept_compression_encodings = self.accept_compression_encodings;
341                    let send_compression_encodings = self.send_compression_encodings;
342                    let inner = self.inner.clone();
343                    let fut = async move {
344                        let inner = inner.0;
345                        let method = WithdrawDelegatorRewardSvc(inner);
346                        let codec = tonic::codec::ProstCodec::default();
347                        let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config(
348                            accept_compression_encodings,
349                            send_compression_encodings,
350                        );
351                        let res = grpc.unary(method, req).await;
352                        Ok(res)
353                    };
354                    Box::pin(fut)
355                }
356                "/cosmos.distribution.v1beta1.Msg/WithdrawValidatorCommission" => {
357                    #[allow(non_camel_case_types)]
358                    struct WithdrawValidatorCommissionSvc<T: Msg>(pub Arc<T>);
359                    impl<T: Msg> tonic::server::UnaryService<super::MsgWithdrawValidatorCommission>
360                        for WithdrawValidatorCommissionSvc<T>
361                    {
362                        type Response = super::MsgWithdrawValidatorCommissionResponse;
363                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
364                        fn call(
365                            &mut self,
366                            request: tonic::Request<super::MsgWithdrawValidatorCommission>,
367                        ) -> Self::Future {
368                            let inner = self.0.clone();
369                            let fut = async move {
370                                (*inner).withdraw_validator_commission(request).await
371                            };
372                            Box::pin(fut)
373                        }
374                    }
375                    let accept_compression_encodings = self.accept_compression_encodings;
376                    let send_compression_encodings = self.send_compression_encodings;
377                    let inner = self.inner.clone();
378                    let fut = async move {
379                        let inner = inner.0;
380                        let method = WithdrawValidatorCommissionSvc(inner);
381                        let codec = tonic::codec::ProstCodec::default();
382                        let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config(
383                            accept_compression_encodings,
384                            send_compression_encodings,
385                        );
386                        let res = grpc.unary(method, req).await;
387                        Ok(res)
388                    };
389                    Box::pin(fut)
390                }
391                "/cosmos.distribution.v1beta1.Msg/FundCommunityPool" => {
392                    #[allow(non_camel_case_types)]
393                    struct FundCommunityPoolSvc<T: Msg>(pub Arc<T>);
394                    impl<T: Msg> tonic::server::UnaryService<super::MsgFundCommunityPool> for FundCommunityPoolSvc<T> {
395                        type Response = super::MsgFundCommunityPoolResponse;
396                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
397                        fn call(
398                            &mut self,
399                            request: tonic::Request<super::MsgFundCommunityPool>,
400                        ) -> Self::Future {
401                            let inner = self.0.clone();
402                            let fut = async move { (*inner).fund_community_pool(request).await };
403                            Box::pin(fut)
404                        }
405                    }
406                    let accept_compression_encodings = self.accept_compression_encodings;
407                    let send_compression_encodings = self.send_compression_encodings;
408                    let inner = self.inner.clone();
409                    let fut = async move {
410                        let inner = inner.0;
411                        let method = FundCommunityPoolSvc(inner);
412                        let codec = tonic::codec::ProstCodec::default();
413                        let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config(
414                            accept_compression_encodings,
415                            send_compression_encodings,
416                        );
417                        let res = grpc.unary(method, req).await;
418                        Ok(res)
419                    };
420                    Box::pin(fut)
421                }
422                _ => Box::pin(async move {
423                    Ok(http::Response::builder()
424                        .status(200)
425                        .header("grpc-status", "12")
426                        .header("content-type", "application/grpc")
427                        .body(empty_body())
428                        .unwrap())
429                }),
430            }
431        }
432    }
433    impl<T: Msg> Clone for MsgServer<T> {
434        fn clone(&self) -> Self {
435            let inner = self.inner.clone();
436            Self {
437                inner,
438                accept_compression_encodings: self.accept_compression_encodings,
439                send_compression_encodings: self.send_compression_encodings,
440            }
441        }
442    }
443    impl<T: Msg> Clone for _Inner<T> {
444        fn clone(&self) -> Self {
445            Self(self.0.clone())
446        }
447    }
448    impl<T: std::fmt::Debug> std::fmt::Debug for _Inner<T> {
449        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
450            write!(f, "{:?}", self.0)
451        }
452    }
453    impl<T: Msg> tonic::server::NamedService for MsgServer<T> {
454        const NAME: &'static str = "cosmos.distribution.v1beta1.Msg";
455    }
456}
457/// Params defines the set of params for the distribution module.
458#[allow(clippy::derive_partial_eq_without_eq)]
459#[derive(Clone, PartialEq, ::prost::Message)]
460pub struct Params {
461    #[prost(string, tag = "1")]
462    pub community_tax: ::prost::alloc::string::String,
463    #[prost(string, tag = "2")]
464    pub base_proposer_reward: ::prost::alloc::string::String,
465    #[prost(string, tag = "3")]
466    pub bonus_proposer_reward: ::prost::alloc::string::String,
467    #[prost(bool, tag = "4")]
468    pub withdraw_addr_enabled: bool,
469}
470/// ValidatorHistoricalRewards represents historical rewards for a validator.
471/// Height is implicit within the store key.
472/// Cumulative reward ratio is the sum from the zeroeth period
473/// until this period of rewards / tokens, per the spec.
474/// The reference count indicates the number of objects
475/// which might need to reference this historical entry at any point.
476/// ReferenceCount =
477///     number of outstanding delegations which ended the associated period (and
478///     might need to read that record)
479///   + number of slashes which ended the associated period (and might need to
480///   read that record)
481///   + one per validator for the zeroeth period, set on initialization
482#[allow(clippy::derive_partial_eq_without_eq)]
483#[derive(Clone, PartialEq, ::prost::Message)]
484pub struct ValidatorHistoricalRewards {
485    #[prost(message, repeated, tag = "1")]
486    pub cumulative_reward_ratio: ::prost::alloc::vec::Vec<super::super::base::v1beta1::DecCoin>,
487    #[prost(uint32, tag = "2")]
488    pub reference_count: u32,
489}
490/// ValidatorCurrentRewards represents current rewards and current
491/// period for a validator kept as a running counter and incremented
492/// each block as long as the validator's tokens remain constant.
493#[allow(clippy::derive_partial_eq_without_eq)]
494#[derive(Clone, PartialEq, ::prost::Message)]
495pub struct ValidatorCurrentRewards {
496    #[prost(message, repeated, tag = "1")]
497    pub rewards: ::prost::alloc::vec::Vec<super::super::base::v1beta1::DecCoin>,
498    #[prost(uint64, tag = "2")]
499    pub period: u64,
500}
501/// ValidatorAccumulatedCommission represents accumulated commission
502/// for a validator kept as a running counter, can be withdrawn at any time.
503#[allow(clippy::derive_partial_eq_without_eq)]
504#[derive(Clone, PartialEq, ::prost::Message)]
505pub struct ValidatorAccumulatedCommission {
506    #[prost(message, repeated, tag = "1")]
507    pub commission: ::prost::alloc::vec::Vec<super::super::base::v1beta1::DecCoin>,
508}
509/// ValidatorOutstandingRewards represents outstanding (un-withdrawn) rewards
510/// for a validator inexpensive to track, allows simple sanity checks.
511#[allow(clippy::derive_partial_eq_without_eq)]
512#[derive(Clone, PartialEq, ::prost::Message)]
513pub struct ValidatorOutstandingRewards {
514    #[prost(message, repeated, tag = "1")]
515    pub rewards: ::prost::alloc::vec::Vec<super::super::base::v1beta1::DecCoin>,
516}
517/// ValidatorSlashEvent represents a validator slash event.
518/// Height is implicit within the store key.
519/// This is needed to calculate appropriate amount of staking tokens
520/// for delegations which are withdrawn after a slash has occurred.
521#[allow(clippy::derive_partial_eq_without_eq)]
522#[derive(Clone, PartialEq, ::prost::Message)]
523pub struct ValidatorSlashEvent {
524    #[prost(uint64, tag = "1")]
525    pub validator_period: u64,
526    #[prost(string, tag = "2")]
527    pub fraction: ::prost::alloc::string::String,
528}
529/// ValidatorSlashEvents is a collection of ValidatorSlashEvent messages.
530#[allow(clippy::derive_partial_eq_without_eq)]
531#[derive(Clone, PartialEq, ::prost::Message)]
532pub struct ValidatorSlashEvents {
533    #[prost(message, repeated, tag = "1")]
534    pub validator_slash_events: ::prost::alloc::vec::Vec<ValidatorSlashEvent>,
535}
536/// FeePool is the global fee pool for distribution.
537#[allow(clippy::derive_partial_eq_without_eq)]
538#[derive(Clone, PartialEq, ::prost::Message)]
539pub struct FeePool {
540    #[prost(message, repeated, tag = "1")]
541    pub community_pool: ::prost::alloc::vec::Vec<super::super::base::v1beta1::DecCoin>,
542}
543/// CommunityPoolSpendProposal details a proposal for use of community funds,
544/// together with how many coins are proposed to be spent, and to which
545/// recipient account.
546#[allow(clippy::derive_partial_eq_without_eq)]
547#[derive(Clone, PartialEq, ::prost::Message)]
548pub struct CommunityPoolSpendProposal {
549    #[prost(string, tag = "1")]
550    pub title: ::prost::alloc::string::String,
551    #[prost(string, tag = "2")]
552    pub description: ::prost::alloc::string::String,
553    #[prost(string, tag = "3")]
554    pub recipient: ::prost::alloc::string::String,
555    #[prost(message, repeated, tag = "4")]
556    pub amount: ::prost::alloc::vec::Vec<super::super::base::v1beta1::Coin>,
557}
558/// DelegatorStartingInfo represents the starting info for a delegator reward
559/// period. It tracks the previous validator period, the delegation's amount of
560/// staking token, and the creation height (to check later on if any slashes have
561/// occurred). NOTE: Even though validators are slashed to whole staking tokens,
562/// the delegators within the validator may be left with less than a full token,
563/// thus sdk.Dec is used.
564#[allow(clippy::derive_partial_eq_without_eq)]
565#[derive(Clone, PartialEq, ::prost::Message)]
566pub struct DelegatorStartingInfo {
567    #[prost(uint64, tag = "1")]
568    pub previous_period: u64,
569    #[prost(string, tag = "2")]
570    pub stake: ::prost::alloc::string::String,
571    #[prost(uint64, tag = "3")]
572    pub height: u64,
573}
574/// DelegationDelegatorReward represents the properties
575/// of a delegator's delegation reward.
576#[allow(clippy::derive_partial_eq_without_eq)]
577#[derive(Clone, PartialEq, ::prost::Message)]
578pub struct DelegationDelegatorReward {
579    #[prost(string, tag = "1")]
580    pub validator_address: ::prost::alloc::string::String,
581    #[prost(message, repeated, tag = "2")]
582    pub reward: ::prost::alloc::vec::Vec<super::super::base::v1beta1::DecCoin>,
583}
584/// CommunityPoolSpendProposalWithDeposit defines a CommunityPoolSpendProposal
585/// with a deposit
586#[allow(clippy::derive_partial_eq_without_eq)]
587#[derive(Clone, PartialEq, ::prost::Message)]
588pub struct CommunityPoolSpendProposalWithDeposit {
589    #[prost(string, tag = "1")]
590    pub title: ::prost::alloc::string::String,
591    #[prost(string, tag = "2")]
592    pub description: ::prost::alloc::string::String,
593    #[prost(string, tag = "3")]
594    pub recipient: ::prost::alloc::string::String,
595    #[prost(string, tag = "4")]
596    pub amount: ::prost::alloc::string::String,
597    #[prost(string, tag = "5")]
598    pub deposit: ::prost::alloc::string::String,
599}
600/// QueryParamsRequest is the request type for the Query/Params RPC method.
601#[allow(clippy::derive_partial_eq_without_eq)]
602#[derive(Clone, PartialEq, ::prost::Message)]
603pub struct QueryParamsRequest {}
604/// QueryParamsResponse is the response type for the Query/Params RPC method.
605#[allow(clippy::derive_partial_eq_without_eq)]
606#[derive(Clone, PartialEq, ::prost::Message)]
607pub struct QueryParamsResponse {
608    /// params defines the parameters of the module.
609    #[prost(message, optional, tag = "1")]
610    pub params: ::core::option::Option<Params>,
611}
612/// QueryValidatorOutstandingRewardsRequest is the request type for the
613/// Query/ValidatorOutstandingRewards RPC method.
614#[allow(clippy::derive_partial_eq_without_eq)]
615#[derive(Clone, PartialEq, ::prost::Message)]
616pub struct QueryValidatorOutstandingRewardsRequest {
617    /// validator_address defines the validator address to query for.
618    #[prost(string, tag = "1")]
619    pub validator_address: ::prost::alloc::string::String,
620}
621/// QueryValidatorOutstandingRewardsResponse is the response type for the
622/// Query/ValidatorOutstandingRewards RPC method.
623#[allow(clippy::derive_partial_eq_without_eq)]
624#[derive(Clone, PartialEq, ::prost::Message)]
625pub struct QueryValidatorOutstandingRewardsResponse {
626    #[prost(message, optional, tag = "1")]
627    pub rewards: ::core::option::Option<ValidatorOutstandingRewards>,
628}
629/// QueryValidatorCommissionRequest is the request type for the
630/// Query/ValidatorCommission RPC method
631#[allow(clippy::derive_partial_eq_without_eq)]
632#[derive(Clone, PartialEq, ::prost::Message)]
633pub struct QueryValidatorCommissionRequest {
634    /// validator_address defines the validator address to query for.
635    #[prost(string, tag = "1")]
636    pub validator_address: ::prost::alloc::string::String,
637}
638/// QueryValidatorCommissionResponse is the response type for the
639/// Query/ValidatorCommission RPC method
640#[allow(clippy::derive_partial_eq_without_eq)]
641#[derive(Clone, PartialEq, ::prost::Message)]
642pub struct QueryValidatorCommissionResponse {
643    /// commission defines the commision the validator received.
644    #[prost(message, optional, tag = "1")]
645    pub commission: ::core::option::Option<ValidatorAccumulatedCommission>,
646}
647/// QueryValidatorSlashesRequest is the request type for the
648/// Query/ValidatorSlashes RPC method
649#[allow(clippy::derive_partial_eq_without_eq)]
650#[derive(Clone, PartialEq, ::prost::Message)]
651pub struct QueryValidatorSlashesRequest {
652    /// validator_address defines the validator address to query for.
653    #[prost(string, tag = "1")]
654    pub validator_address: ::prost::alloc::string::String,
655    /// starting_height defines the optional starting height to query the slashes.
656    #[prost(uint64, tag = "2")]
657    pub starting_height: u64,
658    /// starting_height defines the optional ending height to query the slashes.
659    #[prost(uint64, tag = "3")]
660    pub ending_height: u64,
661    /// pagination defines an optional pagination for the request.
662    #[prost(message, optional, tag = "4")]
663    pub pagination: ::core::option::Option<super::super::base::query::v1beta1::PageRequest>,
664}
665/// QueryValidatorSlashesResponse is the response type for the
666/// Query/ValidatorSlashes RPC method.
667#[allow(clippy::derive_partial_eq_without_eq)]
668#[derive(Clone, PartialEq, ::prost::Message)]
669pub struct QueryValidatorSlashesResponse {
670    /// slashes defines the slashes the validator received.
671    #[prost(message, repeated, tag = "1")]
672    pub slashes: ::prost::alloc::vec::Vec<ValidatorSlashEvent>,
673    /// pagination defines the pagination in the response.
674    #[prost(message, optional, tag = "2")]
675    pub pagination: ::core::option::Option<super::super::base::query::v1beta1::PageResponse>,
676}
677/// QueryDelegationRewardsRequest is the request type for the
678/// Query/DelegationRewards RPC method.
679#[allow(clippy::derive_partial_eq_without_eq)]
680#[derive(Clone, PartialEq, ::prost::Message)]
681pub struct QueryDelegationRewardsRequest {
682    /// delegator_address defines the delegator address to query for.
683    #[prost(string, tag = "1")]
684    pub delegator_address: ::prost::alloc::string::String,
685    /// validator_address defines the validator address to query for.
686    #[prost(string, tag = "2")]
687    pub validator_address: ::prost::alloc::string::String,
688}
689/// QueryDelegationRewardsResponse is the response type for the
690/// Query/DelegationRewards RPC method.
691#[allow(clippy::derive_partial_eq_without_eq)]
692#[derive(Clone, PartialEq, ::prost::Message)]
693pub struct QueryDelegationRewardsResponse {
694    /// rewards defines the rewards accrued by a delegation.
695    #[prost(message, repeated, tag = "1")]
696    pub rewards: ::prost::alloc::vec::Vec<super::super::base::v1beta1::DecCoin>,
697}
698/// QueryDelegationTotalRewardsRequest is the request type for the
699/// Query/DelegationTotalRewards RPC method.
700#[allow(clippy::derive_partial_eq_without_eq)]
701#[derive(Clone, PartialEq, ::prost::Message)]
702pub struct QueryDelegationTotalRewardsRequest {
703    /// delegator_address defines the delegator address to query for.
704    #[prost(string, tag = "1")]
705    pub delegator_address: ::prost::alloc::string::String,
706}
707/// QueryDelegationTotalRewardsResponse is the response type for the
708/// Query/DelegationTotalRewards RPC method.
709#[allow(clippy::derive_partial_eq_without_eq)]
710#[derive(Clone, PartialEq, ::prost::Message)]
711pub struct QueryDelegationTotalRewardsResponse {
712    /// rewards defines all the rewards accrued by a delegator.
713    #[prost(message, repeated, tag = "1")]
714    pub rewards: ::prost::alloc::vec::Vec<DelegationDelegatorReward>,
715    /// total defines the sum of all the rewards.
716    #[prost(message, repeated, tag = "2")]
717    pub total: ::prost::alloc::vec::Vec<super::super::base::v1beta1::DecCoin>,
718}
719/// QueryDelegatorValidatorsRequest is the request type for the
720/// Query/DelegatorValidators RPC method.
721#[allow(clippy::derive_partial_eq_without_eq)]
722#[derive(Clone, PartialEq, ::prost::Message)]
723pub struct QueryDelegatorValidatorsRequest {
724    /// delegator_address defines the delegator address to query for.
725    #[prost(string, tag = "1")]
726    pub delegator_address: ::prost::alloc::string::String,
727}
728/// QueryDelegatorValidatorsResponse is the response type for the
729/// Query/DelegatorValidators RPC method.
730#[allow(clippy::derive_partial_eq_without_eq)]
731#[derive(Clone, PartialEq, ::prost::Message)]
732pub struct QueryDelegatorValidatorsResponse {
733    /// validators defines the validators a delegator is delegating for.
734    #[prost(string, repeated, tag = "1")]
735    pub validators: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
736}
737/// QueryDelegatorWithdrawAddressRequest is the request type for the
738/// Query/DelegatorWithdrawAddress RPC method.
739#[allow(clippy::derive_partial_eq_without_eq)]
740#[derive(Clone, PartialEq, ::prost::Message)]
741pub struct QueryDelegatorWithdrawAddressRequest {
742    /// delegator_address defines the delegator address to query for.
743    #[prost(string, tag = "1")]
744    pub delegator_address: ::prost::alloc::string::String,
745}
746/// QueryDelegatorWithdrawAddressResponse is the response type for the
747/// Query/DelegatorWithdrawAddress RPC method.
748#[allow(clippy::derive_partial_eq_without_eq)]
749#[derive(Clone, PartialEq, ::prost::Message)]
750pub struct QueryDelegatorWithdrawAddressResponse {
751    /// withdraw_address defines the delegator address to query for.
752    #[prost(string, tag = "1")]
753    pub withdraw_address: ::prost::alloc::string::String,
754}
755/// QueryCommunityPoolRequest is the request type for the Query/CommunityPool RPC
756/// method.
757#[allow(clippy::derive_partial_eq_without_eq)]
758#[derive(Clone, PartialEq, ::prost::Message)]
759pub struct QueryCommunityPoolRequest {}
760/// QueryCommunityPoolResponse is the response type for the Query/CommunityPool
761/// RPC method.
762#[allow(clippy::derive_partial_eq_without_eq)]
763#[derive(Clone, PartialEq, ::prost::Message)]
764pub struct QueryCommunityPoolResponse {
765    /// pool defines community pool's coins.
766    #[prost(message, repeated, tag = "1")]
767    pub pool: ::prost::alloc::vec::Vec<super::super::base::v1beta1::DecCoin>,
768}
769/// Generated client implementations.
770#[cfg(feature = "grpc")]
771#[cfg_attr(docsrs, doc(cfg(feature = "grpc")))]
772pub mod query_client {
773    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
774    use tonic::codegen::http::Uri;
775    use tonic::codegen::*;
776    /// Query defines the gRPC querier service for distribution module.
777    #[derive(Debug, Clone)]
778    pub struct QueryClient<T> {
779        inner: tonic::client::Grpc<T>,
780    }
781    #[cfg(feature = "grpc-transport")]
782    #[cfg_attr(docsrs, doc(cfg(feature = "grpc-transport")))]
783    impl QueryClient<tonic::transport::Channel> {
784        /// Attempt to create a new client by connecting to a given endpoint.
785        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
786        where
787            D: std::convert::TryInto<tonic::transport::Endpoint>,
788            D::Error: Into<StdError>,
789        {
790            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
791            Ok(Self::new(conn))
792        }
793    }
794    impl<T> QueryClient<T>
795    where
796        T: tonic::client::GrpcService<tonic::body::BoxBody>,
797        T::Error: Into<StdError>,
798        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
799        <T::ResponseBody as Body>::Error: Into<StdError> + Send,
800    {
801        pub fn new(inner: T) -> Self {
802            let inner = tonic::client::Grpc::new(inner);
803            Self { inner }
804        }
805        pub fn with_origin(inner: T, origin: Uri) -> Self {
806            let inner = tonic::client::Grpc::with_origin(inner, origin);
807            Self { inner }
808        }
809        pub fn with_interceptor<F>(
810            inner: T,
811            interceptor: F,
812        ) -> QueryClient<InterceptedService<T, F>>
813        where
814            F: tonic::service::Interceptor,
815            T::ResponseBody: Default,
816            T: tonic::codegen::Service<
817                http::Request<tonic::body::BoxBody>,
818                Response = http::Response<
819                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
820                >,
821            >,
822            <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
823                Into<StdError> + Send + Sync,
824        {
825            QueryClient::new(InterceptedService::new(inner, interceptor))
826        }
827        /// Compress requests with the given encoding.
828        ///
829        /// This requires the server to support it otherwise it might respond with an
830        /// error.
831        #[must_use]
832        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
833            self.inner = self.inner.send_compressed(encoding);
834            self
835        }
836        /// Enable decompressing responses.
837        #[must_use]
838        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
839            self.inner = self.inner.accept_compressed(encoding);
840            self
841        }
842        /// Params queries params of the distribution module.
843        pub async fn params(
844            &mut self,
845            request: impl tonic::IntoRequest<super::QueryParamsRequest>,
846        ) -> Result<tonic::Response<super::QueryParamsResponse>, tonic::Status> {
847            self.inner.ready().await.map_err(|e| {
848                tonic::Status::new(
849                    tonic::Code::Unknown,
850                    format!("Service was not ready: {}", e.into()),
851                )
852            })?;
853            let codec = tonic::codec::ProstCodec::default();
854            let path =
855                http::uri::PathAndQuery::from_static("/cosmos.distribution.v1beta1.Query/Params");
856            self.inner.unary(request.into_request(), path, codec).await
857        }
858        /// ValidatorOutstandingRewards queries rewards of a validator address.
859        pub async fn validator_outstanding_rewards(
860            &mut self,
861            request: impl tonic::IntoRequest<super::QueryValidatorOutstandingRewardsRequest>,
862        ) -> Result<tonic::Response<super::QueryValidatorOutstandingRewardsResponse>, tonic::Status>
863        {
864            self.inner.ready().await.map_err(|e| {
865                tonic::Status::new(
866                    tonic::Code::Unknown,
867                    format!("Service was not ready: {}", e.into()),
868                )
869            })?;
870            let codec = tonic::codec::ProstCodec::default();
871            let path = http::uri::PathAndQuery::from_static(
872                "/cosmos.distribution.v1beta1.Query/ValidatorOutstandingRewards",
873            );
874            self.inner.unary(request.into_request(), path, codec).await
875        }
876        /// ValidatorCommission queries accumulated commission for a validator.
877        pub async fn validator_commission(
878            &mut self,
879            request: impl tonic::IntoRequest<super::QueryValidatorCommissionRequest>,
880        ) -> Result<tonic::Response<super::QueryValidatorCommissionResponse>, tonic::Status>
881        {
882            self.inner.ready().await.map_err(|e| {
883                tonic::Status::new(
884                    tonic::Code::Unknown,
885                    format!("Service was not ready: {}", e.into()),
886                )
887            })?;
888            let codec = tonic::codec::ProstCodec::default();
889            let path = http::uri::PathAndQuery::from_static(
890                "/cosmos.distribution.v1beta1.Query/ValidatorCommission",
891            );
892            self.inner.unary(request.into_request(), path, codec).await
893        }
894        /// ValidatorSlashes queries slash events of a validator.
895        pub async fn validator_slashes(
896            &mut self,
897            request: impl tonic::IntoRequest<super::QueryValidatorSlashesRequest>,
898        ) -> Result<tonic::Response<super::QueryValidatorSlashesResponse>, tonic::Status> {
899            self.inner.ready().await.map_err(|e| {
900                tonic::Status::new(
901                    tonic::Code::Unknown,
902                    format!("Service was not ready: {}", e.into()),
903                )
904            })?;
905            let codec = tonic::codec::ProstCodec::default();
906            let path = http::uri::PathAndQuery::from_static(
907                "/cosmos.distribution.v1beta1.Query/ValidatorSlashes",
908            );
909            self.inner.unary(request.into_request(), path, codec).await
910        }
911        /// DelegationRewards queries the total rewards accrued by a delegation.
912        pub async fn delegation_rewards(
913            &mut self,
914            request: impl tonic::IntoRequest<super::QueryDelegationRewardsRequest>,
915        ) -> Result<tonic::Response<super::QueryDelegationRewardsResponse>, tonic::Status> {
916            self.inner.ready().await.map_err(|e| {
917                tonic::Status::new(
918                    tonic::Code::Unknown,
919                    format!("Service was not ready: {}", e.into()),
920                )
921            })?;
922            let codec = tonic::codec::ProstCodec::default();
923            let path = http::uri::PathAndQuery::from_static(
924                "/cosmos.distribution.v1beta1.Query/DelegationRewards",
925            );
926            self.inner.unary(request.into_request(), path, codec).await
927        }
928        /// DelegationTotalRewards queries the total rewards accrued by a each
929        /// validator.
930        pub async fn delegation_total_rewards(
931            &mut self,
932            request: impl tonic::IntoRequest<super::QueryDelegationTotalRewardsRequest>,
933        ) -> Result<tonic::Response<super::QueryDelegationTotalRewardsResponse>, tonic::Status>
934        {
935            self.inner.ready().await.map_err(|e| {
936                tonic::Status::new(
937                    tonic::Code::Unknown,
938                    format!("Service was not ready: {}", e.into()),
939                )
940            })?;
941            let codec = tonic::codec::ProstCodec::default();
942            let path = http::uri::PathAndQuery::from_static(
943                "/cosmos.distribution.v1beta1.Query/DelegationTotalRewards",
944            );
945            self.inner.unary(request.into_request(), path, codec).await
946        }
947        /// DelegatorValidators queries the validators of a delegator.
948        pub async fn delegator_validators(
949            &mut self,
950            request: impl tonic::IntoRequest<super::QueryDelegatorValidatorsRequest>,
951        ) -> Result<tonic::Response<super::QueryDelegatorValidatorsResponse>, tonic::Status>
952        {
953            self.inner.ready().await.map_err(|e| {
954                tonic::Status::new(
955                    tonic::Code::Unknown,
956                    format!("Service was not ready: {}", e.into()),
957                )
958            })?;
959            let codec = tonic::codec::ProstCodec::default();
960            let path = http::uri::PathAndQuery::from_static(
961                "/cosmos.distribution.v1beta1.Query/DelegatorValidators",
962            );
963            self.inner.unary(request.into_request(), path, codec).await
964        }
965        /// DelegatorWithdrawAddress queries withdraw address of a delegator.
966        pub async fn delegator_withdraw_address(
967            &mut self,
968            request: impl tonic::IntoRequest<super::QueryDelegatorWithdrawAddressRequest>,
969        ) -> Result<tonic::Response<super::QueryDelegatorWithdrawAddressResponse>, tonic::Status>
970        {
971            self.inner.ready().await.map_err(|e| {
972                tonic::Status::new(
973                    tonic::Code::Unknown,
974                    format!("Service was not ready: {}", e.into()),
975                )
976            })?;
977            let codec = tonic::codec::ProstCodec::default();
978            let path = http::uri::PathAndQuery::from_static(
979                "/cosmos.distribution.v1beta1.Query/DelegatorWithdrawAddress",
980            );
981            self.inner.unary(request.into_request(), path, codec).await
982        }
983        /// CommunityPool queries the community pool coins.
984        pub async fn community_pool(
985            &mut self,
986            request: impl tonic::IntoRequest<super::QueryCommunityPoolRequest>,
987        ) -> Result<tonic::Response<super::QueryCommunityPoolResponse>, tonic::Status> {
988            self.inner.ready().await.map_err(|e| {
989                tonic::Status::new(
990                    tonic::Code::Unknown,
991                    format!("Service was not ready: {}", e.into()),
992                )
993            })?;
994            let codec = tonic::codec::ProstCodec::default();
995            let path = http::uri::PathAndQuery::from_static(
996                "/cosmos.distribution.v1beta1.Query/CommunityPool",
997            );
998            self.inner.unary(request.into_request(), path, codec).await
999        }
1000    }
1001}
1002/// Generated server implementations.
1003#[cfg(feature = "grpc")]
1004#[cfg_attr(docsrs, doc(cfg(feature = "grpc")))]
1005pub mod query_server {
1006    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
1007    use tonic::codegen::*;
1008    /// Generated trait containing gRPC methods that should be implemented for use with QueryServer.
1009    #[async_trait]
1010    pub trait Query: Send + Sync + 'static {
1011        /// Params queries params of the distribution module.
1012        async fn params(
1013            &self,
1014            request: tonic::Request<super::QueryParamsRequest>,
1015        ) -> Result<tonic::Response<super::QueryParamsResponse>, tonic::Status>;
1016        /// ValidatorOutstandingRewards queries rewards of a validator address.
1017        async fn validator_outstanding_rewards(
1018            &self,
1019            request: tonic::Request<super::QueryValidatorOutstandingRewardsRequest>,
1020        ) -> Result<tonic::Response<super::QueryValidatorOutstandingRewardsResponse>, tonic::Status>;
1021        /// ValidatorCommission queries accumulated commission for a validator.
1022        async fn validator_commission(
1023            &self,
1024            request: tonic::Request<super::QueryValidatorCommissionRequest>,
1025        ) -> Result<tonic::Response<super::QueryValidatorCommissionResponse>, tonic::Status>;
1026        /// ValidatorSlashes queries slash events of a validator.
1027        async fn validator_slashes(
1028            &self,
1029            request: tonic::Request<super::QueryValidatorSlashesRequest>,
1030        ) -> Result<tonic::Response<super::QueryValidatorSlashesResponse>, tonic::Status>;
1031        /// DelegationRewards queries the total rewards accrued by a delegation.
1032        async fn delegation_rewards(
1033            &self,
1034            request: tonic::Request<super::QueryDelegationRewardsRequest>,
1035        ) -> Result<tonic::Response<super::QueryDelegationRewardsResponse>, tonic::Status>;
1036        /// DelegationTotalRewards queries the total rewards accrued by a each
1037        /// validator.
1038        async fn delegation_total_rewards(
1039            &self,
1040            request: tonic::Request<super::QueryDelegationTotalRewardsRequest>,
1041        ) -> Result<tonic::Response<super::QueryDelegationTotalRewardsResponse>, tonic::Status>;
1042        /// DelegatorValidators queries the validators of a delegator.
1043        async fn delegator_validators(
1044            &self,
1045            request: tonic::Request<super::QueryDelegatorValidatorsRequest>,
1046        ) -> Result<tonic::Response<super::QueryDelegatorValidatorsResponse>, tonic::Status>;
1047        /// DelegatorWithdrawAddress queries withdraw address of a delegator.
1048        async fn delegator_withdraw_address(
1049            &self,
1050            request: tonic::Request<super::QueryDelegatorWithdrawAddressRequest>,
1051        ) -> Result<tonic::Response<super::QueryDelegatorWithdrawAddressResponse>, tonic::Status>;
1052        /// CommunityPool queries the community pool coins.
1053        async fn community_pool(
1054            &self,
1055            request: tonic::Request<super::QueryCommunityPoolRequest>,
1056        ) -> Result<tonic::Response<super::QueryCommunityPoolResponse>, tonic::Status>;
1057    }
1058    /// Query defines the gRPC querier service for distribution module.
1059    #[derive(Debug)]
1060    pub struct QueryServer<T: Query> {
1061        inner: _Inner<T>,
1062        accept_compression_encodings: EnabledCompressionEncodings,
1063        send_compression_encodings: EnabledCompressionEncodings,
1064    }
1065    struct _Inner<T>(Arc<T>);
1066    impl<T: Query> QueryServer<T> {
1067        pub fn new(inner: T) -> Self {
1068            Self::from_arc(Arc::new(inner))
1069        }
1070        pub fn from_arc(inner: Arc<T>) -> Self {
1071            let inner = _Inner(inner);
1072            Self {
1073                inner,
1074                accept_compression_encodings: Default::default(),
1075                send_compression_encodings: Default::default(),
1076            }
1077        }
1078        pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
1079        where
1080            F: tonic::service::Interceptor,
1081        {
1082            InterceptedService::new(Self::new(inner), interceptor)
1083        }
1084        /// Enable decompressing requests with the given encoding.
1085        #[must_use]
1086        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
1087            self.accept_compression_encodings.enable(encoding);
1088            self
1089        }
1090        /// Compress responses with the given encoding, if the client supports it.
1091        #[must_use]
1092        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
1093            self.send_compression_encodings.enable(encoding);
1094            self
1095        }
1096    }
1097    impl<T, B> tonic::codegen::Service<http::Request<B>> for QueryServer<T>
1098    where
1099        T: Query,
1100        B: Body + Send + 'static,
1101        B::Error: Into<StdError> + Send + 'static,
1102    {
1103        type Response = http::Response<tonic::body::BoxBody>;
1104        type Error = std::convert::Infallible;
1105        type Future = BoxFuture<Self::Response, Self::Error>;
1106        fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
1107            Poll::Ready(Ok(()))
1108        }
1109        fn call(&mut self, req: http::Request<B>) -> Self::Future {
1110            let inner = self.inner.clone();
1111            match req.uri().path() {
1112                "/cosmos.distribution.v1beta1.Query/Params" => {
1113                    #[allow(non_camel_case_types)]
1114                    struct ParamsSvc<T: Query>(pub Arc<T>);
1115                    impl<T: Query> tonic::server::UnaryService<super::QueryParamsRequest> for ParamsSvc<T> {
1116                        type Response = super::QueryParamsResponse;
1117                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1118                        fn call(
1119                            &mut self,
1120                            request: tonic::Request<super::QueryParamsRequest>,
1121                        ) -> Self::Future {
1122                            let inner = self.0.clone();
1123                            let fut = async move { (*inner).params(request).await };
1124                            Box::pin(fut)
1125                        }
1126                    }
1127                    let accept_compression_encodings = self.accept_compression_encodings;
1128                    let send_compression_encodings = self.send_compression_encodings;
1129                    let inner = self.inner.clone();
1130                    let fut = async move {
1131                        let inner = inner.0;
1132                        let method = ParamsSvc(inner);
1133                        let codec = tonic::codec::ProstCodec::default();
1134                        let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config(
1135                            accept_compression_encodings,
1136                            send_compression_encodings,
1137                        );
1138                        let res = grpc.unary(method, req).await;
1139                        Ok(res)
1140                    };
1141                    Box::pin(fut)
1142                }
1143                "/cosmos.distribution.v1beta1.Query/ValidatorOutstandingRewards" => {
1144                    #[allow(non_camel_case_types)]
1145                    struct ValidatorOutstandingRewardsSvc<T: Query>(pub Arc<T>);
1146                    impl<T: Query>
1147                        tonic::server::UnaryService<super::QueryValidatorOutstandingRewardsRequest>
1148                        for ValidatorOutstandingRewardsSvc<T>
1149                    {
1150                        type Response = super::QueryValidatorOutstandingRewardsResponse;
1151                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1152                        fn call(
1153                            &mut self,
1154                            request: tonic::Request<super::QueryValidatorOutstandingRewardsRequest>,
1155                        ) -> Self::Future {
1156                            let inner = self.0.clone();
1157                            let fut = async move {
1158                                (*inner).validator_outstanding_rewards(request).await
1159                            };
1160                            Box::pin(fut)
1161                        }
1162                    }
1163                    let accept_compression_encodings = self.accept_compression_encodings;
1164                    let send_compression_encodings = self.send_compression_encodings;
1165                    let inner = self.inner.clone();
1166                    let fut = async move {
1167                        let inner = inner.0;
1168                        let method = ValidatorOutstandingRewardsSvc(inner);
1169                        let codec = tonic::codec::ProstCodec::default();
1170                        let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config(
1171                            accept_compression_encodings,
1172                            send_compression_encodings,
1173                        );
1174                        let res = grpc.unary(method, req).await;
1175                        Ok(res)
1176                    };
1177                    Box::pin(fut)
1178                }
1179                "/cosmos.distribution.v1beta1.Query/ValidatorCommission" => {
1180                    #[allow(non_camel_case_types)]
1181                    struct ValidatorCommissionSvc<T: Query>(pub Arc<T>);
1182                    impl<T: Query>
1183                        tonic::server::UnaryService<super::QueryValidatorCommissionRequest>
1184                        for ValidatorCommissionSvc<T>
1185                    {
1186                        type Response = super::QueryValidatorCommissionResponse;
1187                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1188                        fn call(
1189                            &mut self,
1190                            request: tonic::Request<super::QueryValidatorCommissionRequest>,
1191                        ) -> Self::Future {
1192                            let inner = self.0.clone();
1193                            let fut = async move { (*inner).validator_commission(request).await };
1194                            Box::pin(fut)
1195                        }
1196                    }
1197                    let accept_compression_encodings = self.accept_compression_encodings;
1198                    let send_compression_encodings = self.send_compression_encodings;
1199                    let inner = self.inner.clone();
1200                    let fut = async move {
1201                        let inner = inner.0;
1202                        let method = ValidatorCommissionSvc(inner);
1203                        let codec = tonic::codec::ProstCodec::default();
1204                        let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config(
1205                            accept_compression_encodings,
1206                            send_compression_encodings,
1207                        );
1208                        let res = grpc.unary(method, req).await;
1209                        Ok(res)
1210                    };
1211                    Box::pin(fut)
1212                }
1213                "/cosmos.distribution.v1beta1.Query/ValidatorSlashes" => {
1214                    #[allow(non_camel_case_types)]
1215                    struct ValidatorSlashesSvc<T: Query>(pub Arc<T>);
1216                    impl<T: Query> tonic::server::UnaryService<super::QueryValidatorSlashesRequest>
1217                        for ValidatorSlashesSvc<T>
1218                    {
1219                        type Response = super::QueryValidatorSlashesResponse;
1220                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1221                        fn call(
1222                            &mut self,
1223                            request: tonic::Request<super::QueryValidatorSlashesRequest>,
1224                        ) -> Self::Future {
1225                            let inner = self.0.clone();
1226                            let fut = async move { (*inner).validator_slashes(request).await };
1227                            Box::pin(fut)
1228                        }
1229                    }
1230                    let accept_compression_encodings = self.accept_compression_encodings;
1231                    let send_compression_encodings = self.send_compression_encodings;
1232                    let inner = self.inner.clone();
1233                    let fut = async move {
1234                        let inner = inner.0;
1235                        let method = ValidatorSlashesSvc(inner);
1236                        let codec = tonic::codec::ProstCodec::default();
1237                        let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config(
1238                            accept_compression_encodings,
1239                            send_compression_encodings,
1240                        );
1241                        let res = grpc.unary(method, req).await;
1242                        Ok(res)
1243                    };
1244                    Box::pin(fut)
1245                }
1246                "/cosmos.distribution.v1beta1.Query/DelegationRewards" => {
1247                    #[allow(non_camel_case_types)]
1248                    struct DelegationRewardsSvc<T: Query>(pub Arc<T>);
1249                    impl<T: Query> tonic::server::UnaryService<super::QueryDelegationRewardsRequest>
1250                        for DelegationRewardsSvc<T>
1251                    {
1252                        type Response = super::QueryDelegationRewardsResponse;
1253                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1254                        fn call(
1255                            &mut self,
1256                            request: tonic::Request<super::QueryDelegationRewardsRequest>,
1257                        ) -> Self::Future {
1258                            let inner = self.0.clone();
1259                            let fut = async move { (*inner).delegation_rewards(request).await };
1260                            Box::pin(fut)
1261                        }
1262                    }
1263                    let accept_compression_encodings = self.accept_compression_encodings;
1264                    let send_compression_encodings = self.send_compression_encodings;
1265                    let inner = self.inner.clone();
1266                    let fut = async move {
1267                        let inner = inner.0;
1268                        let method = DelegationRewardsSvc(inner);
1269                        let codec = tonic::codec::ProstCodec::default();
1270                        let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config(
1271                            accept_compression_encodings,
1272                            send_compression_encodings,
1273                        );
1274                        let res = grpc.unary(method, req).await;
1275                        Ok(res)
1276                    };
1277                    Box::pin(fut)
1278                }
1279                "/cosmos.distribution.v1beta1.Query/DelegationTotalRewards" => {
1280                    #[allow(non_camel_case_types)]
1281                    struct DelegationTotalRewardsSvc<T: Query>(pub Arc<T>);
1282                    impl<T: Query>
1283                        tonic::server::UnaryService<super::QueryDelegationTotalRewardsRequest>
1284                        for DelegationTotalRewardsSvc<T>
1285                    {
1286                        type Response = super::QueryDelegationTotalRewardsResponse;
1287                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1288                        fn call(
1289                            &mut self,
1290                            request: tonic::Request<super::QueryDelegationTotalRewardsRequest>,
1291                        ) -> Self::Future {
1292                            let inner = self.0.clone();
1293                            let fut =
1294                                async move { (*inner).delegation_total_rewards(request).await };
1295                            Box::pin(fut)
1296                        }
1297                    }
1298                    let accept_compression_encodings = self.accept_compression_encodings;
1299                    let send_compression_encodings = self.send_compression_encodings;
1300                    let inner = self.inner.clone();
1301                    let fut = async move {
1302                        let inner = inner.0;
1303                        let method = DelegationTotalRewardsSvc(inner);
1304                        let codec = tonic::codec::ProstCodec::default();
1305                        let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config(
1306                            accept_compression_encodings,
1307                            send_compression_encodings,
1308                        );
1309                        let res = grpc.unary(method, req).await;
1310                        Ok(res)
1311                    };
1312                    Box::pin(fut)
1313                }
1314                "/cosmos.distribution.v1beta1.Query/DelegatorValidators" => {
1315                    #[allow(non_camel_case_types)]
1316                    struct DelegatorValidatorsSvc<T: Query>(pub Arc<T>);
1317                    impl<T: Query>
1318                        tonic::server::UnaryService<super::QueryDelegatorValidatorsRequest>
1319                        for DelegatorValidatorsSvc<T>
1320                    {
1321                        type Response = super::QueryDelegatorValidatorsResponse;
1322                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1323                        fn call(
1324                            &mut self,
1325                            request: tonic::Request<super::QueryDelegatorValidatorsRequest>,
1326                        ) -> Self::Future {
1327                            let inner = self.0.clone();
1328                            let fut = async move { (*inner).delegator_validators(request).await };
1329                            Box::pin(fut)
1330                        }
1331                    }
1332                    let accept_compression_encodings = self.accept_compression_encodings;
1333                    let send_compression_encodings = self.send_compression_encodings;
1334                    let inner = self.inner.clone();
1335                    let fut = async move {
1336                        let inner = inner.0;
1337                        let method = DelegatorValidatorsSvc(inner);
1338                        let codec = tonic::codec::ProstCodec::default();
1339                        let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config(
1340                            accept_compression_encodings,
1341                            send_compression_encodings,
1342                        );
1343                        let res = grpc.unary(method, req).await;
1344                        Ok(res)
1345                    };
1346                    Box::pin(fut)
1347                }
1348                "/cosmos.distribution.v1beta1.Query/DelegatorWithdrawAddress" => {
1349                    #[allow(non_camel_case_types)]
1350                    struct DelegatorWithdrawAddressSvc<T: Query>(pub Arc<T>);
1351                    impl<T: Query>
1352                        tonic::server::UnaryService<super::QueryDelegatorWithdrawAddressRequest>
1353                        for DelegatorWithdrawAddressSvc<T>
1354                    {
1355                        type Response = super::QueryDelegatorWithdrawAddressResponse;
1356                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1357                        fn call(
1358                            &mut self,
1359                            request: tonic::Request<super::QueryDelegatorWithdrawAddressRequest>,
1360                        ) -> Self::Future {
1361                            let inner = self.0.clone();
1362                            let fut =
1363                                async move { (*inner).delegator_withdraw_address(request).await };
1364                            Box::pin(fut)
1365                        }
1366                    }
1367                    let accept_compression_encodings = self.accept_compression_encodings;
1368                    let send_compression_encodings = self.send_compression_encodings;
1369                    let inner = self.inner.clone();
1370                    let fut = async move {
1371                        let inner = inner.0;
1372                        let method = DelegatorWithdrawAddressSvc(inner);
1373                        let codec = tonic::codec::ProstCodec::default();
1374                        let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config(
1375                            accept_compression_encodings,
1376                            send_compression_encodings,
1377                        );
1378                        let res = grpc.unary(method, req).await;
1379                        Ok(res)
1380                    };
1381                    Box::pin(fut)
1382                }
1383                "/cosmos.distribution.v1beta1.Query/CommunityPool" => {
1384                    #[allow(non_camel_case_types)]
1385                    struct CommunityPoolSvc<T: Query>(pub Arc<T>);
1386                    impl<T: Query> tonic::server::UnaryService<super::QueryCommunityPoolRequest>
1387                        for CommunityPoolSvc<T>
1388                    {
1389                        type Response = super::QueryCommunityPoolResponse;
1390                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
1391                        fn call(
1392                            &mut self,
1393                            request: tonic::Request<super::QueryCommunityPoolRequest>,
1394                        ) -> Self::Future {
1395                            let inner = self.0.clone();
1396                            let fut = async move { (*inner).community_pool(request).await };
1397                            Box::pin(fut)
1398                        }
1399                    }
1400                    let accept_compression_encodings = self.accept_compression_encodings;
1401                    let send_compression_encodings = self.send_compression_encodings;
1402                    let inner = self.inner.clone();
1403                    let fut = async move {
1404                        let inner = inner.0;
1405                        let method = CommunityPoolSvc(inner);
1406                        let codec = tonic::codec::ProstCodec::default();
1407                        let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config(
1408                            accept_compression_encodings,
1409                            send_compression_encodings,
1410                        );
1411                        let res = grpc.unary(method, req).await;
1412                        Ok(res)
1413                    };
1414                    Box::pin(fut)
1415                }
1416                _ => Box::pin(async move {
1417                    Ok(http::Response::builder()
1418                        .status(200)
1419                        .header("grpc-status", "12")
1420                        .header("content-type", "application/grpc")
1421                        .body(empty_body())
1422                        .unwrap())
1423                }),
1424            }
1425        }
1426    }
1427    impl<T: Query> Clone for QueryServer<T> {
1428        fn clone(&self) -> Self {
1429            let inner = self.inner.clone();
1430            Self {
1431                inner,
1432                accept_compression_encodings: self.accept_compression_encodings,
1433                send_compression_encodings: self.send_compression_encodings,
1434            }
1435        }
1436    }
1437    impl<T: Query> Clone for _Inner<T> {
1438        fn clone(&self) -> Self {
1439            Self(self.0.clone())
1440        }
1441    }
1442    impl<T: std::fmt::Debug> std::fmt::Debug for _Inner<T> {
1443        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1444            write!(f, "{:?}", self.0)
1445        }
1446    }
1447    impl<T: Query> tonic::server::NamedService for QueryServer<T> {
1448        const NAME: &'static str = "cosmos.distribution.v1beta1.Query";
1449    }
1450}
1451/// DelegatorWithdrawInfo is the address for where distributions rewards are
1452/// withdrawn to by default this struct is only used at genesis to feed in
1453/// default withdraw addresses.
1454#[allow(clippy::derive_partial_eq_without_eq)]
1455#[derive(Clone, PartialEq, ::prost::Message)]
1456pub struct DelegatorWithdrawInfo {
1457    /// delegator_address is the address of the delegator.
1458    #[prost(string, tag = "1")]
1459    pub delegator_address: ::prost::alloc::string::String,
1460    /// withdraw_address is the address to withdraw the delegation rewards to.
1461    #[prost(string, tag = "2")]
1462    pub withdraw_address: ::prost::alloc::string::String,
1463}
1464/// ValidatorOutstandingRewardsRecord is used for import/export via genesis json.
1465#[allow(clippy::derive_partial_eq_without_eq)]
1466#[derive(Clone, PartialEq, ::prost::Message)]
1467pub struct ValidatorOutstandingRewardsRecord {
1468    /// validator_address is the address of the validator.
1469    #[prost(string, tag = "1")]
1470    pub validator_address: ::prost::alloc::string::String,
1471    /// outstanding_rewards represents the oustanding rewards of a validator.
1472    #[prost(message, repeated, tag = "2")]
1473    pub outstanding_rewards: ::prost::alloc::vec::Vec<super::super::base::v1beta1::DecCoin>,
1474}
1475/// ValidatorAccumulatedCommissionRecord is used for import / export via genesis
1476/// json.
1477#[allow(clippy::derive_partial_eq_without_eq)]
1478#[derive(Clone, PartialEq, ::prost::Message)]
1479pub struct ValidatorAccumulatedCommissionRecord {
1480    /// validator_address is the address of the validator.
1481    #[prost(string, tag = "1")]
1482    pub validator_address: ::prost::alloc::string::String,
1483    /// accumulated is the accumulated commission of a validator.
1484    #[prost(message, optional, tag = "2")]
1485    pub accumulated: ::core::option::Option<ValidatorAccumulatedCommission>,
1486}
1487/// ValidatorHistoricalRewardsRecord is used for import / export via genesis
1488/// json.
1489#[allow(clippy::derive_partial_eq_without_eq)]
1490#[derive(Clone, PartialEq, ::prost::Message)]
1491pub struct ValidatorHistoricalRewardsRecord {
1492    /// validator_address is the address of the validator.
1493    #[prost(string, tag = "1")]
1494    pub validator_address: ::prost::alloc::string::String,
1495    /// period defines the period the historical rewards apply to.
1496    #[prost(uint64, tag = "2")]
1497    pub period: u64,
1498    /// rewards defines the historical rewards of a validator.
1499    #[prost(message, optional, tag = "3")]
1500    pub rewards: ::core::option::Option<ValidatorHistoricalRewards>,
1501}
1502/// ValidatorCurrentRewardsRecord is used for import / export via genesis json.
1503#[allow(clippy::derive_partial_eq_without_eq)]
1504#[derive(Clone, PartialEq, ::prost::Message)]
1505pub struct ValidatorCurrentRewardsRecord {
1506    /// validator_address is the address of the validator.
1507    #[prost(string, tag = "1")]
1508    pub validator_address: ::prost::alloc::string::String,
1509    /// rewards defines the current rewards of a validator.
1510    #[prost(message, optional, tag = "2")]
1511    pub rewards: ::core::option::Option<ValidatorCurrentRewards>,
1512}
1513/// DelegatorStartingInfoRecord used for import / export via genesis json.
1514#[allow(clippy::derive_partial_eq_without_eq)]
1515#[derive(Clone, PartialEq, ::prost::Message)]
1516pub struct DelegatorStartingInfoRecord {
1517    /// delegator_address is the address of the delegator.
1518    #[prost(string, tag = "1")]
1519    pub delegator_address: ::prost::alloc::string::String,
1520    /// validator_address is the address of the validator.
1521    #[prost(string, tag = "2")]
1522    pub validator_address: ::prost::alloc::string::String,
1523    /// starting_info defines the starting info of a delegator.
1524    #[prost(message, optional, tag = "3")]
1525    pub starting_info: ::core::option::Option<DelegatorStartingInfo>,
1526}
1527/// ValidatorSlashEventRecord is used for import / export via genesis json.
1528#[allow(clippy::derive_partial_eq_without_eq)]
1529#[derive(Clone, PartialEq, ::prost::Message)]
1530pub struct ValidatorSlashEventRecord {
1531    /// validator_address is the address of the validator.
1532    #[prost(string, tag = "1")]
1533    pub validator_address: ::prost::alloc::string::String,
1534    /// height defines the block height at which the slash event occured.
1535    #[prost(uint64, tag = "2")]
1536    pub height: u64,
1537    /// period is the period of the slash event.
1538    #[prost(uint64, tag = "3")]
1539    pub period: u64,
1540    /// validator_slash_event describes the slash event.
1541    #[prost(message, optional, tag = "4")]
1542    pub validator_slash_event: ::core::option::Option<ValidatorSlashEvent>,
1543}
1544/// GenesisState defines the distribution module's genesis state.
1545#[allow(clippy::derive_partial_eq_without_eq)]
1546#[derive(Clone, PartialEq, ::prost::Message)]
1547pub struct GenesisState {
1548    /// params defines all the paramaters of the module.
1549    #[prost(message, optional, tag = "1")]
1550    pub params: ::core::option::Option<Params>,
1551    /// fee_pool defines the fee pool at genesis.
1552    #[prost(message, optional, tag = "2")]
1553    pub fee_pool: ::core::option::Option<FeePool>,
1554    /// fee_pool defines the delegator withdraw infos at genesis.
1555    #[prost(message, repeated, tag = "3")]
1556    pub delegator_withdraw_infos: ::prost::alloc::vec::Vec<DelegatorWithdrawInfo>,
1557    /// fee_pool defines the previous proposer at genesis.
1558    #[prost(string, tag = "4")]
1559    pub previous_proposer: ::prost::alloc::string::String,
1560    /// fee_pool defines the outstanding rewards of all validators at genesis.
1561    #[prost(message, repeated, tag = "5")]
1562    pub outstanding_rewards: ::prost::alloc::vec::Vec<ValidatorOutstandingRewardsRecord>,
1563    /// fee_pool defines the accumulated commisions of all validators at genesis.
1564    #[prost(message, repeated, tag = "6")]
1565    pub validator_accumulated_commissions:
1566        ::prost::alloc::vec::Vec<ValidatorAccumulatedCommissionRecord>,
1567    /// fee_pool defines the historical rewards of all validators at genesis.
1568    #[prost(message, repeated, tag = "7")]
1569    pub validator_historical_rewards: ::prost::alloc::vec::Vec<ValidatorHistoricalRewardsRecord>,
1570    /// fee_pool defines the current rewards of all validators at genesis.
1571    #[prost(message, repeated, tag = "8")]
1572    pub validator_current_rewards: ::prost::alloc::vec::Vec<ValidatorCurrentRewardsRecord>,
1573    /// fee_pool defines the delegator starting infos at genesis.
1574    #[prost(message, repeated, tag = "9")]
1575    pub delegator_starting_infos: ::prost::alloc::vec::Vec<DelegatorStartingInfoRecord>,
1576    /// fee_pool defines the validator slash events at genesis.
1577    #[prost(message, repeated, tag = "10")]
1578    pub validator_slash_events: ::prost::alloc::vec::Vec<ValidatorSlashEventRecord>,
1579}
juno_rust_proto/prost/cosmos-sdk/cosmos.distribution.v1beta1.rs

juno_rust_proto/prost/cosmos-sdk/
cosmos.distribution.v1beta1.rs
