elys-stdd 0.1.0

use elys_std_deriv::CosmwasmExt;
/// Params defines the parameters for the module.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.LegacyParams")]
pub struct LegacyParams {
    #[prost(string, tag = "1")]
    pub leverage_max: ::prost::alloc::string::String,
    #[prost(int64, tag = "2")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub max_open_positions: i64,
    #[prost(string, tag = "3")]
    pub pool_open_threshold: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub safety_factor: ::prost::alloc::string::String,
    #[prost(bool, tag = "5")]
    pub whitelisting_enabled: bool,
    #[prost(int64, tag = "6")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub epoch_length: i64,
    #[prost(bool, tag = "7")]
    pub fallback_enabled: bool,
    /// Number of positions to process per block
    #[prost(int64, tag = "8")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub number_per_block: i64,
}
/// Params defines the parameters for the module.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.Params")]
pub struct Params {
    #[prost(string, tag = "1")]
    pub leverage_max: ::prost::alloc::string::String,
    #[prost(int64, tag = "2")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub max_open_positions: i64,
    #[prost(string, tag = "3")]
    pub pool_open_threshold: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub safety_factor: ::prost::alloc::string::String,
    #[prost(bool, tag = "5")]
    pub whitelisting_enabled: bool,
    #[prost(int64, tag = "6")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub epoch_length: i64,
    #[prost(bool, tag = "7")]
    pub fallback_enabled: bool,
    /// Number of positions to process per block
    #[prost(int64, tag = "8")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub number_per_block: i64,
    #[prost(uint64, repeated, tag = "9")]
    #[serde(
        serialize_with = "crate::serde::as_str_vec::serialize",
        deserialize_with = "crate::serde::as_str_vec::deserialize"
    )]
    pub enabled_pools: ::prost::alloc::vec::Vec<u64>,
    #[prost(string, tag = "10")]
    pub exit_buffer: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.Pool")]
