osmosis_std/types/osmosis/
incentives.rs

1use osmosis_std_derive::CosmwasmExt;
2/// Gauge is an object that stores and distributes yields to recipients who
3/// satisfy certain conditions. Currently gauges support conditions around the
4/// duration for which a given denom is locked.
5#[allow(clippy::derive_partial_eq_without_eq)]
6#[derive(
7    Clone,
8    PartialEq,
9    Eq,
10    ::prost::Message,
11    ::serde::Serialize,
12    ::serde::Deserialize,
13    ::schemars::JsonSchema,
14    CosmwasmExt,
15)]
16#[proto_message(type_url = "/osmosis.incentives.Gauge")]
17pub struct Gauge {
18    /// id is the unique ID of a Gauge
19    #[prost(uint64, tag = "1")]
20    #[serde(alias = "ID")]
21    #[serde(
22        serialize_with = "crate::serde::as_str::serialize",
23        deserialize_with = "crate::serde::as_str::deserialize"
24    )]
25    pub id: u64,
26    /// is_perpetual is a flag to show if it's a perpetual or non-perpetual gauge
27    /// Non-perpetual gauges distribute their tokens equally per epoch while the
28    /// gauge is in the active period. Perpetual gauges distribute all their tokens
29    /// at a single time and only distribute their tokens again once the gauge is
30    /// refilled, Intended for use with incentives that get refilled daily.
31    #[prost(bool, tag = "2")]
32    pub is_perpetual: bool,
33    /// distribute_to is where the gauge rewards are distributed to.
34    /// This is queried via lock duration or by timestamp
35    #[prost(message, optional, tag = "3")]
36    pub distribute_to: ::core::option::Option<super::lockup::QueryCondition>,
37    /// coins is the total amount of coins that have been in the gauge
38    /// Can distribute multiple coin denoms
39    #[prost(message, repeated, tag = "4")]
40    pub coins: ::prost::alloc::vec::Vec<super::super::cosmos::base::v1beta1::Coin>,
41    /// start_time is the distribution start time
42    #[prost(message, optional, tag = "5")]
43    pub start_time: ::core::option::Option<crate::shim::Timestamp>,
44    /// num_epochs_paid_over is the number of total epochs distribution will be
45    /// completed over
46    #[prost(uint64, tag = "6")]
47    #[serde(
48        serialize_with = "crate::serde::as_str::serialize",
49        deserialize_with = "crate::serde::as_str::deserialize"
50    )]
51    pub num_epochs_paid_over: u64,
52    /// filled_epochs is the number of epochs distribution has been completed on
53    /// already
54    #[prost(uint64, tag = "7")]
55    #[serde(
56        serialize_with = "crate::serde::as_str::serialize",
57        deserialize_with = "crate::serde::as_str::deserialize"
58    )]
59    pub filled_epochs: u64,
60    /// distributed_coins are coins that have been distributed already
61    #[prost(message, repeated, tag = "8")]
62    pub distributed_coins: ::prost::alloc::vec::Vec<super::super::cosmos::base::v1beta1::Coin>,
63}
64#[allow(clippy::derive_partial_eq_without_eq)]
65#[derive(
66    Clone,
67    PartialEq,
68    Eq,
69    ::prost::Message,
70    ::serde::Serialize,
71    ::serde::Deserialize,
72    ::schemars::JsonSchema,
73    CosmwasmExt,
74)]
75#[proto_message(type_url = "/osmosis.incentives.LockableDurationsInfo")]
76pub struct LockableDurationsInfo {
77    /// List of incentivised durations that gauges will pay out to
78    #[prost(message, repeated, tag = "1")]
79    pub lockable_durations: ::prost::alloc::vec::Vec<crate::shim::Duration>,
80}
81/// Params holds parameters for the incentives module
82#[allow(clippy::derive_partial_eq_without_eq)]
83#[derive(
84    Clone,
85    PartialEq,
86    Eq,
87    ::prost::Message,
88    ::serde::Serialize,
89    ::serde::Deserialize,
90    ::schemars::JsonSchema,
91    CosmwasmExt,
92)]
93#[proto_message(type_url = "/osmosis.incentives.Params")]
94pub struct Params {
95    /// distr_epoch_identifier is what epoch type distribution will be triggered by
96    /// (day, week, etc.)
97    #[prost(string, tag = "1")]
98    #[serde(alias = "distr_epochIDentifier")]
99    pub distr_epoch_identifier: ::prost::alloc::string::String,
100    /// group_creation_fee is the fee required to create a new group
101    /// It is only charged to all addresses other than incentive module account
102    /// or addresses in the unrestricted_creator_whitelist
103    #[prost(message, repeated, tag = "2")]
104    pub group_creation_fee: ::prost::alloc::vec::Vec<super::super::cosmos::base::v1beta1::Coin>,
105    /// unrestricted_creator_whitelist is a list of addresses that are
106    /// allowed to bypass restrictions on permissionless Group
107    /// creation. In the future, we might expand these to creating gauges
108    /// as well.
109    /// The goal of this is to allow a subdao to manage incentives efficiently
110    /// without being stopped by 5 day governance process or a high fee.
111    /// At the same time, it prevents spam by having a fee for all
112    /// other users.
113    #[prost(string, repeated, tag = "3")]
114    pub unrestricted_creator_whitelist: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
115    /// internal_uptime is the uptime used for internal incentives on pools that
116    /// use NoLock gauges (currently only Concentrated Liquidity pools).
117    ///
118    /// Since Group gauges route through internal gauges, this parameter affects
119    /// the uptime of those incentives as well (i.e. distributions through volume
120    /// splitting incentives will use this uptime).
121    #[prost(message, optional, tag = "4")]
122    pub internal_uptime: ::core::option::Option<crate::shim::Duration>,
123    /// min_value_for_distribution is the minimum amount a token must be worth
124    /// in order to be eligible for distribution. If the token is worth
125    /// less than this amount (or the route between the two denoms is not
126    /// registered), it will not be distributed and is forfeited to the remaining
127    /// distributees that are eligible.
128    #[prost(message, optional, tag = "5")]
129    pub min_value_for_distribution:
130        ::core::option::Option<super::super::cosmos::base::v1beta1::Coin>,
131}
132/// Note that while both InternalGaugeInfo and InternalGaugeRecord could
133/// technically be replaced by DistrInfo and DistrRecord from the pool-incentives
134/// module, we create separate types here to keep our abstractions clean and
135/// readable (pool-incentives distribution abstractions are used in a very
136/// specific way that does not directly relate to gauge logic). This also helps
137/// us sidestep a refactor to avoid an import cycle.
138#[allow(clippy::derive_partial_eq_without_eq)]
139#[derive(
140    Clone,
141    PartialEq,
142    Eq,
143    ::prost::Message,
144    ::serde::Serialize,
145    ::serde::Deserialize,
146    ::schemars::JsonSchema,
147    CosmwasmExt,
148)]
149#[proto_message(type_url = "/osmosis.incentives.InternalGaugeInfo")]
150pub struct InternalGaugeInfo {
151    #[prost(string, tag = "1")]
152    pub total_weight: ::prost::alloc::string::String,
153    #[prost(message, repeated, tag = "2")]
154    pub gauge_records: ::prost::alloc::vec::Vec<InternalGaugeRecord>,
155}
156#[allow(clippy::derive_partial_eq_without_eq)]
157#[derive(
158    Clone,
159    PartialEq,
160    Eq,
161    ::prost::Message,
162    ::serde::Serialize,
163    ::serde::Deserialize,
164    ::schemars::JsonSchema,
165    CosmwasmExt,
166)]
167#[proto_message(type_url = "/osmosis.incentives.InternalGaugeRecord")]
168pub struct InternalGaugeRecord {
169    #[prost(uint64, tag = "1")]
170    #[serde(alias = "gaugeID")]
171    #[serde(
172        serialize_with = "crate::serde::as_str::serialize",
173        deserialize_with = "crate::serde::as_str::deserialize"
174    )]
175    pub gauge_id: u64,
176    /// CurrentWeight is the current weight of this gauge being distributed to for
177    /// this epoch. For instance, for volume splitting policy, this stores the
178    /// volume generated in the last epoch of the linked pool.
179    #[prost(string, tag = "2")]
180    pub current_weight: ::prost::alloc::string::String,
181    /// CumulativeWeight serves as a snapshot of the accumulator being tracked
182    /// based on splitting policy. For instance, for volume splitting policy, this
183    /// stores the cumulative volume for the linked pool at time of last update.
184    #[prost(string, tag = "3")]
185    pub cumulative_weight: ::prost::alloc::string::String,
186}
187/// Group is an object that stores a 1:1 mapped gauge ID, a list of pool gauge
188/// info, and a splitting policy. These are grouped into a single abstraction to
189/// allow for distribution of group incentives to internal gauges according to
190/// the specified splitting policy.
191#[allow(clippy::derive_partial_eq_without_eq)]
192#[derive(
193    Clone,
194    PartialEq,
195    Eq,
196    ::prost::Message,
197    ::serde::Serialize,
198    ::serde::Deserialize,
199    ::schemars::JsonSchema,
200    CosmwasmExt,
201)]
202#[proto_message(type_url = "/osmosis.incentives.Group")]
203pub struct Group {
204    #[prost(uint64, tag = "1")]
205    #[serde(alias = "group_gaugeID")]
206    #[serde(
207        serialize_with = "crate::serde::as_str::serialize",
208        deserialize_with = "crate::serde::as_str::deserialize"
209    )]
210    pub group_gauge_id: u64,
211    #[prost(message, optional, tag = "2")]
212    pub internal_gauge_info: ::core::option::Option<InternalGaugeInfo>,
213    #[prost(enumeration = "SplittingPolicy", tag = "3")]
214    #[serde(
215        serialize_with = "crate::serde::as_str::serialize",
216        deserialize_with = "crate::serde::as_str::deserialize"
217    )]
218    pub splitting_policy: i32,
219}
220/// CreateGroup is called via governance to create a new group.
221/// It takes an array of pool IDs to split the incentives across.
222#[allow(clippy::derive_partial_eq_without_eq)]
223#[derive(
224    Clone,
225    PartialEq,
226    Eq,
227    ::prost::Message,
228    ::serde::Serialize,
229    ::serde::Deserialize,
230    ::schemars::JsonSchema,
231    CosmwasmExt,
232)]
233#[proto_message(type_url = "/osmosis.incentives.CreateGroup")]
234pub struct CreateGroup {
235    #[prost(uint64, repeated, tag = "1")]
236    #[serde(alias = "poolIDs")]
237    #[serde(
238        serialize_with = "crate::serde::as_str_vec::serialize",
239        deserialize_with = "crate::serde::as_str_vec::deserialize"
240    )]
241    pub pool_ids: ::prost::alloc::vec::Vec<u64>,
242}
243/// GroupsWithGauge is a helper struct that stores a group and its
244/// associated gauge.
245#[allow(clippy::derive_partial_eq_without_eq)]
246#[derive(
247    Clone,
248    PartialEq,
249    Eq,
250    ::prost::Message,
251    ::serde::Serialize,
252    ::serde::Deserialize,
253    ::schemars::JsonSchema,
254    CosmwasmExt,
255)]
256#[proto_message(type_url = "/osmosis.incentives.GroupsWithGauge")]
257pub struct GroupsWithGauge {
258    #[prost(message, optional, tag = "1")]
259    pub group: ::core::option::Option<Group>,
260    #[prost(message, optional, tag = "2")]
261    pub gauge: ::core::option::Option<Gauge>,
262}
263/// SplittingPolicy determines the way we want to split incentives in groupGauges
264#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
265#[repr(i32)]
266#[derive(::serde::Serialize, ::serde::Deserialize, ::schemars::JsonSchema)]
267pub enum SplittingPolicy {
268    ByVolume = 0,
269}
270impl SplittingPolicy {
271    /// String value of the enum field names used in the ProtoBuf definition.
272    ///
273    /// The values are not transformed in any way and thus are considered stable
274    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
275    pub fn as_str_name(&self) -> &'static str {
276        match self {
277            SplittingPolicy::ByVolume => "ByVolume",
278        }
279    }
280    /// Creates an enum from field names used in the ProtoBuf definition.
281    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
282        match value {
283            "ByVolume" => Some(Self::ByVolume),
284            _ => None,
285        }
286    }
287}
288/// GenesisState defines the incentives module's various parameters when first
289/// initialized
290#[allow(clippy::derive_partial_eq_without_eq)]
291#[derive(
292    Clone,
293    PartialEq,
294    Eq,
295    ::prost::Message,
296    ::serde::Serialize,
297    ::serde::Deserialize,
298    ::schemars::JsonSchema,
299    CosmwasmExt,
300)]
301#[proto_message(type_url = "/osmosis.incentives.GenesisState")]
302pub struct GenesisState {
303    /// params are all the parameters of the module
304    #[prost(message, optional, tag = "1")]
305    pub params: ::core::option::Option<Params>,
306    /// gauges are all gauges (not including group gauges) that should exist at
307    /// genesis
308    #[prost(message, repeated, tag = "2")]
309    pub gauges: ::prost::alloc::vec::Vec<Gauge>,
310    /// lockable_durations are all lockup durations that gauges can be locked for
311    /// in order to receive incentives
312    #[prost(message, repeated, tag = "3")]
313    pub lockable_durations: ::prost::alloc::vec::Vec<crate::shim::Duration>,
314    /// last_gauge_id is what the gauge number will increment from when creating
315    /// the next gauge after genesis
316    #[prost(uint64, tag = "4")]
317    #[serde(alias = "last_gaugeID")]
318    #[serde(
319        serialize_with = "crate::serde::as_str::serialize",
320        deserialize_with = "crate::serde::as_str::deserialize"
321    )]
322    pub last_gauge_id: u64,
323    /// gauges are all group gauges that should exist at genesis
324    #[prost(message, repeated, tag = "5")]
325    pub group_gauges: ::prost::alloc::vec::Vec<Gauge>,
326    /// groups are all the groups that should exist at genesis
327    #[prost(message, repeated, tag = "6")]
328    pub groups: ::prost::alloc::vec::Vec<Group>,
329}
330/// CreateGroupsProposal is a type for creating one or more groups via
331/// governance. This is useful for creating groups without having to pay
332/// creation fees.
333#[allow(clippy::derive_partial_eq_without_eq)]
334#[derive(
335    Clone,
336    PartialEq,
337    Eq,
338    ::prost::Message,
339    ::serde::Serialize,
340    ::serde::Deserialize,
341    ::schemars::JsonSchema,
342    CosmwasmExt,
343)]
344#[proto_message(type_url = "/osmosis.incentives.CreateGroupsProposal")]
345pub struct CreateGroupsProposal {
346    #[prost(string, tag = "1")]
347    pub title: ::prost::alloc::string::String,
348    #[prost(string, tag = "2")]
349    pub description: ::prost::alloc::string::String,
350    #[prost(message, repeated, tag = "3")]
351    pub create_groups: ::prost::alloc::vec::Vec<CreateGroup>,
352}
353#[allow(clippy::derive_partial_eq_without_eq)]
354#[derive(
355    Clone,
356    PartialEq,
357    Eq,
358    ::prost::Message,
359    ::serde::Serialize,
360    ::serde::Deserialize,
361    ::schemars::JsonSchema,
362    CosmwasmExt,
363)]
364#[proto_message(type_url = "/osmosis.incentives.ModuleToDistributeCoinsRequest")]
365#[proto_query(
366    path = "/osmosis.incentives.Query/ModuleToDistributeCoins",
367    response_type = ModuleToDistributeCoinsResponse
368)]
369pub struct ModuleToDistributeCoinsRequest {}
370#[allow(clippy::derive_partial_eq_without_eq)]
371#[derive(
372    Clone,
373    PartialEq,
374    Eq,
375    ::prost::Message,
376    ::serde::Serialize,
377    ::serde::Deserialize,
378    ::schemars::JsonSchema,
379    CosmwasmExt,
380)]
381#[proto_message(type_url = "/osmosis.incentives.ModuleToDistributeCoinsResponse")]
382pub struct ModuleToDistributeCoinsResponse {
383    /// Coins that have yet to be distributed
384    #[prost(message, repeated, tag = "1")]
385    pub coins: ::prost::alloc::vec::Vec<super::super::cosmos::base::v1beta1::Coin>,
386}
387#[allow(clippy::derive_partial_eq_without_eq)]
388#[derive(
389    Clone,
390    PartialEq,
391    Eq,
392    ::prost::Message,
393    ::serde::Serialize,
394    ::serde::Deserialize,
395    ::schemars::JsonSchema,
396    CosmwasmExt,
397)]
398#[proto_message(type_url = "/osmosis.incentives.GaugeByIDRequest")]
399#[proto_query(
400    path = "/osmosis.incentives.Query/GaugeByID",
401    response_type = GaugeByIdResponse
402)]
403pub struct GaugeByIdRequest {
404    /// Gauge ID being queried
405    #[prost(uint64, tag = "1")]
406    #[serde(alias = "ID")]
407    #[serde(
408        serialize_with = "crate::serde::as_str::serialize",
409        deserialize_with = "crate::serde::as_str::deserialize"
410    )]
411    pub id: u64,
412}
413#[allow(clippy::derive_partial_eq_without_eq)]
414#[derive(
415    Clone,
416    PartialEq,
417    Eq,
418    ::prost::Message,
419    ::serde::Serialize,
420    ::serde::Deserialize,
421    ::schemars::JsonSchema,
422    CosmwasmExt,
423)]
424#[proto_message(type_url = "/osmosis.incentives.GaugeByIDResponse")]
425pub struct GaugeByIdResponse {
426    /// Gauge that corresponds to provided gauge ID
427    #[prost(message, optional, tag = "1")]
428    pub gauge: ::core::option::Option<Gauge>,
429}
430#[allow(clippy::derive_partial_eq_without_eq)]
431#[derive(
432    Clone,
433    PartialEq,
434    Eq,
435    ::prost::Message,
436    ::serde::Serialize,
437    ::serde::Deserialize,
438    ::schemars::JsonSchema,
439    CosmwasmExt,
440)]
441#[proto_message(type_url = "/osmosis.incentives.GaugesRequest")]
442#[proto_query(path = "/osmosis.incentives.Query/Gauges", response_type = GaugesResponse)]
443pub struct GaugesRequest {
444    /// Pagination defines pagination for the request
445    #[prost(message, optional, tag = "1")]
446    pub pagination: ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageRequest>,
447}
448#[allow(clippy::derive_partial_eq_without_eq)]
449#[derive(
450    Clone,
451    PartialEq,
452    Eq,
453    ::prost::Message,
454    ::serde::Serialize,
455    ::serde::Deserialize,
456    ::schemars::JsonSchema,
457    CosmwasmExt,
458)]
459#[proto_message(type_url = "/osmosis.incentives.GaugesResponse")]
460pub struct GaugesResponse {
461    /// Upcoming and active gauges
462    #[prost(message, repeated, tag = "1")]
463    pub data: ::prost::alloc::vec::Vec<Gauge>,
464    /// Pagination defines pagination for the response
465    #[prost(message, optional, tag = "2")]
466    pub pagination:
467        ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageResponse>,
468}
469#[allow(clippy::derive_partial_eq_without_eq)]
470#[derive(
471    Clone,
472    PartialEq,
473    Eq,
474    ::prost::Message,
475    ::serde::Serialize,
476    ::serde::Deserialize,
477    ::schemars::JsonSchema,
478    CosmwasmExt,
479)]
480#[proto_message(type_url = "/osmosis.incentives.ActiveGaugesRequest")]
481#[proto_query(
482    path = "/osmosis.incentives.Query/ActiveGauges",
483    response_type = ActiveGaugesResponse
484)]
485pub struct ActiveGaugesRequest {
486    /// Pagination defines pagination for the request
487    #[prost(message, optional, tag = "1")]
488    pub pagination: ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageRequest>,
489}
490#[allow(clippy::derive_partial_eq_without_eq)]
491#[derive(
492    Clone,
493    PartialEq,
494    Eq,
495    ::prost::Message,
496    ::serde::Serialize,
497    ::serde::Deserialize,
498    ::schemars::JsonSchema,
499    CosmwasmExt,
500)]
501#[proto_message(type_url = "/osmosis.incentives.ActiveGaugesResponse")]
502pub struct ActiveGaugesResponse {
503    /// Active gauges only
504    #[prost(message, repeated, tag = "1")]
505    pub data: ::prost::alloc::vec::Vec<Gauge>,
506    /// Pagination defines pagination for the response
507    #[prost(message, optional, tag = "2")]
508    pub pagination:
509        ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageResponse>,
510}
511#[allow(clippy::derive_partial_eq_without_eq)]
512#[derive(
513    Clone,
514    PartialEq,
515    Eq,
516    ::prost::Message,
517    ::serde::Serialize,
518    ::serde::Deserialize,
519    ::schemars::JsonSchema,
520    CosmwasmExt,
521)]
522#[proto_message(type_url = "/osmosis.incentives.ActiveGaugesPerDenomRequest")]
523#[proto_query(
524    path = "/osmosis.incentives.Query/ActiveGaugesPerDenom",
525    response_type = ActiveGaugesPerDenomResponse
526)]
527pub struct ActiveGaugesPerDenomRequest {
528    /// Desired denom when querying active gauges
529    #[prost(string, tag = "1")]
530    pub denom: ::prost::alloc::string::String,
531    /// Pagination defines pagination for the request
532    #[prost(message, optional, tag = "2")]
533    pub pagination: ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageRequest>,
534}
535#[allow(clippy::derive_partial_eq_without_eq)]
536#[derive(
537    Clone,
538    PartialEq,
539    Eq,
540    ::prost::Message,
541    ::serde::Serialize,
542    ::serde::Deserialize,
543    ::schemars::JsonSchema,
544    CosmwasmExt,
545)]
546#[proto_message(type_url = "/osmosis.incentives.ActiveGaugesPerDenomResponse")]
547pub struct ActiveGaugesPerDenomResponse {
548    /// Active gauges that match denom in query
549    #[prost(message, repeated, tag = "1")]
550    pub data: ::prost::alloc::vec::Vec<Gauge>,
551    /// Pagination defines pagination for the response
552    #[prost(message, optional, tag = "2")]
553    pub pagination:
554        ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageResponse>,
555}
556#[allow(clippy::derive_partial_eq_without_eq)]
557#[derive(
558    Clone,
559    PartialEq,
560    Eq,
561    ::prost::Message,
562    ::serde::Serialize,
563    ::serde::Deserialize,
564    ::schemars::JsonSchema,
565    CosmwasmExt,
566)]
567#[proto_message(type_url = "/osmosis.incentives.UpcomingGaugesRequest")]
568#[proto_query(
569    path = "/osmosis.incentives.Query/UpcomingGauges",
570    response_type = UpcomingGaugesResponse
571)]
572pub struct UpcomingGaugesRequest {
573    /// Pagination defines pagination for the request
574    #[prost(message, optional, tag = "1")]
575    pub pagination: ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageRequest>,
576}
577#[allow(clippy::derive_partial_eq_without_eq)]
578#[derive(
579    Clone,
580    PartialEq,
581    Eq,
582    ::prost::Message,
583    ::serde::Serialize,
584    ::serde::Deserialize,
585    ::schemars::JsonSchema,
586    CosmwasmExt,
587)]
588#[proto_message(type_url = "/osmosis.incentives.UpcomingGaugesResponse")]
589pub struct UpcomingGaugesResponse {
590    /// Gauges whose distribution is upcoming
591    #[prost(message, repeated, tag = "1")]
592    pub data: ::prost::alloc::vec::Vec<Gauge>,
593    /// Pagination defines pagination for the response
594    #[prost(message, optional, tag = "2")]
595    pub pagination:
596        ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageResponse>,
597}
598#[allow(clippy::derive_partial_eq_without_eq)]
599#[derive(
600    Clone,
601    PartialEq,
602    Eq,
603    ::prost::Message,
604    ::serde::Serialize,
605    ::serde::Deserialize,
606    ::schemars::JsonSchema,
607    CosmwasmExt,
608)]
609#[proto_message(type_url = "/osmosis.incentives.UpcomingGaugesPerDenomRequest")]
610#[proto_query(
611    path = "/osmosis.incentives.Query/UpcomingGaugesPerDenom",
612    response_type = UpcomingGaugesPerDenomResponse
613)]
614pub struct UpcomingGaugesPerDenomRequest {
615    /// Filter for upcoming gauges that match specific denom
616    #[prost(string, tag = "1")]
617    pub denom: ::prost::alloc::string::String,
618    /// Pagination defines pagination for the request
619    #[prost(message, optional, tag = "2")]
620    pub pagination: ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageRequest>,
621}
622#[allow(clippy::derive_partial_eq_without_eq)]
623#[derive(
624    Clone,
625    PartialEq,
626    Eq,
627    ::prost::Message,
628    ::serde::Serialize,
629    ::serde::Deserialize,
630    ::schemars::JsonSchema,
631    CosmwasmExt,
632)]
633#[proto_message(type_url = "/osmosis.incentives.UpcomingGaugesPerDenomResponse")]
634pub struct UpcomingGaugesPerDenomResponse {
635    /// Upcoming gauges that match denom in query
636    #[prost(message, repeated, tag = "1")]
637    pub upcoming_gauges: ::prost::alloc::vec::Vec<Gauge>,
638    /// Pagination defines pagination for the response
639    #[prost(message, optional, tag = "2")]
640    pub pagination:
641        ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageResponse>,
642}
643#[allow(clippy::derive_partial_eq_without_eq)]
644#[derive(
645    Clone,
646    PartialEq,
647    Eq,
648    ::prost::Message,
649    ::serde::Serialize,
650    ::serde::Deserialize,
651    ::schemars::JsonSchema,
652    CosmwasmExt,
653)]
654#[proto_message(type_url = "/osmosis.incentives.RewardsEstRequest")]
655#[proto_query(
656    path = "/osmosis.incentives.Query/RewardsEst",
657    response_type = RewardsEstResponse
658)]
659pub struct RewardsEstRequest {
660    /// Address that is being queried for future estimated rewards
661    #[prost(string, tag = "1")]
662    pub owner: ::prost::alloc::string::String,
663    /// Lock IDs included in future reward estimation
664    #[prost(uint64, repeated, tag = "2")]
665    #[serde(alias = "lockIDs")]
666    #[serde(
667        serialize_with = "crate::serde::as_str_vec::serialize",
668        deserialize_with = "crate::serde::as_str_vec::deserialize"
669    )]
670    pub lock_ids: ::prost::alloc::vec::Vec<u64>,
671    /// Upper time limit of reward estimation
672    /// Lower limit is current epoch
673    #[prost(int64, tag = "3")]
674    #[serde(
675        serialize_with = "crate::serde::as_str::serialize",
676        deserialize_with = "crate::serde::as_str::deserialize"
677    )]
678    pub end_epoch: i64,
679}
680#[allow(clippy::derive_partial_eq_without_eq)]
681#[derive(
682    Clone,
683    PartialEq,
684    Eq,
685    ::prost::Message,
686    ::serde::Serialize,
687    ::serde::Deserialize,
688    ::schemars::JsonSchema,
689    CosmwasmExt,
690)]
691#[proto_message(type_url = "/osmosis.incentives.RewardsEstResponse")]
692pub struct RewardsEstResponse {
693    /// Estimated coin rewards that will be received at provided address
694    /// from specified locks between current time and end epoch
695    #[prost(message, repeated, tag = "1")]
696    pub coins: ::prost::alloc::vec::Vec<super::super::cosmos::base::v1beta1::Coin>,
697}
698#[allow(clippy::derive_partial_eq_without_eq)]
699#[derive(
700    Clone,
701    PartialEq,
702    Eq,
703    ::prost::Message,
704    ::serde::Serialize,
705    ::serde::Deserialize,
706    ::schemars::JsonSchema,
707    CosmwasmExt,
708)]
709#[proto_message(type_url = "/osmosis.incentives.QueryLockableDurationsRequest")]
710#[proto_query(
711    path = "/osmosis.incentives.Query/LockableDurations",
712    response_type = QueryLockableDurationsResponse
713)]
714pub struct QueryLockableDurationsRequest {}
715#[allow(clippy::derive_partial_eq_without_eq)]
716#[derive(
717    Clone,
718    PartialEq,
719    Eq,
720    ::prost::Message,
721    ::serde::Serialize,
722    ::serde::Deserialize,
723    ::schemars::JsonSchema,
724    CosmwasmExt,
725)]
726#[proto_message(type_url = "/osmosis.incentives.QueryLockableDurationsResponse")]
727pub struct QueryLockableDurationsResponse {
728    /// Time durations that users can lock coins for in order to receive rewards
729    #[prost(message, repeated, tag = "1")]
730    pub lockable_durations: ::prost::alloc::vec::Vec<crate::shim::Duration>,
731}
732#[allow(clippy::derive_partial_eq_without_eq)]
733#[derive(
734    Clone,
735    PartialEq,
736    Eq,
737    ::prost::Message,
738    ::serde::Serialize,
739    ::serde::Deserialize,
740    ::schemars::JsonSchema,
741    CosmwasmExt,
742)]
743#[proto_message(type_url = "/osmosis.incentives.QueryAllGroupsRequest")]
744#[proto_query(
745    path = "/osmosis.incentives.Query/AllGroups",
746    response_type = QueryAllGroupsResponse
747)]
748pub struct QueryAllGroupsRequest {}
749#[allow(clippy::derive_partial_eq_without_eq)]
750#[derive(
751    Clone,
752    PartialEq,
753    Eq,
754    ::prost::Message,
755    ::serde::Serialize,
756    ::serde::Deserialize,
757    ::schemars::JsonSchema,
758    CosmwasmExt,
759)]
760#[proto_message(type_url = "/osmosis.incentives.QueryAllGroupsResponse")]
761pub struct QueryAllGroupsResponse {
762    #[prost(message, repeated, tag = "1")]
763    pub groups: ::prost::alloc::vec::Vec<Group>,
764}
765#[allow(clippy::derive_partial_eq_without_eq)]
766#[derive(
767    Clone,
768    PartialEq,
769    Eq,
770    ::prost::Message,
771    ::serde::Serialize,
772    ::serde::Deserialize,
773    ::schemars::JsonSchema,
774    CosmwasmExt,
775)]
776#[proto_message(type_url = "/osmosis.incentives.QueryAllGroupsGaugesRequest")]
777#[proto_query(
778    path = "/osmosis.incentives.Query/AllGroupsGauges",
779    response_type = QueryAllGroupsGaugesResponse
780)]
781pub struct QueryAllGroupsGaugesRequest {}
782#[allow(clippy::derive_partial_eq_without_eq)]
783#[derive(
784    Clone,
785    PartialEq,
786    Eq,
787    ::prost::Message,
788    ::serde::Serialize,
789    ::serde::Deserialize,
790    ::schemars::JsonSchema,
791    CosmwasmExt,
792)]
793#[proto_message(type_url = "/osmosis.incentives.QueryAllGroupsGaugesResponse")]
794pub struct QueryAllGroupsGaugesResponse {
795    #[prost(message, repeated, tag = "1")]
796    pub gauges: ::prost::alloc::vec::Vec<Gauge>,
797}
798#[allow(clippy::derive_partial_eq_without_eq)]
799#[derive(
800    Clone,
801    PartialEq,
802    Eq,
803    ::prost::Message,
804    ::serde::Serialize,
805    ::serde::Deserialize,
806    ::schemars::JsonSchema,
807    CosmwasmExt,
808)]
809#[proto_message(type_url = "/osmosis.incentives.QueryAllGroupsWithGaugeRequest")]
810#[proto_query(
811    path = "/osmosis.incentives.Query/AllGroupsWithGauge",
812    response_type = QueryAllGroupsWithGaugeResponse
813)]
814pub struct QueryAllGroupsWithGaugeRequest {}
815#[allow(clippy::derive_partial_eq_without_eq)]
816#[derive(
817    Clone,
818    PartialEq,
819    Eq,
820    ::prost::Message,
821    ::serde::Serialize,
822    ::serde::Deserialize,
823    ::schemars::JsonSchema,
824    CosmwasmExt,
825)]
826#[proto_message(type_url = "/osmosis.incentives.QueryAllGroupsWithGaugeResponse")]
827pub struct QueryAllGroupsWithGaugeResponse {
828    #[prost(message, repeated, tag = "1")]
829    pub groups_with_gauge: ::prost::alloc::vec::Vec<GroupsWithGauge>,
830}
831#[allow(clippy::derive_partial_eq_without_eq)]
832#[derive(
833    Clone,
834    PartialEq,
835    Eq,
836    ::prost::Message,
837    ::serde::Serialize,
838    ::serde::Deserialize,
839    ::schemars::JsonSchema,
840    CosmwasmExt,
841)]
842#[proto_message(type_url = "/osmosis.incentives.QueryGroupByGroupGaugeIDRequest")]
843#[proto_query(
844    path = "/osmosis.incentives.Query/GroupByGroupGaugeID",
845    response_type = QueryGroupByGroupGaugeIdResponse
846)]
847pub struct QueryGroupByGroupGaugeIdRequest {
848    #[prost(uint64, tag = "1")]
849    #[serde(alias = "ID")]
850    #[serde(
851        serialize_with = "crate::serde::as_str::serialize",
852        deserialize_with = "crate::serde::as_str::deserialize"
853    )]
854    pub id: u64,
855}
856#[allow(clippy::derive_partial_eq_without_eq)]
857#[derive(
858    Clone,
859    PartialEq,
860    Eq,
861    ::prost::Message,
862    ::serde::Serialize,
863    ::serde::Deserialize,
864    ::schemars::JsonSchema,
865    CosmwasmExt,
866)]
867#[proto_message(type_url = "/osmosis.incentives.QueryGroupByGroupGaugeIDResponse")]
868pub struct QueryGroupByGroupGaugeIdResponse {
869    #[prost(message, optional, tag = "1")]
870    pub group: ::core::option::Option<Group>,
871}
872#[allow(clippy::derive_partial_eq_without_eq)]
873#[derive(
874    Clone,
875    PartialEq,
876    Eq,
877    ::prost::Message,
878    ::serde::Serialize,
879    ::serde::Deserialize,
880    ::schemars::JsonSchema,
881    CosmwasmExt,
882)]
883#[proto_message(type_url = "/osmosis.incentives.QueryCurrentWeightByGroupGaugeIDRequest")]
884#[proto_query(
885    path = "/osmosis.incentives.Query/CurrentWeightByGroupGaugeID",
886    response_type = QueryCurrentWeightByGroupGaugeIdResponse
887)]
888pub struct QueryCurrentWeightByGroupGaugeIdRequest {
889    #[prost(uint64, tag = "1")]
890    #[serde(alias = "group_gaugeID")]
891    #[serde(
892        serialize_with = "crate::serde::as_str::serialize",
893        deserialize_with = "crate::serde::as_str::deserialize"
894    )]
895    pub group_gauge_id: u64,
896}
897#[allow(clippy::derive_partial_eq_without_eq)]
898#[derive(
899    Clone,
900    PartialEq,
901    Eq,
902    ::prost::Message,
903    ::serde::Serialize,
904    ::serde::Deserialize,
905    ::schemars::JsonSchema,
906    CosmwasmExt,
907)]
908#[proto_message(type_url = "/osmosis.incentives.QueryCurrentWeightByGroupGaugeIDResponse")]
909pub struct QueryCurrentWeightByGroupGaugeIdResponse {
910    #[prost(message, repeated, tag = "1")]
911    pub gauge_weight: ::prost::alloc::vec::Vec<GaugeWeight>,
912}
913#[allow(clippy::derive_partial_eq_without_eq)]
914#[derive(
915    Clone,
916    PartialEq,
917    Eq,
918    ::prost::Message,
919    ::serde::Serialize,
920    ::serde::Deserialize,
921    ::schemars::JsonSchema,
922    CosmwasmExt,
923)]
924#[proto_message(type_url = "/osmosis.incentives.GaugeWeight")]
925pub struct GaugeWeight {
926    #[prost(uint64, tag = "1")]
927    #[serde(alias = "gaugeID")]
928    #[serde(
929        serialize_with = "crate::serde::as_str::serialize",
930        deserialize_with = "crate::serde::as_str::deserialize"
931    )]
932    pub gauge_id: u64,
933    #[prost(string, tag = "2")]
934    pub weight_ratio: ::prost::alloc::string::String,
935}
936#[allow(clippy::derive_partial_eq_without_eq)]
937#[derive(
938    Clone,
939    PartialEq,
940    Eq,
941    ::prost::Message,
942    ::serde::Serialize,
943    ::serde::Deserialize,
944    ::schemars::JsonSchema,
945    CosmwasmExt,
946)]
947#[proto_message(type_url = "/osmosis.incentives.QueryInternalGaugesRequest")]
948#[proto_query(
949    path = "/osmosis.incentives.Query/InternalGauges",
950    response_type = QueryInternalGaugesResponse
951)]
952pub struct QueryInternalGaugesRequest {
953    /// Pagination defines pagination for the request
954    #[prost(message, optional, tag = "1")]
955    pub pagination: ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageRequest>,
956}
957#[allow(clippy::derive_partial_eq_without_eq)]
958#[derive(
959    Clone,
960    PartialEq,
961    Eq,
962    ::prost::Message,
963    ::serde::Serialize,
964    ::serde::Deserialize,
965    ::schemars::JsonSchema,
966    CosmwasmExt,
967)]
968#[proto_message(type_url = "/osmosis.incentives.QueryInternalGaugesResponse")]
969pub struct QueryInternalGaugesResponse {
970    #[prost(message, repeated, tag = "1")]
971    pub gauges: ::prost::alloc::vec::Vec<Gauge>,
972    /// Pagination defines pagination for the response
973    #[prost(message, optional, tag = "2")]
974    pub pagination:
975        ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageResponse>,
976}
977#[allow(clippy::derive_partial_eq_without_eq)]
978#[derive(
979    Clone,
980    PartialEq,
981    Eq,
982    ::prost::Message,
983    ::serde::Serialize,
984    ::serde::Deserialize,
985    ::schemars::JsonSchema,
986    CosmwasmExt,
987)]
988#[proto_message(type_url = "/osmosis.incentives.QueryExternalGaugesRequest")]
989#[proto_query(
990    path = "/osmosis.incentives.Query/ExternalGauges",
991    response_type = QueryExternalGaugesResponse
992)]
993pub struct QueryExternalGaugesRequest {
994    /// Pagination defines pagination for the request
995    #[prost(message, optional, tag = "1")]
996    pub pagination: ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageRequest>,
997}
998#[allow(clippy::derive_partial_eq_without_eq)]
999#[derive(
1000    Clone,
1001    PartialEq,
1002    Eq,
1003    ::prost::Message,
1004    ::serde::Serialize,
1005    ::serde::Deserialize,
1006    ::schemars::JsonSchema,
1007    CosmwasmExt,
1008)]
1009#[proto_message(type_url = "/osmosis.incentives.QueryExternalGaugesResponse")]
1010pub struct QueryExternalGaugesResponse {
1011    #[prost(message, repeated, tag = "1")]
1012    pub gauges: ::prost::alloc::vec::Vec<Gauge>,
1013    /// Pagination defines pagination for the response
1014    #[prost(message, optional, tag = "2")]
1015    pub pagination:
1016        ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageResponse>,
1017}
1018#[allow(clippy::derive_partial_eq_without_eq)]
1019#[derive(
1020    Clone,
1021    PartialEq,
1022    Eq,
1023    ::prost::Message,
1024    ::serde::Serialize,
1025    ::serde::Deserialize,
1026    ::schemars::JsonSchema,
1027    CosmwasmExt,
1028)]
1029#[proto_message(type_url = "/osmosis.incentives.QueryGaugesByPoolIDRequest")]
1030#[proto_query(
1031    path = "/osmosis.incentives.Query/GaugesByPoolID",
1032    response_type = QueryGaugesByPoolIdResponse
1033)]
1034pub struct QueryGaugesByPoolIdRequest {
1035    #[prost(uint64, tag = "1")]
1036    #[serde(alias = "ID")]
1037    #[serde(
1038        serialize_with = "crate::serde::as_str::serialize",
1039        deserialize_with = "crate::serde::as_str::deserialize"
1040    )]
1041    pub id: u64,
1042    /// Pagination defines pagination for the request
1043    #[prost(message, optional, tag = "2")]
1044    pub pagination: ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageRequest>,
1045}
1046#[allow(clippy::derive_partial_eq_without_eq)]
1047#[derive(
1048    Clone,
1049    PartialEq,
1050    Eq,
1051    ::prost::Message,
1052    ::serde::Serialize,
1053    ::serde::Deserialize,
1054    ::schemars::JsonSchema,
1055    CosmwasmExt,
1056)]
1057#[proto_message(type_url = "/osmosis.incentives.QueryGaugesByPoolIDResponse")]
1058pub struct QueryGaugesByPoolIdResponse {
1059    #[prost(message, repeated, tag = "1")]
1060    pub gauges: ::prost::alloc::vec::Vec<Gauge>,
1061    /// Pagination defines pagination for the response
1062    #[prost(message, optional, tag = "2")]
1063    pub pagination:
1064        ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageResponse>,
1065}
1066#[allow(clippy::derive_partial_eq_without_eq)]
1067#[derive(
1068    Clone,
1069    PartialEq,
1070    Eq,
1071    ::prost::Message,
1072    ::serde::Serialize,
1073    ::serde::Deserialize,
1074    ::schemars::JsonSchema,
1075    CosmwasmExt,
1076)]
1077#[proto_message(type_url = "/osmosis.incentives.ParamsRequest")]
1078#[proto_query(path = "/osmosis.incentives.Query/Params", response_type = ParamsResponse)]
1079pub struct ParamsRequest {}
1080#[allow(clippy::derive_partial_eq_without_eq)]
1081#[derive(
1082    Clone,
1083    PartialEq,
1084    Eq,
1085    ::prost::Message,
1086    ::serde::Serialize,
1087    ::serde::Deserialize,
1088    ::schemars::JsonSchema,
1089    CosmwasmExt,
1090)]
1091#[proto_message(type_url = "/osmosis.incentives.ParamsResponse")]
1092pub struct ParamsResponse {
1093    #[prost(message, optional, tag = "1")]
1094    pub params: ::core::option::Option<Params>,
1095}
1096/// MsgCreateGauge creates a gauge to distribute rewards to users
1097#[allow(clippy::derive_partial_eq_without_eq)]
1098#[derive(
1099    Clone,
1100    PartialEq,
1101    Eq,
1102    ::prost::Message,
1103    ::serde::Serialize,
1104    ::serde::Deserialize,
1105    ::schemars::JsonSchema,
1106    CosmwasmExt,
1107)]
1108#[proto_message(type_url = "/osmosis.incentives.MsgCreateGauge")]
1109pub struct MsgCreateGauge {
1110    /// is_perpetual shows if it's a perpetual or non-perpetual gauge
1111    /// Non-perpetual gauges distribute their tokens equally per epoch while the
1112    /// gauge is in the active period. Perpetual gauges distribute all their tokens
1113    /// at a single time and only distribute their tokens again once the gauge is
1114    /// refilled
1115    #[prost(bool, tag = "1")]
1116    pub is_perpetual: bool,
1117    /// owner is the address of gauge creator
1118    #[prost(string, tag = "2")]
1119    pub owner: ::prost::alloc::string::String,
1120    /// distribute_to show which lock the gauge should distribute to by time
1121    /// duration or by timestamp
1122    #[prost(message, optional, tag = "3")]
1123    pub distribute_to: ::core::option::Option<super::lockup::QueryCondition>,
1124    /// coins are coin(s) to be distributed by the gauge
1125    #[prost(message, repeated, tag = "4")]
1126    pub coins: ::prost::alloc::vec::Vec<super::super::cosmos::base::v1beta1::Coin>,
1127    /// start_time is the distribution start time
1128    #[prost(message, optional, tag = "5")]
1129    pub start_time: ::core::option::Option<crate::shim::Timestamp>,
1130    /// num_epochs_paid_over is the number of epochs distribution will be completed
1131    /// over
1132    #[prost(uint64, tag = "6")]
1133    #[serde(
1134        serialize_with = "crate::serde::as_str::serialize",
1135        deserialize_with = "crate::serde::as_str::deserialize"
1136    )]
1137    pub num_epochs_paid_over: u64,
1138    /// pool_id is the ID of the pool that the gauge is meant to be associated
1139    /// with. if pool_id is set, then the "QueryCondition.LockQueryType" must be
1140    /// "NoLock" with all other fields of the "QueryCondition.LockQueryType" struct
1141    /// unset, including "QueryCondition.Denom". However, note that, internally,
1142    /// the empty string in "QueryCondition.Denom" ends up being overwritten with
1143    /// incentivestypes.NoLockExternalGaugeDenom(<pool-id>) so that the gauges
1144    /// associated with a pool can be queried by this prefix if needed.
1145    #[prost(uint64, tag = "7")]
1146    #[serde(alias = "poolID")]
1147    #[serde(
1148        serialize_with = "crate::serde::as_str::serialize",
1149        deserialize_with = "crate::serde::as_str::deserialize"
1150    )]
1151    pub pool_id: u64,
1152}
1153#[allow(clippy::derive_partial_eq_without_eq)]
1154#[derive(
1155    Clone,
1156    PartialEq,
1157    Eq,
1158    ::prost::Message,
1159    ::serde::Serialize,
1160    ::serde::Deserialize,
1161    ::schemars::JsonSchema,
1162    CosmwasmExt,
1163)]
1164#[proto_message(type_url = "/osmosis.incentives.MsgCreateGaugeResponse")]
1165pub struct MsgCreateGaugeResponse {}
1166/// MsgAddToGauge adds coins to a previously created gauge
1167#[allow(clippy::derive_partial_eq_without_eq)]
1168#[derive(
1169    Clone,
1170    PartialEq,
1171    Eq,
1172    ::prost::Message,
1173    ::serde::Serialize,
1174    ::serde::Deserialize,
1175    ::schemars::JsonSchema,
1176    CosmwasmExt,
1177)]
1178#[proto_message(type_url = "/osmosis.incentives.MsgAddToGauge")]
1179pub struct MsgAddToGauge {
1180    /// owner is the gauge owner's address
1181    #[prost(string, tag = "1")]
1182    pub owner: ::prost::alloc::string::String,
1183    /// gauge_id is the ID of gauge that rewards are getting added to
1184    #[prost(uint64, tag = "2")]
1185    #[serde(alias = "gaugeID")]
1186    #[serde(
1187        serialize_with = "crate::serde::as_str::serialize",
1188        deserialize_with = "crate::serde::as_str::deserialize"
1189    )]
1190    pub gauge_id: u64,
1191    /// rewards are the coin(s) to add to gauge
1192    #[prost(message, repeated, tag = "3")]
1193    pub rewards: ::prost::alloc::vec::Vec<super::super::cosmos::base::v1beta1::Coin>,
1194}
1195#[allow(clippy::derive_partial_eq_without_eq)]
1196#[derive(
1197    Clone,
1198    PartialEq,
1199    Eq,
1200    ::prost::Message,
1201    ::serde::Serialize,
1202    ::serde::Deserialize,
1203    ::schemars::JsonSchema,
1204    CosmwasmExt,
1205)]
1206#[proto_message(type_url = "/osmosis.incentives.MsgAddToGaugeResponse")]
1207pub struct MsgAddToGaugeResponse {}
1208/// MsgCreateGroup creates a group to distribute rewards to a group of pools
1209#[allow(clippy::derive_partial_eq_without_eq)]
1210#[derive(
1211    Clone,
1212    PartialEq,
1213    Eq,
1214    ::prost::Message,
1215    ::serde::Serialize,
1216    ::serde::Deserialize,
1217    ::schemars::JsonSchema,
1218    CosmwasmExt,
1219)]
1220#[proto_message(type_url = "/osmosis.incentives.MsgCreateGroup")]
1221pub struct MsgCreateGroup {
1222    /// coins are the provided coins that the group will distribute
1223    #[prost(message, repeated, tag = "1")]
1224    pub coins: ::prost::alloc::vec::Vec<super::super::cosmos::base::v1beta1::Coin>,
1225    /// num_epochs_paid_over is the number of epochs distribution will be completed
1226    /// in. 0 means it's perpetual
1227    #[prost(uint64, tag = "2")]
1228    #[serde(
1229        serialize_with = "crate::serde::as_str::serialize",
1230        deserialize_with = "crate::serde::as_str::deserialize"
1231    )]
1232    pub num_epochs_paid_over: u64,
1233    /// owner is the group owner's address
1234    #[prost(string, tag = "3")]
1235    pub owner: ::prost::alloc::string::String,
1236    /// pool_ids are the IDs of pools that the group is comprised of
1237    #[prost(uint64, repeated, tag = "4")]
1238    #[serde(alias = "poolIDs")]
1239    #[serde(
1240        serialize_with = "crate::serde::as_str_vec::serialize",
1241        deserialize_with = "crate::serde::as_str_vec::deserialize"
1242    )]
1243    pub pool_ids: ::prost::alloc::vec::Vec<u64>,
1244}
1245#[allow(clippy::derive_partial_eq_without_eq)]
1246#[derive(
1247    Clone,
1248    PartialEq,
1249    Eq,
1250    ::prost::Message,
1251    ::serde::Serialize,
1252    ::serde::Deserialize,
1253    ::schemars::JsonSchema,
1254    CosmwasmExt,
1255)]
1256#[proto_message(type_url = "/osmosis.incentives.MsgCreateGroupResponse")]
1257pub struct MsgCreateGroupResponse {
1258    /// group_id is the ID of the group that is created from this msg
1259    #[prost(uint64, tag = "1")]
1260    #[serde(alias = "groupID")]
1261    #[serde(
1262        serialize_with = "crate::serde::as_str::serialize",
1263        deserialize_with = "crate::serde::as_str::deserialize"
1264    )]
1265    pub group_id: u64,
1266}
1267pub struct IncentivesQuerier<'a, Q: cosmwasm_std::CustomQuery> {
1268    querier: &'a cosmwasm_std::QuerierWrapper<'a, Q>,
1269}
1270impl<'a, Q: cosmwasm_std::CustomQuery> IncentivesQuerier<'a, Q> {
1271    pub fn new(querier: &'a cosmwasm_std::QuerierWrapper<'a, Q>) -> Self {
1272        Self { querier }
1273    }
1274    pub fn module_to_distribute_coins(
1275        &self,
1276    ) -> Result<ModuleToDistributeCoinsResponse, cosmwasm_std::StdError> {
1277        ModuleToDistributeCoinsRequest {}.query(self.querier)
1278    }
1279    pub fn gauge_by_id(&self, id: u64) -> Result<GaugeByIdResponse, cosmwasm_std::StdError> {
1280        GaugeByIdRequest { id }.query(self.querier)
1281    }
1282    pub fn gauges(
1283        &self,
1284        pagination: ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageRequest>,
1285    ) -> Result<GaugesResponse, cosmwasm_std::StdError> {
1286        GaugesRequest { pagination }.query(self.querier)
1287    }
1288    pub fn active_gauges(
1289        &self,
1290        pagination: ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageRequest>,
1291    ) -> Result<ActiveGaugesResponse, cosmwasm_std::StdError> {
1292        ActiveGaugesRequest { pagination }.query(self.querier)
1293    }
1294    pub fn active_gauges_per_denom(
1295        &self,
1296        denom: ::prost::alloc::string::String,
1297        pagination: ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageRequest>,
1298    ) -> Result<ActiveGaugesPerDenomResponse, cosmwasm_std::StdError> {
1299        ActiveGaugesPerDenomRequest { denom, pagination }.query(self.querier)
1300    }
1301    pub fn upcoming_gauges(
1302        &self,
1303        pagination: ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageRequest>,
1304    ) -> Result<UpcomingGaugesResponse, cosmwasm_std::StdError> {
1305        UpcomingGaugesRequest { pagination }.query(self.querier)
1306    }
1307    pub fn upcoming_gauges_per_denom(
1308        &self,
1309        denom: ::prost::alloc::string::String,
1310        pagination: ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageRequest>,
1311    ) -> Result<UpcomingGaugesPerDenomResponse, cosmwasm_std::StdError> {
1312        UpcomingGaugesPerDenomRequest { denom, pagination }.query(self.querier)
1313    }
1314    pub fn rewards_est(
1315        &self,
1316        owner: ::prost::alloc::string::String,
1317        lock_ids: ::prost::alloc::vec::Vec<u64>,
1318        end_epoch: i64,
1319    ) -> Result<RewardsEstResponse, cosmwasm_std::StdError> {
1320        RewardsEstRequest {
1321            owner,
1322            lock_ids,
1323            end_epoch,
1324        }
1325        .query(self.querier)
1326    }
1327    pub fn lockable_durations(
1328        &self,
1329    ) -> Result<QueryLockableDurationsResponse, cosmwasm_std::StdError> {
1330        QueryLockableDurationsRequest {}.query(self.querier)
1331    }
1332    pub fn all_groups(&self) -> Result<QueryAllGroupsResponse, cosmwasm_std::StdError> {
1333        QueryAllGroupsRequest {}.query(self.querier)
1334    }
1335    pub fn all_groups_gauges(
1336        &self,
1337    ) -> Result<QueryAllGroupsGaugesResponse, cosmwasm_std::StdError> {
1338        QueryAllGroupsGaugesRequest {}.query(self.querier)
1339    }
1340    pub fn all_groups_with_gauge(
1341        &self,
1342    ) -> Result<QueryAllGroupsWithGaugeResponse, cosmwasm_std::StdError> {
1343        QueryAllGroupsWithGaugeRequest {}.query(self.querier)
1344    }
1345    pub fn group_by_group_gauge_id(
1346        &self,
1347        id: u64,
1348    ) -> Result<QueryGroupByGroupGaugeIdResponse, cosmwasm_std::StdError> {
1349        QueryGroupByGroupGaugeIdRequest { id }.query(self.querier)
1350    }
1351    pub fn current_weight_by_group_gauge_id(
1352        &self,
1353        group_gauge_id: u64,
1354    ) -> Result<QueryCurrentWeightByGroupGaugeIdResponse, cosmwasm_std::StdError> {
1355        QueryCurrentWeightByGroupGaugeIdRequest { group_gauge_id }.query(self.querier)
1356    }
1357    pub fn internal_gauges(
1358        &self,
1359        pagination: ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageRequest>,
1360    ) -> Result<QueryInternalGaugesResponse, cosmwasm_std::StdError> {
1361        QueryInternalGaugesRequest { pagination }.query(self.querier)
1362    }
1363    pub fn external_gauges(
1364        &self,
1365        pagination: ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageRequest>,
1366    ) -> Result<QueryExternalGaugesResponse, cosmwasm_std::StdError> {
1367        QueryExternalGaugesRequest { pagination }.query(self.querier)
1368    }
1369    pub fn gauges_by_pool_id(
1370        &self,
1371        id: u64,
1372        pagination: ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageRequest>,
1373    ) -> Result<QueryGaugesByPoolIdResponse, cosmwasm_std::StdError> {
1374        QueryGaugesByPoolIdRequest { id, pagination }.query(self.querier)
1375    }
1376    pub fn params(&self) -> Result<ParamsResponse, cosmwasm_std::StdError> {
1377        ParamsRequest {}.query(self.querier)
1378    }
1379}
osmosis_std/types/osmosis/incentives.rs

osmosis_std/types/osmosis/
incentives.rs
