use milkyway_std_derive::CosmwasmExt;
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.stakeibc.AddressUnbonding")]
pub struct AddressUnbonding {
    #[prost(string, tag = "1")]
    pub address: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub receiver: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub unbonding_estimated_time: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub amount: ::prost::alloc::string::String,
    #[prost(string, tag = "5")]
    pub denom: ::prost::alloc::string::String,
    #[prost(bool, tag = "8")]
    pub claim_is_pending: bool,
    #[prost(uint64, tag = "9")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub epoch_number: 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 = "/stride.stakeibc.Validator")]
pub struct Validator {
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub address: ::prost::alloc::string::String,
    #[prost(uint64, tag = "6")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub weight: u64,
    #[prost(string, tag = "5")]
    pub delegation: ::prost::alloc::string::String,
    #[prost(string, tag = "9")]
    pub slash_query_progress_tracker: ::prost::alloc::string::String,
    #[prost(string, tag = "12")]
    pub slash_query_checkpoint: ::prost::alloc::string::String,
    #[prost(string, tag = "10")]
    pub shares_to_tokens_rate: ::prost::alloc::string::String,
    #[prost(int64, tag = "11")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub delegation_changes_in_progress: i64,
    #[prost(bool, tag = "13")]
    pub slash_query_in_progress: bool,
}
/// CommunityPoolRebate stores the size of the community pool liquid stake
/// (denominated in stTokens) and the rebate rate as a decimal
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.stakeibc.CommunityPoolRebate")]
pub struct CommunityPoolRebate {
    /// Rebate percentage as a decimal (e.g. 0.2 for 20%)
    #[prost(string, tag = "1")]
    pub rebate_rate: ::prost::alloc::string::String,
    /// Number of stTokens received from the community pool liquid stake
    #[prost(string, tag = "2")]
    pub liquid_staked_st_token_amount: ::prost::alloc::string::String,
}
/// Core data structure to track liquid staking zones
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.stakeibc.HostZone")]
pub struct HostZone {
    /// Chain ID of the host zone
    #[prost(string, tag = "1")]
    #[serde(alias = "chainID")]
    pub chain_id: ::prost::alloc::string::String,
    /// Bech32 prefix of host zone's address
    #[prost(string, tag = "17")]
    pub bech32prefix: ::prost::alloc::string::String,
    /// ConnectionID from Stride to the host zone (ID is on the stride side)
    #[prost(string, tag = "2")]
    #[serde(alias = "connectionID")]
    pub connection_id: ::prost::alloc::string::String,
    /// Transfer Channel ID from Stride to the host zone (ID is on the stride side)
    #[prost(string, tag = "12")]
    #[serde(alias = "transfer_channelID")]
    pub transfer_channel_id: ::prost::alloc::string::String,
    /// ibc denom of the host zone's native token on stride
    #[prost(string, tag = "8")]
    pub ibc_denom: ::prost::alloc::string::String,
    /// native denom on host zone
    #[prost(string, tag = "9")]
    pub host_denom: ::prost::alloc::string::String,
    /// The unbonding period in days (e.g. 21)
    #[prost(uint64, tag = "26")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub unbonding_period: u64,
    /// List of validators that are delegated to
    #[prost(message, repeated, tag = "3")]
    pub validators: ::prost::alloc::vec::Vec<Validator>,
    /// Address that custodies native tokens during a liquid stake
    #[prost(string, tag = "18")]
    pub deposit_address: ::prost::alloc::string::String,
    /// ICA Address on the host zone responsible for collecting rewards
    #[prost(string, tag = "22")]
    pub withdrawal_ica_address: ::prost::alloc::string::String,
    /// ICA Address on the host zone responsible for commission
    #[prost(string, tag = "23")]
    pub fee_ica_address: ::prost::alloc::string::String,
    /// ICA Address on the host zone responsible for staking and unstaking
    #[prost(string, tag = "24")]
    pub delegation_ica_address: ::prost::alloc::string::String,
    /// ICA Address that receives unstaked tokens after they've finished unbonding
    #[prost(string, tag = "25")]
    pub redemption_ica_address: ::prost::alloc::string::String,
    /// ICA Address that receives tokens from a community pool to liquid stake or
    /// redeem In the case of a liquid stake, the community pool deposits native
    /// tokens In the case of a redemption, the community pool deposits stTokens
    #[prost(string, tag = "30")]
    pub community_pool_deposit_ica_address: ::prost::alloc::string::String,
    /// ICA Address that distributes tokens back to the community pool during a
    /// community pool liquid stake or redeem In the case of a liquid stake, the
    /// return address sends back stTokens In the case of a redemption, the return
    /// address sends back native tokens
    #[prost(string, tag = "31")]
    pub community_pool_return_ica_address: ::prost::alloc::string::String,
    /// Module account on Stride that receives native tokens from the deposit ICA
    /// and liquid stakes them
    #[prost(string, tag = "32")]
    pub community_pool_stake_holding_address: ::prost::alloc::string::String,
    /// Module account on Stride that receives stTokens from the deposit ICA and
    /// redeems them
    #[prost(string, tag = "33")]
    pub community_pool_redeem_holding_address: ::prost::alloc::string::String,
    /// Optional community pool address to send tokens to after a community pool
    /// liquid stake or redemption If this address is empty, the tokens are sent to
    /// the main community pool
    #[prost(string, tag = "35")]
    pub community_pool_treasury_address: ::prost::alloc::string::String,
    /// The total delegated balance on the host zone
    #[prost(string, tag = "13")]
    pub total_delegations: ::prost::alloc::string::String,
    /// The redemption rate from the previous epoch
    #[prost(string, tag = "10")]
    pub last_redemption_rate: ::prost::alloc::string::String,
    /// The current redemption rate
    #[prost(string, tag = "11")]
    pub redemption_rate: ::prost::alloc::string::String,
    /// The min outer redemption rate bound - controlled only be governance
    /// The min inner bound cannot exceed this bound
    #[prost(string, tag = "20")]
    pub min_redemption_rate: ::prost::alloc::string::String,
    /// The max outer redemption rate bound - controlled only be governance
    /// The max inner bound cannot exceed this bound
    #[prost(string, tag = "21")]
    pub max_redemption_rate: ::prost::alloc::string::String,
    /// The min minner redemption rate bound - controlled by the admin
    /// If the redemption rate exceeds this bound, the host zone is halted
    #[prost(string, tag = "28")]
    pub min_inner_redemption_rate: ::prost::alloc::string::String,
    /// The max minner redemption rate bound - controlled by the admin
    /// If the redemption rate exceeds this bound, the host zone is halted
    #[prost(string, tag = "29")]
    pub max_inner_redemption_rate: ::prost::alloc::string::String,
    /// The max number of messages that can be sent in a delegation
    /// or undelegation ICA tx
    #[prost(uint64, tag = "36")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub max_messages_per_ica_tx: u64,
    /// An optional fee rebate
    /// If there is no rebate for the host zone, this will be nil
    #[prost(message, optional, tag = "34")]
    pub community_pool_rebate: ::core::option::Option<CommunityPoolRebate>,
    /// A boolean indicating whether the chain has LSM enabled
    #[prost(bool, tag = "27")]
    pub lsm_liquid_stake_enabled: bool,
    /// A boolean indicating whether the chain is currently halted
    #[prost(bool, tag = "19")]
    pub halted: 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 = "/stride.stakeibc.ICAAccount")]