pub struct Pool {
    #[prost(uint64, tag = "1")]
    #[serde(alias = "amm_poolID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub amm_pool_id: u64,
    #[prost(string, tag = "2")]
    pub health: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub leveraged_lp_amount: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub leverage_max: ::prost::alloc::string::String,
    #[prost(string, tag = "5")]
    pub max_leveragelp_ratio: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.LegacyPool")]
pub struct LegacyPool {
    #[prost(uint64, tag = "1")]
    #[serde(alias = "amm_poolID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub amm_pool_id: u64,
    #[prost(string, tag = "2")]
    pub health: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub leveraged_lp_amount: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub leverage_max: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.PositionRequest")]
#[proto_query(
    path = "/elys.leveragelp.Query/Position",
    response_type = PositionResponse
)]
pub struct PositionRequest {
    #[prost(string, tag = "1")]
    pub address: ::prost::alloc::string::String,
    #[prost(uint64, tag = "2")]
    #[serde(alias = "ID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub id: u64,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.Position")]
pub struct Position {
    #[prost(string, tag = "1")]
    pub address: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub collateral: ::core::option::Option<super::super::cosmos::base::v1beta1::Coin>,
    /// For recording
    #[prost(string, tag = "3")]
    pub liabilities: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub leveraged_lp_amount: ::prost::alloc::string::String,
    #[prost(string, tag = "5")]
    pub position_health: ::prost::alloc::string::String,
    #[prost(uint64, tag = "6")]
    #[serde(alias = "ID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub id: u64,
    #[prost(uint64, tag = "7")]
    #[serde(alias = "amm_poolID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub amm_pool_id: u64,
    #[prost(string, tag = "8")]
    pub stop_loss_price: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.LegacyPosition")]
pub struct LegacyPosition {
    #[prost(string, tag = "1")]
    pub address: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub collateral: ::core::option::Option<super::super::cosmos::base::v1beta1::Coin>,
    /// For recording
    #[prost(string, tag = "3")]
    pub liabilities: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub leverage: ::prost::alloc::string::String,
    #[prost(string, tag = "5")]
    pub leveraged_lp_amount: ::prost::alloc::string::String,
    #[prost(string, tag = "6")]
    pub position_health: ::prost::alloc::string::String,
    #[prost(uint64, tag = "7")]
    #[serde(alias = "ID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub id: u64,
    #[prost(uint64, tag = "8")]
    #[serde(alias = "amm_poolID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub amm_pool_id: u64,
    #[prost(string, tag = "9")]
    pub stop_loss_price: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.QueryPosition")]
pub struct QueryPosition {
    #[prost(message, optional, tag = "1")]
    pub position: ::core::option::Option<Position>,
    #[prost(string, tag = "2")]
    pub updated_leverage: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub position_usd_value: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.PositionAndInterest")]
pub struct PositionAndInterest {
    #[prost(message, optional, tag = "1")]
    pub position: ::core::option::Option<QueryPosition>,
    #[prost(string, tag = "2")]
    pub interest_rate_hour: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub interest_rate_hour_usd: ::prost::alloc::string::String,
}
/// GenesisState defines the leveragelp module's genesis state.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.GenesisState")]
pub struct GenesisState {
    #[prost(message, optional, tag = "1")]
    pub params: ::core::option::Option<Params>,
    #[prost(message, repeated, tag = "2")]
    pub pool_list: ::prost::alloc::vec::Vec<Pool>,
    #[prost(message, repeated, tag = "3")]
    pub position_list: ::prost::alloc::vec::Vec<Position>,
    #[prost(string, repeated, tag = "4")]
    pub address_whitelist: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// ParamsRequest is request type for the Query/Params RPC method.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.ParamsRequest")]
#[proto_query(path = "/elys.leveragelp.Query/Params", response_type = ParamsResponse)]
pub struct ParamsRequest {}
/// ParamsResponse is response type for the Query/Params RPC method.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.ParamsResponse")]
pub struct ParamsResponse {
    /// params holds all the parameters of this module.
    #[prost(message, optional, tag = "1")]
    pub params: ::core::option::Option<Params>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.PositionsRequest")]
#[proto_query(
    path = "/elys.leveragelp.Query/QueryPositions",
    response_type = PositionsResponse
)]
pub struct PositionsRequest {
    #[prost(message, optional, tag = "1")]
    pub pagination: ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageRequest>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.PositionsResponse")]
pub struct PositionsResponse {
    #[prost(message, repeated, tag = "1")]
    pub positions: ::prost::alloc::vec::Vec<QueryPosition>,
    #[prost(message, optional, tag = "2")]
    pub pagination:
        ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageResponse>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.PositionsByPoolRequest")]
#[proto_query(
    path = "/elys.leveragelp.Query/QueryPositionsByPool",
    response_type = PositionsByPoolResponse
)]
pub struct PositionsByPoolRequest {
    #[prost(uint64, tag = "1")]
    #[serde(alias = "amm_poolID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub amm_pool_id: u64,
    #[prost(message, optional, tag = "2")]
    pub pagination: ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageRequest>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.PositionsByPoolResponse")]
pub struct PositionsByPoolResponse {
    #[prost(message, repeated, tag = "1")]
    pub positions: ::prost::alloc::vec::Vec<QueryPosition>,
    #[prost(message, optional, tag = "2")]
    pub pagination:
        ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageResponse>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.StatusRequest")]
#[proto_query(path = "/elys.leveragelp.Query/GetStatus", response_type = StatusResponse)]
pub struct StatusRequest {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.StatusResponse")]
pub struct StatusResponse {
    #[prost(uint64, tag = "1")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub open_position_count: u64,
    #[prost(uint64, tag = "2")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub lifetime_position_count: u64,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.PositionsForAddressRequest")]
#[proto_query(
    path = "/elys.leveragelp.Query/QueryPositionsForAddress",
    response_type = PositionsForAddressResponse
)]
pub struct PositionsForAddressRequest {
    #[prost(string, tag = "1")]
    pub address: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub pagination: ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageRequest>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.PositionsForAddressResponse")]
pub struct PositionsForAddressResponse {
    #[prost(message, repeated, tag = "1")]
    pub positions: ::prost::alloc::vec::Vec<PositionAndInterest>,
    #[prost(message, optional, tag = "2")]
    pub pagination:
        ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageResponse>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.WhitelistRequest")]
#[proto_query(
    path = "/elys.leveragelp.Query/GetWhitelist",
    response_type = WhitelistResponse
)]
pub struct WhitelistRequest {
    #[prost(message, optional, tag = "1")]
    pub pagination: ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageRequest>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.WhitelistResponse")]
pub struct WhitelistResponse {
    #[prost(string, repeated, tag = "1")]
    pub whitelist: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(message, optional, tag = "2")]
    pub pagination:
        ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageResponse>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.IsWhitelistedRequest")]
#[proto_query(
    path = "/elys.leveragelp.Query/IsWhitelisted",
    response_type = IsWhitelistedResponse
)]
pub struct IsWhitelistedRequest {
    #[prost(string, tag = "1")]
    pub address: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.IsWhitelistedResponse")]
pub struct IsWhitelistedResponse {
    #[prost(string, tag = "1")]
    pub address: ::prost::alloc::string::String,
    #[prost(bool, tag = "2")]
    pub is_whitelisted: bool,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.QueryGetPoolRequest")]
#[proto_query(
    path = "/elys.leveragelp.Query/Pool",
    response_type = QueryGetPoolResponse
)]
pub struct QueryGetPoolRequest {
    #[prost(uint64, tag = "1")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub index: u64,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.QueryGetPoolResponse")]
pub struct QueryGetPoolResponse {
    #[prost(message, optional, tag = "1")]
    pub pool: ::core::option::Option<Pool>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.QueryAllPoolRequest")]
#[proto_query(
    path = "/elys.leveragelp.Query/Pools",
    response_type = QueryAllPoolResponse
)]
pub struct QueryAllPoolRequest {
    #[prost(message, optional, tag = "1")]
    pub pagination: ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageRequest>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.QueryAllPoolResponse")]
pub struct QueryAllPoolResponse {
    #[prost(message, repeated, tag = "1")]
    pub pool: ::prost::alloc::vec::Vec<Pool>,
    #[prost(message, optional, tag = "2")]
    pub pagination:
        ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageResponse>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.PositionResponse")]
pub struct PositionResponse {
    #[prost(message, optional, tag = "1")]
    pub position: ::core::option::Option<QueryPosition>,
    #[prost(string, tag = "2")]
    pub locked_lp_token: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.QueryLiquidationPriceRequest")]
#[proto_query(
    path = "/elys.leveragelp.Query/LiquidationPrice",
    response_type = QueryLiquidationPriceResponse
)]
pub struct QueryLiquidationPriceRequest {
    #[prost(string, tag = "1")]
    pub address: ::prost::alloc::string::String,
    #[prost(uint64, tag = "2")]
    #[serde(alias = "positionID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub position_id: u64,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.QueryLiquidationPriceResponse")]
pub struct QueryLiquidationPriceResponse {
    #[prost(string, tag = "1")]
    pub price: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.QueryOpenEstRequest")]
#[proto_query(
    path = "/elys.leveragelp.Query/OpenEst",
    response_type = QueryOpenEstResponse
)]
pub struct QueryOpenEstRequest {
    #[prost(string, tag = "1")]
    pub collateral_asset: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub collateral_amount: ::prost::alloc::string::String,
    #[prost(uint64, tag = "3")]
    #[serde(alias = "amm_poolID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub amm_pool_id: u64,
    #[prost(string, tag = "4")]
    pub leverage: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.QueryOpenEstResponse")]
pub struct QueryOpenEstResponse {
    #[prost(string, tag = "1")]
    pub position_size: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub weight_balance_ratio: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub borrow_fee: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.QueryCloseEstRequest")]
#[proto_query(
    path = "/elys.leveragelp.Query/CloseEst",
    response_type = QueryCloseEstResponse
)]
pub struct QueryCloseEstRequest {
    #[prost(string, tag = "1")]
    pub owner: ::prost::alloc::string::String,
    #[prost(uint64, tag = "2")]
    #[serde(alias = "ID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub id: u64,
    #[prost(string, tag = "3")]
    pub lp_amount: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.QueryRewardsRequest")]
#[proto_query(
    path = "/elys.leveragelp.Query/Rewards",
    response_type = QueryRewardsResponse
)]
pub struct QueryRewardsRequest {
    #[prost(string, tag = "1")]
    pub address: ::prost::alloc::string::String,
    #[prost(uint64, repeated, tag = "2")]
    #[serde(
        serialize_with = "crate::serde::as_str_vec::serialize",
        deserialize_with = "crate::serde::as_str_vec::deserialize"
    )]
    pub ids: ::prost::alloc::vec::Vec<u64>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.RewardInfo")]
pub struct RewardInfo {
    #[prost(uint64, tag = "1")]
    #[serde(alias = "positionID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub position_id: u64,
    #[prost(message, repeated, tag = "2")]
    pub reward: ::prost::alloc::vec::Vec<super::super::cosmos::base::v1beta1::Coin>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.QueryRewardsResponse")]
pub struct QueryRewardsResponse {
    #[prost(message, repeated, tag = "1")]
    pub rewards: ::prost::alloc::vec::Vec<RewardInfo>,
    #[prost(message, repeated, tag = "2")]
    pub total_rewards: ::prost::alloc::vec::Vec<super::super::cosmos::base::v1beta1::Coin>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.QueryCloseEstResponse")]
pub struct QueryCloseEstResponse {
    #[prost(string, tag = "1")]
    pub repay_amount: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub final_closing_ratio: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub closing_lp_amount: ::prost::alloc::string::String,
    #[prost(message, repeated, tag = "4")]
    pub coins_to_amm: ::prost::alloc::vec::Vec<super::super::cosmos::base::v1beta1::Coin>,
    #[prost(message, repeated, tag = "5")]
    pub user_return_tokens: ::prost::alloc::vec::Vec<super::super::cosmos::base::v1beta1::Coin>,
    #[prost(string, tag = "6")]
    pub exit_weight_fee: ::prost::alloc::string::String,
    #[prost(string, tag = "7")]
    pub weight_breaking_fee: ::prost::alloc::string::String,
    #[prost(string, tag = "8")]
    pub exit_slippage_fee: ::prost::alloc::string::String,
    #[prost(string, tag = "9")]
    pub exit_swap_fee: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.QueryCommittedTokensLockedRequest")]
#[proto_query(
    path = "/elys.leveragelp.Query/CommittedTokensLocked",
    response_type = QueryCommittedTokensLockedResponse
)]
pub struct QueryCommittedTokensLockedRequest {
    #[prost(string, tag = "1")]
    pub address: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.QueryCommittedTokensLockedResponse")]
pub struct QueryCommittedTokensLockedResponse {
    #[prost(string, tag = "1")]
    pub address: ::prost::alloc::string::String,
    #[prost(message, repeated, tag = "2")]
    pub locked_committed: ::prost::alloc::vec::Vec<super::super::cosmos::base::v1beta1::Coin>,
    #[prost(message, repeated, tag = "3")]
    pub total_committed: ::prost::alloc::vec::Vec<super::super::cosmos::base::v1beta1::Coin>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.MsgOpen")]
pub struct MsgOpen {
    #[prost(string, tag = "1")]
    pub creator: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub collateral_asset: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub collateral_amount: ::prost::alloc::string::String,
    #[prost(uint64, tag = "4")]
    #[serde(alias = "amm_poolID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub amm_pool_id: u64,
    #[prost(string, tag = "5")]
    pub leverage: ::prost::alloc::string::String,
    #[prost(string, tag = "6")]
    pub stop_loss_price: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.MsgOpenResponse")]
pub struct MsgOpenResponse {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.MsgClose")]
pub struct MsgClose {
    #[prost(string, tag = "1")]
    pub creator: ::prost::alloc::string::String,
    #[prost(uint64, tag = "2")]
    #[serde(alias = "ID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub id: u64,
    #[prost(string, tag = "3")]
    pub lp_amount: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.MsgCloseResponse")]
pub struct MsgCloseResponse {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.MsgClaimRewards")]
pub struct MsgClaimRewards {
    #[prost(string, tag = "1")]
    pub sender: ::prost::alloc::string::String,
    #[prost(uint64, repeated, tag = "2")]
    #[serde(
        serialize_with = "crate::serde::as_str_vec::serialize",
        deserialize_with = "crate::serde::as_str_vec::deserialize"
    )]
    pub ids: ::prost::alloc::vec::Vec<u64>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.MsgClaimRewardsResponse")]
pub struct MsgClaimRewardsResponse {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.MsgUpdateParams")]
pub struct MsgUpdateParams {
    /// authority is the address that controls the module (defaults to x/gov unless
    /// overwritten).
    #[prost(string, tag = "1")]
    pub authority: ::prost::alloc::string::String,
    /// NOTE: All parameters must be supplied.
    #[prost(message, optional, tag = "2")]
    pub params: ::core::option::Option<Params>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.MsgUpdateParamsResponse")]
pub struct MsgUpdateParamsResponse {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.MsgWhitelist")]
pub struct MsgWhitelist {
    #[prost(string, tag = "1")]
    pub authority: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub whitelisted_address: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.MsgWhitelistResponse")]
pub struct MsgWhitelistResponse {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.MsgDewhitelist")]
pub struct MsgDewhitelist {
    #[prost(string, tag = "1")]
    pub authority: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub whitelisted_address: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.MsgDewhitelistResponse")]
pub struct MsgDewhitelistResponse {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.MsgUpdateStopLoss")]
pub struct MsgUpdateStopLoss {
    #[prost(string, tag = "1")]
    pub creator: ::prost::alloc::string::String,
    #[prost(uint64, tag = "2")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub position: u64,
    #[prost(string, tag = "3")]
    pub price: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.MsgUpdateStopLossResponse")]
pub struct MsgUpdateStopLossResponse {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.AddPool")]
pub struct AddPool {
    #[prost(uint64, tag = "1")]
    #[serde(alias = "amm_poolID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub amm_pool_id: u64,
    #[prost(string, tag = "3")]
    pub leverage_max: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.MsgAddPool")]
pub struct MsgAddPool {
    #[prost(string, tag = "1")]
    pub authority: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub pool: ::core::option::Option<AddPool>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.MsgAddPoolResponse")]
pub struct MsgAddPoolResponse {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.MsgRemovePool")]
pub struct MsgRemovePool {
    #[prost(string, tag = "1")]
    pub authority: ::prost::alloc::string::String,
    #[prost(uint64, tag = "2")]
    #[serde(alias = "ID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub id: u64,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.MsgRemovePoolResponse")]
pub struct MsgRemovePoolResponse {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.MsgClosePositions")]
pub struct MsgClosePositions {
    #[prost(string, tag = "1")]
    pub creator: ::prost::alloc::string::String,
    #[prost(message, repeated, tag = "2")]
    pub liquidate: ::prost::alloc::vec::Vec<PositionRequest>,
    #[prost(message, repeated, tag = "3")]
    pub stop_loss: ::prost::alloc::vec::Vec<PositionRequest>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.MsgClosePositionsResponse")]
pub struct MsgClosePositionsResponse {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.MsgUpdatePool")]
pub struct MsgUpdatePool {
    /// authority is the address that controls the module (defaults to x/gov unless
    /// overwritten).
    #[prost(string, tag = "1")]
    pub authority: ::prost::alloc::string::String,
    #[prost(uint64, tag = "2")]
    #[serde(alias = "poolID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub pool_id: u64,
    #[prost(string, tag = "3")]
    pub leverage_max: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub max_leveragelp_ratio: ::prost::alloc::string::String,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.MsgUpdatePoolResponse")]
pub struct MsgUpdatePoolResponse {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.MsgUpdateEnabledPools")]
pub struct MsgUpdateEnabledPools {
    /// authority is the address that controls the module (defaults to x/gov unless
    /// overwritten).
    #[prost(string, tag = "1")]
    pub authority: ::prost::alloc::string::String,
    #[prost(uint64, repeated, tag = "2")]
    #[serde(
        serialize_with = "crate::serde::as_str_vec::serialize",
        deserialize_with = "crate::serde::as_str_vec::deserialize"
    )]
    pub enabled_pools: ::prost::alloc::vec::Vec<u64>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/elys.leveragelp.MsgUpdateEnabledPoolsResponse")]
pub struct MsgUpdateEnabledPoolsResponse {}
pub struct LeveragelpQuerier<'a, Q: cosmwasm_std::CustomQuery> {
    querier: &'a cosmwasm_std::QuerierWrapper<'a, Q>,
}
impl<'a, Q: cosmwasm_std::CustomQuery> LeveragelpQuerier<'a, Q> {
    pub fn new(querier: &'a cosmwasm_std::QuerierWrapper<'a, Q>) -> Self {
        Self { querier }
    }
    pub fn params(&self) -> Result<ParamsResponse, cosmwasm_std::StdError> {
        ParamsRequest {}.query(self.querier)
    }
    pub fn query_positions(
        &self,
        pagination: ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageRequest>,
    ) -> Result<PositionsResponse, cosmwasm_std::StdError> {
        PositionsRequest { pagination }.query(self.querier)
    }
    pub fn query_positions_by_pool(
        &self,
        amm_pool_id: u64,
        pagination: ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageRequest>,
    ) -> Result<PositionsByPoolResponse, cosmwasm_std::StdError> {
        PositionsByPoolRequest {
            amm_pool_id,
            pagination,
        }
        .query(self.querier)
    }
    pub fn get_status(&self) -> Result<StatusResponse, cosmwasm_std::StdError> {
        StatusRequest {}.query(self.querier)
    }
    pub fn query_positions_for_address(
        &self,
        address: ::prost::alloc::string::String,
        pagination: ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageRequest>,
    ) -> Result<PositionsForAddressResponse, cosmwasm_std::StdError> {
        PositionsForAddressRequest {
            address,
            pagination,
        }
        .query(self.querier)
    }
    pub fn get_whitelist(
        &self,
        pagination: ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageRequest>,
    ) -> Result<WhitelistResponse, cosmwasm_std::StdError> {
        WhitelistRequest { pagination }.query(self.querier)
    }
    pub fn is_whitelisted(
        &self,
        address: ::prost::alloc::string::String,
    ) -> Result<IsWhitelistedResponse, cosmwasm_std::StdError> {
        IsWhitelistedRequest { address }.query(self.querier)
    }
    pub fn pool(&self, index: u64) -> Result<QueryGetPoolResponse, cosmwasm_std::StdError> {
        QueryGetPoolRequest { index }.query(self.querier)
    }
    pub fn pools(
        &self,
        pagination: ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageRequest>,
    ) -> Result<QueryAllPoolResponse, cosmwasm_std::StdError> {
        QueryAllPoolRequest { pagination }.query(self.querier)
    }
    pub fn position(
        &self,
        address: ::prost::alloc::string::String,
        id: u64,
    ) -> Result<PositionResponse, cosmwasm_std::StdError> {
        PositionRequest { address, id }.query(self.querier)
    }
    pub fn liquidation_price(
        &self,
        address: ::prost::alloc::string::String,
        position_id: u64,
    ) -> Result<QueryLiquidationPriceResponse, cosmwasm_std::StdError> {
        QueryLiquidationPriceRequest {
            address,
            position_id,
        }
        .query(self.querier)
    }
    pub fn open_est(
        &self,
        collateral_asset: ::prost::alloc::string::String,
        collateral_amount: ::prost::alloc::string::String,
        amm_pool_id: u64,
        leverage: ::prost::alloc::string::String,
    ) -> Result<QueryOpenEstResponse, cosmwasm_std::StdError> {
        QueryOpenEstRequest {
            collateral_asset,
            collateral_amount,
            amm_pool_id,
            leverage,
        }
        .query(self.querier)
    }
    pub fn close_est(
        &self,
        owner: ::prost::alloc::string::String,
        id: u64,
        lp_amount: ::prost::alloc::string::String,
    ) -> Result<QueryCloseEstResponse, cosmwasm_std::StdError> {
        QueryCloseEstRequest {
            owner,
            id,
            lp_amount,
        }
        .query(self.querier)
    }
    pub fn rewards(
        &self,
        address: ::prost::alloc::string::String,
        ids: ::prost::alloc::vec::Vec<u64>,
    ) -> Result<QueryRewardsResponse, cosmwasm_std::StdError> {
        QueryRewardsRequest { address, ids }.query(self.querier)
    }
    pub fn committed_tokens_locked(
        &self,
        address: ::prost::alloc::string::String,
    ) -> Result<QueryCommittedTokensLockedResponse, cosmwasm_std::StdError> {
        QueryCommittedTokensLockedRequest { address }.query(self.querier)
    }
}