osmosis_std/types/osmosis/
lockup.rs

1use osmosis_std_derive::CosmwasmExt;
2/// PeriodLock is a single lock unit by period defined by the x/lockup module.
3/// It's a record of a locked coin at a specific time. It stores owner, duration,
4/// unlock time and the number of coins locked. A state of a period lock is
5/// created upon lock creation, and deleted once the lock has been matured after
6/// the `duration` has passed since unbonding started.
7#[allow(clippy::derive_partial_eq_without_eq)]
8#[derive(
9    Clone,
10    PartialEq,
11    Eq,
12    ::prost::Message,
13    ::serde::Serialize,
14    ::serde::Deserialize,
15    ::schemars::JsonSchema,
16    CosmwasmExt,
17)]
18#[proto_message(type_url = "/osmosis.lockup.PeriodLock")]
19pub struct PeriodLock {
20    /// ID is the unique id of the lock.
21    /// The ID of the lock is decided upon lock creation, incrementing by 1 for
22    /// every lock.
23    #[prost(uint64, tag = "1")]
24    #[serde(alias = "ID")]
25    #[serde(
26        serialize_with = "crate::serde::as_str::serialize",
27        deserialize_with = "crate::serde::as_str::deserialize"
28    )]
29    pub id: u64,
30    /// Owner is the account address of the lock owner.
31    /// Only the owner can modify the state of the lock.
32    #[prost(string, tag = "2")]
33    pub owner: ::prost::alloc::string::String,
34    /// Duration is the time needed for a lock to mature after unlocking has
35    /// started.
36    #[prost(message, optional, tag = "3")]
37    pub duration: ::core::option::Option<crate::shim::Duration>,
38    /// EndTime refers to the time at which the lock would mature and get deleted.
39    /// This value is first initialized when an unlock has started for the lock,
40    /// end time being block time + duration.
41    #[prost(message, optional, tag = "4")]
42    pub end_time: ::core::option::Option<crate::shim::Timestamp>,
43    /// Coins are the tokens locked within the lock, kept in the module account.
44    #[prost(message, repeated, tag = "5")]
45    pub coins: ::prost::alloc::vec::Vec<super::super::cosmos::base::v1beta1::Coin>,
46    /// Reward Receiver Address is the address that would be receiving rewards for
47    /// the incentives for the lock. This is set to owner by default and can be
48    /// changed via separate msg.
49    #[prost(string, tag = "6")]
50    pub reward_receiver_address: ::prost::alloc::string::String,
51}
52/// QueryCondition is a struct used for querying locks upon different conditions.
53/// Duration field and timestamp fields could be optional, depending on the
54/// LockQueryType.
55#[allow(clippy::derive_partial_eq_without_eq)]
56#[derive(
57    Clone,
58    PartialEq,
59    Eq,
60    ::prost::Message,
61    ::serde::Serialize,
62    ::serde::Deserialize,
63    ::schemars::JsonSchema,
64    CosmwasmExt,
65)]
66#[proto_message(type_url = "/osmosis.lockup.QueryCondition")]
67pub struct QueryCondition {
68    /// LockQueryType is a type of lock query, ByLockDuration | ByLockTime
69    #[prost(enumeration = "LockQueryType", tag = "1")]
70    #[serde(
71        serialize_with = "crate::serde::as_str::serialize",
72        deserialize_with = "crate::serde::as_str::deserialize"
73    )]
74    pub lock_query_type: i32,
75    /// Denom represents the token denomination we are looking to lock up
76    #[prost(string, tag = "2")]
77    pub denom: ::prost::alloc::string::String,
78    /// Duration is used to query locks with longer duration than the specified
79    /// duration. Duration field must not be nil when the lock query type is
80    /// `ByLockDuration`.
81    #[prost(message, optional, tag = "3")]
82    pub duration: ::core::option::Option<crate::shim::Duration>,
83    /// Timestamp is used by locks started before the specified duration.
84    /// Timestamp field must not be nil when the lock query type is `ByLockTime`.
85    /// Querying locks with timestamp is currently not implemented.
86    #[prost(message, optional, tag = "4")]
87    pub timestamp: ::core::option::Option<crate::shim::Timestamp>,
88}
89/// SyntheticLock is creating virtual lockup where new denom is combination of
90/// original denom and synthetic suffix. At the time of synthetic lockup creation
91/// and deletion, accumulation store is also being updated and on querier side,
92/// they can query as freely as native lockup.
93#[allow(clippy::derive_partial_eq_without_eq)]
94#[derive(
95    Clone,
96    PartialEq,
97    Eq,
98    ::prost::Message,
99    ::serde::Serialize,
100    ::serde::Deserialize,
101    ::schemars::JsonSchema,
102    CosmwasmExt,
103)]
104#[proto_message(type_url = "/osmosis.lockup.SyntheticLock")]
105pub struct SyntheticLock {
106    /// Underlying Lock ID is the underlying native lock's id for this synthetic
107    /// lockup. A synthetic lock MUST have an underlying lock.
108    #[prost(uint64, tag = "1")]
109    #[serde(alias = "underlying_lockID")]
110    #[serde(
111        serialize_with = "crate::serde::as_str::serialize",
112        deserialize_with = "crate::serde::as_str::deserialize"
113    )]
114    pub underlying_lock_id: u64,
115    /// SynthDenom is the synthetic denom that is a combination of
116    /// gamm share + bonding status + validator address.
117    #[prost(string, tag = "2")]
118    pub synth_denom: ::prost::alloc::string::String,
119    /// used for unbonding synthetic lockups, for active synthetic lockups, this
120    /// value is set to uninitialized value
121    #[prost(message, optional, tag = "3")]
122    pub end_time: ::core::option::Option<crate::shim::Timestamp>,
123    /// Duration is the duration for a synthetic lock to mature
124    /// at the point of unbonding has started.
125    #[prost(message, optional, tag = "4")]
126    pub duration: ::core::option::Option<crate::shim::Duration>,
127}
128/// LockQueryType defines the type of the lock query that can
129/// either be by duration or start time of the lock.
130#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
131#[repr(i32)]
132#[derive(::serde::Serialize, ::serde::Deserialize, ::schemars::JsonSchema)]
133pub enum LockQueryType {
134    ByDuration = 0,
135    ByTime = 1,
136    NoLock = 2,
137    ByGroup = 3,
138}
139impl LockQueryType {
140    /// String value of the enum field names used in the ProtoBuf definition.
141    ///
142    /// The values are not transformed in any way and thus are considered stable
143    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
144    pub fn as_str_name(&self) -> &'static str {
145        match self {
146            LockQueryType::ByDuration => "ByDuration",
147            LockQueryType::ByTime => "ByTime",
148            LockQueryType::NoLock => "NoLock",
149            LockQueryType::ByGroup => "ByGroup",
150        }
151    }
152    /// Creates an enum from field names used in the ProtoBuf definition.
153    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
154        match value {
155            "ByDuration" => Some(Self::ByDuration),
156            "ByTime" => Some(Self::ByTime),
157            "NoLock" => Some(Self::NoLock),
158            "ByGroup" => Some(Self::ByGroup),
159            _ => None,
160        }
161    }
162}
163#[allow(clippy::derive_partial_eq_without_eq)]
164#[derive(
165    Clone,
166    PartialEq,
167    Eq,
168    ::prost::Message,
169    ::serde::Serialize,
170    ::serde::Deserialize,
171    ::schemars::JsonSchema,
172    CosmwasmExt,
173)]
174#[proto_message(type_url = "/osmosis.lockup.Params")]
175pub struct Params {
176    #[prost(string, repeated, tag = "1")]
177    pub force_unlock_allowed_addresses: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
178}
179/// GenesisState defines the lockup module's genesis state.
180#[allow(clippy::derive_partial_eq_without_eq)]
181#[derive(
182    Clone,
183    PartialEq,
184    Eq,
185    ::prost::Message,
186    ::serde::Serialize,
187    ::serde::Deserialize,
188    ::schemars::JsonSchema,
189    CosmwasmExt,
190)]
191#[proto_message(type_url = "/osmosis.lockup.GenesisState")]
192pub struct GenesisState {
193    #[prost(uint64, tag = "1")]
194    #[serde(alias = "last_lockID")]
195    #[serde(
196        serialize_with = "crate::serde::as_str::serialize",
197        deserialize_with = "crate::serde::as_str::deserialize"
198    )]
199    pub last_lock_id: u64,
200    #[prost(message, repeated, tag = "2")]
201    pub locks: ::prost::alloc::vec::Vec<PeriodLock>,
202    #[prost(message, repeated, tag = "3")]
203    pub synthetic_locks: ::prost::alloc::vec::Vec<SyntheticLock>,
204    #[prost(message, optional, tag = "4")]
205    pub params: ::core::option::Option<Params>,
206}
207#[allow(clippy::derive_partial_eq_without_eq)]
208#[derive(
209    Clone,
210    PartialEq,
211    Eq,
212    ::prost::Message,
213    ::serde::Serialize,
214    ::serde::Deserialize,
215    ::schemars::JsonSchema,
216    CosmwasmExt,
217)]
218#[proto_message(type_url = "/osmosis.lockup.ModuleBalanceRequest")]
219#[proto_query(
220    path = "/osmosis.lockup.Query/ModuleBalance",
221    response_type = ModuleBalanceResponse
222)]
223pub struct ModuleBalanceRequest {}
224#[allow(clippy::derive_partial_eq_without_eq)]
225#[derive(
226    Clone,
227    PartialEq,
228    Eq,
229    ::prost::Message,
230    ::serde::Serialize,
231    ::serde::Deserialize,
232    ::schemars::JsonSchema,
233    CosmwasmExt,
234)]
235#[proto_message(type_url = "/osmosis.lockup.ModuleBalanceResponse")]
236pub struct ModuleBalanceResponse {
237    #[prost(message, repeated, tag = "1")]
238    pub coins: ::prost::alloc::vec::Vec<super::super::cosmos::base::v1beta1::Coin>,
239}
240#[allow(clippy::derive_partial_eq_without_eq)]
241#[derive(
242    Clone,
243    PartialEq,
244    Eq,
245    ::prost::Message,
246    ::serde::Serialize,
247    ::serde::Deserialize,
248    ::schemars::JsonSchema,
249    CosmwasmExt,
250)]
251#[proto_message(type_url = "/osmosis.lockup.ModuleLockedAmountRequest")]
252#[proto_query(
253    path = "/osmosis.lockup.Query/ModuleLockedAmount",
254    response_type = ModuleLockedAmountResponse
255)]
256pub struct ModuleLockedAmountRequest {}
257#[allow(clippy::derive_partial_eq_without_eq)]
258#[derive(
259    Clone,
260    PartialEq,
261    Eq,
262    ::prost::Message,
263    ::serde::Serialize,
264    ::serde::Deserialize,
265    ::schemars::JsonSchema,
266    CosmwasmExt,
267)]
268#[proto_message(type_url = "/osmosis.lockup.ModuleLockedAmountResponse")]
269pub struct ModuleLockedAmountResponse {
270    #[prost(message, repeated, tag = "1")]
271    pub coins: ::prost::alloc::vec::Vec<super::super::cosmos::base::v1beta1::Coin>,
272}
273#[allow(clippy::derive_partial_eq_without_eq)]
274#[derive(
275    Clone,
276    PartialEq,
277    Eq,
278    ::prost::Message,
279    ::serde::Serialize,
280    ::serde::Deserialize,
281    ::schemars::JsonSchema,
282    CosmwasmExt,
283)]
284#[proto_message(type_url = "/osmosis.lockup.AccountUnlockableCoinsRequest")]
285#[proto_query(
286    path = "/osmosis.lockup.Query/AccountUnlockableCoins",
287    response_type = AccountUnlockableCoinsResponse
288)]
289pub struct AccountUnlockableCoinsRequest {
290    #[prost(string, tag = "1")]
291    pub owner: ::prost::alloc::string::String,
292}
293#[allow(clippy::derive_partial_eq_without_eq)]
294#[derive(
295    Clone,
296    PartialEq,
297    Eq,
298    ::prost::Message,
299    ::serde::Serialize,
300    ::serde::Deserialize,
301    ::schemars::JsonSchema,
302    CosmwasmExt,
303)]
304#[proto_message(type_url = "/osmosis.lockup.AccountUnlockableCoinsResponse")]
305pub struct AccountUnlockableCoinsResponse {
306    #[prost(message, repeated, tag = "1")]
307    pub coins: ::prost::alloc::vec::Vec<super::super::cosmos::base::v1beta1::Coin>,
308}
309#[allow(clippy::derive_partial_eq_without_eq)]
310#[derive(
311    Clone,
312    PartialEq,
313    Eq,
314    ::prost::Message,
315    ::serde::Serialize,
316    ::serde::Deserialize,
317    ::schemars::JsonSchema,
318    CosmwasmExt,
319)]
320#[proto_message(type_url = "/osmosis.lockup.AccountUnlockingCoinsRequest")]
321#[proto_query(
322    path = "/osmosis.lockup.Query/AccountUnlockingCoins",
323    response_type = AccountUnlockingCoinsResponse
324)]
325pub struct AccountUnlockingCoinsRequest {
326    #[prost(string, tag = "1")]
327    pub owner: ::prost::alloc::string::String,
328}
329#[allow(clippy::derive_partial_eq_without_eq)]
330#[derive(
331    Clone,
332    PartialEq,
333    Eq,
334    ::prost::Message,
335    ::serde::Serialize,
336    ::serde::Deserialize,
337    ::schemars::JsonSchema,
338    CosmwasmExt,
339)]
340#[proto_message(type_url = "/osmosis.lockup.AccountUnlockingCoinsResponse")]
341pub struct AccountUnlockingCoinsResponse {
342    #[prost(message, repeated, tag = "1")]
343    pub coins: ::prost::alloc::vec::Vec<super::super::cosmos::base::v1beta1::Coin>,
344}
345#[allow(clippy::derive_partial_eq_without_eq)]
346#[derive(
347    Clone,
348    PartialEq,
349    Eq,
350    ::prost::Message,
351    ::serde::Serialize,
352    ::serde::Deserialize,
353    ::schemars::JsonSchema,
354    CosmwasmExt,
355)]
356#[proto_message(type_url = "/osmosis.lockup.AccountLockedCoinsRequest")]
357#[proto_query(
358    path = "/osmosis.lockup.Query/AccountLockedCoins",
359    response_type = AccountLockedCoinsResponse
360)]
361pub struct AccountLockedCoinsRequest {
362    #[prost(string, tag = "1")]
363    pub owner: ::prost::alloc::string::String,
364}
365#[allow(clippy::derive_partial_eq_without_eq)]
366#[derive(
367    Clone,
368    PartialEq,
369    Eq,
370    ::prost::Message,
371    ::serde::Serialize,
372    ::serde::Deserialize,
373    ::schemars::JsonSchema,
374    CosmwasmExt,
375)]
376#[proto_message(type_url = "/osmosis.lockup.AccountLockedCoinsResponse")]
377pub struct AccountLockedCoinsResponse {
378    #[prost(message, repeated, tag = "1")]
379    pub coins: ::prost::alloc::vec::Vec<super::super::cosmos::base::v1beta1::Coin>,
380}
381#[allow(clippy::derive_partial_eq_without_eq)]
382#[derive(
383    Clone,
384    PartialEq,
385    Eq,
386    ::prost::Message,
387    ::serde::Serialize,
388    ::serde::Deserialize,
389    ::schemars::JsonSchema,
390    CosmwasmExt,
391)]
392#[proto_message(type_url = "/osmosis.lockup.AccountLockedPastTimeRequest")]
393#[proto_query(
394    path = "/osmosis.lockup.Query/AccountLockedPastTime",
395    response_type = AccountLockedPastTimeResponse
396)]
397pub struct AccountLockedPastTimeRequest {
398    #[prost(string, tag = "1")]
399    pub owner: ::prost::alloc::string::String,
400    #[prost(message, optional, tag = "2")]
401    pub timestamp: ::core::option::Option<crate::shim::Timestamp>,
402}
403#[allow(clippy::derive_partial_eq_without_eq)]
404#[derive(
405    Clone,
406    PartialEq,
407    Eq,
408    ::prost::Message,
409    ::serde::Serialize,
410    ::serde::Deserialize,
411    ::schemars::JsonSchema,
412    CosmwasmExt,
413)]
414#[proto_message(type_url = "/osmosis.lockup.AccountLockedPastTimeResponse")]
415pub struct AccountLockedPastTimeResponse {
416    #[prost(message, repeated, tag = "1")]
417    pub locks: ::prost::alloc::vec::Vec<PeriodLock>,
418}
419#[allow(clippy::derive_partial_eq_without_eq)]
420#[derive(
421    Clone,
422    PartialEq,
423    Eq,
424    ::prost::Message,
425    ::serde::Serialize,
426    ::serde::Deserialize,
427    ::schemars::JsonSchema,
428    CosmwasmExt,
429)]
430#[proto_message(type_url = "/osmosis.lockup.AccountLockedPastTimeNotUnlockingOnlyRequest")]
431#[proto_query(
432    path = "/osmosis.lockup.Query/AccountLockedPastTimeNotUnlockingOnly",
433    response_type = AccountLockedPastTimeNotUnlockingOnlyResponse
434)]
435pub struct AccountLockedPastTimeNotUnlockingOnlyRequest {
436    #[prost(string, tag = "1")]
437    pub owner: ::prost::alloc::string::String,
438    #[prost(message, optional, tag = "2")]
439    pub timestamp: ::core::option::Option<crate::shim::Timestamp>,
440}
441#[allow(clippy::derive_partial_eq_without_eq)]
442#[derive(
443    Clone,
444    PartialEq,
445    Eq,
446    ::prost::Message,
447    ::serde::Serialize,
448    ::serde::Deserialize,
449    ::schemars::JsonSchema,
450    CosmwasmExt,
451)]
452#[proto_message(type_url = "/osmosis.lockup.AccountLockedPastTimeNotUnlockingOnlyResponse")]
453pub struct AccountLockedPastTimeNotUnlockingOnlyResponse {
454    #[prost(message, repeated, tag = "1")]
455    pub locks: ::prost::alloc::vec::Vec<PeriodLock>,
456}
457#[allow(clippy::derive_partial_eq_without_eq)]
458#[derive(
459    Clone,
460    PartialEq,
461    Eq,
462    ::prost::Message,
463    ::serde::Serialize,
464    ::serde::Deserialize,
465    ::schemars::JsonSchema,
466    CosmwasmExt,
467)]
468#[proto_message(type_url = "/osmosis.lockup.AccountUnlockedBeforeTimeRequest")]
469#[proto_query(
470    path = "/osmosis.lockup.Query/AccountUnlockedBeforeTime",
471    response_type = AccountUnlockedBeforeTimeResponse
472)]
473pub struct AccountUnlockedBeforeTimeRequest {
474    #[prost(string, tag = "1")]
475    pub owner: ::prost::alloc::string::String,
476    #[prost(message, optional, tag = "2")]
477    pub timestamp: ::core::option::Option<crate::shim::Timestamp>,
478}
479#[allow(clippy::derive_partial_eq_without_eq)]
480#[derive(
481    Clone,
482    PartialEq,
483    Eq,
484    ::prost::Message,
485    ::serde::Serialize,
486    ::serde::Deserialize,
487    ::schemars::JsonSchema,
488    CosmwasmExt,
489)]
490#[proto_message(type_url = "/osmosis.lockup.AccountUnlockedBeforeTimeResponse")]
491pub struct AccountUnlockedBeforeTimeResponse {
492    #[prost(message, repeated, tag = "1")]
493    pub locks: ::prost::alloc::vec::Vec<PeriodLock>,
494}
495#[allow(clippy::derive_partial_eq_without_eq)]
496#[derive(
497    Clone,
498    PartialEq,
499    Eq,
500    ::prost::Message,
501    ::serde::Serialize,
502    ::serde::Deserialize,
503    ::schemars::JsonSchema,
504    CosmwasmExt,
505)]
506#[proto_message(type_url = "/osmosis.lockup.AccountLockedPastTimeDenomRequest")]
507#[proto_query(
508    path = "/osmosis.lockup.Query/AccountLockedPastTimeDenom",
509    response_type = AccountLockedPastTimeDenomResponse
510)]
511pub struct AccountLockedPastTimeDenomRequest {
512    #[prost(string, tag = "1")]
513    pub owner: ::prost::alloc::string::String,
514    #[prost(message, optional, tag = "2")]
515    pub timestamp: ::core::option::Option<crate::shim::Timestamp>,
516    #[prost(string, tag = "3")]
517    pub denom: ::prost::alloc::string::String,
518}
519#[allow(clippy::derive_partial_eq_without_eq)]
520#[derive(
521    Clone,
522    PartialEq,
523    Eq,
524    ::prost::Message,
525    ::serde::Serialize,
526    ::serde::Deserialize,
527    ::schemars::JsonSchema,
528    CosmwasmExt,
529)]
530#[proto_message(type_url = "/osmosis.lockup.AccountLockedPastTimeDenomResponse")]
531pub struct AccountLockedPastTimeDenomResponse {
532    #[prost(message, repeated, tag = "1")]
533    pub locks: ::prost::alloc::vec::Vec<PeriodLock>,
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.lockup.LockedDenomRequest")]
547#[proto_query(
548    path = "/osmosis.lockup.Query/LockedDenom",
549    response_type = LockedDenomResponse
550)]
551pub struct LockedDenomRequest {
552    #[prost(string, tag = "1")]
553    pub denom: ::prost::alloc::string::String,
554    #[prost(message, optional, tag = "2")]
555    pub duration: ::core::option::Option<crate::shim::Duration>,
556}
557#[allow(clippy::derive_partial_eq_without_eq)]
558#[derive(
559    Clone,
560    PartialEq,
561    Eq,
562    ::prost::Message,
563    ::serde::Serialize,
564    ::serde::Deserialize,
565    ::schemars::JsonSchema,
566    CosmwasmExt,
567)]
568#[proto_message(type_url = "/osmosis.lockup.LockedDenomResponse")]
569pub struct LockedDenomResponse {
570    #[prost(string, tag = "1")]
571    pub amount: ::prost::alloc::string::String,
572}
573#[allow(clippy::derive_partial_eq_without_eq)]
574#[derive(
575    Clone,
576    PartialEq,
577    Eq,
578    ::prost::Message,
579    ::serde::Serialize,
580    ::serde::Deserialize,
581    ::schemars::JsonSchema,
582    CosmwasmExt,
583)]
584#[proto_message(type_url = "/osmosis.lockup.LockedRequest")]
585#[proto_query(path = "/osmosis.lockup.Query/LockedByID", response_type = LockedResponse)]
586pub struct LockedRequest {
587    #[prost(uint64, tag = "1")]
588    #[serde(alias = "lockID")]
589    #[serde(
590        serialize_with = "crate::serde::as_str::serialize",
591        deserialize_with = "crate::serde::as_str::deserialize"
592    )]
593    pub lock_id: u64,
594}
595#[allow(clippy::derive_partial_eq_without_eq)]
596#[derive(
597    Clone,
598    PartialEq,
599    Eq,
600    ::prost::Message,
601    ::serde::Serialize,
602    ::serde::Deserialize,
603    ::schemars::JsonSchema,
604    CosmwasmExt,
605)]
606#[proto_message(type_url = "/osmosis.lockup.LockedResponse")]
607pub struct LockedResponse {
608    #[prost(message, optional, tag = "1")]
609    pub lock: ::core::option::Option<PeriodLock>,
610}
611#[allow(clippy::derive_partial_eq_without_eq)]
612#[derive(
613    Clone,
614    PartialEq,
615    Eq,
616    ::prost::Message,
617    ::serde::Serialize,
618    ::serde::Deserialize,
619    ::schemars::JsonSchema,
620    CosmwasmExt,
621)]
622#[proto_message(type_url = "/osmosis.lockup.LockRewardReceiverRequest")]
623#[proto_query(
624    path = "/osmosis.lockup.Query/LockRewardReceiver",
625    response_type = LockRewardReceiverResponse
626)]
627pub struct LockRewardReceiverRequest {
628    #[prost(uint64, tag = "1")]
629    #[serde(alias = "lockID")]
630    #[serde(
631        serialize_with = "crate::serde::as_str::serialize",
632        deserialize_with = "crate::serde::as_str::deserialize"
633    )]
634    pub lock_id: u64,
635}
636#[allow(clippy::derive_partial_eq_without_eq)]
637#[derive(
638    Clone,
639    PartialEq,
640    Eq,
641    ::prost::Message,
642    ::serde::Serialize,
643    ::serde::Deserialize,
644    ::schemars::JsonSchema,
645    CosmwasmExt,
646)]
647#[proto_message(type_url = "/osmosis.lockup.LockRewardReceiverResponse")]
648pub struct LockRewardReceiverResponse {
649    #[prost(string, tag = "1")]
650    pub reward_receiver: ::prost::alloc::string::String,
651}
652#[allow(clippy::derive_partial_eq_without_eq)]
653#[derive(
654    Clone,
655    PartialEq,
656    Eq,
657    ::prost::Message,
658    ::serde::Serialize,
659    ::serde::Deserialize,
660    ::schemars::JsonSchema,
661    CosmwasmExt,
662)]
663#[proto_message(type_url = "/osmosis.lockup.NextLockIDRequest")]
664#[proto_query(
665    path = "/osmosis.lockup.Query/NextLockID",
666    response_type = NextLockIdResponse
667)]
668pub struct NextLockIdRequest {}
669#[allow(clippy::derive_partial_eq_without_eq)]
670#[derive(
671    Clone,
672    PartialEq,
673    Eq,
674    ::prost::Message,
675    ::serde::Serialize,
676    ::serde::Deserialize,
677    ::schemars::JsonSchema,
678    CosmwasmExt,
679)]
680#[proto_message(type_url = "/osmosis.lockup.NextLockIDResponse")]
681pub struct NextLockIdResponse {
682    #[prost(uint64, tag = "1")]
683    #[serde(alias = "lockID")]
684    #[serde(
685        serialize_with = "crate::serde::as_str::serialize",
686        deserialize_with = "crate::serde::as_str::deserialize"
687    )]
688    pub lock_id: u64,
689}
690#[allow(clippy::derive_partial_eq_without_eq)]
691#[derive(
692    Clone,
693    PartialEq,
694    Eq,
695    ::prost::Message,
696    ::serde::Serialize,
697    ::serde::Deserialize,
698    ::schemars::JsonSchema,
699    CosmwasmExt,
700)]
701#[proto_message(type_url = "/osmosis.lockup.SyntheticLockupsByLockupIDRequest")]
702#[proto_query(
703    path = "/osmosis.lockup.Query/SyntheticLockupsByLockupID",
704    response_type = SyntheticLockupsByLockupIdResponse
705)]
706#[deprecated]
707pub struct SyntheticLockupsByLockupIdRequest {
708    #[prost(uint64, tag = "1")]
709    #[serde(alias = "lockID")]
710    #[serde(
711        serialize_with = "crate::serde::as_str::serialize",
712        deserialize_with = "crate::serde::as_str::deserialize"
713    )]
714    pub lock_id: u64,
715}
716#[allow(clippy::derive_partial_eq_without_eq)]
717#[derive(
718    Clone,
719    PartialEq,
720    Eq,
721    ::prost::Message,
722    ::serde::Serialize,
723    ::serde::Deserialize,
724    ::schemars::JsonSchema,
725    CosmwasmExt,
726)]
727#[proto_message(type_url = "/osmosis.lockup.SyntheticLockupsByLockupIDResponse")]
728#[deprecated]
729pub struct SyntheticLockupsByLockupIdResponse {
730    #[prost(message, repeated, tag = "1")]
731    pub synthetic_locks: ::prost::alloc::vec::Vec<SyntheticLock>,
732}
733#[allow(clippy::derive_partial_eq_without_eq)]
734#[derive(
735    Clone,
736    PartialEq,
737    Eq,
738    ::prost::Message,
739    ::serde::Serialize,
740    ::serde::Deserialize,
741    ::schemars::JsonSchema,
742    CosmwasmExt,
743)]
744#[proto_message(type_url = "/osmosis.lockup.SyntheticLockupByLockupIDRequest")]
745#[proto_query(
746    path = "/osmosis.lockup.Query/SyntheticLockupByLockupID",
747    response_type = SyntheticLockupByLockupIdResponse
748)]
749pub struct SyntheticLockupByLockupIdRequest {
750    #[prost(uint64, tag = "1")]
751    #[serde(alias = "lockID")]
752    #[serde(
753        serialize_with = "crate::serde::as_str::serialize",
754        deserialize_with = "crate::serde::as_str::deserialize"
755    )]
756    pub lock_id: u64,
757}
758#[allow(clippy::derive_partial_eq_without_eq)]
759#[derive(
760    Clone,
761    PartialEq,
762    Eq,
763    ::prost::Message,
764    ::serde::Serialize,
765    ::serde::Deserialize,
766    ::schemars::JsonSchema,
767    CosmwasmExt,
768)]
769#[proto_message(type_url = "/osmosis.lockup.SyntheticLockupByLockupIDResponse")]
770pub struct SyntheticLockupByLockupIdResponse {
771    #[prost(message, optional, tag = "1")]
772    pub synthetic_lock: ::core::option::Option<SyntheticLock>,
773}
774#[allow(clippy::derive_partial_eq_without_eq)]
775#[derive(
776    Clone,
777    PartialEq,
778    Eq,
779    ::prost::Message,
780    ::serde::Serialize,
781    ::serde::Deserialize,
782    ::schemars::JsonSchema,
783    CosmwasmExt,
784)]
785#[proto_message(type_url = "/osmosis.lockup.AccountLockedLongerDurationRequest")]
786#[proto_query(
787    path = "/osmosis.lockup.Query/AccountLockedLongerDuration",
788    response_type = AccountLockedLongerDurationResponse
789)]
790pub struct AccountLockedLongerDurationRequest {
791    #[prost(string, tag = "1")]
792    pub owner: ::prost::alloc::string::String,
793    #[prost(message, optional, tag = "2")]
794    pub duration: ::core::option::Option<crate::shim::Duration>,
795}
796#[allow(clippy::derive_partial_eq_without_eq)]
797#[derive(
798    Clone,
799    PartialEq,
800    Eq,
801    ::prost::Message,
802    ::serde::Serialize,
803    ::serde::Deserialize,
804    ::schemars::JsonSchema,
805    CosmwasmExt,
806)]
807#[proto_message(type_url = "/osmosis.lockup.AccountLockedLongerDurationResponse")]
808pub struct AccountLockedLongerDurationResponse {
809    #[prost(message, repeated, tag = "1")]
810    pub locks: ::prost::alloc::vec::Vec<PeriodLock>,
811}
812#[allow(clippy::derive_partial_eq_without_eq)]
813#[derive(
814    Clone,
815    PartialEq,
816    Eq,
817    ::prost::Message,
818    ::serde::Serialize,
819    ::serde::Deserialize,
820    ::schemars::JsonSchema,
821    CosmwasmExt,
822)]
823#[proto_message(type_url = "/osmosis.lockup.AccountLockedDurationRequest")]
824#[proto_query(
825    path = "/osmosis.lockup.Query/AccountLockedDuration",
826    response_type = AccountLockedDurationResponse
827)]
828pub struct AccountLockedDurationRequest {
829    #[prost(string, tag = "1")]
830    pub owner: ::prost::alloc::string::String,
831    #[prost(message, optional, tag = "2")]
832    pub duration: ::core::option::Option<crate::shim::Duration>,
833}
834#[allow(clippy::derive_partial_eq_without_eq)]
835#[derive(
836    Clone,
837    PartialEq,
838    Eq,
839    ::prost::Message,
840    ::serde::Serialize,
841    ::serde::Deserialize,
842    ::schemars::JsonSchema,
843    CosmwasmExt,
844)]
845#[proto_message(type_url = "/osmosis.lockup.AccountLockedDurationResponse")]
846pub struct AccountLockedDurationResponse {
847    #[prost(message, repeated, tag = "1")]
848    pub locks: ::prost::alloc::vec::Vec<PeriodLock>,
849}
850#[allow(clippy::derive_partial_eq_without_eq)]
851#[derive(
852    Clone,
853    PartialEq,
854    Eq,
855    ::prost::Message,
856    ::serde::Serialize,
857    ::serde::Deserialize,
858    ::schemars::JsonSchema,
859    CosmwasmExt,
860)]
861#[proto_message(type_url = "/osmosis.lockup.AccountLockedLongerDurationNotUnlockingOnlyRequest")]
862#[proto_query(
863    path = "/osmosis.lockup.Query/AccountLockedLongerDurationNotUnlockingOnly",
864    response_type = AccountLockedLongerDurationNotUnlockingOnlyResponse
865)]
866pub struct AccountLockedLongerDurationNotUnlockingOnlyRequest {
867    #[prost(string, tag = "1")]
868    pub owner: ::prost::alloc::string::String,
869    #[prost(message, optional, tag = "2")]
870    pub duration: ::core::option::Option<crate::shim::Duration>,
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.lockup.AccountLockedLongerDurationNotUnlockingOnlyResponse")]
884pub struct AccountLockedLongerDurationNotUnlockingOnlyResponse {
885    #[prost(message, repeated, tag = "1")]
886    pub locks: ::prost::alloc::vec::Vec<PeriodLock>,
887}
888#[allow(clippy::derive_partial_eq_without_eq)]
889#[derive(
890    Clone,
891    PartialEq,
892    Eq,
893    ::prost::Message,
894    ::serde::Serialize,
895    ::serde::Deserialize,
896    ::schemars::JsonSchema,
897    CosmwasmExt,
898)]
899#[proto_message(type_url = "/osmosis.lockup.AccountLockedLongerDurationDenomRequest")]
900#[proto_query(
901    path = "/osmosis.lockup.Query/AccountLockedLongerDurationDenom",
902    response_type = AccountLockedLongerDurationDenomResponse
903)]
904pub struct AccountLockedLongerDurationDenomRequest {
905    #[prost(string, tag = "1")]
906    pub owner: ::prost::alloc::string::String,
907    #[prost(message, optional, tag = "2")]
908    pub duration: ::core::option::Option<crate::shim::Duration>,
909    #[prost(string, tag = "3")]
910    pub denom: ::prost::alloc::string::String,
911}
912#[allow(clippy::derive_partial_eq_without_eq)]
913#[derive(
914    Clone,
915    PartialEq,
916    Eq,
917    ::prost::Message,
918    ::serde::Serialize,
919    ::serde::Deserialize,
920    ::schemars::JsonSchema,
921    CosmwasmExt,
922)]
923#[proto_message(type_url = "/osmosis.lockup.AccountLockedLongerDurationDenomResponse")]
924pub struct AccountLockedLongerDurationDenomResponse {
925    #[prost(message, repeated, tag = "1")]
926    pub locks: ::prost::alloc::vec::Vec<PeriodLock>,
927}
928#[allow(clippy::derive_partial_eq_without_eq)]
929#[derive(
930    Clone,
931    PartialEq,
932    Eq,
933    ::prost::Message,
934    ::serde::Serialize,
935    ::serde::Deserialize,
936    ::schemars::JsonSchema,
937    CosmwasmExt,
938)]
939#[proto_message(type_url = "/osmosis.lockup.QueryParamsRequest")]
940#[proto_query(
941    path = "/osmosis.lockup.Query/Params",
942    response_type = QueryParamsResponse
943)]
944pub struct QueryParamsRequest {}
945#[allow(clippy::derive_partial_eq_without_eq)]
946#[derive(
947    Clone,
948    PartialEq,
949    Eq,
950    ::prost::Message,
951    ::serde::Serialize,
952    ::serde::Deserialize,
953    ::schemars::JsonSchema,
954    CosmwasmExt,
955)]
956#[proto_message(type_url = "/osmosis.lockup.QueryParamsResponse")]
957pub struct QueryParamsResponse {
958    #[prost(message, optional, tag = "1")]
959    pub params: ::core::option::Option<Params>,
960}
961#[allow(clippy::derive_partial_eq_without_eq)]
962#[derive(
963    Clone,
964    PartialEq,
965    Eq,
966    ::prost::Message,
967    ::serde::Serialize,
968    ::serde::Deserialize,
969    ::schemars::JsonSchema,
970    CosmwasmExt,
971)]
972#[proto_message(type_url = "/osmosis.lockup.MsgLockTokens")]
973pub struct MsgLockTokens {
974    #[prost(string, tag = "1")]
975    pub owner: ::prost::alloc::string::String,
976    #[prost(message, optional, tag = "2")]
977    pub duration: ::core::option::Option<crate::shim::Duration>,
978    #[prost(message, repeated, tag = "3")]
979    pub coins: ::prost::alloc::vec::Vec<super::super::cosmos::base::v1beta1::Coin>,
980}
981#[allow(clippy::derive_partial_eq_without_eq)]
982#[derive(
983    Clone,
984    PartialEq,
985    Eq,
986    ::prost::Message,
987    ::serde::Serialize,
988    ::serde::Deserialize,
989    ::schemars::JsonSchema,
990    CosmwasmExt,
991)]
992#[proto_message(type_url = "/osmosis.lockup.MsgLockTokensResponse")]
993pub struct MsgLockTokensResponse {
994    #[prost(uint64, tag = "1")]
995    #[serde(alias = "ID")]
996    #[serde(
997        serialize_with = "crate::serde::as_str::serialize",
998        deserialize_with = "crate::serde::as_str::deserialize"
999    )]
1000    pub id: u64,
1001}
1002#[allow(clippy::derive_partial_eq_without_eq)]
1003#[derive(
1004    Clone,
1005    PartialEq,
1006    Eq,
1007    ::prost::Message,
1008    ::serde::Serialize,
1009    ::serde::Deserialize,
1010    ::schemars::JsonSchema,
1011    CosmwasmExt,
1012)]
1013#[proto_message(type_url = "/osmosis.lockup.MsgBeginUnlockingAll")]
1014pub struct MsgBeginUnlockingAll {
1015    #[prost(string, tag = "1")]
1016    pub owner: ::prost::alloc::string::String,
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.lockup.MsgBeginUnlockingAllResponse")]
1030pub struct MsgBeginUnlockingAllResponse {
1031    #[prost(message, repeated, tag = "1")]
1032    pub unlocks: ::prost::alloc::vec::Vec<PeriodLock>,
1033}
1034#[allow(clippy::derive_partial_eq_without_eq)]
1035#[derive(
1036    Clone,
1037    PartialEq,
1038    Eq,
1039    ::prost::Message,
1040    ::serde::Serialize,
1041    ::serde::Deserialize,
1042    ::schemars::JsonSchema,
1043    CosmwasmExt,
1044)]
1045#[proto_message(type_url = "/osmosis.lockup.MsgBeginUnlocking")]
1046pub struct MsgBeginUnlocking {
1047    #[prost(string, tag = "1")]
1048    pub owner: ::prost::alloc::string::String,
1049    #[prost(uint64, tag = "2")]
1050    #[serde(alias = "ID")]
1051    #[serde(
1052        serialize_with = "crate::serde::as_str::serialize",
1053        deserialize_with = "crate::serde::as_str::deserialize"
1054    )]
1055    pub id: u64,
1056    /// Amount of unlocking coins. Unlock all if not set.
1057    #[prost(message, repeated, tag = "3")]
1058    pub coins: ::prost::alloc::vec::Vec<super::super::cosmos::base::v1beta1::Coin>,
1059}
1060#[allow(clippy::derive_partial_eq_without_eq)]
1061#[derive(
1062    Clone,
1063    PartialEq,
1064    Eq,
1065    ::prost::Message,
1066    ::serde::Serialize,
1067    ::serde::Deserialize,
1068    ::schemars::JsonSchema,
1069    CosmwasmExt,
1070)]
1071#[proto_message(type_url = "/osmosis.lockup.MsgBeginUnlockingResponse")]
1072pub struct MsgBeginUnlockingResponse {
1073    #[prost(bool, tag = "1")]
1074    pub success: bool,
1075    #[prost(uint64, tag = "2")]
1076    #[serde(alias = "unlocking_lockID")]
1077    #[serde(
1078        serialize_with = "crate::serde::as_str::serialize",
1079        deserialize_with = "crate::serde::as_str::deserialize"
1080    )]
1081    pub unlocking_lock_id: u64,
1082}
1083/// MsgExtendLockup extends the existing lockup's duration.
1084/// The new duration is longer than the original.
1085#[allow(clippy::derive_partial_eq_without_eq)]
1086#[derive(
1087    Clone,
1088    PartialEq,
1089    Eq,
1090    ::prost::Message,
1091    ::serde::Serialize,
1092    ::serde::Deserialize,
1093    ::schemars::JsonSchema,
1094    CosmwasmExt,
1095)]
1096#[proto_message(type_url = "/osmosis.lockup.MsgExtendLockup")]
1097pub struct MsgExtendLockup {
1098    #[prost(string, tag = "1")]
1099    pub owner: ::prost::alloc::string::String,
1100    #[prost(uint64, tag = "2")]
1101    #[serde(alias = "ID")]
1102    #[serde(
1103        serialize_with = "crate::serde::as_str::serialize",
1104        deserialize_with = "crate::serde::as_str::deserialize"
1105    )]
1106    pub id: u64,
1107    /// duration to be set. fails if lower than the current duration, or is
1108    /// unlocking
1109    #[prost(message, optional, tag = "3")]
1110    pub duration: ::core::option::Option<crate::shim::Duration>,
1111}
1112#[allow(clippy::derive_partial_eq_without_eq)]
1113#[derive(
1114    Clone,
1115    PartialEq,
1116    Eq,
1117    ::prost::Message,
1118    ::serde::Serialize,
1119    ::serde::Deserialize,
1120    ::schemars::JsonSchema,
1121    CosmwasmExt,
1122)]
1123#[proto_message(type_url = "/osmosis.lockup.MsgExtendLockupResponse")]
1124pub struct MsgExtendLockupResponse {
1125    #[prost(bool, tag = "1")]
1126    pub success: bool,
1127}
1128/// MsgForceUnlock unlocks locks immediately for
1129/// addresses registered via governance.
1130#[allow(clippy::derive_partial_eq_without_eq)]
1131#[derive(
1132    Clone,
1133    PartialEq,
1134    Eq,
1135    ::prost::Message,
1136    ::serde::Serialize,
1137    ::serde::Deserialize,
1138    ::schemars::JsonSchema,
1139    CosmwasmExt,
1140)]
1141#[proto_message(type_url = "/osmosis.lockup.MsgForceUnlock")]
1142pub struct MsgForceUnlock {
1143    #[prost(string, tag = "1")]
1144    pub owner: ::prost::alloc::string::String,
1145    #[prost(uint64, tag = "2")]
1146    #[serde(alias = "ID")]
1147    #[serde(
1148        serialize_with = "crate::serde::as_str::serialize",
1149        deserialize_with = "crate::serde::as_str::deserialize"
1150    )]
1151    pub id: u64,
1152    /// Amount of unlocking coins. Unlock all if not set.
1153    #[prost(message, repeated, tag = "3")]
1154    pub coins: ::prost::alloc::vec::Vec<super::super::cosmos::base::v1beta1::Coin>,
1155}
1156#[allow(clippy::derive_partial_eq_without_eq)]
1157#[derive(
1158    Clone,
1159    PartialEq,
1160    Eq,
1161    ::prost::Message,
1162    ::serde::Serialize,
1163    ::serde::Deserialize,
1164    ::schemars::JsonSchema,
1165    CosmwasmExt,
1166)]
1167#[proto_message(type_url = "/osmosis.lockup.MsgForceUnlockResponse")]
1168pub struct MsgForceUnlockResponse {
1169    #[prost(bool, tag = "1")]
1170    pub success: bool,
1171}
1172#[allow(clippy::derive_partial_eq_without_eq)]
1173#[derive(
1174    Clone,
1175    PartialEq,
1176    Eq,
1177    ::prost::Message,
1178    ::serde::Serialize,
1179    ::serde::Deserialize,
1180    ::schemars::JsonSchema,
1181    CosmwasmExt,
1182)]
1183#[proto_message(type_url = "/osmosis.lockup.MsgSetRewardReceiverAddress")]
1184pub struct MsgSetRewardReceiverAddress {
1185    #[prost(string, tag = "1")]
1186    pub owner: ::prost::alloc::string::String,
1187    #[prost(uint64, tag = "2")]
1188    #[serde(alias = "lockID")]
1189    #[serde(
1190        serialize_with = "crate::serde::as_str::serialize",
1191        deserialize_with = "crate::serde::as_str::deserialize"
1192    )]
1193    pub lock_id: u64,
1194    #[prost(string, tag = "3")]
1195    pub reward_receiver: ::prost::alloc::string::String,
1196}
1197#[allow(clippy::derive_partial_eq_without_eq)]
1198#[derive(
1199    Clone,
1200    PartialEq,
1201    Eq,
1202    ::prost::Message,
1203    ::serde::Serialize,
1204    ::serde::Deserialize,
1205    ::schemars::JsonSchema,
1206    CosmwasmExt,
1207)]
1208#[proto_message(type_url = "/osmosis.lockup.MsgSetRewardReceiverAddressResponse")]
1209pub struct MsgSetRewardReceiverAddressResponse {
1210    #[prost(bool, tag = "1")]
1211    pub success: bool,
1212}
1213/// DEPRECATED
1214/// Following messages are deprecated but kept to support indexing.
1215#[allow(clippy::derive_partial_eq_without_eq)]
1216#[derive(
1217    Clone,
1218    PartialEq,
1219    Eq,
1220    ::prost::Message,
1221    ::serde::Serialize,
1222    ::serde::Deserialize,
1223    ::schemars::JsonSchema,
1224    CosmwasmExt,
1225)]
1226#[proto_message(type_url = "/osmosis.lockup.MsgUnlockPeriodLock")]
1227pub struct MsgUnlockPeriodLock {
1228    #[prost(string, tag = "1")]
1229    pub owner: ::prost::alloc::string::String,
1230    #[prost(uint64, tag = "2")]
1231    #[serde(alias = "ID")]
1232    #[serde(
1233        serialize_with = "crate::serde::as_str::serialize",
1234        deserialize_with = "crate::serde::as_str::deserialize"
1235    )]
1236    pub id: u64,
1237}
1238#[allow(clippy::derive_partial_eq_without_eq)]
1239#[derive(
1240    Clone,
1241    PartialEq,
1242    Eq,
1243    ::prost::Message,
1244    ::serde::Serialize,
1245    ::serde::Deserialize,
1246    ::schemars::JsonSchema,
1247    CosmwasmExt,
1248)]
1249#[proto_message(type_url = "/osmosis.lockup.MsgUnlockTokens")]
1250pub struct MsgUnlockTokens {
1251    #[prost(string, tag = "1")]
1252    pub owner: ::prost::alloc::string::String,
1253}
1254pub struct LockupQuerier<'a, Q: cosmwasm_std::CustomQuery> {
1255    querier: &'a cosmwasm_std::QuerierWrapper<'a, Q>,
1256}
1257impl<'a, Q: cosmwasm_std::CustomQuery> LockupQuerier<'a, Q> {
1258    pub fn new(querier: &'a cosmwasm_std::QuerierWrapper<'a, Q>) -> Self {
1259        Self { querier }
1260    }
1261    pub fn module_balance(&self) -> Result<ModuleBalanceResponse, cosmwasm_std::StdError> {
1262        ModuleBalanceRequest {}.query(self.querier)
1263    }
1264    pub fn module_locked_amount(
1265        &self,
1266    ) -> Result<ModuleLockedAmountResponse, cosmwasm_std::StdError> {
1267        ModuleLockedAmountRequest {}.query(self.querier)
1268    }
1269    pub fn account_unlockable_coins(
1270        &self,
1271        owner: ::prost::alloc::string::String,
1272    ) -> Result<AccountUnlockableCoinsResponse, cosmwasm_std::StdError> {
1273        AccountUnlockableCoinsRequest { owner }.query(self.querier)
1274    }
1275    pub fn account_unlocking_coins(
1276        &self,
1277        owner: ::prost::alloc::string::String,
1278    ) -> Result<AccountUnlockingCoinsResponse, cosmwasm_std::StdError> {
1279        AccountUnlockingCoinsRequest { owner }.query(self.querier)
1280    }
1281    pub fn account_locked_coins(
1282        &self,
1283        owner: ::prost::alloc::string::String,
1284    ) -> Result<AccountLockedCoinsResponse, cosmwasm_std::StdError> {
1285        AccountLockedCoinsRequest { owner }.query(self.querier)
1286    }
1287    pub fn account_locked_past_time(
1288        &self,
1289        owner: ::prost::alloc::string::String,
1290        timestamp: ::core::option::Option<crate::shim::Timestamp>,
1291    ) -> Result<AccountLockedPastTimeResponse, cosmwasm_std::StdError> {
1292        AccountLockedPastTimeRequest { owner, timestamp }.query(self.querier)
1293    }
1294    pub fn account_locked_past_time_not_unlocking_only(
1295        &self,
1296        owner: ::prost::alloc::string::String,
1297        timestamp: ::core::option::Option<crate::shim::Timestamp>,
1298    ) -> Result<AccountLockedPastTimeNotUnlockingOnlyResponse, cosmwasm_std::StdError> {
1299        AccountLockedPastTimeNotUnlockingOnlyRequest { owner, timestamp }.query(self.querier)
1300    }
1301    pub fn account_unlocked_before_time(
1302        &self,
1303        owner: ::prost::alloc::string::String,
1304        timestamp: ::core::option::Option<crate::shim::Timestamp>,
1305    ) -> Result<AccountUnlockedBeforeTimeResponse, cosmwasm_std::StdError> {
1306        AccountUnlockedBeforeTimeRequest { owner, timestamp }.query(self.querier)
1307    }
1308    pub fn account_locked_past_time_denom(
1309        &self,
1310        owner: ::prost::alloc::string::String,
1311        timestamp: ::core::option::Option<crate::shim::Timestamp>,
1312        denom: ::prost::alloc::string::String,
1313    ) -> Result<AccountLockedPastTimeDenomResponse, cosmwasm_std::StdError> {
1314        AccountLockedPastTimeDenomRequest {
1315            owner,
1316            timestamp,
1317            denom,
1318        }
1319        .query(self.querier)
1320    }
1321    pub fn locked_denom(
1322        &self,
1323        denom: ::prost::alloc::string::String,
1324        duration: ::core::option::Option<crate::shim::Duration>,
1325    ) -> Result<LockedDenomResponse, cosmwasm_std::StdError> {
1326        LockedDenomRequest { denom, duration }.query(self.querier)
1327    }
1328    pub fn locked_by_id(&self, lock_id: u64) -> Result<LockedResponse, cosmwasm_std::StdError> {
1329        LockedRequest { lock_id }.query(self.querier)
1330    }
1331    pub fn lock_reward_receiver(
1332        &self,
1333        lock_id: u64,
1334    ) -> Result<LockRewardReceiverResponse, cosmwasm_std::StdError> {
1335        LockRewardReceiverRequest { lock_id }.query(self.querier)
1336    }
1337    pub fn next_lock_id(&self) -> Result<NextLockIdResponse, cosmwasm_std::StdError> {
1338        NextLockIdRequest {}.query(self.querier)
1339    }
1340    #[deprecated]
1341    pub fn synthetic_lockups_by_lockup_id(
1342        &self,
1343        lock_id: u64,
1344    ) -> Result<SyntheticLockupsByLockupIdResponse, cosmwasm_std::StdError> {
1345        SyntheticLockupsByLockupIdRequest { lock_id }.query(self.querier)
1346    }
1347    pub fn synthetic_lockup_by_lockup_id(
1348        &self,
1349        lock_id: u64,
1350    ) -> Result<SyntheticLockupByLockupIdResponse, cosmwasm_std::StdError> {
1351        SyntheticLockupByLockupIdRequest { lock_id }.query(self.querier)
1352    }
1353    pub fn account_locked_longer_duration(
1354        &self,
1355        owner: ::prost::alloc::string::String,
1356        duration: ::core::option::Option<crate::shim::Duration>,
1357    ) -> Result<AccountLockedLongerDurationResponse, cosmwasm_std::StdError> {
1358        AccountLockedLongerDurationRequest { owner, duration }.query(self.querier)
1359    }
1360    pub fn account_locked_duration(
1361        &self,
1362        owner: ::prost::alloc::string::String,
1363        duration: ::core::option::Option<crate::shim::Duration>,
1364    ) -> Result<AccountLockedDurationResponse, cosmwasm_std::StdError> {
1365        AccountLockedDurationRequest { owner, duration }.query(self.querier)
1366    }
1367    pub fn account_locked_longer_duration_not_unlocking_only(
1368        &self,
1369        owner: ::prost::alloc::string::String,
1370        duration: ::core::option::Option<crate::shim::Duration>,
1371    ) -> Result<AccountLockedLongerDurationNotUnlockingOnlyResponse, cosmwasm_std::StdError> {
1372        AccountLockedLongerDurationNotUnlockingOnlyRequest { owner, duration }.query(self.querier)
1373    }
1374    pub fn account_locked_longer_duration_denom(
1375        &self,
1376        owner: ::prost::alloc::string::String,
1377        duration: ::core::option::Option<crate::shim::Duration>,
1378        denom: ::prost::alloc::string::String,
1379    ) -> Result<AccountLockedLongerDurationDenomResponse, cosmwasm_std::StdError> {
1380        AccountLockedLongerDurationDenomRequest {
1381            owner,
1382            duration,
1383            denom,
1384        }
1385        .query(self.querier)
1386    }
1387    pub fn params(&self) -> Result<QueryParamsResponse, cosmwasm_std::StdError> {
1388        QueryParamsRequest {}.query(self.querier)
1389    }
1390}
osmosis_std/types/osmosis/lockup.rs

osmosis_std/types/osmosis/
lockup.rs