pub struct IcaAccount {
    #[prost(string, tag = "1")]
    #[serde(alias = "chainID")]
    pub chain_id: ::prost::alloc::string::String,
    #[prost(enumeration = "IcaAccountType", tag = "2")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub r#type: i32,
    #[prost(string, tag = "3")]
    #[serde(alias = "connectionID")]
    pub connection_id: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub address: ::prost::alloc::string::String,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
#[derive(::serde::Serialize, ::serde::Deserialize, ::schemars::JsonSchema)]
pub enum IcaAccountType {
    Delegation = 0,
    Fee = 1,
    Withdrawal = 2,
    Redemption = 3,
    CommunityPoolDeposit = 4,
    CommunityPoolReturn = 5,
    ConverterUnwind = 6,
    ConverterTrade = 7,
}
impl IcaAccountType {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            IcaAccountType::Delegation => "DELEGATION",
            IcaAccountType::Fee => "FEE",
            IcaAccountType::Withdrawal => "WITHDRAWAL",
            IcaAccountType::Redemption => "REDEMPTION",
            IcaAccountType::CommunityPoolDeposit => "COMMUNITY_POOL_DEPOSIT",
            IcaAccountType::CommunityPoolReturn => "COMMUNITY_POOL_RETURN",
            IcaAccountType::ConverterUnwind => "CONVERTER_UNWIND",
            IcaAccountType::ConverterTrade => "CONVERTER_TRADE",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "DELEGATION" => Some(Self::Delegation),
            "FEE" => Some(Self::Fee),
            "WITHDRAWAL" => Some(Self::Withdrawal),
            "REDEMPTION" => Some(Self::Redemption),
            "COMMUNITY_POOL_DEPOSIT" => Some(Self::CommunityPoolDeposit),
            "COMMUNITY_POOL_RETURN" => Some(Self::CommunityPoolReturn),
            "CONVERTER_UNWIND" => Some(Self::ConverterUnwind),
            "CONVERTER_TRADE" => Some(Self::ConverterTrade),
            _ => None,
        }
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.stakeibc.SplitDelegation")]
pub struct SplitDelegation {
    #[prost(string, tag = "1")]
    pub validator: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub 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 = "/stride.stakeibc.DelegateCallback")]
pub struct DelegateCallback {
    #[prost(string, tag = "1")]
    #[serde(alias = "host_zoneID")]
    pub host_zone_id: ::prost::alloc::string::String,
    #[prost(uint64, tag = "2")]
    #[serde(alias = "deposit_recordID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub deposit_record_id: u64,
    #[prost(message, repeated, tag = "3")]
    pub split_delegations: ::prost::alloc::vec::Vec<SplitDelegation>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.stakeibc.ClaimCallback")]
pub struct ClaimCallback {
    #[prost(string, tag = "1")]
    #[serde(alias = "user_redemption_recordID")]
    pub user_redemption_record_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    #[serde(alias = "chainID")]
    pub chain_id: ::prost::alloc::string::String,
    #[prost(uint64, tag = "3")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub epoch_number: 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 = "/stride.stakeibc.ReinvestCallback")]
pub struct ReinvestCallback {
    #[prost(message, optional, tag = "1")]
    pub reinvest_amount: ::core::option::Option<super::super::cosmos::base::v1beta1::Coin>,
    #[prost(string, tag = "3")]
    #[serde(alias = "host_zoneID")]
    pub host_zone_id: ::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 = "/stride.stakeibc.UndelegateCallback")]
pub struct UndelegateCallback {
    #[prost(string, tag = "1")]
    #[serde(alias = "host_zoneID")]
    pub host_zone_id: ::prost::alloc::string::String,
    #[prost(message, repeated, tag = "2")]
    pub split_delegations: ::prost::alloc::vec::Vec<SplitDelegation>,
    #[prost(uint64, repeated, tag = "3")]
    #[serde(alias = "epoch_unbonding_recordIDs")]
    #[serde(
        serialize_with = "crate::serde::as_str_vec::serialize",
        deserialize_with = "crate::serde::as_str_vec::deserialize"
    )]
    pub epoch_unbonding_record_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 = "/stride.stakeibc.RedemptionCallback")]
pub struct RedemptionCallback {
    #[prost(string, tag = "1")]
    #[serde(alias = "host_zoneID")]
    pub host_zone_id: ::prost::alloc::string::String,
    #[prost(uint64, repeated, tag = "2")]
    #[serde(alias = "epoch_unbonding_recordIDs")]
    #[serde(
        serialize_with = "crate::serde::as_str_vec::serialize",
        deserialize_with = "crate::serde::as_str_vec::deserialize"
    )]
    pub epoch_unbonding_record_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 = "/stride.stakeibc.Rebalancing")]
pub struct Rebalancing {
    #[prost(string, tag = "1")]
    pub src_validator: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub dst_validator: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub amt: ::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 = "/stride.stakeibc.RebalanceCallback")]
