osmosis_std/types/osmosis/protorev/
v1beta1.rs

1use osmosis_std_derive::CosmwasmExt;
2/// TokenPairArbRoutes tracks all of the hot routes for a given pair of tokens
3#[allow(clippy::derive_partial_eq_without_eq)]
4#[derive(
5    Clone,
6    PartialEq,
7    Eq,
8    ::prost::Message,
9    ::serde::Serialize,
10    ::serde::Deserialize,
11    ::schemars::JsonSchema,
12    CosmwasmExt,
13)]
14#[proto_message(type_url = "/osmosis.protorev.v1beta1.TokenPairArbRoutes")]
15pub struct TokenPairArbRoutes {
16    /// Stores all of the possible hot paths for a given pair of tokens
17    #[prost(message, repeated, tag = "1")]
18    pub arb_routes: ::prost::alloc::vec::Vec<Route>,
19    /// Token denomination of the first asset
20    #[prost(string, tag = "2")]
21    pub token_in: ::prost::alloc::string::String,
22    /// Token denomination of the second asset
23    #[prost(string, tag = "3")]
24    pub token_out: ::prost::alloc::string::String,
25}
26/// Route is a hot route for a given pair of tokens
27#[allow(clippy::derive_partial_eq_without_eq)]
28#[derive(
29    Clone,
30    PartialEq,
31    Eq,
32    ::prost::Message,
33    ::serde::Serialize,
34    ::serde::Deserialize,
35    ::schemars::JsonSchema,
36    CosmwasmExt,
37)]
38#[proto_message(type_url = "/osmosis.protorev.v1beta1.Route")]
39pub struct Route {
40    /// The pool IDs that are traversed in the directed cyclic graph (traversed
41    /// left
42    /// -> right)
43    #[prost(message, repeated, tag = "1")]
44    pub trades: ::prost::alloc::vec::Vec<Trade>,
45    /// The step size that will be used to find the optimal swap amount in the
46    /// binary search
47    #[prost(string, tag = "2")]
48    pub step_size: ::prost::alloc::string::String,
49}
50/// Trade is a single trade in a route
51#[allow(clippy::derive_partial_eq_without_eq)]
52#[derive(
53    Clone,
54    PartialEq,
55    Eq,
56    ::prost::Message,
57    ::serde::Serialize,
58    ::serde::Deserialize,
59    ::schemars::JsonSchema,
60    CosmwasmExt,
61)]
62#[proto_message(type_url = "/osmosis.protorev.v1beta1.Trade")]
63pub struct Trade {
64    /// The pool id of the pool that is traded on
65    #[prost(uint64, tag = "1")]
66    #[serde(
67        serialize_with = "crate::serde::as_str::serialize",
68        deserialize_with = "crate::serde::as_str::deserialize"
69    )]
70    pub pool: u64,
71    /// The denom of the token that is traded
72    #[prost(string, tag = "2")]
73    pub token_in: ::prost::alloc::string::String,
74    /// The denom of the token that is received
75    #[prost(string, tag = "3")]
76    pub token_out: ::prost::alloc::string::String,
77}
78/// RouteStatistics contains the number of trades the module has executed after a
79/// swap on a given route and the profits from the trades
80#[allow(clippy::derive_partial_eq_without_eq)]
81#[derive(
82    Clone,
83    PartialEq,
84    Eq,
85    ::prost::Message,
86    ::serde::Serialize,
87    ::serde::Deserialize,
88    ::schemars::JsonSchema,
89    CosmwasmExt,
90)]
91#[proto_message(type_url = "/osmosis.protorev.v1beta1.RouteStatistics")]
92pub struct RouteStatistics {
93    /// profits is the total profit from all trades on this route
94    #[prost(message, repeated, tag = "1")]
95    pub profits: ::prost::alloc::vec::Vec<super::super::super::cosmos::base::v1beta1::Coin>,
96    /// number_of_trades is the number of trades the module has executed using this
97    /// route
98    #[prost(string, tag = "2")]
99    pub number_of_trades: ::prost::alloc::string::String,
100    /// route is the route that was used (pool ids along the arbitrage route)
101    #[prost(uint64, repeated, packed = "false", tag = "3")]
102    #[serde(
103        serialize_with = "crate::serde::as_str_vec::serialize",
104        deserialize_with = "crate::serde::as_str_vec::deserialize"
105    )]
106    pub route: ::prost::alloc::vec::Vec<u64>,
107}
108/// PoolWeights contains the weights of all of the different pool types. This
109/// distinction is made and necessary because the execution time ranges
110/// significantly between the different pool types. Each weight roughly
111/// corresponds to the amount of time (in ms) it takes to execute a swap on that
112/// pool type.
113///
114/// DEPRECATED: This field is deprecated and will be removed in the next
115/// release. It is replaced by the `info_by_pool_type` field.
116#[allow(clippy::derive_partial_eq_without_eq)]
117#[derive(
118    Clone,
119    PartialEq,
120    Eq,
121    ::prost::Message,
122    ::serde::Serialize,
123    ::serde::Deserialize,
124    ::schemars::JsonSchema,
125    CosmwasmExt,
126)]
127#[proto_message(type_url = "/osmosis.protorev.v1beta1.PoolWeights")]
128pub struct PoolWeights {
129    /// The weight of a stableswap pool
130    #[prost(uint64, tag = "1")]
131    #[serde(
132        serialize_with = "crate::serde::as_str::serialize",
133        deserialize_with = "crate::serde::as_str::deserialize"
134    )]
135    pub stable_weight: u64,
136    /// The weight of a balancer pool
137    #[prost(uint64, tag = "2")]
138    #[serde(
139        serialize_with = "crate::serde::as_str::serialize",
140        deserialize_with = "crate::serde::as_str::deserialize"
141    )]
142    pub balancer_weight: u64,
143    /// The weight of a concentrated pool
144    #[prost(uint64, tag = "3")]
145    #[serde(
146        serialize_with = "crate::serde::as_str::serialize",
147        deserialize_with = "crate::serde::as_str::deserialize"
148    )]
149    pub concentrated_weight: u64,
150    /// The weight of a cosmwasm pool
151    #[prost(uint64, tag = "4")]
152    #[serde(
153        serialize_with = "crate::serde::as_str::serialize",
154        deserialize_with = "crate::serde::as_str::deserialize"
155    )]
156    pub cosmwasm_weight: u64,
157}
158/// InfoByPoolType contains information pertaining to how expensive (in terms of
159/// gas and time) it is to execute a swap on a given pool type. This distinction
160/// is made and necessary because the execution time ranges significantly between
161/// the different pool types.
162#[allow(clippy::derive_partial_eq_without_eq)]
163#[derive(
164    Clone,
165    PartialEq,
166    Eq,
167    ::prost::Message,
168    ::serde::Serialize,
169    ::serde::Deserialize,
170    ::schemars::JsonSchema,
171    CosmwasmExt,
172)]
173#[proto_message(type_url = "/osmosis.protorev.v1beta1.InfoByPoolType")]
174pub struct InfoByPoolType {
175    /// The stable pool info
176    #[prost(message, optional, tag = "1")]
177    pub stable: ::core::option::Option<StablePoolInfo>,
178    /// The balancer pool info
179    #[prost(message, optional, tag = "2")]
180    pub balancer: ::core::option::Option<BalancerPoolInfo>,
181    /// The concentrated pool info
182    #[prost(message, optional, tag = "3")]
183    pub concentrated: ::core::option::Option<ConcentratedPoolInfo>,
184    /// The cosmwasm pool info
185    #[prost(message, optional, tag = "4")]
186    pub cosmwasm: ::core::option::Option<CosmwasmPoolInfo>,
187}
188/// StablePoolInfo contains meta data pertaining to a stableswap pool type.
189#[allow(clippy::derive_partial_eq_without_eq)]
190#[derive(
191    Clone,
192    PartialEq,
193    Eq,
194    ::prost::Message,
195    ::serde::Serialize,
196    ::serde::Deserialize,
197    ::schemars::JsonSchema,
198    CosmwasmExt,
199)]
200#[proto_message(type_url = "/osmosis.protorev.v1beta1.StablePoolInfo")]
201pub struct StablePoolInfo {
202    /// The weight of a stableswap pool
203    #[prost(uint64, tag = "1")]
204    #[serde(
205        serialize_with = "crate::serde::as_str::serialize",
206        deserialize_with = "crate::serde::as_str::deserialize"
207    )]
208    pub weight: u64,
209}
210/// BalancerPoolInfo contains meta data pertaining to a balancer pool type.
211#[allow(clippy::derive_partial_eq_without_eq)]
212#[derive(
213    Clone,
214    PartialEq,
215    Eq,
216    ::prost::Message,
217    ::serde::Serialize,
218    ::serde::Deserialize,
219    ::schemars::JsonSchema,
220    CosmwasmExt,
221)]
222#[proto_message(type_url = "/osmosis.protorev.v1beta1.BalancerPoolInfo")]
223pub struct BalancerPoolInfo {
224    /// The weight of a balancer pool
225    #[prost(uint64, tag = "1")]
226    #[serde(
227        serialize_with = "crate::serde::as_str::serialize",
228        deserialize_with = "crate::serde::as_str::deserialize"
229    )]
230    pub weight: u64,
231}
232/// ConcentratedPoolInfo contains meta data pertaining to a concentrated pool
233/// type.
234#[allow(clippy::derive_partial_eq_without_eq)]
235#[derive(
236    Clone,
237    PartialEq,
238    Eq,
239    ::prost::Message,
240    ::serde::Serialize,
241    ::serde::Deserialize,
242    ::schemars::JsonSchema,
243    CosmwasmExt,
244)]
245#[proto_message(type_url = "/osmosis.protorev.v1beta1.ConcentratedPoolInfo")]
246pub struct ConcentratedPoolInfo {
247    /// The weight of a concentrated pool
248    #[prost(uint64, tag = "1")]
249    #[serde(
250        serialize_with = "crate::serde::as_str::serialize",
251        deserialize_with = "crate::serde::as_str::deserialize"
252    )]
253    pub weight: u64,
254    /// The maximum number of ticks we can move when rebalancing
255    #[prost(uint64, tag = "2")]
256    #[serde(
257        serialize_with = "crate::serde::as_str::serialize",
258        deserialize_with = "crate::serde::as_str::deserialize"
259    )]
260    pub max_ticks_crossed: u64,
261}
262/// CosmwasmPoolInfo contains meta data pertaining to a cosmwasm pool type.
263#[allow(clippy::derive_partial_eq_without_eq)]
264#[derive(
265    Clone,
266    PartialEq,
267    Eq,
268    ::prost::Message,
269    ::serde::Serialize,
270    ::serde::Deserialize,
271    ::schemars::JsonSchema,
272    CosmwasmExt,
273)]
274#[proto_message(type_url = "/osmosis.protorev.v1beta1.CosmwasmPoolInfo")]
275pub struct CosmwasmPoolInfo {
276    /// The weight of a cosmwasm pool (by contract address)
277    #[prost(message, repeated, tag = "1")]
278    pub weight_maps: ::prost::alloc::vec::Vec<WeightMap>,
279}
280/// WeightMap maps a contract address to a weight. The weight of an address
281/// corresponds to the amount of ms required to execute a swap on that contract.
282#[allow(clippy::derive_partial_eq_without_eq)]
283#[derive(
284    Clone,
285    PartialEq,
286    Eq,
287    ::prost::Message,
288    ::serde::Serialize,
289    ::serde::Deserialize,
290    ::schemars::JsonSchema,
291    CosmwasmExt,
292)]
293#[proto_message(type_url = "/osmosis.protorev.v1beta1.WeightMap")]
294pub struct WeightMap {
295    /// The weight of a cosmwasm pool (by contract address)
296    #[prost(uint64, tag = "1")]
297    #[serde(
298        serialize_with = "crate::serde::as_str::serialize",
299        deserialize_with = "crate::serde::as_str::deserialize"
300    )]
301    pub weight: u64,
302    /// The contract address
303    #[prost(string, tag = "2")]
304    pub contract_address: ::prost::alloc::string::String,
305}
306/// BaseDenom represents a single base denom that the module uses for its
307/// arbitrage trades. It contains the denom name alongside the step size of the
308/// binary search that is used to find the optimal swap amount
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.protorev.v1beta1.BaseDenom")]
321pub struct BaseDenom {
322    /// The denom i.e. name of the base denom (ex. uosmo)
323    #[prost(string, tag = "1")]
324    pub denom: ::prost::alloc::string::String,
325    /// The step size of the binary search that is used to find the optimal swap
326    /// amount
327    #[prost(string, tag = "2")]
328    pub step_size: ::prost::alloc::string::String,
329}
330/// BaseDenoms represents all of the base denoms that the module uses for its
331/// arbitrage trades.
332#[allow(clippy::derive_partial_eq_without_eq)]
333#[derive(
334    Clone,
335    PartialEq,
336    Eq,
337    ::prost::Message,
338    ::serde::Serialize,
339    ::serde::Deserialize,
340    ::schemars::JsonSchema,
341    CosmwasmExt,
342)]
343#[proto_message(type_url = "/osmosis.protorev.v1beta1.BaseDenoms")]
344pub struct BaseDenoms {
345    #[prost(message, repeated, tag = "1")]
346    pub base_denoms: ::prost::alloc::vec::Vec<BaseDenom>,
347}
348#[allow(clippy::derive_partial_eq_without_eq)]
349#[derive(
350    Clone,
351    PartialEq,
352    Eq,
353    ::prost::Message,
354    ::serde::Serialize,
355    ::serde::Deserialize,
356    ::schemars::JsonSchema,
357    CosmwasmExt,
358)]
359#[proto_message(type_url = "/osmosis.protorev.v1beta1.AllProtocolRevenue")]
360pub struct AllProtocolRevenue {
361    #[prost(message, optional, tag = "1")]
362    pub taker_fees_tracker:
363        ::core::option::Option<super::super::poolmanager::v1beta1::TakerFeesTracker>,
364    /// DEPRECATED
365    #[deprecated]
366    #[prost(message, optional, tag = "2")]
367    pub tx_fees_tracker: ::core::option::Option<super::super::txfees::v1beta1::TxFeesTracker>,
368    #[prost(message, optional, tag = "3")]
369    pub cyclic_arb_tracker: ::core::option::Option<CyclicArbTracker>,
370}
371#[allow(clippy::derive_partial_eq_without_eq)]
372#[derive(
373    Clone,
374    PartialEq,
375    Eq,
376    ::prost::Message,
377    ::serde::Serialize,
378    ::serde::Deserialize,
379    ::schemars::JsonSchema,
380    CosmwasmExt,
381)]
382#[proto_message(type_url = "/osmosis.protorev.v1beta1.CyclicArbTracker")]
383pub struct CyclicArbTracker {
384    #[prost(message, repeated, tag = "1")]
385    pub cyclic_arb: ::prost::alloc::vec::Vec<super::super::super::cosmos::base::v1beta1::Coin>,
386    #[prost(int64, tag = "2")]
387    #[serde(
388        serialize_with = "crate::serde::as_str::serialize",
389        deserialize_with = "crate::serde::as_str::deserialize"
390    )]
391    pub height_accounting_starts_from: i64,
392}
393/// Params defines the parameters for the module.
394#[allow(clippy::derive_partial_eq_without_eq)]
395#[derive(
396    Clone,
397    PartialEq,
398    Eq,
399    ::prost::Message,
400    ::serde::Serialize,
401    ::serde::Deserialize,
402    ::schemars::JsonSchema,
403    CosmwasmExt,
404)]
405#[proto_message(type_url = "/osmosis.protorev.v1beta1.Params")]
406pub struct Params {
407    /// Boolean whether the protorev module is enabled.
408    #[prost(bool, tag = "1")]
409    pub enabled: bool,
410    /// The admin account (settings manager) of the protorev module.
411    #[prost(string, tag = "2")]
412    pub admin: ::prost::alloc::string::String,
413}
414/// GenesisState defines the protorev module's genesis state.
415#[allow(clippy::derive_partial_eq_without_eq)]
416#[derive(
417    Clone,
418    PartialEq,
419    Eq,
420    ::prost::Message,
421    ::serde::Serialize,
422    ::serde::Deserialize,
423    ::schemars::JsonSchema,
424    CosmwasmExt,
425)]
426#[proto_message(type_url = "/osmosis.protorev.v1beta1.GenesisState")]
427pub struct GenesisState {
428    /// Parameters for the protorev module.
429    #[prost(message, optional, tag = "1")]
430    pub params: ::core::option::Option<Params>,
431    /// Token pair arb routes for the protorev module (hot routes).
432    #[prost(message, repeated, tag = "2")]
433    pub token_pair_arb_routes: ::prost::alloc::vec::Vec<TokenPairArbRoutes>,
434    /// The base denominations being used to create cyclic arbitrage routes via the
435    /// highest liquidity method.
436    #[prost(message, repeated, tag = "3")]
437    pub base_denoms: ::prost::alloc::vec::Vec<BaseDenom>,
438    /// DEPRECATED: pool_weights are weights that are being used to calculate the
439    /// compute cost of each route. This field is deprecated.
440    /// It is replaced by the `info_by_pool_type` field.
441    #[deprecated]
442    #[prost(message, optional, tag = "4")]
443    pub pool_weights: ::core::option::Option<PoolWeights>,
444    /// The number of days since module genesis.
445    #[prost(uint64, tag = "5")]
446    #[serde(
447        serialize_with = "crate::serde::as_str::serialize",
448        deserialize_with = "crate::serde::as_str::deserialize"
449    )]
450    pub days_since_module_genesis: u64,
451    /// The fees the developer account has accumulated over time.
452    #[prost(message, repeated, tag = "6")]
453    pub developer_fees: ::prost::alloc::vec::Vec<super::super::super::cosmos::base::v1beta1::Coin>,
454    /// The latest block height that the module has processed.
455    #[prost(uint64, tag = "7")]
456    #[serde(
457        serialize_with = "crate::serde::as_str::serialize",
458        deserialize_with = "crate::serde::as_str::deserialize"
459    )]
460    pub latest_block_height: u64,
461    /// The developer account address of the module.
462    #[prost(string, tag = "8")]
463    pub developer_address: ::prost::alloc::string::String,
464    /// Max pool points per block i.e. the maximum compute time (in ms)
465    /// that protorev can use per block.
466    #[prost(uint64, tag = "9")]
467    #[serde(
468        serialize_with = "crate::serde::as_str::serialize",
469        deserialize_with = "crate::serde::as_str::deserialize"
470    )]
471    pub max_pool_points_per_block: u64,
472    /// Max pool points per tx i.e. the maximum compute time (in ms) that
473    /// protorev can use per tx.
474    #[prost(uint64, tag = "10")]
475    #[serde(
476        serialize_with = "crate::serde::as_str::serialize",
477        deserialize_with = "crate::serde::as_str::deserialize"
478    )]
479    pub max_pool_points_per_tx: u64,
480    /// The number of pool points that have been consumed in the current block.
481    #[prost(uint64, tag = "11")]
482    #[serde(
483        serialize_with = "crate::serde::as_str::serialize",
484        deserialize_with = "crate::serde::as_str::deserialize"
485    )]
486    pub point_count_for_block: u64,
487    /// All of the profits that have been accumulated by the module.
488    #[prost(message, repeated, tag = "12")]
489    pub profits: ::prost::alloc::vec::Vec<super::super::super::cosmos::base::v1beta1::Coin>,
490    /// Information that is used to estimate execution time / gas
491    /// consumption of a swap on a given pool type.
492    #[prost(message, optional, tag = "13")]
493    pub info_by_pool_type: ::core::option::Option<InfoByPoolType>,
494    #[prost(message, optional, tag = "14")]
495    pub cyclic_arb_tracker: ::core::option::Option<CyclicArbTracker>,
496}
497/// SetProtoRevEnabledProposal is a gov Content type to update whether the
498/// protorev module is enabled
499#[allow(clippy::derive_partial_eq_without_eq)]
500#[derive(
501    Clone,
502    PartialEq,
503    Eq,
504    ::prost::Message,
505    ::serde::Serialize,
506    ::serde::Deserialize,
507    ::schemars::JsonSchema,
508    CosmwasmExt,
509)]
510#[proto_message(type_url = "/osmosis.protorev.v1beta1.SetProtoRevEnabledProposal")]
511pub struct SetProtoRevEnabledProposal {
512    #[prost(string, tag = "1")]
513    pub title: ::prost::alloc::string::String,
514    #[prost(string, tag = "2")]
515    pub description: ::prost::alloc::string::String,
516    #[prost(bool, tag = "3")]
517    pub enabled: bool,
518}
519/// SetProtoRevAdminAccountProposal is a gov Content type to set the admin
520/// account that will receive permissions to alter hot routes and set the
521/// developer address that will be receiving a share of profits from the module
522#[allow(clippy::derive_partial_eq_without_eq)]
523#[derive(
524    Clone,
525    PartialEq,
526    Eq,
527    ::prost::Message,
528    ::serde::Serialize,
529    ::serde::Deserialize,
530    ::schemars::JsonSchema,
531    CosmwasmExt,
532)]
533#[proto_message(type_url = "/osmosis.protorev.v1beta1.SetProtoRevAdminAccountProposal")]
534pub struct SetProtoRevAdminAccountProposal {
535    #[prost(string, tag = "1")]
536    pub title: ::prost::alloc::string::String,
537    #[prost(string, tag = "2")]
538    pub description: ::prost::alloc::string::String,
539    #[prost(string, tag = "3")]
540    pub account: ::prost::alloc::string::String,
541}
542/// QueryParamsRequest is request type for the Query/Params RPC method.
543#[allow(clippy::derive_partial_eq_without_eq)]
544#[derive(
545    Clone,
546    PartialEq,
547    Eq,
548    ::prost::Message,
549    ::serde::Serialize,
550    ::serde::Deserialize,
551    ::schemars::JsonSchema,
552    CosmwasmExt,
553)]
554#[proto_message(type_url = "/osmosis.protorev.v1beta1.QueryParamsRequest")]
555#[proto_query(
556    path = "/osmosis.protorev.v1beta1.Query/Params",
557    response_type = QueryParamsResponse
558)]
559pub struct QueryParamsRequest {}
560/// QueryParamsResponse is response type for the Query/Params RPC method.
561#[allow(clippy::derive_partial_eq_without_eq)]
562#[derive(
563    Clone,
564    PartialEq,
565    Eq,
566    ::prost::Message,
567    ::serde::Serialize,
568    ::serde::Deserialize,
569    ::schemars::JsonSchema,
570    CosmwasmExt,
571)]
572#[proto_message(type_url = "/osmosis.protorev.v1beta1.QueryParamsResponse")]
573pub struct QueryParamsResponse {
574    /// params holds all the parameters of this module.
575    #[prost(message, optional, tag = "1")]
576    pub params: ::core::option::Option<Params>,
577}
578/// QueryGetProtoRevNumberOfTradesRequest is request type for the
579/// Query/GetProtoRevNumberOfTrades RPC method.
580#[allow(clippy::derive_partial_eq_without_eq)]
581#[derive(
582    Clone,
583    PartialEq,
584    Eq,
585    ::prost::Message,
586    ::serde::Serialize,
587    ::serde::Deserialize,
588    ::schemars::JsonSchema,
589    CosmwasmExt,
590)]
591#[proto_message(type_url = "/osmosis.protorev.v1beta1.QueryGetProtoRevNumberOfTradesRequest")]
592#[proto_query(
593    path = "/osmosis.protorev.v1beta1.Query/GetProtoRevNumberOfTrades",
594    response_type = QueryGetProtoRevNumberOfTradesResponse
595)]
596pub struct QueryGetProtoRevNumberOfTradesRequest {}
597/// QueryGetProtoRevNumberOfTradesResponse is response type for the
598/// Query/GetProtoRevNumberOfTrades RPC method.
599#[allow(clippy::derive_partial_eq_without_eq)]
600#[derive(
601    Clone,
602    PartialEq,
603    Eq,
604    ::prost::Message,
605    ::serde::Serialize,
606    ::serde::Deserialize,
607    ::schemars::JsonSchema,
608    CosmwasmExt,
609)]
610#[proto_message(type_url = "/osmosis.protorev.v1beta1.QueryGetProtoRevNumberOfTradesResponse")]
611pub struct QueryGetProtoRevNumberOfTradesResponse {
612    /// number_of_trades is the number of trades the module has executed
613    #[prost(string, tag = "1")]
614    pub number_of_trades: ::prost::alloc::string::String,
615}
616/// QueryGetProtoRevProfitsByDenomRequest is request type for the
617/// Query/GetProtoRevProfitsByDenom RPC method.
618#[allow(clippy::derive_partial_eq_without_eq)]
619#[derive(
620    Clone,
621    PartialEq,
622    Eq,
623    ::prost::Message,
624    ::serde::Serialize,
625    ::serde::Deserialize,
626    ::schemars::JsonSchema,
627    CosmwasmExt,
628)]
629#[proto_message(type_url = "/osmosis.protorev.v1beta1.QueryGetProtoRevProfitsByDenomRequest")]
630#[proto_query(
631    path = "/osmosis.protorev.v1beta1.Query/GetProtoRevProfitsByDenom",
632    response_type = QueryGetProtoRevProfitsByDenomResponse
633)]
634pub struct QueryGetProtoRevProfitsByDenomRequest {
635    /// denom is the denom to query profits by
636    #[prost(string, tag = "1")]
637    pub denom: ::prost::alloc::string::String,
638}
639/// QueryGetProtoRevProfitsByDenomResponse is response type for the
640/// Query/GetProtoRevProfitsByDenom RPC method.
641#[allow(clippy::derive_partial_eq_without_eq)]
642#[derive(
643    Clone,
644    PartialEq,
645    Eq,
646    ::prost::Message,
647    ::serde::Serialize,
648    ::serde::Deserialize,
649    ::schemars::JsonSchema,
650    CosmwasmExt,
651)]
652#[proto_message(type_url = "/osmosis.protorev.v1beta1.QueryGetProtoRevProfitsByDenomResponse")]
653pub struct QueryGetProtoRevProfitsByDenomResponse {
654    /// profit is the profits of the module by the selected denom
655    #[prost(message, optional, tag = "1")]
656    pub profit: ::core::option::Option<super::super::super::cosmos::base::v1beta1::Coin>,
657}
658/// QueryGetProtoRevAllProfitsRequest is request type for the
659/// Query/GetProtoRevAllProfits RPC method.
660#[allow(clippy::derive_partial_eq_without_eq)]
661#[derive(
662    Clone,
663    PartialEq,
664    Eq,
665    ::prost::Message,
666    ::serde::Serialize,
667    ::serde::Deserialize,
668    ::schemars::JsonSchema,
669    CosmwasmExt,
670)]
671#[proto_message(type_url = "/osmosis.protorev.v1beta1.QueryGetProtoRevAllProfitsRequest")]
672#[proto_query(
673    path = "/osmosis.protorev.v1beta1.Query/GetProtoRevAllProfits",
674    response_type = QueryGetProtoRevAllProfitsResponse
675)]
676pub struct QueryGetProtoRevAllProfitsRequest {}
677/// QueryGetProtoRevAllProfitsResponse is response type for the
678/// Query/GetProtoRevAllProfits RPC method.
679#[allow(clippy::derive_partial_eq_without_eq)]
680#[derive(
681    Clone,
682    PartialEq,
683    Eq,
684    ::prost::Message,
685    ::serde::Serialize,
686    ::serde::Deserialize,
687    ::schemars::JsonSchema,
688    CosmwasmExt,
689)]
690#[proto_message(type_url = "/osmosis.protorev.v1beta1.QueryGetProtoRevAllProfitsResponse")]
691pub struct QueryGetProtoRevAllProfitsResponse {
692    /// profits is a list of all of the profits from the module
693    #[prost(message, repeated, tag = "1")]
694    pub profits: ::prost::alloc::vec::Vec<super::super::super::cosmos::base::v1beta1::Coin>,
695}
696/// QueryGetProtoRevStatisticsByPoolRequest is request type for the
697/// Query/GetProtoRevStatisticsByRoute RPC method.
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.protorev.v1beta1.QueryGetProtoRevStatisticsByRouteRequest")]
710#[proto_query(
711    path = "/osmosis.protorev.v1beta1.Query/GetProtoRevStatisticsByRoute",
712    response_type = QueryGetProtoRevStatisticsByRouteResponse
713)]
714pub struct QueryGetProtoRevStatisticsByRouteRequest {
715    /// route is the set of pool ids to query statistics by i.e. 1,2,3
716    #[prost(uint64, repeated, packed = "false", tag = "1")]
717    #[serde(
718        serialize_with = "crate::serde::as_str_vec::serialize",
719        deserialize_with = "crate::serde::as_str_vec::deserialize"
720    )]
721    pub route: ::prost::alloc::vec::Vec<u64>,
722}
723/// QueryGetProtoRevStatisticsByRouteResponse is response type for the
724/// Query/GetProtoRevStatisticsByRoute RPC method.
725#[allow(clippy::derive_partial_eq_without_eq)]
726#[derive(
727    Clone,
728    PartialEq,
729    Eq,
730    ::prost::Message,
731    ::serde::Serialize,
732    ::serde::Deserialize,
733    ::schemars::JsonSchema,
734    CosmwasmExt,
735)]
736#[proto_message(type_url = "/osmosis.protorev.v1beta1.QueryGetProtoRevStatisticsByRouteResponse")]
737pub struct QueryGetProtoRevStatisticsByRouteResponse {
738    /// statistics contains the number of trades the module has executed after a
739    /// swap on a given pool and the profits from the trades
740    #[prost(message, optional, tag = "1")]
741    pub statistics: ::core::option::Option<RouteStatistics>,
742}
743/// QueryGetProtoRevAllRouteStatisticsRequest is request type for the
744/// Query/GetProtoRevAllRouteStatistics RPC method.
745#[allow(clippy::derive_partial_eq_without_eq)]
746#[derive(
747    Clone,
748    PartialEq,
749    Eq,
750    ::prost::Message,
751    ::serde::Serialize,
752    ::serde::Deserialize,
753    ::schemars::JsonSchema,
754    CosmwasmExt,
755)]
756#[proto_message(type_url = "/osmosis.protorev.v1beta1.QueryGetProtoRevAllRouteStatisticsRequest")]
757#[proto_query(
758    path = "/osmosis.protorev.v1beta1.Query/GetProtoRevAllRouteStatistics",
759    response_type = QueryGetProtoRevAllRouteStatisticsResponse
760)]
761pub struct QueryGetProtoRevAllRouteStatisticsRequest {}
762/// QueryGetProtoRevAllRouteStatisticsResponse is response type for the
763/// Query/GetProtoRevAllRouteStatistics RPC method.
764#[allow(clippy::derive_partial_eq_without_eq)]
765#[derive(
766    Clone,
767    PartialEq,
768    Eq,
769    ::prost::Message,
770    ::serde::Serialize,
771    ::serde::Deserialize,
772    ::schemars::JsonSchema,
773    CosmwasmExt,
774)]
775#[proto_message(type_url = "/osmosis.protorev.v1beta1.QueryGetProtoRevAllRouteStatisticsResponse")]
776pub struct QueryGetProtoRevAllRouteStatisticsResponse {
777    /// statistics contains the number of trades/profits the module has executed on
778    /// all routes it has successfully executed a trade on
779    #[prost(message, repeated, tag = "1")]
780    pub statistics: ::prost::alloc::vec::Vec<RouteStatistics>,
781}
782/// QueryGetProtoRevTokenPairArbRoutesRequest is request type for the
783/// Query/GetProtoRevTokenPairArbRoutes RPC method.
784#[allow(clippy::derive_partial_eq_without_eq)]
785#[derive(
786    Clone,
787    PartialEq,
788    Eq,
789    ::prost::Message,
790    ::serde::Serialize,
791    ::serde::Deserialize,
792    ::schemars::JsonSchema,
793    CosmwasmExt,
794)]
795#[proto_message(type_url = "/osmosis.protorev.v1beta1.QueryGetProtoRevTokenPairArbRoutesRequest")]
796#[proto_query(
797    path = "/osmosis.protorev.v1beta1.Query/GetProtoRevTokenPairArbRoutes",
798    response_type = QueryGetProtoRevTokenPairArbRoutesResponse
799)]
800pub struct QueryGetProtoRevTokenPairArbRoutesRequest {}
801/// QueryGetProtoRevTokenPairArbRoutesResponse is response type for the
802/// Query/GetProtoRevTokenPairArbRoutes RPC method.
803#[allow(clippy::derive_partial_eq_without_eq)]
804#[derive(
805    Clone,
806    PartialEq,
807    Eq,
808    ::prost::Message,
809    ::serde::Serialize,
810    ::serde::Deserialize,
811    ::schemars::JsonSchema,
812    CosmwasmExt,
813)]
814#[proto_message(type_url = "/osmosis.protorev.v1beta1.QueryGetProtoRevTokenPairArbRoutesResponse")]
815pub struct QueryGetProtoRevTokenPairArbRoutesResponse {
816    /// routes is a list of all of the hot routes that the module is currently
817    /// arbitraging
818    #[prost(message, repeated, tag = "1")]
819    pub routes: ::prost::alloc::vec::Vec<TokenPairArbRoutes>,
820}
821/// QueryGetProtoRevAdminAccountRequest is request type for the
822/// Query/GetProtoRevAdminAccount RPC method.
823#[allow(clippy::derive_partial_eq_without_eq)]
824#[derive(
825    Clone,
826    PartialEq,
827    Eq,
828    ::prost::Message,
829    ::serde::Serialize,
830    ::serde::Deserialize,
831    ::schemars::JsonSchema,
832    CosmwasmExt,
833)]
834#[proto_message(type_url = "/osmosis.protorev.v1beta1.QueryGetProtoRevAdminAccountRequest")]
835#[proto_query(
836    path = "/osmosis.protorev.v1beta1.Query/GetProtoRevAdminAccount",
837    response_type = QueryGetProtoRevAdminAccountResponse
838)]
839pub struct QueryGetProtoRevAdminAccountRequest {}
840/// QueryGetProtoRevAdminAccountResponse is response type for the
841/// Query/GetProtoRevAdminAccount RPC method.
842#[allow(clippy::derive_partial_eq_without_eq)]
843#[derive(
844    Clone,
845    PartialEq,
846    Eq,
847    ::prost::Message,
848    ::serde::Serialize,
849    ::serde::Deserialize,
850    ::schemars::JsonSchema,
851    CosmwasmExt,
852)]
853#[proto_message(type_url = "/osmosis.protorev.v1beta1.QueryGetProtoRevAdminAccountResponse")]
854pub struct QueryGetProtoRevAdminAccountResponse {
855    /// admin_account is the admin account of the module
856    #[prost(string, tag = "1")]
857    pub admin_account: ::prost::alloc::string::String,
858}
859/// QueryGetProtoRevDeveloperAccountRequest is request type for the
860/// Query/GetProtoRevDeveloperAccount RPC method.
861#[allow(clippy::derive_partial_eq_without_eq)]
862#[derive(
863    Clone,
864    PartialEq,
865    Eq,
866    ::prost::Message,
867    ::serde::Serialize,
868    ::serde::Deserialize,
869    ::schemars::JsonSchema,
870    CosmwasmExt,
871)]
872#[proto_message(type_url = "/osmosis.protorev.v1beta1.QueryGetProtoRevDeveloperAccountRequest")]
873#[proto_query(
874    path = "/osmosis.protorev.v1beta1.Query/GetProtoRevDeveloperAccount",
875    response_type = QueryGetProtoRevDeveloperAccountResponse
876)]
877pub struct QueryGetProtoRevDeveloperAccountRequest {}
878/// QueryGetProtoRevDeveloperAccountResponse is response type for the
879/// Query/GetProtoRevDeveloperAccount RPC method.
880#[allow(clippy::derive_partial_eq_without_eq)]
881#[derive(
882    Clone,
883    PartialEq,
884    Eq,
885    ::prost::Message,
886    ::serde::Serialize,
887    ::serde::Deserialize,
888    ::schemars::JsonSchema,
889    CosmwasmExt,
890)]
891#[proto_message(type_url = "/osmosis.protorev.v1beta1.QueryGetProtoRevDeveloperAccountResponse")]
892pub struct QueryGetProtoRevDeveloperAccountResponse {
893    /// developer_account is the developer account of the module
894    #[prost(string, tag = "1")]
895    pub developer_account: ::prost::alloc::string::String,
896}
897/// QueryGetProtoRevInfoByPoolTypeRequest is request type for the
898/// Query/GetProtoRevInfoByPoolType RPC method.
899#[allow(clippy::derive_partial_eq_without_eq)]
900#[derive(
901    Clone,
902    PartialEq,
903    Eq,
904    ::prost::Message,
905    ::serde::Serialize,
906    ::serde::Deserialize,
907    ::schemars::JsonSchema,
908    CosmwasmExt,
909)]
910#[proto_message(type_url = "/osmosis.protorev.v1beta1.QueryGetProtoRevInfoByPoolTypeRequest")]
911#[proto_query(
912    path = "/osmosis.protorev.v1beta1.Query/GetProtoRevInfoByPoolType",
913    response_type = QueryGetProtoRevInfoByPoolTypeResponse
914)]
915pub struct QueryGetProtoRevInfoByPoolTypeRequest {}
916/// QueryGetProtoRevInfoByPoolTypeResponse is response type for the
917/// Query/GetProtoRevInfoByPoolType RPC method.
918#[allow(clippy::derive_partial_eq_without_eq)]
919#[derive(
920    Clone,
921    PartialEq,
922    Eq,
923    ::prost::Message,
924    ::serde::Serialize,
925    ::serde::Deserialize,
926    ::schemars::JsonSchema,
927    CosmwasmExt,
928)]
929#[proto_message(type_url = "/osmosis.protorev.v1beta1.QueryGetProtoRevInfoByPoolTypeResponse")]
930pub struct QueryGetProtoRevInfoByPoolTypeResponse {
931    /// InfoByPoolType contains all information pertaining to how different
932    /// pool types are handled by the module.
933    #[prost(message, optional, tag = "1")]
934    pub info_by_pool_type: ::core::option::Option<InfoByPoolType>,
935}
936/// QueryGetProtoRevMaxPoolPointsPerBlockRequest is request type for the
937/// Query/GetProtoRevMaxPoolPointsPerBlock RPC method.
938#[allow(clippy::derive_partial_eq_without_eq)]
939#[derive(
940    Clone,
941    PartialEq,
942    Eq,
943    ::prost::Message,
944    ::serde::Serialize,
945    ::serde::Deserialize,
946    ::schemars::JsonSchema,
947    CosmwasmExt,
948)]
949#[proto_message(
950    type_url = "/osmosis.protorev.v1beta1.QueryGetProtoRevMaxPoolPointsPerBlockRequest"
951)]
952#[proto_query(
953    path = "/osmosis.protorev.v1beta1.Query/GetProtoRevMaxPoolPointsPerBlock",
954    response_type = QueryGetProtoRevMaxPoolPointsPerBlockResponse
955)]
956pub struct QueryGetProtoRevMaxPoolPointsPerBlockRequest {}
957/// QueryGetProtoRevMaxPoolPointsPerBlockResponse is response type for the
958/// Query/GetProtoRevMaxPoolPointsPerBlock RPC method.
959#[allow(clippy::derive_partial_eq_without_eq)]
960#[derive(
961    Clone,
962    PartialEq,
963    Eq,
964    ::prost::Message,
965    ::serde::Serialize,
966    ::serde::Deserialize,
967    ::schemars::JsonSchema,
968    CosmwasmExt,
969)]
970#[proto_message(
971    type_url = "/osmosis.protorev.v1beta1.QueryGetProtoRevMaxPoolPointsPerBlockResponse"
972)]
973pub struct QueryGetProtoRevMaxPoolPointsPerBlockResponse {
974    /// max_pool_points_per_block is the maximum number of pool points that can be
975    /// consumed per block
976    #[prost(uint64, tag = "1")]
977    #[serde(
978        serialize_with = "crate::serde::as_str::serialize",
979        deserialize_with = "crate::serde::as_str::deserialize"
980    )]
981    pub max_pool_points_per_block: u64,
982}
983/// QueryGetProtoRevMaxPoolPointsPerTxRequest is request type for the
984/// Query/GetProtoRevMaxPoolPointsPerTx RPC method.
985#[allow(clippy::derive_partial_eq_without_eq)]
986#[derive(
987    Clone,
988    PartialEq,
989    Eq,
990    ::prost::Message,
991    ::serde::Serialize,
992    ::serde::Deserialize,
993    ::schemars::JsonSchema,
994    CosmwasmExt,
995)]
996#[proto_message(type_url = "/osmosis.protorev.v1beta1.QueryGetProtoRevMaxPoolPointsPerTxRequest")]
997#[proto_query(
998    path = "/osmosis.protorev.v1beta1.Query/GetProtoRevMaxPoolPointsPerTx",
999    response_type = QueryGetProtoRevMaxPoolPointsPerTxResponse
1000)]
1001pub struct QueryGetProtoRevMaxPoolPointsPerTxRequest {}
1002/// QueryGetProtoRevMaxPoolPointsPerTxResponse is response type for the
1003/// Query/GetProtoRevMaxPoolPointsPerTx RPC method.
1004#[allow(clippy::derive_partial_eq_without_eq)]
1005#[derive(
1006    Clone,
1007    PartialEq,
1008    Eq,
1009    ::prost::Message,
1010    ::serde::Serialize,
1011    ::serde::Deserialize,
1012    ::schemars::JsonSchema,
1013    CosmwasmExt,
1014)]
1015#[proto_message(type_url = "/osmosis.protorev.v1beta1.QueryGetProtoRevMaxPoolPointsPerTxResponse")]
1016pub struct QueryGetProtoRevMaxPoolPointsPerTxResponse {
1017    /// max_pool_points_per_tx is the maximum number of pool points that can be
1018    /// consumed per transaction
1019    #[prost(uint64, tag = "1")]
1020    #[serde(
1021        serialize_with = "crate::serde::as_str::serialize",
1022        deserialize_with = "crate::serde::as_str::deserialize"
1023    )]
1024    pub max_pool_points_per_tx: u64,
1025}
1026/// QueryGetProtoRevBaseDenomsRequest is request type for the
1027/// Query/GetProtoRevBaseDenoms RPC method.
1028#[allow(clippy::derive_partial_eq_without_eq)]
1029#[derive(
1030    Clone,
1031    PartialEq,
1032    Eq,
1033    ::prost::Message,
1034    ::serde::Serialize,
1035    ::serde::Deserialize,
1036    ::schemars::JsonSchema,
1037    CosmwasmExt,
1038)]
1039#[proto_message(type_url = "/osmosis.protorev.v1beta1.QueryGetProtoRevBaseDenomsRequest")]
1040#[proto_query(
1041    path = "/osmosis.protorev.v1beta1.Query/GetProtoRevBaseDenoms",
1042    response_type = QueryGetProtoRevBaseDenomsResponse
1043)]
1044pub struct QueryGetProtoRevBaseDenomsRequest {}
1045/// QueryGetProtoRevBaseDenomsResponse is response type for the
1046/// Query/GetProtoRevBaseDenoms RPC method.
1047#[allow(clippy::derive_partial_eq_without_eq)]
1048#[derive(
1049    Clone,
1050    PartialEq,
1051    Eq,
1052    ::prost::Message,
1053    ::serde::Serialize,
1054    ::serde::Deserialize,
1055    ::schemars::JsonSchema,
1056    CosmwasmExt,
1057)]
1058#[proto_message(type_url = "/osmosis.protorev.v1beta1.QueryGetProtoRevBaseDenomsResponse")]
1059pub struct QueryGetProtoRevBaseDenomsResponse {
1060    /// base_denoms is a list of all of the base denoms and step sizes
1061    #[prost(message, repeated, tag = "1")]
1062    pub base_denoms: ::prost::alloc::vec::Vec<BaseDenom>,
1063}
1064/// QueryGetProtoRevEnabledRequest is request type for the
1065/// Query/GetProtoRevEnabled RPC method.
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.protorev.v1beta1.QueryGetProtoRevEnabledRequest")]
1078#[proto_query(
1079    path = "/osmosis.protorev.v1beta1.Query/GetProtoRevEnabled",
1080    response_type = QueryGetProtoRevEnabledResponse
1081)]
1082pub struct QueryGetProtoRevEnabledRequest {}
1083/// QueryGetProtoRevEnabledResponse is response type for the
1084/// Query/GetProtoRevEnabled RPC method.
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.protorev.v1beta1.QueryGetProtoRevEnabledResponse")]
1097pub struct QueryGetProtoRevEnabledResponse {
1098    /// enabled is whether the module is enabled
1099    #[prost(bool, tag = "1")]
1100    pub enabled: bool,
1101}
1102/// QueryGetProtoRevPoolRequest is request type for the
1103/// Query/GetProtoRevPool RPC method.
1104#[allow(clippy::derive_partial_eq_without_eq)]
1105#[derive(
1106    Clone,
1107    PartialEq,
1108    Eq,
1109    ::prost::Message,
1110    ::serde::Serialize,
1111    ::serde::Deserialize,
1112    ::schemars::JsonSchema,
1113    CosmwasmExt,
1114)]
1115#[proto_message(type_url = "/osmosis.protorev.v1beta1.QueryGetProtoRevPoolRequest")]
1116#[proto_query(
1117    path = "/osmosis.protorev.v1beta1.Query/GetProtoRevPool",
1118    response_type = QueryGetProtoRevPoolResponse
1119)]
1120pub struct QueryGetProtoRevPoolRequest {
1121    /// base_denom is the base denom set in protorev for the denom pair to pool
1122    /// mapping
1123    #[prost(string, tag = "1")]
1124    pub base_denom: ::prost::alloc::string::String,
1125    /// other_denom is the other denom for the denom pair to pool mapping
1126    #[prost(string, tag = "2")]
1127    pub other_denom: ::prost::alloc::string::String,
1128}
1129/// QueryGetProtoRevPoolResponse is response type for the
1130/// Query/GetProtoRevPool RPC method.
1131#[allow(clippy::derive_partial_eq_without_eq)]
1132#[derive(
1133    Clone,
1134    PartialEq,
1135    Eq,
1136    ::prost::Message,
1137    ::serde::Serialize,
1138    ::serde::Deserialize,
1139    ::schemars::JsonSchema,
1140    CosmwasmExt,
1141)]
1142#[proto_message(type_url = "/osmosis.protorev.v1beta1.QueryGetProtoRevPoolResponse")]
1143pub struct QueryGetProtoRevPoolResponse {
1144    /// pool_id is the pool_id stored for the denom pair
1145    #[prost(uint64, tag = "1")]
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.protorev.v1beta1.QueryGetAllProtocolRevenueRequest")]
1165#[proto_query(
1166    path = "/osmosis.protorev.v1beta1.Query/GetAllProtocolRevenue",
1167    response_type = QueryGetAllProtocolRevenueResponse
1168)]
1169pub struct QueryGetAllProtocolRevenueRequest {}
1170#[allow(clippy::derive_partial_eq_without_eq)]
1171#[derive(
1172    Clone,
1173    PartialEq,
1174    Eq,
1175    ::prost::Message,
1176    ::serde::Serialize,
1177    ::serde::Deserialize,
1178    ::schemars::JsonSchema,
1179    CosmwasmExt,
1180)]
1181#[proto_message(type_url = "/osmosis.protorev.v1beta1.QueryGetAllProtocolRevenueResponse")]
1182pub struct QueryGetAllProtocolRevenueResponse {
1183    #[prost(message, optional, tag = "1")]
1184    pub all_protocol_revenue: ::core::option::Option<AllProtocolRevenue>,
1185}
1186/// MsgSetHotRoutes defines the Msg/SetHotRoutes request type.
1187#[allow(clippy::derive_partial_eq_without_eq)]
1188#[derive(
1189    Clone,
1190    PartialEq,
1191    Eq,
1192    ::prost::Message,
1193    ::serde::Serialize,
1194    ::serde::Deserialize,
1195    ::schemars::JsonSchema,
1196    CosmwasmExt,
1197)]
1198#[proto_message(type_url = "/osmosis.protorev.v1beta1.MsgSetHotRoutes")]
1199pub struct MsgSetHotRoutes {
1200    /// admin is the account that is authorized to set the hot routes.
1201    #[prost(string, tag = "1")]
1202    pub admin: ::prost::alloc::string::String,
1203    /// hot_routes is the list of hot routes to set.
1204    #[prost(message, repeated, tag = "2")]
1205    pub hot_routes: ::prost::alloc::vec::Vec<TokenPairArbRoutes>,
1206}
1207/// MsgSetHotRoutesResponse defines the Msg/SetHotRoutes response type.
1208#[allow(clippy::derive_partial_eq_without_eq)]
1209#[derive(
1210    Clone,
1211    PartialEq,
1212    Eq,
1213    ::prost::Message,
1214    ::serde::Serialize,
1215    ::serde::Deserialize,
1216    ::schemars::JsonSchema,
1217    CosmwasmExt,
1218)]
1219#[proto_message(type_url = "/osmosis.protorev.v1beta1.MsgSetHotRoutesResponse")]
1220pub struct MsgSetHotRoutesResponse {}
1221/// MsgSetDeveloperAccount defines the Msg/SetDeveloperAccount request type.
1222#[allow(clippy::derive_partial_eq_without_eq)]
1223#[derive(
1224    Clone,
1225    PartialEq,
1226    Eq,
1227    ::prost::Message,
1228    ::serde::Serialize,
1229    ::serde::Deserialize,
1230    ::schemars::JsonSchema,
1231    CosmwasmExt,
1232)]
1233#[proto_message(type_url = "/osmosis.protorev.v1beta1.MsgSetDeveloperAccount")]
1234pub struct MsgSetDeveloperAccount {
1235    /// admin is the account that is authorized to set the developer account.
1236    #[prost(string, tag = "1")]
1237    pub admin: ::prost::alloc::string::String,
1238    /// developer_account is the account that will receive a portion of the profits
1239    /// from the protorev module.
1240    #[prost(string, tag = "2")]
1241    pub developer_account: ::prost::alloc::string::String,
1242}
1243/// MsgSetDeveloperAccountResponse defines the Msg/SetDeveloperAccount response
1244/// type.
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.protorev.v1beta1.MsgSetDeveloperAccountResponse")]
1257pub struct MsgSetDeveloperAccountResponse {}
1258/// MsgSetInfoByPoolType defines the Msg/SetInfoByPoolType request type.
1259#[allow(clippy::derive_partial_eq_without_eq)]
1260#[derive(
1261    Clone,
1262    PartialEq,
1263    Eq,
1264    ::prost::Message,
1265    ::serde::Serialize,
1266    ::serde::Deserialize,
1267    ::schemars::JsonSchema,
1268    CosmwasmExt,
1269)]
1270#[proto_message(type_url = "/osmosis.protorev.v1beta1.MsgSetInfoByPoolType")]
1271pub struct MsgSetInfoByPoolType {
1272    /// admin is the account that is authorized to set the pool weights.
1273    #[prost(string, tag = "1")]
1274    pub admin: ::prost::alloc::string::String,
1275    /// info_by_pool_type contains information about the pool types.
1276    #[prost(message, optional, tag = "2")]
1277    pub info_by_pool_type: ::core::option::Option<InfoByPoolType>,
1278}
1279/// MsgSetInfoByPoolTypeResponse defines the Msg/SetInfoByPoolType response type.
1280#[allow(clippy::derive_partial_eq_without_eq)]
1281#[derive(
1282    Clone,
1283    PartialEq,
1284    Eq,
1285    ::prost::Message,
1286    ::serde::Serialize,
1287    ::serde::Deserialize,
1288    ::schemars::JsonSchema,
1289    CosmwasmExt,
1290)]
1291#[proto_message(type_url = "/osmosis.protorev.v1beta1.MsgSetInfoByPoolTypeResponse")]
1292pub struct MsgSetInfoByPoolTypeResponse {}
1293/// MsgSetMaxPoolPointsPerTx defines the Msg/SetMaxPoolPointsPerTx request type.
1294#[allow(clippy::derive_partial_eq_without_eq)]
1295#[derive(
1296    Clone,
1297    PartialEq,
1298    Eq,
1299    ::prost::Message,
1300    ::serde::Serialize,
1301    ::serde::Deserialize,
1302    ::schemars::JsonSchema,
1303    CosmwasmExt,
1304)]
1305#[proto_message(type_url = "/osmosis.protorev.v1beta1.MsgSetMaxPoolPointsPerTx")]
1306pub struct MsgSetMaxPoolPointsPerTx {
1307    /// admin is the account that is authorized to set the max pool points per tx.
1308    #[prost(string, tag = "1")]
1309    pub admin: ::prost::alloc::string::String,
1310    /// max_pool_points_per_tx is the maximum number of pool points that can be
1311    /// consumed per transaction.
1312    #[prost(uint64, tag = "2")]
1313    #[serde(
1314        serialize_with = "crate::serde::as_str::serialize",
1315        deserialize_with = "crate::serde::as_str::deserialize"
1316    )]
1317    pub max_pool_points_per_tx: u64,
1318}
1319/// MsgSetMaxPoolPointsPerTxResponse defines the Msg/SetMaxPoolPointsPerTx
1320/// response type.
1321#[allow(clippy::derive_partial_eq_without_eq)]
1322#[derive(
1323    Clone,
1324    PartialEq,
1325    Eq,
1326    ::prost::Message,
1327    ::serde::Serialize,
1328    ::serde::Deserialize,
1329    ::schemars::JsonSchema,
1330    CosmwasmExt,
1331)]
1332#[proto_message(type_url = "/osmosis.protorev.v1beta1.MsgSetMaxPoolPointsPerTxResponse")]
1333pub struct MsgSetMaxPoolPointsPerTxResponse {}
1334/// MsgSetMaxPoolPointsPerBlock defines the Msg/SetMaxPoolPointsPerBlock request
1335/// type.
1336#[allow(clippy::derive_partial_eq_without_eq)]
1337#[derive(
1338    Clone,
1339    PartialEq,
1340    Eq,
1341    ::prost::Message,
1342    ::serde::Serialize,
1343    ::serde::Deserialize,
1344    ::schemars::JsonSchema,
1345    CosmwasmExt,
1346)]
1347#[proto_message(type_url = "/osmosis.protorev.v1beta1.MsgSetMaxPoolPointsPerBlock")]
1348pub struct MsgSetMaxPoolPointsPerBlock {
1349    /// admin is the account that is authorized to set the max pool points per
1350    /// block.
1351    #[prost(string, tag = "1")]
1352    pub admin: ::prost::alloc::string::String,
1353    /// max_pool_points_per_block is the maximum number of pool points that can be
1354    /// consumed per block.
1355    #[prost(uint64, tag = "2")]
1356    #[serde(
1357        serialize_with = "crate::serde::as_str::serialize",
1358        deserialize_with = "crate::serde::as_str::deserialize"
1359    )]
1360    pub max_pool_points_per_block: u64,
1361}
1362/// MsgSetMaxPoolPointsPerBlockResponse defines the
1363/// Msg/SetMaxPoolPointsPerBlock response type.
1364#[allow(clippy::derive_partial_eq_without_eq)]
1365#[derive(
1366    Clone,
1367    PartialEq,
1368    Eq,
1369    ::prost::Message,
1370    ::serde::Serialize,
1371    ::serde::Deserialize,
1372    ::schemars::JsonSchema,
1373    CosmwasmExt,
1374)]
1375#[proto_message(type_url = "/osmosis.protorev.v1beta1.MsgSetMaxPoolPointsPerBlockResponse")]
1376pub struct MsgSetMaxPoolPointsPerBlockResponse {}
1377/// MsgSetBaseDenoms defines the Msg/SetBaseDenoms request type.
1378#[allow(clippy::derive_partial_eq_without_eq)]
1379#[derive(
1380    Clone,
1381    PartialEq,
1382    Eq,
1383    ::prost::Message,
1384    ::serde::Serialize,
1385    ::serde::Deserialize,
1386    ::schemars::JsonSchema,
1387    CosmwasmExt,
1388)]
1389#[proto_message(type_url = "/osmosis.protorev.v1beta1.MsgSetBaseDenoms")]
1390pub struct MsgSetBaseDenoms {
1391    /// admin is the account that is authorized to set the base denoms.
1392    #[prost(string, tag = "1")]
1393    pub admin: ::prost::alloc::string::String,
1394    /// base_denoms is the list of base denoms to set.
1395    #[prost(message, repeated, tag = "2")]
1396    pub base_denoms: ::prost::alloc::vec::Vec<BaseDenom>,
1397}
1398/// Deprecated, but must be retained in the file to allow indexers
1399/// to index blocks since genesis
1400#[allow(clippy::derive_partial_eq_without_eq)]
1401#[derive(
1402    Clone,
1403    PartialEq,
1404    Eq,
1405    ::prost::Message,
1406    ::serde::Serialize,
1407    ::serde::Deserialize,
1408    ::schemars::JsonSchema,
1409    CosmwasmExt,
1410)]
1411#[proto_message(type_url = "/osmosis.protorev.v1beta1.MsgSetBaseDenomsResponse")]
1412pub struct MsgSetBaseDenomsResponse {}
1413/// MsgSetPoolWeights defines the Msg/SetPoolWeights request type.
1414#[allow(clippy::derive_partial_eq_without_eq)]
1415#[derive(
1416    Clone,
1417    PartialEq,
1418    Eq,
1419    ::prost::Message,
1420    ::serde::Serialize,
1421    ::serde::Deserialize,
1422    ::schemars::JsonSchema,
1423    CosmwasmExt,
1424)]
1425#[proto_message(type_url = "/osmosis.protorev.v1beta1.MsgSetPoolWeights")]
1426pub struct MsgSetPoolWeights {
1427    /// admin is the account that is authorized to set the pool weights.
1428    #[prost(string, tag = "1")]
1429    pub admin: ::prost::alloc::string::String,
1430    /// pool_weights is the list of pool weights to set.
1431    #[prost(message, optional, tag = "2")]
1432    pub pool_weights: ::core::option::Option<PoolWeights>,
1433}
1434pub struct ProtorevQuerier<'a, Q: cosmwasm_std::CustomQuery> {
1435    querier: &'a cosmwasm_std::QuerierWrapper<'a, Q>,
1436}
1437impl<'a, Q: cosmwasm_std::CustomQuery> ProtorevQuerier<'a, Q> {
1438    pub fn new(querier: &'a cosmwasm_std::QuerierWrapper<'a, Q>) -> Self {
1439        Self { querier }
1440    }
1441    pub fn params(&self) -> Result<QueryParamsResponse, cosmwasm_std::StdError> {
1442        QueryParamsRequest {}.query(self.querier)
1443    }
1444    pub fn get_proto_rev_number_of_trades(
1445        &self,
1446    ) -> Result<QueryGetProtoRevNumberOfTradesResponse, cosmwasm_std::StdError> {
1447        QueryGetProtoRevNumberOfTradesRequest {}.query(self.querier)
1448    }
1449    pub fn get_proto_rev_profits_by_denom(
1450        &self,
1451        denom: ::prost::alloc::string::String,
1452    ) -> Result<QueryGetProtoRevProfitsByDenomResponse, cosmwasm_std::StdError> {
1453        QueryGetProtoRevProfitsByDenomRequest { denom }.query(self.querier)
1454    }
1455    pub fn get_proto_rev_all_profits(
1456        &self,
1457    ) -> Result<QueryGetProtoRevAllProfitsResponse, cosmwasm_std::StdError> {
1458        QueryGetProtoRevAllProfitsRequest {}.query(self.querier)
1459    }
1460    pub fn get_proto_rev_statistics_by_route(
1461        &self,
1462        route: ::prost::alloc::vec::Vec<u64>,
1463    ) -> Result<QueryGetProtoRevStatisticsByRouteResponse, cosmwasm_std::StdError> {
1464        QueryGetProtoRevStatisticsByRouteRequest { route }.query(self.querier)
1465    }
1466    pub fn get_proto_rev_all_route_statistics(
1467        &self,
1468    ) -> Result<QueryGetProtoRevAllRouteStatisticsResponse, cosmwasm_std::StdError> {
1469        QueryGetProtoRevAllRouteStatisticsRequest {}.query(self.querier)
1470    }
1471    pub fn get_proto_rev_token_pair_arb_routes(
1472        &self,
1473    ) -> Result<QueryGetProtoRevTokenPairArbRoutesResponse, cosmwasm_std::StdError> {
1474        QueryGetProtoRevTokenPairArbRoutesRequest {}.query(self.querier)
1475    }
1476    pub fn get_proto_rev_admin_account(
1477        &self,
1478    ) -> Result<QueryGetProtoRevAdminAccountResponse, cosmwasm_std::StdError> {
1479        QueryGetProtoRevAdminAccountRequest {}.query(self.querier)
1480    }
1481    pub fn get_proto_rev_developer_account(
1482        &self,
1483    ) -> Result<QueryGetProtoRevDeveloperAccountResponse, cosmwasm_std::StdError> {
1484        QueryGetProtoRevDeveloperAccountRequest {}.query(self.querier)
1485    }
1486    pub fn get_proto_rev_info_by_pool_type(
1487        &self,
1488    ) -> Result<QueryGetProtoRevInfoByPoolTypeResponse, cosmwasm_std::StdError> {
1489        QueryGetProtoRevInfoByPoolTypeRequest {}.query(self.querier)
1490    }
1491    pub fn get_proto_rev_max_pool_points_per_tx(
1492        &self,
1493    ) -> Result<QueryGetProtoRevMaxPoolPointsPerTxResponse, cosmwasm_std::StdError> {
1494        QueryGetProtoRevMaxPoolPointsPerTxRequest {}.query(self.querier)
1495    }
1496    pub fn get_proto_rev_max_pool_points_per_block(
1497        &self,
1498    ) -> Result<QueryGetProtoRevMaxPoolPointsPerBlockResponse, cosmwasm_std::StdError> {
1499        QueryGetProtoRevMaxPoolPointsPerBlockRequest {}.query(self.querier)
1500    }
1501    pub fn get_proto_rev_base_denoms(
1502        &self,
1503    ) -> Result<QueryGetProtoRevBaseDenomsResponse, cosmwasm_std::StdError> {
1504        QueryGetProtoRevBaseDenomsRequest {}.query(self.querier)
1505    }
1506    pub fn get_proto_rev_enabled(
1507        &self,
1508    ) -> Result<QueryGetProtoRevEnabledResponse, cosmwasm_std::StdError> {
1509        QueryGetProtoRevEnabledRequest {}.query(self.querier)
1510    }
1511    pub fn get_proto_rev_pool(
1512        &self,
1513        base_denom: ::prost::alloc::string::String,
1514        other_denom: ::prost::alloc::string::String,
1515    ) -> Result<QueryGetProtoRevPoolResponse, cosmwasm_std::StdError> {
1516        QueryGetProtoRevPoolRequest {
1517            base_denom,
1518            other_denom,
1519        }
1520        .query(self.querier)
1521    }
1522    pub fn get_all_protocol_revenue(
1523        &self,
1524    ) -> Result<QueryGetAllProtocolRevenueResponse, cosmwasm_std::StdError> {
1525        QueryGetAllProtocolRevenueRequest {}.query(self.querier)
1526    }
1527}
osmosis_std/types/osmosis/protorev/v1beta1.rs

osmosis_std/types/osmosis/protorev/
v1beta1.rs