pub struct RebalanceCallback {
    #[prost(string, tag = "1")]
    #[serde(alias = "host_zoneID")]
    pub host_zone_id: ::prost::alloc::string::String,
    #[prost(message, repeated, tag = "2")]
    pub rebalancings: ::prost::alloc::vec::Vec<Rebalancing>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.stakeibc.DetokenizeSharesCallback")]
pub struct DetokenizeSharesCallback {
    #[prost(message, optional, tag = "1")]
    pub deposit: ::core::option::Option<super::records::LsmTokenDeposit>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.stakeibc.LSMLiquidStake")]
pub struct LsmLiquidStake {
    #[prost(message, optional, tag = "1")]
    pub deposit: ::core::option::Option<super::records::LsmTokenDeposit>,
    #[prost(message, optional, tag = "2")]
    pub host_zone: ::core::option::Option<HostZone>,
    #[prost(message, optional, tag = "3")]
    pub validator: ::core::option::Option<Validator>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.stakeibc.ValidatorSharesToTokensQueryCallback")]
pub struct ValidatorSharesToTokensQueryCallback {
    #[prost(message, optional, tag = "1")]
    pub lsm_liquid_stake: ::core::option::Option<LsmLiquidStake>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.stakeibc.DelegatorSharesQueryCallback")]
pub struct DelegatorSharesQueryCallback {
    /// Validator delegation at the time the query is submitted
    #[prost(string, tag = "1")]
    pub initial_validator_delegation: ::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 = "/stride.stakeibc.CommunityPoolBalanceQueryCallback")]
pub struct CommunityPoolBalanceQueryCallback {
    #[prost(enumeration = "IcaAccountType", tag = "1")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub ica_type: i32,
    #[prost(string, tag = "2")]
    pub denom: ::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 = "/stride.stakeibc.TradeRouteCallback")]
pub struct TradeRouteCallback {
    #[prost(string, tag = "1")]
    pub reward_denom: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub host_denom: ::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 = "/stride.stakeibc.EpochTracker")]
pub struct EpochTracker {
    #[prost(string, tag = "1")]
    #[serde(alias = "epochIDentifier")]
    pub epoch_identifier: ::prost::alloc::string::String,
    #[prost(uint64, tag = "2")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub epoch_number: u64,
    #[prost(uint64, tag = "3")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub next_epoch_start_time: u64,
    #[prost(uint64, tag = "4")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub duration: u64,
}
/// Params defines the parameters for the module.
/// next id: 20
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.stakeibc.Params")]
pub struct Params {
    /// define epoch lengths, in stride_epochs
    #[prost(uint64, tag = "1")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub rewards_interval: u64,
    #[prost(uint64, tag = "6")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub delegate_interval: u64,
    #[prost(uint64, tag = "2")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub deposit_interval: u64,
    #[prost(uint64, tag = "3")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub redemption_rate_interval: u64,
    #[prost(uint64, tag = "4")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub stride_commission: u64,
    #[prost(uint64, tag = "7")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub reinvest_interval: u64,
    #[prost(uint64, tag = "9")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub ica_timeout_nanos: u64,
    #[prost(uint64, tag = "10")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub buffer_size: u64,
    #[prost(uint64, tag = "11")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub ibc_timeout_blocks: u64,
    #[prost(uint64, tag = "12")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub fee_transfer_timeout_nanos: u64,
    #[prost(uint64, tag = "13")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub max_stake_ica_calls_per_epoch: u64,
    #[prost(uint64, tag = "14")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub default_min_redemption_rate_threshold: u64,
    #[prost(uint64, tag = "15")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub default_max_redemption_rate_threshold: u64,
    #[prost(uint64, tag = "16")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub ibc_transfer_timeout_nanos: u64,
    #[prost(uint64, tag = "19")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub validator_slash_query_threshold: u64,
    #[prost(uint64, tag = "20")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub validator_weight_cap: u64,
}
/// GenesisState defines the stakeibc 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 = "/stride.stakeibc.GenesisState")]
pub struct GenesisState {
    #[prost(message, optional, tag = "1")]
    pub params: ::core::option::Option<Params>,
    #[prost(string, tag = "2")]
    #[serde(alias = "portID")]
    pub port_id: ::prost::alloc::string::String,
    /// list of zones that are registered by the protocol
    #[prost(message, repeated, tag = "5")]
    pub host_zone_list: ::prost::alloc::vec::Vec<HostZone>,
    #[prost(message, repeated, tag = "10")]
    pub epoch_tracker_list: ::prost::alloc::vec::Vec<EpochTracker>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.stakeibc.StakeibcPacketData")]
pub struct StakeibcPacketData {
    #[prost(oneof = "stakeibc_packet_data::Packet", tags = "1")]
    pub packet: ::core::option::Option<stakeibc_packet_data::Packet>,
}
/// Nested message and enum types in `StakeibcPacketData`.
pub mod stakeibc_packet_data {
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[derive(
        Clone,
        PartialEq,
        Eq,
        ::prost::Oneof,
        ::serde::Serialize,
        ::serde::Deserialize,
        ::schemars::JsonSchema,
    )]
    pub enum Packet {
        /// this line is used by starport scaffolding # ibc/packet/proto/field
        #[prost(message, tag = "1")]
        NoData(super::NoData),
    }
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.stakeibc.NoData")]
pub struct NoData {}
/// Stores pool information needed to execute the swap along a trade route
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.stakeibc.TradeConfig")]
pub struct TradeConfig {
    /// Currently Osmosis is the only trade chain so this is an osmosis pool id
    #[prost(uint64, tag = "1")]
    #[serde(alias = "poolID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub pool_id: u64,
    /// Spot price in the pool to convert the reward denom to the host denom
    /// output_tokens = swap_price * input tokens
    /// This value may be slightly stale as it is updated by an ICQ
    #[prost(string, tag = "2")]
    pub swap_price: ::prost::alloc::string::String,
    /// unix time in seconds that the price was last updated
    #[prost(uint64, tag = "3")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub price_update_timestamp: u64,
    /// Threshold defining the percentage of tokens that could be lost in the trade
    /// This captures both the loss from slippage and from a stale price on stride
    /// 0.05 means the output from the trade can be no less than a 5% deviation
    /// from the current value
    #[prost(string, tag = "4")]
    pub max_allowed_swap_loss_rate: ::prost::alloc::string::String,
    /// min and max set boundaries of reward denom on trade chain we will swap
    /// min also decides when reward token transfers are worth it (transfer fees)
    #[prost(string, tag = "5")]
    pub min_swap_amount: ::prost::alloc::string::String,
    #[prost(string, tag = "6")]
    pub max_swap_amount: ::prost::alloc::string::String,
}
/// TradeRoute represents a round trip including info on transfer and how to do
/// the swap. It makes the assumption that the reward token is always foreign to
/// the host so therefore the first two hops are to unwind the ibc denom enroute
/// to the trade chain and the last hop is the return so funds start/end in the
/// withdrawl ICA on hostZone
/// The structure is key'd on reward denom and host denom in their native forms
/// (i.e. reward_denom_on_reward_zone and host_denom_on_host_zone)
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.stakeibc.TradeRoute")]
pub struct TradeRoute {
    /// ibc denom for the reward on the host zone
    #[prost(string, tag = "1")]
    pub reward_denom_on_host_zone: ::prost::alloc::string::String,
    /// should be the native denom for the reward chain
    #[prost(string, tag = "2")]
    pub reward_denom_on_reward_zone: ::prost::alloc::string::String,
    /// ibc denom of the reward on the trade chain, input to the swap
    #[prost(string, tag = "3")]
    pub reward_denom_on_trade_zone: ::prost::alloc::string::String,
    /// ibc of the host denom on the trade chain, output from the swap
    #[prost(string, tag = "4")]
    pub host_denom_on_trade_zone: ::prost::alloc::string::String,
    /// should be the same as the native host denom on the host chain
    #[prost(string, tag = "5")]
    pub host_denom_on_host_zone: ::prost::alloc::string::String,
    /// ICAAccount on the host zone with the reward tokens
    /// This is the same as the host zone withdrawal ICA account
    #[prost(message, optional, tag = "6")]
    pub host_account: ::core::option::Option<IcaAccount>,
    /// ICAAccount on the reward zone that is acts as the intermediate
    /// receiver of the transfer from host zone to trade zone
    #[prost(message, optional, tag = "7")]
    pub reward_account: ::core::option::Option<IcaAccount>,
    /// ICAAccount responsible for executing the swap of reward
    /// tokens for host tokens
    #[prost(message, optional, tag = "8")]
    pub trade_account: ::core::option::Option<IcaAccount>,
    /// Channel responsible for the transfer of reward tokens from the host
    /// zone to the reward zone. This is the channel ID on the host zone side
    #[prost(string, tag = "9")]
    #[serde(alias = "host_to_reward_channelID")]
    pub host_to_reward_channel_id: ::prost::alloc::string::String,
    /// Channel responsible for the transfer of reward tokens from the reward
    /// zone to the trade zone. This is the channel ID on the reward zone side
    #[prost(string, tag = "10")]
    #[serde(alias = "reward_to_trade_channelID")]
    pub reward_to_trade_channel_id: ::prost::alloc::string::String,
    /// Channel responsible for the transfer of host tokens from the trade
    /// zone, back to the host zone. This is the channel ID on the trade zone side
    #[prost(string, tag = "11")]
    #[serde(alias = "trade_to_host_channelID")]
    pub trade_to_host_channel_id: ::prost::alloc::string::String,
    /// specifies the configuration needed to execute the swap
    /// such as pool_id, slippage, min trade amount, etc.
    #[prost(message, optional, tag = "12")]
    pub trade_config: ::core::option::Option<TradeConfig>,
}
/// QueryInterchainAccountFromAddressRequest is the request type for the
/// Query/InterchainAccountAddress RPC
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.stakeibc.QueryInterchainAccountFromAddressRequest")]
#[proto_query(
    path = "/stride.stakeibc.Query/InterchainAccountFromAddress",
    response_type = QueryInterchainAccountFromAddressResponse
)]
pub struct QueryInterchainAccountFromAddressRequest {
    #[prost(string, tag = "1")]
    pub owner: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    #[serde(alias = "connectionID")]
    pub connection_id: ::prost::alloc::string::String,
}
/// QueryInterchainAccountFromAddressResponse the response type for the
/// Query/InterchainAccountAddress RPC
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.stakeibc.QueryInterchainAccountFromAddressResponse")]
pub struct QueryInterchainAccountFromAddressResponse {
    #[prost(string, tag = "1")]
    pub interchain_account_address: ::prost::alloc::string::String,
}
/// QueryParamsRequest 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 = "/stride.stakeibc.QueryParamsRequest")]
#[proto_query(
    path = "/stride.stakeibc.Query/Params",
    response_type = QueryParamsResponse
)]
pub struct QueryParamsRequest {}
/// QueryParamsResponse 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 = "/stride.stakeibc.QueryParamsResponse")]
pub struct QueryParamsResponse {
    /// 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 = "/stride.stakeibc.QueryGetValidatorsRequest")]
#[proto_query(
    path = "/stride.stakeibc.Query/Validators",
    response_type = QueryGetValidatorsResponse
)]
pub struct QueryGetValidatorsRequest {
    #[prost(string, tag = "1")]
    #[serde(alias = "chainID")]
    pub chain_id: ::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 = "/stride.stakeibc.QueryGetValidatorsResponse")]
pub struct QueryGetValidatorsResponse {
    #[prost(message, repeated, tag = "1")]
    pub validators: ::prost::alloc::vec::Vec<Validator>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.stakeibc.QueryGetHostZoneRequest")]
#[proto_query(
    path = "/stride.stakeibc.Query/HostZone",
    response_type = QueryGetHostZoneResponse
)]
pub struct QueryGetHostZoneRequest {
    #[prost(string, tag = "1")]
    #[serde(alias = "chainID")]
    pub chain_id: ::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 = "/stride.stakeibc.QueryGetHostZoneResponse")]
pub struct QueryGetHostZoneResponse {
    #[prost(message, optional, tag = "1")]
    pub host_zone: ::core::option::Option<HostZone>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.stakeibc.QueryAllHostZoneRequest")]
#[proto_query(
    path = "/stride.stakeibc.Query/HostZoneAll",
    response_type = QueryAllHostZoneResponse
)]
pub struct QueryAllHostZoneRequest {
    #[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 = "/stride.stakeibc.QueryAllHostZoneResponse")]
pub struct QueryAllHostZoneResponse {
    #[prost(message, repeated, tag = "1")]
    pub host_zone: ::prost::alloc::vec::Vec<HostZone>,
    #[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 = "/stride.stakeibc.QueryModuleAddressRequest")]
#[proto_query(
    path = "/stride.stakeibc.Query/ModuleAddress",
    response_type = QueryModuleAddressResponse
)]
pub struct QueryModuleAddressRequest {
    #[prost(string, tag = "1")]
    pub name: ::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 = "/stride.stakeibc.QueryModuleAddressResponse")]
pub struct QueryModuleAddressResponse {
    #[prost(string, tag = "1")]
    pub addr: ::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 = "/stride.stakeibc.QueryGetEpochTrackerRequest")]
#[proto_query(
    path = "/stride.stakeibc.Query/EpochTracker",
    response_type = QueryGetEpochTrackerResponse
)]
pub struct QueryGetEpochTrackerRequest {
    #[prost(string, tag = "1")]
    #[serde(alias = "epochIDentifier")]
    pub epoch_identifier: ::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 = "/stride.stakeibc.QueryGetEpochTrackerResponse")]
pub struct QueryGetEpochTrackerResponse {
    #[prost(message, optional, tag = "1")]
    pub epoch_tracker: ::core::option::Option<EpochTracker>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.stakeibc.QueryAllEpochTrackerRequest")]
#[proto_query(
    path = "/stride.stakeibc.Query/EpochTrackerAll",
    response_type = QueryAllEpochTrackerResponse
)]
pub struct QueryAllEpochTrackerRequest {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.stakeibc.QueryAllEpochTrackerResponse")]
pub struct QueryAllEpochTrackerResponse {
    #[prost(message, repeated, tag = "1")]
    pub epoch_tracker: ::prost::alloc::vec::Vec<EpochTracker>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.stakeibc.QueryGetNextPacketSequenceRequest")]
#[proto_query(
    path = "/stride.stakeibc.Query/NextPacketSequence",
    response_type = QueryGetNextPacketSequenceResponse
)]
pub struct QueryGetNextPacketSequenceRequest {
    #[prost(string, tag = "1")]
    #[serde(alias = "channelID")]
    pub channel_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    #[serde(alias = "portID")]
    pub port_id: ::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 = "/stride.stakeibc.QueryGetNextPacketSequenceResponse")]
pub struct QueryGetNextPacketSequenceResponse {
    #[prost(uint64, tag = "1")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub sequence: 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 = "/stride.stakeibc.QueryAddressUnbondings")]
#[proto_query(
    path = "/stride.stakeibc.Query/AddressUnbondings",
    response_type = QueryAddressUnbondingsResponse
)]
pub struct QueryAddressUnbondings {
    #[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 = "/stride.stakeibc.QueryAddressUnbondingsResponse")]
pub struct QueryAddressUnbondingsResponse {
    #[prost(message, repeated, tag = "1")]
    pub address_unbondings: ::prost::alloc::vec::Vec<AddressUnbonding>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.stakeibc.QueryAllTradeRoutes")]
#[proto_query(
    path = "/stride.stakeibc.Query/AllTradeRoutes",
    response_type = QueryAllTradeRoutesResponse
)]
pub struct QueryAllTradeRoutes {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.stakeibc.QueryAllTradeRoutesResponse")]
pub struct QueryAllTradeRoutesResponse {
    #[prost(message, repeated, tag = "1")]
    pub trade_routes: ::prost::alloc::vec::Vec<TradeRoute>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.stakeibc.MsgUpdateInnerRedemptionRateBounds")]
pub struct MsgUpdateInnerRedemptionRateBounds {
    #[prost(string, tag = "1")]
    pub creator: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    #[serde(alias = "chainID")]
    pub chain_id: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub min_inner_redemption_rate: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub max_inner_redemption_rate: ::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 = "/stride.stakeibc.MsgUpdateInnerRedemptionRateBoundsResponse")]
pub struct MsgUpdateInnerRedemptionRateBoundsResponse {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.stakeibc.MsgLiquidStake")]
pub struct MsgLiquidStake {
    #[prost(string, tag = "1")]
    pub creator: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub amount: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub host_denom: ::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 = "/stride.stakeibc.MsgLiquidStakeResponse")]
pub struct MsgLiquidStakeResponse {
    #[prost(message, optional, tag = "1")]
    pub st_token: ::core::option::Option<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 = "/stride.stakeibc.MsgLSMLiquidStake")]
pub struct MsgLsmLiquidStake {
    #[prost(string, tag = "1")]
    pub creator: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub amount: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub lsm_token_ibc_denom: ::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 = "/stride.stakeibc.MsgLSMLiquidStakeResponse")]
pub struct MsgLsmLiquidStakeResponse {
    #[prost(bool, tag = "1")]
    pub transaction_complete: 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 = "/stride.stakeibc.MsgClearBalance")]
pub struct MsgClearBalance {
    #[prost(string, tag = "1")]
    pub creator: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    #[serde(alias = "chainID")]
    pub chain_id: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub amount: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub channel: ::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 = "/stride.stakeibc.MsgClearBalanceResponse")]
pub struct MsgClearBalanceResponse {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.stakeibc.MsgRedeemStake")]
pub struct MsgRedeemStake {
    #[prost(string, tag = "1")]
    pub creator: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub amount: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub host_zone: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub receiver: ::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 = "/stride.stakeibc.MsgRedeemStakeResponse")]
pub struct MsgRedeemStakeResponse {}
/// next: 15
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.stakeibc.MsgRegisterHostZone")]
pub struct MsgRegisterHostZone {
    #[prost(string, tag = "2")]
    #[serde(alias = "connectionID")]
    pub connection_id: ::prost::alloc::string::String,
    #[prost(string, tag = "12")]
    pub bech32prefix: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub host_denom: ::prost::alloc::string::String,
    #[prost(string, tag = "5")]
    pub ibc_denom: ::prost::alloc::string::String,
    #[prost(string, tag = "6")]
    pub creator: ::prost::alloc::string::String,
    #[prost(string, tag = "10")]
    #[serde(alias = "transfer_channelID")]
    pub transfer_channel_id: ::prost::alloc::string::String,
    #[prost(uint64, tag = "11")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub unbonding_period: u64,
    #[prost(string, tag = "13")]
    pub min_redemption_rate: ::prost::alloc::string::String,
    #[prost(string, tag = "14")]
    pub max_redemption_rate: ::prost::alloc::string::String,
    #[prost(bool, tag = "15")]
    pub lsm_liquid_stake_enabled: bool,
    #[prost(string, tag = "16")]
    pub community_pool_treasury_address: ::prost::alloc::string::String,
    #[prost(uint64, tag = "17")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub max_messages_per_ica_tx: 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 = "/stride.stakeibc.MsgRegisterHostZoneResponse")]
pub struct MsgRegisterHostZoneResponse {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.stakeibc.MsgClaimUndelegatedTokens")]
pub struct MsgClaimUndelegatedTokens {
    #[prost(string, tag = "1")]
    pub creator: ::prost::alloc::string::String,
    /// UserUnbondingRecords are keyed on {chain_id}.{epoch}.{receiver}
    #[prost(string, tag = "2")]
    #[serde(alias = "host_zoneID")]
    pub host_zone_id: ::prost::alloc::string::String,
    #[prost(uint64, tag = "3")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub epoch: u64,
    #[prost(string, tag = "5")]
    pub receiver: ::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 = "/stride.stakeibc.MsgClaimUndelegatedTokensResponse")]
pub struct MsgClaimUndelegatedTokensResponse {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.stakeibc.MsgRebalanceValidators")]
pub struct MsgRebalanceValidators {
    #[prost(string, tag = "1")]
    pub creator: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub host_zone: ::prost::alloc::string::String,
    #[prost(uint64, tag = "3")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub num_rebalance: 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 = "/stride.stakeibc.MsgRebalanceValidatorsResponse")]
pub struct MsgRebalanceValidatorsResponse {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.stakeibc.MsgAddValidators")]
pub struct MsgAddValidators {
    #[prost(string, tag = "1")]
    pub creator: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub host_zone: ::prost::alloc::string::String,
    #[prost(message, repeated, tag = "3")]
    pub validators: ::prost::alloc::vec::Vec<Validator>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.stakeibc.MsgAddValidatorsResponse")]
pub struct MsgAddValidatorsResponse {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.stakeibc.ValidatorWeight")]
pub struct ValidatorWeight {
    #[prost(string, tag = "1")]
    pub address: ::prost::alloc::string::String,
    #[prost(uint64, tag = "2")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub weight: 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 = "/stride.stakeibc.MsgChangeValidatorWeights")]
pub struct MsgChangeValidatorWeights {
    #[prost(string, tag = "1")]
    pub creator: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub host_zone: ::prost::alloc::string::String,
    #[prost(message, repeated, tag = "3")]
    pub validator_weights: ::prost::alloc::vec::Vec<ValidatorWeight>,
}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.stakeibc.MsgChangeValidatorWeightsResponse")]
pub struct MsgChangeValidatorWeightsResponse {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.stakeibc.MsgDeleteValidator")]
pub struct MsgDeleteValidator {
    #[prost(string, tag = "1")]
    pub creator: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub host_zone: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub val_addr: ::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 = "/stride.stakeibc.MsgDeleteValidatorResponse")]
pub struct MsgDeleteValidatorResponse {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.stakeibc.MsgRestoreInterchainAccount")]
pub struct MsgRestoreInterchainAccount {
    #[prost(string, tag = "1")]
    pub creator: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    #[serde(alias = "chainID")]
    pub chain_id: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    #[serde(alias = "connectionID")]
    pub connection_id: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    pub account_owner: ::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 = "/stride.stakeibc.MsgRestoreInterchainAccountResponse")]
pub struct MsgRestoreInterchainAccountResponse {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.stakeibc.MsgUpdateValidatorSharesExchRate")]
pub struct MsgUpdateValidatorSharesExchRate {
    #[prost(string, tag = "1")]
    pub creator: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    #[serde(alias = "chainID")]
    pub chain_id: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub valoper: ::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 = "/stride.stakeibc.MsgUpdateValidatorSharesExchRateResponse")]
pub struct MsgUpdateValidatorSharesExchRateResponse {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.stakeibc.MsgCalibrateDelegation")]
pub struct MsgCalibrateDelegation {
    #[prost(string, tag = "1")]
    pub creator: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    #[serde(alias = "chainID")]
    pub chain_id: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub valoper: ::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 = "/stride.stakeibc.MsgCalibrateDelegationResponse")]
pub struct MsgCalibrateDelegationResponse {}
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.stakeibc.MsgResumeHostZone")]
pub struct MsgResumeHostZone {
    #[prost(string, tag = "1")]
    pub creator: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    #[serde(alias = "chainID")]
    pub chain_id: ::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 = "/stride.stakeibc.MsgResumeHostZoneResponse")]
pub struct MsgResumeHostZoneResponse {}
/// Creates a new trade route
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.stakeibc.MsgCreateTradeRoute")]
pub struct MsgCreateTradeRoute {
    /// authority is the address that controls the module (defaults to x/gov unless
    /// overwritten).
    #[prost(string, tag = "1")]
    pub authority: ::prost::alloc::string::String,
    /// The chain ID of the host zone
    #[prost(string, tag = "2")]
    #[serde(alias = "host_chainID")]
    pub host_chain_id: ::prost::alloc::string::String,
    /// Connection IDs between stride and the other zones
    #[prost(string, tag = "3")]
    #[serde(alias = "stride_to_reward_connectionID")]
    pub stride_to_reward_connection_id: ::prost::alloc::string::String,
    #[prost(string, tag = "4")]
    #[serde(alias = "stride_to_trade_connectionID")]
    pub stride_to_trade_connection_id: ::prost::alloc::string::String,
    /// Transfer channels between the host, reward, and trade zones
    #[prost(string, tag = "5")]
    #[serde(alias = "host_to_reward_transfer_channelID")]
    pub host_to_reward_transfer_channel_id: ::prost::alloc::string::String,
    #[prost(string, tag = "6")]
    #[serde(alias = "reward_to_trade_transfer_channelID")]
    pub reward_to_trade_transfer_channel_id: ::prost::alloc::string::String,
    #[prost(string, tag = "7")]
    #[serde(alias = "trade_to_host_transfer_channelID")]
    pub trade_to_host_transfer_channel_id: ::prost::alloc::string::String,
    /// ibc denom for the reward token on the host zone (e.g. ibc/usdc on dYdX)
    #[prost(string, tag = "8")]
    pub reward_denom_on_host: ::prost::alloc::string::String,
    /// native denom of reward token on the reward zone (e.g. usdc on Noble)
    #[prost(string, tag = "9")]
    pub reward_denom_on_reward: ::prost::alloc::string::String,
    /// ibc denom of the reward token on the trade zone (e.g. ibc/usdc on Osmosis)
    #[prost(string, tag = "10")]
    pub reward_denom_on_trade: ::prost::alloc::string::String,
    /// ibc denom of the host's token on the trade zone (e.g. ibc/dydx on Osmosis)
    #[prost(string, tag = "11")]
    pub host_denom_on_trade: ::prost::alloc::string::String,
    /// the host zone's native denom (e.g. dydx on dYdX)
    #[prost(string, tag = "12")]
    pub host_denom_on_host: ::prost::alloc::string::String,
    /// The osmosis pool ID
    #[prost(uint64, tag = "13")]
    #[serde(alias = "poolID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub pool_id: u64,
    /// Threshold defining the percentage of tokens that could be lost in the trade
    /// This captures both the loss from slippage and from a stale price on stride
    /// "0.05" means the output from the trade can be no less than a 5% deviation
    /// from the current value
    #[prost(string, tag = "14")]
    pub max_allowed_swap_loss_rate: ::prost::alloc::string::String,
    /// minimum amount of reward tokens to initate a swap
    /// if not provided, defaults to 0
    #[prost(string, tag = "15")]
    pub min_swap_amount: ::prost::alloc::string::String,
    /// maximum amount of reward tokens in a single swap
    /// if not provided, defaults to 10e24
    #[prost(string, tag = "16")]
    pub max_swap_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 = "/stride.stakeibc.MsgCreateTradeRouteResponse")]
pub struct MsgCreateTradeRouteResponse {}
/// Deletes a trade route
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.stakeibc.MsgDeleteTradeRoute")]
pub struct MsgDeleteTradeRoute {
    /// authority is the address that controls the module (defaults to x/gov unless
    /// overwritten).
    #[prost(string, tag = "1")]
    pub authority: ::prost::alloc::string::String,
    /// The reward denom of the route in it's native form (e.g. usdc)
    #[prost(string, tag = "2")]
    pub reward_denom: ::prost::alloc::string::String,
    /// The host zone's denom in it's native form (e.g. dydx)
    #[prost(string, tag = "3")]
    pub host_denom: ::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 = "/stride.stakeibc.MsgDeleteTradeRouteResponse")]
pub struct MsgDeleteTradeRouteResponse {}
/// Updates the config of a trade route
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.stakeibc.MsgUpdateTradeRoute")]
pub struct MsgUpdateTradeRoute {
    /// authority is the address that controls the module (defaults to x/gov unless
    /// overwritten).
    #[prost(string, tag = "1")]
    pub authority: ::prost::alloc::string::String,
    /// The reward denom of the route in it's native form (e.g. usdc)
    #[prost(string, tag = "2")]
    pub reward_denom: ::prost::alloc::string::String,
    /// The host zone's denom in it's native form (e.g. dydx)
    #[prost(string, tag = "3")]
    pub host_denom: ::prost::alloc::string::String,
    /// The osmosis pool ID
    #[prost(uint64, tag = "4")]
    #[serde(alias = "poolID")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub pool_id: u64,
    /// Threshold defining the percentage of tokens that could be lost in the trade
    /// This captures both the loss from slippage and from a stale price on stride
    /// "0.05" means the output from the trade can be no less than a 5% deviation
    /// from the current value
    #[prost(string, tag = "5")]
    pub max_allowed_swap_loss_rate: ::prost::alloc::string::String,
    /// minimum amount of reward tokens to initate a swap
    /// if not provided, defaults to 0
    #[prost(string, tag = "6")]
    pub min_swap_amount: ::prost::alloc::string::String,
    /// maximum amount of reward tokens in a single swap
    /// if not provided, defaults to 10e24
    #[prost(string, tag = "7")]
    pub max_swap_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 = "/stride.stakeibc.MsgUpdateTradeRouteResponse")]
pub struct MsgUpdateTradeRouteResponse {}
/// Registers or updates a community pool rebate by specifying the amount liquid
/// staked
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.stakeibc.MsgSetCommunityPoolRebate")]
pub struct MsgSetCommunityPoolRebate {
    /// Message signer (admin only)
    #[prost(string, tag = "1")]
    pub creator: ::prost::alloc::string::String,
    /// Chain id of the chain whose community pool has a liquid staking rebate
    /// arrangement with stride
    #[prost(string, tag = "2")]
    #[serde(alias = "chainID")]
    pub chain_id: ::prost::alloc::string::String,
    /// Rebate percentage represented as a decimal (e.g. 0.2 for 20%)
    #[prost(string, tag = "3")]
    pub rebate_rate: ::prost::alloc::string::String,
    /// Number of stTokens recieved by the community pool after liquid staking
    #[prost(string, tag = "4")]
    pub liquid_staked_st_token_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 = "/stride.stakeibc.MsgSetCommunityPoolRebateResponse")]
pub struct MsgSetCommunityPoolRebateResponse {}
/// Grants or revokes trade permissions to a given address via authz
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.stakeibc.MsgToggleTradeController")]
pub struct MsgToggleTradeController {
    /// Message signer (admin only)
    #[prost(string, tag = "1")]
    pub creator: ::prost::alloc::string::String,
    /// Chain ID of the trade account
    #[prost(string, tag = "2")]
    #[serde(alias = "chainID")]
    pub chain_id: ::prost::alloc::string::String,
    /// Permission change (either grant or revoke)
    #[prost(enumeration = "AuthzPermissionChange", tag = "3")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub permission_change: i32,
    /// Address of trade operator
    #[prost(string, tag = "4")]
    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 = "/stride.stakeibc.MsgToggleTradeControllerResponse")]
pub struct MsgToggleTradeControllerResponse {}
/// Updates host zone 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 = "/stride.stakeibc.MsgUpdateHostZoneParams")]
pub struct MsgUpdateHostZoneParams {
    /// authority is the address that controls the module (defaults to x/gov unless
    /// overwritten).
    #[prost(string, tag = "1")]
    pub authority: ::prost::alloc::string::String,
    /// Chain ID of the host zone
    #[prost(string, tag = "2")]
    #[serde(alias = "chainID")]
    pub chain_id: ::prost::alloc::string::String,
    /// Max messages that can be sent in a single ICA message
    #[prost(uint64, tag = "3")]
    #[serde(
        serialize_with = "crate::serde::as_str::serialize",
        deserialize_with = "crate::serde::as_str::deserialize"
    )]
    pub max_messages_per_ica_tx: 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 = "/stride.stakeibc.MsgUpdateHostZoneParamsResponse")]
pub struct MsgUpdateHostZoneParamsResponse {}
/// MsgUpdateParams is the Msg/UpdateParams request type.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.stakeibc.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,
    /// params defines the x/staking parameters to update.
    ///
    /// NOTE: All parameters must be supplied.
    #[prost(message, optional, tag = "2")]
    pub params: ::core::option::Option<Params>,
}
/// MsgUpdateParamsResponse defines the response structure for executing a
/// MsgUpdateParams message.
#[allow(clippy::derive_partial_eq_without_eq)]
#[derive(
    Clone,
    PartialEq,
    Eq,
    ::prost::Message,
    ::serde::Serialize,
    ::serde::Deserialize,
    ::schemars::JsonSchema,
    CosmwasmExt,
)]
#[proto_message(type_url = "/stride.stakeibc.MsgUpdateParamsResponse")]
pub struct MsgUpdateParamsResponse {}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
#[derive(::serde::Serialize, ::serde::Deserialize, ::schemars::JsonSchema)]
pub enum AuthzPermissionChange {
    /// Grant the address trade permissions
    Grant = 0,
    /// Revoke trade permissions from the address
    Revoke = 1,
}
impl AuthzPermissionChange {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            AuthzPermissionChange::Grant => "GRANT",
            AuthzPermissionChange::Revoke => "REVOKE",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "GRANT" => Some(Self::Grant),
            "REVOKE" => Some(Self::Revoke),
            _ => None,
        }
    }
}
pub struct StakeibcQuerier<'a, Q: cosmwasm_std::CustomQuery> {
    querier: &'a cosmwasm_std::QuerierWrapper<'a, Q>,
}
impl<'a, Q: cosmwasm_std::CustomQuery> StakeibcQuerier<'a, Q> {
    pub fn new(querier: &'a cosmwasm_std::QuerierWrapper<'a, Q>) -> Self {
        Self { querier }
    }
    pub fn params(&self) -> Result<QueryParamsResponse, cosmwasm_std::StdError> {
        QueryParamsRequest {}.query(self.querier)
    }
    pub fn validators(
        &self,
        chain_id: ::prost::alloc::string::String,
    ) -> Result<QueryGetValidatorsResponse, cosmwasm_std::StdError> {
        QueryGetValidatorsRequest { chain_id }.query(self.querier)
    }
    pub fn host_zone(
        &self,
        chain_id: ::prost::alloc::string::String,
    ) -> Result<QueryGetHostZoneResponse, cosmwasm_std::StdError> {
        QueryGetHostZoneRequest { chain_id }.query(self.querier)
    }
    pub fn host_zone_all(
        &self,
        pagination: ::core::option::Option<super::super::cosmos::base::query::v1beta1::PageRequest>,
    ) -> Result<QueryAllHostZoneResponse, cosmwasm_std::StdError> {
        QueryAllHostZoneRequest { pagination }.query(self.querier)
    }
    pub fn module_address(
        &self,
        name: ::prost::alloc::string::String,
    ) -> Result<QueryModuleAddressResponse, cosmwasm_std::StdError> {
        QueryModuleAddressRequest { name }.query(self.querier)
    }
    pub fn interchain_account_from_address(
        &self,
        owner: ::prost::alloc::string::String,
        connection_id: ::prost::alloc::string::String,
    ) -> Result<QueryInterchainAccountFromAddressResponse, cosmwasm_std::StdError> {
        QueryInterchainAccountFromAddressRequest {
            owner,
            connection_id,
        }
        .query(self.querier)
    }
    pub fn epoch_tracker(
        &self,
        epoch_identifier: ::prost::alloc::string::String,
    ) -> Result<QueryGetEpochTrackerResponse, cosmwasm_std::StdError> {
        QueryGetEpochTrackerRequest { epoch_identifier }.query(self.querier)
    }
    pub fn epoch_tracker_all(
        &self,
    ) -> Result<QueryAllEpochTrackerResponse, cosmwasm_std::StdError> {
        QueryAllEpochTrackerRequest {}.query(self.querier)
    }
    pub fn next_packet_sequence(
        &self,
        channel_id: ::prost::alloc::string::String,
        port_id: ::prost::alloc::string::String,
    ) -> Result<QueryGetNextPacketSequenceResponse, cosmwasm_std::StdError> {
        QueryGetNextPacketSequenceRequest {
            channel_id,
            port_id,
        }
        .query(self.querier)
    }
    pub fn address_unbondings(
        &self,
        address: ::prost::alloc::string::String,
    ) -> Result<QueryAddressUnbondingsResponse, cosmwasm_std::StdError> {
        QueryAddressUnbondings { address }.query(self.querier)
    }
    pub fn all_trade_routes(&self) -> Result<QueryAllTradeRoutesResponse, cosmwasm_std::StdError> {
        QueryAllTradeRoutes {}.query(self.querier)
    }
}
