/// HistoricalInfo contains header and validator information for a given block. /// It is stored as part of staking module's state, which persists the `n` most /// recent HistoricalInfo /// (`n` is set by the staking module's `historical_entries` parameter). #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct HistoricalInfo { #[prost(message, optional, tag = "1")] pub header: ::core::option::Option<::tendermint_proto::types::Header>, #[prost(message, repeated, tag = "2")] pub valset: ::prost::alloc::vec::Vec, } /// CommissionRates defines the initial commission rates to be used for creating /// a validator. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct CommissionRates { /// rate is the commission rate charged to delegators, as a fraction. #[prost(string, tag = "1")] pub rate: ::prost::alloc::string::String, /// max_rate defines the maximum commission rate which validator can ever charge, as a fraction. #[prost(string, tag = "2")] pub max_rate: ::prost::alloc::string::String, /// max_change_rate defines the maximum daily increase of the validator commission, as a fraction. #[prost(string, tag = "3")] pub max_change_rate: ::prost::alloc::string::String, } /// Commission defines commission parameters for a given validator. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct Commission { /// commission_rates defines the initial commission rates to be used for creating a validator. #[prost(message, optional, tag = "1")] pub commission_rates: ::core::option::Option, /// update_time is the last time the commission rate was changed. #[prost(message, optional, tag = "2")] pub update_time: ::core::option::Option<::prost_types::Timestamp>, } /// Description defines a validator description. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct Description { /// moniker defines a human-readable name for the validator. #[prost(string, tag = "1")] pub moniker: ::prost::alloc::string::String, /// identity defines an optional identity signature (ex. UPort or Keybase). #[prost(string, tag = "2")] pub identity: ::prost::alloc::string::String, /// website defines an optional website link. #[prost(string, tag = "3")] pub website: ::prost::alloc::string::String, /// security_contact defines an optional email for security contact. #[prost(string, tag = "4")] pub security_contact: ::prost::alloc::string::String, /// details define other optional details. #[prost(string, tag = "5")] pub details: ::prost::alloc::string::String, } /// Validator defines a validator, together with the total amount of the /// Validator's bond shares and their exchange rate to coins. Slashing results in /// a decrease in the exchange rate, allowing correct calculation of future /// undelegations without iterating over delegators. When coins are delegated to /// this validator, the validator is credited with a delegation whose number of /// bond shares is based on the amount of coins delegated divided by the current /// exchange rate. Voting power can be calculated as total bonded shares /// multiplied by exchange rate. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct Validator { /// operator_address defines the address of the validator's operator; bech encoded in JSON. #[prost(string, tag = "1")] pub operator_address: ::prost::alloc::string::String, /// consensus_pubkey is the consensus public key of the validator, as a Protobuf Any. #[prost(message, optional, tag = "2")] pub consensus_pubkey: ::core::option::Option<::prost_types::Any>, /// jailed defined whether the validator has been jailed from bonded status or not. #[prost(bool, tag = "3")] pub jailed: bool, /// status is the validator status (bonded/unbonding/unbonded). #[prost(enumeration = "BondStatus", tag = "4")] pub status: i32, /// tokens define the delegated tokens (incl. self-delegation). #[prost(string, tag = "5")] pub tokens: ::prost::alloc::string::String, /// delegator_shares defines total shares issued to a validator's delegators. #[prost(string, tag = "6")] pub delegator_shares: ::prost::alloc::string::String, /// description defines the description terms for the validator. #[prost(message, optional, tag = "7")] pub description: ::core::option::Option, /// unbonding_height defines, if unbonding, the height at which this validator has begun unbonding. #[prost(int64, tag = "8")] pub unbonding_height: i64, /// unbonding_time defines, if unbonding, the min time for the validator to complete unbonding. #[prost(message, optional, tag = "9")] pub unbonding_time: ::core::option::Option<::prost_types::Timestamp>, /// commission defines the commission parameters. #[prost(message, optional, tag = "10")] pub commission: ::core::option::Option, /// min_self_delegation is the validator's self declared minimum self delegation. /// /// Since: cosmos-sdk 0.46 #[prost(string, tag = "11")] pub min_self_delegation: ::prost::alloc::string::String, /// strictly positive if this validator's unbonding has been stopped by external modules #[prost(int64, tag = "12")] pub unbonding_on_hold_ref_count: i64, /// list of unbonding ids, each uniquely identifing an unbonding of this validator #[prost(uint64, repeated, tag = "13")] pub unbonding_ids: ::prost::alloc::vec::Vec, } /// ValAddresses defines a repeated set of validator addresses. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct ValAddresses { #[prost(string, repeated, tag = "1")] pub addresses: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, } /// DVPair is struct that just has a delegator-validator pair with no other data. /// It is intended to be used as a marshalable pointer. For example, a DVPair can /// be used to construct the key to getting an UnbondingDelegation from state. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct DvPair { #[prost(string, tag = "1")] pub delegator_address: ::prost::alloc::string::String, #[prost(string, tag = "2")] pub validator_address: ::prost::alloc::string::String, } /// DVPairs defines an array of DVPair objects. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct DvPairs { #[prost(message, repeated, tag = "1")] pub pairs: ::prost::alloc::vec::Vec, } /// DVVTriplet is struct that just has a delegator-validator-validator triplet /// with no other data. It is intended to be used as a marshalable pointer. For /// example, a DVVTriplet can be used to construct the key to getting a /// Redelegation from state. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct DvvTriplet { #[prost(string, tag = "1")] pub delegator_address: ::prost::alloc::string::String, #[prost(string, tag = "2")] pub validator_src_address: ::prost::alloc::string::String, #[prost(string, tag = "3")] pub validator_dst_address: ::prost::alloc::string::String, } /// DVVTriplets defines an array of DVVTriplet objects. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct DvvTriplets { #[prost(message, repeated, tag = "1")] pub triplets: ::prost::alloc::vec::Vec, } /// Delegation represents the bond with tokens held by an account. It is /// owned by one delegator, and is associated with the voting power of one /// validator. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct Delegation { /// delegator_address is the bech32-encoded address of the delegator. #[prost(string, tag = "1")] pub delegator_address: ::prost::alloc::string::String, /// validator_address is the bech32-encoded address of the validator. #[prost(string, tag = "2")] pub validator_address: ::prost::alloc::string::String, /// shares define the delegation shares received. #[prost(string, tag = "3")] pub shares: ::prost::alloc::string::String, } /// UnbondingDelegation stores all of a single delegator's unbonding bonds /// for a single validator in an time-ordered list. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct UnbondingDelegation { /// delegator_address is the bech32-encoded address of the delegator. #[prost(string, tag = "1")] pub delegator_address: ::prost::alloc::string::String, /// validator_address is the bech32-encoded address of the validator. #[prost(string, tag = "2")] pub validator_address: ::prost::alloc::string::String, /// entries are the unbonding delegation entries. /// /// unbonding delegation entries #[prost(message, repeated, tag = "3")] pub entries: ::prost::alloc::vec::Vec, } /// UnbondingDelegationEntry defines an unbonding object with relevant metadata. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct UnbondingDelegationEntry { /// creation_height is the height which the unbonding took place. #[prost(int64, tag = "1")] pub creation_height: i64, /// completion_time is the unix time for unbonding completion. #[prost(message, optional, tag = "2")] pub completion_time: ::core::option::Option<::prost_types::Timestamp>, /// initial_balance defines the tokens initially scheduled to receive at completion. #[prost(string, tag = "3")] pub initial_balance: ::prost::alloc::string::String, /// balance defines the tokens to receive at completion. #[prost(string, tag = "4")] pub balance: ::prost::alloc::string::String, /// Incrementing id that uniquely identifies this entry #[prost(uint64, tag = "5")] pub unbonding_id: u64, /// Strictly positive if this entry's unbonding has been stopped by external modules #[prost(int64, tag = "6")] pub unbonding_on_hold_ref_count: i64, } /// RedelegationEntry defines a redelegation object with relevant metadata. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct RedelegationEntry { /// creation_height defines the height which the redelegation took place. #[prost(int64, tag = "1")] pub creation_height: i64, /// completion_time defines the unix time for redelegation completion. #[prost(message, optional, tag = "2")] pub completion_time: ::core::option::Option<::prost_types::Timestamp>, /// initial_balance defines the initial balance when redelegation started. #[prost(string, tag = "3")] pub initial_balance: ::prost::alloc::string::String, /// shares_dst is the amount of destination-validator shares created by redelegation. #[prost(string, tag = "4")] pub shares_dst: ::prost::alloc::string::String, /// Incrementing id that uniquely identifies this entry #[prost(uint64, tag = "5")] pub unbonding_id: u64, /// Strictly positive if this entry's unbonding has been stopped by external modules #[prost(int64, tag = "6")] pub unbonding_on_hold_ref_count: i64, } /// Redelegation contains the list of a particular delegator's redelegating bonds /// from a particular source validator to a particular destination validator. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct Redelegation { /// delegator_address is the bech32-encoded address of the delegator. #[prost(string, tag = "1")] pub delegator_address: ::prost::alloc::string::String, /// validator_src_address is the validator redelegation source operator address. #[prost(string, tag = "2")] pub validator_src_address: ::prost::alloc::string::String, /// validator_dst_address is the validator redelegation destination operator address. #[prost(string, tag = "3")] pub validator_dst_address: ::prost::alloc::string::String, /// entries are the redelegation entries. /// /// redelegation entries #[prost(message, repeated, tag = "4")] pub entries: ::prost::alloc::vec::Vec, } /// Params defines the parameters for the x/staking module. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct Params { /// unbonding_time is the time duration of unbonding. #[prost(message, optional, tag = "1")] pub unbonding_time: ::core::option::Option<::prost_types::Duration>, /// max_validators is the maximum number of validators. #[prost(uint32, tag = "2")] pub max_validators: u32, /// max_entries is the max entries for either unbonding delegation or redelegation (per pair/trio). #[prost(uint32, tag = "3")] pub max_entries: u32, /// historical_entries is the number of historical entries to persist. #[prost(uint32, tag = "4")] pub historical_entries: u32, /// bond_denom defines the bondable coin denomination. #[prost(string, tag = "5")] pub bond_denom: ::prost::alloc::string::String, /// min_commission_rate is the chain-wide minimum commission rate that a validator can charge their delegators #[prost(string, tag = "6")] pub min_commission_rate: ::prost::alloc::string::String, } /// DelegationResponse is equivalent to Delegation except that it contains a /// balance in addition to shares which is more suitable for client responses. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct DelegationResponse { #[prost(message, optional, tag = "1")] pub delegation: ::core::option::Option, #[prost(message, optional, tag = "2")] pub balance: ::core::option::Option, } /// RedelegationEntryResponse is equivalent to a RedelegationEntry except that it /// contains a balance in addition to shares which is more suitable for client /// responses. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct RedelegationEntryResponse { #[prost(message, optional, tag = "1")] pub redelegation_entry: ::core::option::Option, #[prost(string, tag = "4")] pub balance: ::prost::alloc::string::String, } /// RedelegationResponse is equivalent to a Redelegation except that its entries /// contain a balance in addition to shares which is more suitable for client /// responses. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct RedelegationResponse { #[prost(message, optional, tag = "1")] pub redelegation: ::core::option::Option, #[prost(message, repeated, tag = "2")] pub entries: ::prost::alloc::vec::Vec, } /// Pool is used for tracking bonded and not-bonded token supply of the bond /// denomination. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct Pool { #[prost(string, tag = "1")] pub not_bonded_tokens: ::prost::alloc::string::String, #[prost(string, tag = "2")] pub bonded_tokens: ::prost::alloc::string::String, } /// ValidatorUpdates defines an array of abci.ValidatorUpdate objects. /// TODO: explore moving this to proto/cosmos/base to separate modules from tendermint dependence #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct ValidatorUpdates { #[prost(message, repeated, tag = "1")] pub updates: ::prost::alloc::vec::Vec<::tendermint_proto::abci::ValidatorUpdate>, } /// BondStatus is the status of a validator. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum BondStatus { /// UNSPECIFIED defines an invalid validator status. Unspecified = 0, /// UNBONDED defines a validator that is not bonded. Unbonded = 1, /// UNBONDING defines a validator that is unbonding. Unbonding = 2, /// BONDED defines a validator that is bonded. Bonded = 3, } impl BondStatus { /// 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 { BondStatus::Unspecified => "BOND_STATUS_UNSPECIFIED", BondStatus::Unbonded => "BOND_STATUS_UNBONDED", BondStatus::Unbonding => "BOND_STATUS_UNBONDING", BondStatus::Bonded => "BOND_STATUS_BONDED", } } /// Creates an enum from field names used in the ProtoBuf definition. pub fn from_str_name(value: &str) -> ::core::option::Option { match value { "BOND_STATUS_UNSPECIFIED" => Some(Self::Unspecified), "BOND_STATUS_UNBONDED" => Some(Self::Unbonded), "BOND_STATUS_UNBONDING" => Some(Self::Unbonding), "BOND_STATUS_BONDED" => Some(Self::Bonded), _ => None, } } } /// Infraction indicates the infraction a validator commited. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum Infraction { /// UNSPECIFIED defines an empty infraction. Unspecified = 0, /// DOUBLE_SIGN defines a validator that double-signs a block. DoubleSign = 1, /// DOWNTIME defines a validator that missed signing too many blocks. Downtime = 2, } impl Infraction { /// 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 { Infraction::Unspecified => "INFRACTION_UNSPECIFIED", Infraction::DoubleSign => "INFRACTION_DOUBLE_SIGN", Infraction::Downtime => "INFRACTION_DOWNTIME", } } /// Creates an enum from field names used in the ProtoBuf definition. pub fn from_str_name(value: &str) -> ::core::option::Option { match value { "INFRACTION_UNSPECIFIED" => Some(Self::Unspecified), "INFRACTION_DOUBLE_SIGN" => Some(Self::DoubleSign), "INFRACTION_DOWNTIME" => Some(Self::Downtime), _ => None, } } } /// GenesisState defines the staking module's genesis state. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct GenesisState { /// params defines all the parameters of related to deposit. #[prost(message, optional, tag = "1")] pub params: ::core::option::Option, /// last_total_power tracks the total amounts of bonded tokens recorded during /// the previous end block. #[prost(bytes = "vec", tag = "2")] pub last_total_power: ::prost::alloc::vec::Vec, /// last_validator_powers is a special index that provides a historical list /// of the last-block's bonded validators. #[prost(message, repeated, tag = "3")] pub last_validator_powers: ::prost::alloc::vec::Vec, /// delegations defines the validator set at genesis. #[prost(message, repeated, tag = "4")] pub validators: ::prost::alloc::vec::Vec, /// delegations defines the delegations active at genesis. #[prost(message, repeated, tag = "5")] pub delegations: ::prost::alloc::vec::Vec, /// unbonding_delegations defines the unbonding delegations active at genesis. #[prost(message, repeated, tag = "6")] pub unbonding_delegations: ::prost::alloc::vec::Vec, /// redelegations defines the redelegations active at genesis. #[prost(message, repeated, tag = "7")] pub redelegations: ::prost::alloc::vec::Vec, #[prost(bool, tag = "8")] pub exported: bool, } /// LastValidatorPower required for validator set update logic. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct LastValidatorPower { /// address is the address of the validator. #[prost(string, tag = "1")] pub address: ::prost::alloc::string::String, /// power defines the power of the validator. #[prost(int64, tag = "2")] pub power: i64, } /// QueryValidatorsRequest is request type for Query/Validators RPC method. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryValidatorsRequest { /// status enables to query for validators matching a given status. #[prost(string, tag = "1")] pub status: ::prost::alloc::string::String, /// pagination defines an optional pagination for the request. #[prost(message, optional, tag = "2")] pub pagination: ::core::option::Option, } /// QueryValidatorsResponse is response type for the Query/Validators RPC method #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryValidatorsResponse { /// validators contains all the queried validators. #[prost(message, repeated, tag = "1")] pub validators: ::prost::alloc::vec::Vec, /// pagination defines the pagination in the response. #[prost(message, optional, tag = "2")] pub pagination: ::core::option::Option, } /// QueryValidatorRequest is response type for the Query/Validator RPC method #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryValidatorRequest { /// validator_addr defines the validator address to query for. #[prost(string, tag = "1")] pub validator_addr: ::prost::alloc::string::String, } /// QueryValidatorResponse is response type for the Query/Validator RPC method #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryValidatorResponse { /// validator defines the validator info. #[prost(message, optional, tag = "1")] pub validator: ::core::option::Option, } /// QueryValidatorDelegationsRequest is request type for the /// Query/ValidatorDelegations RPC method #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryValidatorDelegationsRequest { /// validator_addr defines the validator address to query for. #[prost(string, tag = "1")] pub validator_addr: ::prost::alloc::string::String, /// pagination defines an optional pagination for the request. #[prost(message, optional, tag = "2")] pub pagination: ::core::option::Option, } /// QueryValidatorDelegationsResponse is response type for the /// Query/ValidatorDelegations RPC method #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryValidatorDelegationsResponse { #[prost(message, repeated, tag = "1")] pub delegation_responses: ::prost::alloc::vec::Vec, /// pagination defines the pagination in the response. #[prost(message, optional, tag = "2")] pub pagination: ::core::option::Option, } /// QueryValidatorUnbondingDelegationsRequest is required type for the /// Query/ValidatorUnbondingDelegations RPC method #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryValidatorUnbondingDelegationsRequest { /// validator_addr defines the validator address to query for. #[prost(string, tag = "1")] pub validator_addr: ::prost::alloc::string::String, /// pagination defines an optional pagination for the request. #[prost(message, optional, tag = "2")] pub pagination: ::core::option::Option, } /// QueryValidatorUnbondingDelegationsResponse is response type for the /// Query/ValidatorUnbondingDelegations RPC method. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryValidatorUnbondingDelegationsResponse { #[prost(message, repeated, tag = "1")] pub unbonding_responses: ::prost::alloc::vec::Vec, /// pagination defines the pagination in the response. #[prost(message, optional, tag = "2")] pub pagination: ::core::option::Option, } /// QueryDelegationRequest is request type for the Query/Delegation RPC method. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryDelegationRequest { /// delegator_addr defines the delegator address to query for. #[prost(string, tag = "1")] pub delegator_addr: ::prost::alloc::string::String, /// validator_addr defines the validator address to query for. #[prost(string, tag = "2")] pub validator_addr: ::prost::alloc::string::String, } /// QueryDelegationResponse is response type for the Query/Delegation RPC method. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryDelegationResponse { /// delegation_responses defines the delegation info of a delegation. #[prost(message, optional, tag = "1")] pub delegation_response: ::core::option::Option, } /// QueryUnbondingDelegationRequest is request type for the /// Query/UnbondingDelegation RPC method. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryUnbondingDelegationRequest { /// delegator_addr defines the delegator address to query for. #[prost(string, tag = "1")] pub delegator_addr: ::prost::alloc::string::String, /// validator_addr defines the validator address to query for. #[prost(string, tag = "2")] pub validator_addr: ::prost::alloc::string::String, } /// QueryDelegationResponse is response type for the Query/UnbondingDelegation /// RPC method. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryUnbondingDelegationResponse { /// unbond defines the unbonding information of a delegation. #[prost(message, optional, tag = "1")] pub unbond: ::core::option::Option, } /// QueryDelegatorDelegationsRequest is request type for the /// Query/DelegatorDelegations RPC method. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryDelegatorDelegationsRequest { /// delegator_addr defines the delegator address to query for. #[prost(string, tag = "1")] pub delegator_addr: ::prost::alloc::string::String, /// pagination defines an optional pagination for the request. #[prost(message, optional, tag = "2")] pub pagination: ::core::option::Option, } /// QueryDelegatorDelegationsResponse is response type for the /// Query/DelegatorDelegations RPC method. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryDelegatorDelegationsResponse { /// delegation_responses defines all the delegations' info of a delegator. #[prost(message, repeated, tag = "1")] pub delegation_responses: ::prost::alloc::vec::Vec, /// pagination defines the pagination in the response. #[prost(message, optional, tag = "2")] pub pagination: ::core::option::Option, } /// QueryDelegatorUnbondingDelegationsRequest is request type for the /// Query/DelegatorUnbondingDelegations RPC method. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryDelegatorUnbondingDelegationsRequest { /// delegator_addr defines the delegator address to query for. #[prost(string, tag = "1")] pub delegator_addr: ::prost::alloc::string::String, /// pagination defines an optional pagination for the request. #[prost(message, optional, tag = "2")] pub pagination: ::core::option::Option, } /// QueryUnbondingDelegatorDelegationsResponse is response type for the /// Query/UnbondingDelegatorDelegations RPC method. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryDelegatorUnbondingDelegationsResponse { #[prost(message, repeated, tag = "1")] pub unbonding_responses: ::prost::alloc::vec::Vec, /// pagination defines the pagination in the response. #[prost(message, optional, tag = "2")] pub pagination: ::core::option::Option, } /// QueryRedelegationsRequest is request type for the Query/Redelegations RPC /// method. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryRedelegationsRequest { /// delegator_addr defines the delegator address to query for. #[prost(string, tag = "1")] pub delegator_addr: ::prost::alloc::string::String, /// src_validator_addr defines the validator address to redelegate from. #[prost(string, tag = "2")] pub src_validator_addr: ::prost::alloc::string::String, /// dst_validator_addr defines the validator address to redelegate to. #[prost(string, tag = "3")] pub dst_validator_addr: ::prost::alloc::string::String, /// pagination defines an optional pagination for the request. #[prost(message, optional, tag = "4")] pub pagination: ::core::option::Option, } /// QueryRedelegationsResponse is response type for the Query/Redelegations RPC /// method. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryRedelegationsResponse { #[prost(message, repeated, tag = "1")] pub redelegation_responses: ::prost::alloc::vec::Vec, /// pagination defines the pagination in the response. #[prost(message, optional, tag = "2")] pub pagination: ::core::option::Option, } /// QueryDelegatorValidatorsRequest is request type for the /// Query/DelegatorValidators RPC method. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryDelegatorValidatorsRequest { /// delegator_addr defines the delegator address to query for. #[prost(string, tag = "1")] pub delegator_addr: ::prost::alloc::string::String, /// pagination defines an optional pagination for the request. #[prost(message, optional, tag = "2")] pub pagination: ::core::option::Option, } /// QueryDelegatorValidatorsResponse is response type for the /// Query/DelegatorValidators RPC method. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryDelegatorValidatorsResponse { /// validators defines the validators' info of a delegator. #[prost(message, repeated, tag = "1")] pub validators: ::prost::alloc::vec::Vec, /// pagination defines the pagination in the response. #[prost(message, optional, tag = "2")] pub pagination: ::core::option::Option, } /// QueryDelegatorValidatorRequest is request type for the /// Query/DelegatorValidator RPC method. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryDelegatorValidatorRequest { /// delegator_addr defines the delegator address to query for. #[prost(string, tag = "1")] pub delegator_addr: ::prost::alloc::string::String, /// validator_addr defines the validator address to query for. #[prost(string, tag = "2")] pub validator_addr: ::prost::alloc::string::String, } /// QueryDelegatorValidatorResponse response type for the /// Query/DelegatorValidator RPC method. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryDelegatorValidatorResponse { /// validator defines the validator info. #[prost(message, optional, tag = "1")] pub validator: ::core::option::Option, } /// QueryHistoricalInfoRequest is request type for the Query/HistoricalInfo RPC /// method. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryHistoricalInfoRequest { /// height defines at which height to query the historical info. #[prost(int64, tag = "1")] pub height: i64, } /// QueryHistoricalInfoResponse is response type for the Query/HistoricalInfo RPC /// method. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryHistoricalInfoResponse { /// hist defines the historical info at the given height. #[prost(message, optional, tag = "1")] pub hist: ::core::option::Option, } /// QueryPoolRequest is request type for the Query/Pool RPC method. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryPoolRequest {} /// QueryPoolResponse is response type for the Query/Pool RPC method. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryPoolResponse { /// pool defines the pool info. #[prost(message, optional, tag = "1")] pub pool: ::core::option::Option, } /// QueryParamsRequest is request type for the Query/Params RPC method. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryParamsRequest {} /// QueryParamsResponse is response type for the Query/Params RPC method. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct QueryParamsResponse { /// params holds all the parameters of this module. #[prost(message, optional, tag = "1")] pub params: ::core::option::Option, } /// Generated client implementations. #[cfg(feature = "grpc")] #[cfg_attr(docsrs, doc(cfg(feature = "grpc")))] pub mod query_client { #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] use tonic::codegen::http::Uri; use tonic::codegen::*; /// Query defines the gRPC querier service. #[derive(Debug, Clone)] pub struct QueryClient { inner: tonic::client::Grpc, } #[cfg(feature = "grpc-transport")] #[cfg_attr(docsrs, doc(cfg(feature = "grpc-transport")))] impl QueryClient { /// Attempt to create a new client by connecting to a given endpoint. pub async fn connect(dst: D) -> Result where D: std::convert::TryInto, D::Error: Into, { let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; Ok(Self::new(conn)) } } impl QueryClient where T: tonic::client::GrpcService, T::Error: Into, T::ResponseBody: Body + Send + 'static, ::Error: Into + Send, { pub fn new(inner: T) -> Self { let inner = tonic::client::Grpc::new(inner); Self { inner } } pub fn with_origin(inner: T, origin: Uri) -> Self { let inner = tonic::client::Grpc::with_origin(inner, origin); Self { inner } } pub fn with_interceptor( inner: T, interceptor: F, ) -> QueryClient> where F: tonic::service::Interceptor, T::ResponseBody: Default, T: tonic::codegen::Service< http::Request, Response = http::Response< >::ResponseBody, >, >, >>::Error: Into + Send + Sync, { QueryClient::new(InterceptedService::new(inner, interceptor)) } /// Compress requests with the given encoding. /// /// This requires the server to support it otherwise it might respond with an /// error. #[must_use] pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { self.inner = self.inner.send_compressed(encoding); self } /// Enable decompressing responses. #[must_use] pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { self.inner = self.inner.accept_compressed(encoding); self } /// Validators queries all validators that match the given status. /// /// When called from another module, this query might consume a high amount of /// gas if the pagination field is incorrectly set. pub async fn validators( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static("/cosmos.staking.v1beta1.Query/Validators"); self.inner.unary(request.into_request(), path, codec).await } /// Validator queries validator info for given validator address. pub async fn validator( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static("/cosmos.staking.v1beta1.Query/Validator"); self.inner.unary(request.into_request(), path, codec).await } /// ValidatorDelegations queries delegate info for given validator. /// /// When called from another module, this query might consume a high amount of /// gas if the pagination field is incorrectly set. pub async fn validator_delegations( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/cosmos.staking.v1beta1.Query/ValidatorDelegations", ); self.inner.unary(request.into_request(), path, codec).await } /// ValidatorUnbondingDelegations queries unbonding delegations of a validator. /// /// When called from another module, this query might consume a high amount of /// gas if the pagination field is incorrectly set. pub async fn validator_unbonding_delegations( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/cosmos.staking.v1beta1.Query/ValidatorUnbondingDelegations", ); self.inner.unary(request.into_request(), path, codec).await } /// Delegation queries delegate info for given validator delegator pair. pub async fn delegation( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static("/cosmos.staking.v1beta1.Query/Delegation"); self.inner.unary(request.into_request(), path, codec).await } /// UnbondingDelegation queries unbonding info for given validator delegator /// pair. pub async fn unbonding_delegation( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/cosmos.staking.v1beta1.Query/UnbondingDelegation", ); self.inner.unary(request.into_request(), path, codec).await } /// DelegatorDelegations queries all delegations of a given delegator address. /// /// When called from another module, this query might consume a high amount of /// gas if the pagination field is incorrectly set. pub async fn delegator_delegations( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/cosmos.staking.v1beta1.Query/DelegatorDelegations", ); self.inner.unary(request.into_request(), path, codec).await } /// DelegatorUnbondingDelegations queries all unbonding delegations of a given /// delegator address. /// /// When called from another module, this query might consume a high amount of /// gas if the pagination field is incorrectly set. pub async fn delegator_unbonding_delegations( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/cosmos.staking.v1beta1.Query/DelegatorUnbondingDelegations", ); self.inner.unary(request.into_request(), path, codec).await } /// Redelegations queries redelegations of given address. /// /// When called from another module, this query might consume a high amount of /// gas if the pagination field is incorrectly set. pub async fn redelegations( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static("/cosmos.staking.v1beta1.Query/Redelegations"); self.inner.unary(request.into_request(), path, codec).await } /// DelegatorValidators queries all validators info for given delegator /// address. /// /// When called from another module, this query might consume a high amount of /// gas if the pagination field is incorrectly set. pub async fn delegator_validators( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/cosmos.staking.v1beta1.Query/DelegatorValidators", ); self.inner.unary(request.into_request(), path, codec).await } /// DelegatorValidator queries validator info for given delegator validator /// pair. pub async fn delegator_validator( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/cosmos.staking.v1beta1.Query/DelegatorValidator", ); self.inner.unary(request.into_request(), path, codec).await } /// HistoricalInfo queries the historical info for given height. pub async fn historical_info( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/cosmos.staking.v1beta1.Query/HistoricalInfo", ); self.inner.unary(request.into_request(), path, codec).await } /// Pool queries the pool info. pub async fn pool( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static("/cosmos.staking.v1beta1.Query/Pool"); self.inner.unary(request.into_request(), path, codec).await } /// Parameters queries the staking parameters. pub async fn params( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static("/cosmos.staking.v1beta1.Query/Params"); self.inner.unary(request.into_request(), path, codec).await } } } /// Generated server implementations. #[cfg(feature = "grpc")] #[cfg_attr(docsrs, doc(cfg(feature = "grpc")))] pub mod query_server { #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] use tonic::codegen::*; /// Generated trait containing gRPC methods that should be implemented for use with QueryServer. #[async_trait] pub trait Query: Send + Sync + 'static { /// Validators queries all validators that match the given status. /// /// When called from another module, this query might consume a high amount of /// gas if the pagination field is incorrectly set. async fn validators( &self, request: tonic::Request, ) -> Result, tonic::Status>; /// Validator queries validator info for given validator address. async fn validator( &self, request: tonic::Request, ) -> Result, tonic::Status>; /// ValidatorDelegations queries delegate info for given validator. /// /// When called from another module, this query might consume a high amount of /// gas if the pagination field is incorrectly set. async fn validator_delegations( &self, request: tonic::Request, ) -> Result, tonic::Status>; /// ValidatorUnbondingDelegations queries unbonding delegations of a validator. /// /// When called from another module, this query might consume a high amount of /// gas if the pagination field is incorrectly set. async fn validator_unbonding_delegations( &self, request: tonic::Request, ) -> Result, tonic::Status>; /// Delegation queries delegate info for given validator delegator pair. async fn delegation( &self, request: tonic::Request, ) -> Result, tonic::Status>; /// UnbondingDelegation queries unbonding info for given validator delegator /// pair. async fn unbonding_delegation( &self, request: tonic::Request, ) -> Result, tonic::Status>; /// DelegatorDelegations queries all delegations of a given delegator address. /// /// When called from another module, this query might consume a high amount of /// gas if the pagination field is incorrectly set. async fn delegator_delegations( &self, request: tonic::Request, ) -> Result, tonic::Status>; /// DelegatorUnbondingDelegations queries all unbonding delegations of a given /// delegator address. /// /// When called from another module, this query might consume a high amount of /// gas if the pagination field is incorrectly set. async fn delegator_unbonding_delegations( &self, request: tonic::Request, ) -> Result, tonic::Status>; /// Redelegations queries redelegations of given address. /// /// When called from another module, this query might consume a high amount of /// gas if the pagination field is incorrectly set. async fn redelegations( &self, request: tonic::Request, ) -> Result, tonic::Status>; /// DelegatorValidators queries all validators info for given delegator /// address. /// /// When called from another module, this query might consume a high amount of /// gas if the pagination field is incorrectly set. async fn delegator_validators( &self, request: tonic::Request, ) -> Result, tonic::Status>; /// DelegatorValidator queries validator info for given delegator validator /// pair. async fn delegator_validator( &self, request: tonic::Request, ) -> Result, tonic::Status>; /// HistoricalInfo queries the historical info for given height. async fn historical_info( &self, request: tonic::Request, ) -> Result, tonic::Status>; /// Pool queries the pool info. async fn pool( &self, request: tonic::Request, ) -> Result, tonic::Status>; /// Parameters queries the staking parameters. async fn params( &self, request: tonic::Request, ) -> Result, tonic::Status>; } /// Query defines the gRPC querier service. #[derive(Debug)] pub struct QueryServer { inner: _Inner, accept_compression_encodings: EnabledCompressionEncodings, send_compression_encodings: EnabledCompressionEncodings, } struct _Inner(Arc); impl QueryServer { pub fn new(inner: T) -> Self { Self::from_arc(Arc::new(inner)) } pub fn from_arc(inner: Arc) -> Self { let inner = _Inner(inner); Self { inner, accept_compression_encodings: Default::default(), send_compression_encodings: Default::default(), } } pub fn with_interceptor(inner: T, interceptor: F) -> InterceptedService where F: tonic::service::Interceptor, { InterceptedService::new(Self::new(inner), interceptor) } /// Enable decompressing requests with the given encoding. #[must_use] pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { self.accept_compression_encodings.enable(encoding); self } /// Compress responses with the given encoding, if the client supports it. #[must_use] pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { self.send_compression_encodings.enable(encoding); self } } impl tonic::codegen::Service> for QueryServer where T: Query, B: Body + Send + 'static, B::Error: Into + Send + 'static, { type Response = http::Response; type Error = std::convert::Infallible; type Future = BoxFuture; fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll> { Poll::Ready(Ok(())) } fn call(&mut self, req: http::Request) -> Self::Future { let inner = self.inner.clone(); match req.uri().path() { "/cosmos.staking.v1beta1.Query/Validators" => { #[allow(non_camel_case_types)] struct ValidatorsSvc(pub Arc); impl tonic::server::UnaryService for ValidatorsSvc { type Response = super::QueryValidatorsResponse; type Future = BoxFuture, tonic::Status>; fn call( &mut self, request: tonic::Request, ) -> Self::Future { let inner = self.0.clone(); let fut = async move { (*inner).validators(request).await }; Box::pin(fut) } } let accept_compression_encodings = self.accept_compression_encodings; let send_compression_encodings = self.send_compression_encodings; let inner = self.inner.clone(); let fut = async move { let inner = inner.0; let method = ValidatorsSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config( accept_compression_encodings, send_compression_encodings, ); let res = grpc.unary(method, req).await; Ok(res) }; Box::pin(fut) } "/cosmos.staking.v1beta1.Query/Validator" => { #[allow(non_camel_case_types)] struct ValidatorSvc(pub Arc); impl tonic::server::UnaryService for ValidatorSvc { type Response = super::QueryValidatorResponse; type Future = BoxFuture, tonic::Status>; fn call( &mut self, request: tonic::Request, ) -> Self::Future { let inner = self.0.clone(); let fut = async move { (*inner).validator(request).await }; Box::pin(fut) } } let accept_compression_encodings = self.accept_compression_encodings; let send_compression_encodings = self.send_compression_encodings; let inner = self.inner.clone(); let fut = async move { let inner = inner.0; let method = ValidatorSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config( accept_compression_encodings, send_compression_encodings, ); let res = grpc.unary(method, req).await; Ok(res) }; Box::pin(fut) } "/cosmos.staking.v1beta1.Query/ValidatorDelegations" => { #[allow(non_camel_case_types)] struct ValidatorDelegationsSvc(pub Arc); impl tonic::server::UnaryService for ValidatorDelegationsSvc { type Response = super::QueryValidatorDelegationsResponse; type Future = BoxFuture, tonic::Status>; fn call( &mut self, request: tonic::Request, ) -> Self::Future { let inner = self.0.clone(); let fut = async move { (*inner).validator_delegations(request).await }; Box::pin(fut) } } let accept_compression_encodings = self.accept_compression_encodings; let send_compression_encodings = self.send_compression_encodings; let inner = self.inner.clone(); let fut = async move { let inner = inner.0; let method = ValidatorDelegationsSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config( accept_compression_encodings, send_compression_encodings, ); let res = grpc.unary(method, req).await; Ok(res) }; Box::pin(fut) } "/cosmos.staking.v1beta1.Query/ValidatorUnbondingDelegations" => { #[allow(non_camel_case_types)] struct ValidatorUnbondingDelegationsSvc(pub Arc); impl tonic::server::UnaryService< super::QueryValidatorUnbondingDelegationsRequest, > for ValidatorUnbondingDelegationsSvc { type Response = super::QueryValidatorUnbondingDelegationsResponse; type Future = BoxFuture, tonic::Status>; fn call( &mut self, request: tonic::Request< super::QueryValidatorUnbondingDelegationsRequest, >, ) -> Self::Future { let inner = self.0.clone(); let fut = async move { (*inner).validator_unbonding_delegations(request).await }; Box::pin(fut) } } let accept_compression_encodings = self.accept_compression_encodings; let send_compression_encodings = self.send_compression_encodings; let inner = self.inner.clone(); let fut = async move { let inner = inner.0; let method = ValidatorUnbondingDelegationsSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config( accept_compression_encodings, send_compression_encodings, ); let res = grpc.unary(method, req).await; Ok(res) }; Box::pin(fut) } "/cosmos.staking.v1beta1.Query/Delegation" => { #[allow(non_camel_case_types)] struct DelegationSvc(pub Arc); impl tonic::server::UnaryService for DelegationSvc { type Response = super::QueryDelegationResponse; type Future = BoxFuture, tonic::Status>; fn call( &mut self, request: tonic::Request, ) -> Self::Future { let inner = self.0.clone(); let fut = async move { (*inner).delegation(request).await }; Box::pin(fut) } } let accept_compression_encodings = self.accept_compression_encodings; let send_compression_encodings = self.send_compression_encodings; let inner = self.inner.clone(); let fut = async move { let inner = inner.0; let method = DelegationSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config( accept_compression_encodings, send_compression_encodings, ); let res = grpc.unary(method, req).await; Ok(res) }; Box::pin(fut) } "/cosmos.staking.v1beta1.Query/UnbondingDelegation" => { #[allow(non_camel_case_types)] struct UnbondingDelegationSvc(pub Arc); impl tonic::server::UnaryService for UnbondingDelegationSvc { type Response = super::QueryUnbondingDelegationResponse; type Future = BoxFuture, tonic::Status>; fn call( &mut self, request: tonic::Request, ) -> Self::Future { let inner = self.0.clone(); let fut = async move { (*inner).unbonding_delegation(request).await }; Box::pin(fut) } } let accept_compression_encodings = self.accept_compression_encodings; let send_compression_encodings = self.send_compression_encodings; let inner = self.inner.clone(); let fut = async move { let inner = inner.0; let method = UnbondingDelegationSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config( accept_compression_encodings, send_compression_encodings, ); let res = grpc.unary(method, req).await; Ok(res) }; Box::pin(fut) } "/cosmos.staking.v1beta1.Query/DelegatorDelegations" => { #[allow(non_camel_case_types)] struct DelegatorDelegationsSvc(pub Arc); impl tonic::server::UnaryService for DelegatorDelegationsSvc { type Response = super::QueryDelegatorDelegationsResponse; type Future = BoxFuture, tonic::Status>; fn call( &mut self, request: tonic::Request, ) -> Self::Future { let inner = self.0.clone(); let fut = async move { (*inner).delegator_delegations(request).await }; Box::pin(fut) } } let accept_compression_encodings = self.accept_compression_encodings; let send_compression_encodings = self.send_compression_encodings; let inner = self.inner.clone(); let fut = async move { let inner = inner.0; let method = DelegatorDelegationsSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config( accept_compression_encodings, send_compression_encodings, ); let res = grpc.unary(method, req).await; Ok(res) }; Box::pin(fut) } "/cosmos.staking.v1beta1.Query/DelegatorUnbondingDelegations" => { #[allow(non_camel_case_types)] struct DelegatorUnbondingDelegationsSvc(pub Arc); impl tonic::server::UnaryService< super::QueryDelegatorUnbondingDelegationsRequest, > for DelegatorUnbondingDelegationsSvc { type Response = super::QueryDelegatorUnbondingDelegationsResponse; type Future = BoxFuture, tonic::Status>; fn call( &mut self, request: tonic::Request< super::QueryDelegatorUnbondingDelegationsRequest, >, ) -> Self::Future { let inner = self.0.clone(); let fut = async move { (*inner).delegator_unbonding_delegations(request).await }; Box::pin(fut) } } let accept_compression_encodings = self.accept_compression_encodings; let send_compression_encodings = self.send_compression_encodings; let inner = self.inner.clone(); let fut = async move { let inner = inner.0; let method = DelegatorUnbondingDelegationsSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config( accept_compression_encodings, send_compression_encodings, ); let res = grpc.unary(method, req).await; Ok(res) }; Box::pin(fut) } "/cosmos.staking.v1beta1.Query/Redelegations" => { #[allow(non_camel_case_types)] struct RedelegationsSvc(pub Arc); impl tonic::server::UnaryService for RedelegationsSvc { type Response = super::QueryRedelegationsResponse; type Future = BoxFuture, tonic::Status>; fn call( &mut self, request: tonic::Request, ) -> Self::Future { let inner = self.0.clone(); let fut = async move { (*inner).redelegations(request).await }; Box::pin(fut) } } let accept_compression_encodings = self.accept_compression_encodings; let send_compression_encodings = self.send_compression_encodings; let inner = self.inner.clone(); let fut = async move { let inner = inner.0; let method = RedelegationsSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config( accept_compression_encodings, send_compression_encodings, ); let res = grpc.unary(method, req).await; Ok(res) }; Box::pin(fut) } "/cosmos.staking.v1beta1.Query/DelegatorValidators" => { #[allow(non_camel_case_types)] struct DelegatorValidatorsSvc(pub Arc); impl tonic::server::UnaryService for DelegatorValidatorsSvc { type Response = super::QueryDelegatorValidatorsResponse; type Future = BoxFuture, tonic::Status>; fn call( &mut self, request: tonic::Request, ) -> Self::Future { let inner = self.0.clone(); let fut = async move { (*inner).delegator_validators(request).await }; Box::pin(fut) } } let accept_compression_encodings = self.accept_compression_encodings; let send_compression_encodings = self.send_compression_encodings; let inner = self.inner.clone(); let fut = async move { let inner = inner.0; let method = DelegatorValidatorsSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config( accept_compression_encodings, send_compression_encodings, ); let res = grpc.unary(method, req).await; Ok(res) }; Box::pin(fut) } "/cosmos.staking.v1beta1.Query/DelegatorValidator" => { #[allow(non_camel_case_types)] struct DelegatorValidatorSvc(pub Arc); impl tonic::server::UnaryService for DelegatorValidatorSvc { type Response = super::QueryDelegatorValidatorResponse; type Future = BoxFuture, tonic::Status>; fn call( &mut self, request: tonic::Request, ) -> Self::Future { let inner = self.0.clone(); let fut = async move { (*inner).delegator_validator(request).await }; Box::pin(fut) } } let accept_compression_encodings = self.accept_compression_encodings; let send_compression_encodings = self.send_compression_encodings; let inner = self.inner.clone(); let fut = async move { let inner = inner.0; let method = DelegatorValidatorSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config( accept_compression_encodings, send_compression_encodings, ); let res = grpc.unary(method, req).await; Ok(res) }; Box::pin(fut) } "/cosmos.staking.v1beta1.Query/HistoricalInfo" => { #[allow(non_camel_case_types)] struct HistoricalInfoSvc(pub Arc); impl tonic::server::UnaryService for HistoricalInfoSvc { type Response = super::QueryHistoricalInfoResponse; type Future = BoxFuture, tonic::Status>; fn call( &mut self, request: tonic::Request, ) -> Self::Future { let inner = self.0.clone(); let fut = async move { (*inner).historical_info(request).await }; Box::pin(fut) } } let accept_compression_encodings = self.accept_compression_encodings; let send_compression_encodings = self.send_compression_encodings; let inner = self.inner.clone(); let fut = async move { let inner = inner.0; let method = HistoricalInfoSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config( accept_compression_encodings, send_compression_encodings, ); let res = grpc.unary(method, req).await; Ok(res) }; Box::pin(fut) } "/cosmos.staking.v1beta1.Query/Pool" => { #[allow(non_camel_case_types)] struct PoolSvc(pub Arc); impl tonic::server::UnaryService for PoolSvc { type Response = super::QueryPoolResponse; type Future = BoxFuture, tonic::Status>; fn call( &mut self, request: tonic::Request, ) -> Self::Future { let inner = self.0.clone(); let fut = async move { (*inner).pool(request).await }; Box::pin(fut) } } let accept_compression_encodings = self.accept_compression_encodings; let send_compression_encodings = self.send_compression_encodings; let inner = self.inner.clone(); let fut = async move { let inner = inner.0; let method = PoolSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config( accept_compression_encodings, send_compression_encodings, ); let res = grpc.unary(method, req).await; Ok(res) }; Box::pin(fut) } "/cosmos.staking.v1beta1.Query/Params" => { #[allow(non_camel_case_types)] struct ParamsSvc(pub Arc); impl tonic::server::UnaryService for ParamsSvc { type Response = super::QueryParamsResponse; type Future = BoxFuture, tonic::Status>; fn call( &mut self, request: tonic::Request, ) -> Self::Future { let inner = self.0.clone(); let fut = async move { (*inner).params(request).await }; Box::pin(fut) } } let accept_compression_encodings = self.accept_compression_encodings; let send_compression_encodings = self.send_compression_encodings; let inner = self.inner.clone(); let fut = async move { let inner = inner.0; let method = ParamsSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config( accept_compression_encodings, send_compression_encodings, ); let res = grpc.unary(method, req).await; Ok(res) }; Box::pin(fut) } _ => Box::pin(async move { Ok(http::Response::builder() .status(200) .header("grpc-status", "12") .header("content-type", "application/grpc") .body(empty_body()) .unwrap()) }), } } } impl Clone for QueryServer { fn clone(&self) -> Self { let inner = self.inner.clone(); Self { inner, accept_compression_encodings: self.accept_compression_encodings, send_compression_encodings: self.send_compression_encodings, } } } impl Clone for _Inner { fn clone(&self) -> Self { Self(self.0.clone()) } } impl std::fmt::Debug for _Inner { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { write!(f, "{:?}", self.0) } } impl tonic::server::NamedService for QueryServer { const NAME: &'static str = "cosmos.staking.v1beta1.Query"; } } /// MsgCreateValidator defines a SDK message for creating a new validator. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgCreateValidator { #[prost(message, optional, tag = "1")] pub description: ::core::option::Option, #[prost(message, optional, tag = "2")] pub commission: ::core::option::Option, #[prost(string, tag = "3")] pub min_self_delegation: ::prost::alloc::string::String, #[prost(string, tag = "4")] pub delegator_address: ::prost::alloc::string::String, #[prost(string, tag = "5")] pub validator_address: ::prost::alloc::string::String, #[prost(message, optional, tag = "6")] pub pubkey: ::core::option::Option<::prost_types::Any>, #[prost(message, optional, tag = "7")] pub value: ::core::option::Option, } /// MsgCreateValidatorResponse defines the Msg/CreateValidator response type. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgCreateValidatorResponse {} /// MsgEditValidator defines a SDK message for editing an existing validator. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgEditValidator { #[prost(message, optional, tag = "1")] pub description: ::core::option::Option, #[prost(string, tag = "2")] pub validator_address: ::prost::alloc::string::String, /// We pass a reference to the new commission rate and min self delegation as /// it's not mandatory to update. If not updated, the deserialized rate will be /// zero with no way to distinguish if an update was intended. /// REF: #2373 #[prost(string, tag = "3")] pub commission_rate: ::prost::alloc::string::String, #[prost(string, tag = "4")] pub min_self_delegation: ::prost::alloc::string::String, } /// MsgEditValidatorResponse defines the Msg/EditValidator response type. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgEditValidatorResponse {} /// MsgDelegate defines a SDK message for performing a delegation of coins /// from a delegator to a validator. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgDelegate { #[prost(string, tag = "1")] pub delegator_address: ::prost::alloc::string::String, #[prost(string, tag = "2")] pub validator_address: ::prost::alloc::string::String, #[prost(message, optional, tag = "3")] pub amount: ::core::option::Option, } /// MsgDelegateResponse defines the Msg/Delegate response type. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgDelegateResponse {} /// MsgBeginRedelegate defines a SDK message for performing a redelegation /// of coins from a delegator and source validator to a destination validator. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgBeginRedelegate { #[prost(string, tag = "1")] pub delegator_address: ::prost::alloc::string::String, #[prost(string, tag = "2")] pub validator_src_address: ::prost::alloc::string::String, #[prost(string, tag = "3")] pub validator_dst_address: ::prost::alloc::string::String, #[prost(message, optional, tag = "4")] pub amount: ::core::option::Option, } /// MsgBeginRedelegateResponse defines the Msg/BeginRedelegate response type. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgBeginRedelegateResponse { #[prost(message, optional, tag = "1")] pub completion_time: ::core::option::Option<::prost_types::Timestamp>, } /// MsgUndelegate defines a SDK message for performing an undelegation from a /// delegate and a validator. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgUndelegate { #[prost(string, tag = "1")] pub delegator_address: ::prost::alloc::string::String, #[prost(string, tag = "2")] pub validator_address: ::prost::alloc::string::String, #[prost(message, optional, tag = "3")] pub amount: ::core::option::Option, } /// MsgUndelegateResponse defines the Msg/Undelegate response type. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgUndelegateResponse { #[prost(message, optional, tag = "1")] pub completion_time: ::core::option::Option<::prost_types::Timestamp>, } /// MsgCancelUnbondingDelegation defines the SDK message for performing a cancel unbonding delegation for delegator /// /// Since: cosmos-sdk 0.46 #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgCancelUnbondingDelegation { #[prost(string, tag = "1")] pub delegator_address: ::prost::alloc::string::String, #[prost(string, tag = "2")] pub validator_address: ::prost::alloc::string::String, /// amount is always less than or equal to unbonding delegation entry balance #[prost(message, optional, tag = "3")] pub amount: ::core::option::Option, /// creation_height is the height which the unbonding took place. #[prost(int64, tag = "4")] pub creation_height: i64, } /// MsgCancelUnbondingDelegationResponse /// /// Since: cosmos-sdk 0.46 #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgCancelUnbondingDelegationResponse {} /// MsgUpdateParams is the Msg/UpdateParams request type. /// /// Since: cosmos-sdk 0.47 #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] 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, } /// MsgUpdateParamsResponse defines the response structure for executing a /// MsgUpdateParams message. /// /// Since: cosmos-sdk 0.47 #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct MsgUpdateParamsResponse {} /// Generated client implementations. #[cfg(feature = "grpc")] #[cfg_attr(docsrs, doc(cfg(feature = "grpc")))] pub mod msg_client { #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] use tonic::codegen::http::Uri; use tonic::codegen::*; /// Msg defines the staking Msg service. #[derive(Debug, Clone)] pub struct MsgClient { inner: tonic::client::Grpc, } #[cfg(feature = "grpc-transport")] #[cfg_attr(docsrs, doc(cfg(feature = "grpc-transport")))] impl MsgClient { /// Attempt to create a new client by connecting to a given endpoint. pub async fn connect(dst: D) -> Result where D: std::convert::TryInto, D::Error: Into, { let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; Ok(Self::new(conn)) } } impl MsgClient where T: tonic::client::GrpcService, T::Error: Into, T::ResponseBody: Body + Send + 'static, ::Error: Into + Send, { pub fn new(inner: T) -> Self { let inner = tonic::client::Grpc::new(inner); Self { inner } } pub fn with_origin(inner: T, origin: Uri) -> Self { let inner = tonic::client::Grpc::with_origin(inner, origin); Self { inner } } pub fn with_interceptor(inner: T, interceptor: F) -> MsgClient> where F: tonic::service::Interceptor, T::ResponseBody: Default, T: tonic::codegen::Service< http::Request, Response = http::Response< >::ResponseBody, >, >, >>::Error: Into + Send + Sync, { MsgClient::new(InterceptedService::new(inner, interceptor)) } /// Compress requests with the given encoding. /// /// This requires the server to support it otherwise it might respond with an /// error. #[must_use] pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { self.inner = self.inner.send_compressed(encoding); self } /// Enable decompressing responses. #[must_use] pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { self.inner = self.inner.accept_compressed(encoding); self } /// CreateValidator defines a method for creating a new validator. pub async fn create_validator( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static("/cosmos.staking.v1beta1.Msg/CreateValidator"); self.inner.unary(request.into_request(), path, codec).await } /// EditValidator defines a method for editing an existing validator. pub async fn edit_validator( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static("/cosmos.staking.v1beta1.Msg/EditValidator"); self.inner.unary(request.into_request(), path, codec).await } /// Delegate defines a method for performing a delegation of coins /// from a delegator to a validator. pub async fn delegate( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static("/cosmos.staking.v1beta1.Msg/Delegate"); self.inner.unary(request.into_request(), path, codec).await } /// BeginRedelegate defines a method for performing a redelegation /// of coins from a delegator and source validator to a destination validator. pub async fn begin_redelegate( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static("/cosmos.staking.v1beta1.Msg/BeginRedelegate"); self.inner.unary(request.into_request(), path, codec).await } /// Undelegate defines a method for performing an undelegation from a /// delegate and a validator. pub async fn undelegate( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static("/cosmos.staking.v1beta1.Msg/Undelegate"); self.inner.unary(request.into_request(), path, codec).await } /// CancelUnbondingDelegation defines a method for performing canceling the unbonding delegation /// and delegate back to previous validator. /// /// Since: cosmos-sdk 0.46 pub async fn cancel_unbonding_delegation( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/cosmos.staking.v1beta1.Msg/CancelUnbondingDelegation", ); self.inner.unary(request.into_request(), path, codec).await } /// UpdateParams defines an operation for updating the x/staking module /// parameters. /// Since: cosmos-sdk 0.47 pub async fn update_params( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static("/cosmos.staking.v1beta1.Msg/UpdateParams"); self.inner.unary(request.into_request(), path, codec).await } } } /// Generated server implementations. #[cfg(feature = "grpc")] #[cfg_attr(docsrs, doc(cfg(feature = "grpc")))] pub mod msg_server { #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] use tonic::codegen::*; /// Generated trait containing gRPC methods that should be implemented for use with MsgServer. #[async_trait] pub trait Msg: Send + Sync + 'static { /// CreateValidator defines a method for creating a new validator. async fn create_validator( &self, request: tonic::Request, ) -> Result, tonic::Status>; /// EditValidator defines a method for editing an existing validator. async fn edit_validator( &self, request: tonic::Request, ) -> Result, tonic::Status>; /// Delegate defines a method for performing a delegation of coins /// from a delegator to a validator. async fn delegate( &self, request: tonic::Request, ) -> Result, tonic::Status>; /// BeginRedelegate defines a method for performing a redelegation /// of coins from a delegator and source validator to a destination validator. async fn begin_redelegate( &self, request: tonic::Request, ) -> Result, tonic::Status>; /// Undelegate defines a method for performing an undelegation from a /// delegate and a validator. async fn undelegate( &self, request: tonic::Request, ) -> Result, tonic::Status>; /// CancelUnbondingDelegation defines a method for performing canceling the unbonding delegation /// and delegate back to previous validator. /// /// Since: cosmos-sdk 0.46 async fn cancel_unbonding_delegation( &self, request: tonic::Request, ) -> Result, tonic::Status>; /// UpdateParams defines an operation for updating the x/staking module /// parameters. /// Since: cosmos-sdk 0.47 async fn update_params( &self, request: tonic::Request, ) -> Result, tonic::Status>; } /// Msg defines the staking Msg service. #[derive(Debug)] pub struct MsgServer { inner: _Inner, accept_compression_encodings: EnabledCompressionEncodings, send_compression_encodings: EnabledCompressionEncodings, } struct _Inner(Arc); impl MsgServer { pub fn new(inner: T) -> Self { Self::from_arc(Arc::new(inner)) } pub fn from_arc(inner: Arc) -> Self { let inner = _Inner(inner); Self { inner, accept_compression_encodings: Default::default(), send_compression_encodings: Default::default(), } } pub fn with_interceptor(inner: T, interceptor: F) -> InterceptedService where F: tonic::service::Interceptor, { InterceptedService::new(Self::new(inner), interceptor) } /// Enable decompressing requests with the given encoding. #[must_use] pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { self.accept_compression_encodings.enable(encoding); self } /// Compress responses with the given encoding, if the client supports it. #[must_use] pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { self.send_compression_encodings.enable(encoding); self } } impl tonic::codegen::Service> for MsgServer where T: Msg, B: Body + Send + 'static, B::Error: Into + Send + 'static, { type Response = http::Response; type Error = std::convert::Infallible; type Future = BoxFuture; fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll> { Poll::Ready(Ok(())) } fn call(&mut self, req: http::Request) -> Self::Future { let inner = self.inner.clone(); match req.uri().path() { "/cosmos.staking.v1beta1.Msg/CreateValidator" => { #[allow(non_camel_case_types)] struct CreateValidatorSvc(pub Arc); impl tonic::server::UnaryService for CreateValidatorSvc { type Response = super::MsgCreateValidatorResponse; type Future = BoxFuture, tonic::Status>; fn call( &mut self, request: tonic::Request, ) -> Self::Future { let inner = self.0.clone(); let fut = async move { (*inner).create_validator(request).await }; Box::pin(fut) } } let accept_compression_encodings = self.accept_compression_encodings; let send_compression_encodings = self.send_compression_encodings; let inner = self.inner.clone(); let fut = async move { let inner = inner.0; let method = CreateValidatorSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config( accept_compression_encodings, send_compression_encodings, ); let res = grpc.unary(method, req).await; Ok(res) }; Box::pin(fut) } "/cosmos.staking.v1beta1.Msg/EditValidator" => { #[allow(non_camel_case_types)] struct EditValidatorSvc(pub Arc); impl tonic::server::UnaryService for EditValidatorSvc { type Response = super::MsgEditValidatorResponse; type Future = BoxFuture, tonic::Status>; fn call( &mut self, request: tonic::Request, ) -> Self::Future { let inner = self.0.clone(); let fut = async move { (*inner).edit_validator(request).await }; Box::pin(fut) } } let accept_compression_encodings = self.accept_compression_encodings; let send_compression_encodings = self.send_compression_encodings; let inner = self.inner.clone(); let fut = async move { let inner = inner.0; let method = EditValidatorSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config( accept_compression_encodings, send_compression_encodings, ); let res = grpc.unary(method, req).await; Ok(res) }; Box::pin(fut) } "/cosmos.staking.v1beta1.Msg/Delegate" => { #[allow(non_camel_case_types)] struct DelegateSvc(pub Arc); impl tonic::server::UnaryService for DelegateSvc { type Response = super::MsgDelegateResponse; type Future = BoxFuture, tonic::Status>; fn call( &mut self, request: tonic::Request, ) -> Self::Future { let inner = self.0.clone(); let fut = async move { (*inner).delegate(request).await }; Box::pin(fut) } } let accept_compression_encodings = self.accept_compression_encodings; let send_compression_encodings = self.send_compression_encodings; let inner = self.inner.clone(); let fut = async move { let inner = inner.0; let method = DelegateSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config( accept_compression_encodings, send_compression_encodings, ); let res = grpc.unary(method, req).await; Ok(res) }; Box::pin(fut) } "/cosmos.staking.v1beta1.Msg/BeginRedelegate" => { #[allow(non_camel_case_types)] struct BeginRedelegateSvc(pub Arc); impl tonic::server::UnaryService for BeginRedelegateSvc { type Response = super::MsgBeginRedelegateResponse; type Future = BoxFuture, tonic::Status>; fn call( &mut self, request: tonic::Request, ) -> Self::Future { let inner = self.0.clone(); let fut = async move { (*inner).begin_redelegate(request).await }; Box::pin(fut) } } let accept_compression_encodings = self.accept_compression_encodings; let send_compression_encodings = self.send_compression_encodings; let inner = self.inner.clone(); let fut = async move { let inner = inner.0; let method = BeginRedelegateSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config( accept_compression_encodings, send_compression_encodings, ); let res = grpc.unary(method, req).await; Ok(res) }; Box::pin(fut) } "/cosmos.staking.v1beta1.Msg/Undelegate" => { #[allow(non_camel_case_types)] struct UndelegateSvc(pub Arc); impl tonic::server::UnaryService for UndelegateSvc { type Response = super::MsgUndelegateResponse; type Future = BoxFuture, tonic::Status>; fn call( &mut self, request: tonic::Request, ) -> Self::Future { let inner = self.0.clone(); let fut = async move { (*inner).undelegate(request).await }; Box::pin(fut) } } let accept_compression_encodings = self.accept_compression_encodings; let send_compression_encodings = self.send_compression_encodings; let inner = self.inner.clone(); let fut = async move { let inner = inner.0; let method = UndelegateSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config( accept_compression_encodings, send_compression_encodings, ); let res = grpc.unary(method, req).await; Ok(res) }; Box::pin(fut) } "/cosmos.staking.v1beta1.Msg/CancelUnbondingDelegation" => { #[allow(non_camel_case_types)] struct CancelUnbondingDelegationSvc(pub Arc); impl tonic::server::UnaryService for CancelUnbondingDelegationSvc { type Response = super::MsgCancelUnbondingDelegationResponse; type Future = BoxFuture, tonic::Status>; fn call( &mut self, request: tonic::Request, ) -> Self::Future { let inner = self.0.clone(); let fut = async move { (*inner).cancel_unbonding_delegation(request).await }; Box::pin(fut) } } let accept_compression_encodings = self.accept_compression_encodings; let send_compression_encodings = self.send_compression_encodings; let inner = self.inner.clone(); let fut = async move { let inner = inner.0; let method = CancelUnbondingDelegationSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config( accept_compression_encodings, send_compression_encodings, ); let res = grpc.unary(method, req).await; Ok(res) }; Box::pin(fut) } "/cosmos.staking.v1beta1.Msg/UpdateParams" => { #[allow(non_camel_case_types)] struct UpdateParamsSvc(pub Arc); impl tonic::server::UnaryService for UpdateParamsSvc { type Response = super::MsgUpdateParamsResponse; type Future = BoxFuture, tonic::Status>; fn call( &mut self, request: tonic::Request, ) -> Self::Future { let inner = self.0.clone(); let fut = async move { (*inner).update_params(request).await }; Box::pin(fut) } } let accept_compression_encodings = self.accept_compression_encodings; let send_compression_encodings = self.send_compression_encodings; let inner = self.inner.clone(); let fut = async move { let inner = inner.0; let method = UpdateParamsSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config( accept_compression_encodings, send_compression_encodings, ); let res = grpc.unary(method, req).await; Ok(res) }; Box::pin(fut) } _ => Box::pin(async move { Ok(http::Response::builder() .status(200) .header("grpc-status", "12") .header("content-type", "application/grpc") .body(empty_body()) .unwrap()) }), } } } impl Clone for MsgServer { fn clone(&self) -> Self { let inner = self.inner.clone(); Self { inner, accept_compression_encodings: self.accept_compression_encodings, send_compression_encodings: self.send_compression_encodings, } } } impl Clone for _Inner { fn clone(&self) -> Self { Self(self.0.clone()) } } impl std::fmt::Debug for _Inner { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { write!(f, "{:?}", self.0) } } impl tonic::server::NamedService for MsgServer { const NAME: &'static str = "cosmos.staking.v1beta1.Msg"; } } /// StakeAuthorization defines authorization for delegate/undelegate/redelegate. /// /// Since: cosmos-sdk 0.43 #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct StakeAuthorization { /// max_tokens specifies the maximum amount of tokens can be delegate to a validator. If it is /// empty, there is no spend limit and any amount of coins can be delegated. #[prost(message, optional, tag = "1")] pub max_tokens: ::core::option::Option, /// authorization_type defines one of AuthorizationType. #[prost(enumeration = "AuthorizationType", tag = "4")] pub authorization_type: i32, /// validators is the oneof that represents either allow_list or deny_list #[prost(oneof = "stake_authorization::Policy", tags = "2, 3")] pub validators: ::core::option::Option, } /// Nested message and enum types in `StakeAuthorization`. pub mod stake_authorization { /// Validators defines list of validator addresses. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] pub struct Validators { #[prost(string, repeated, tag = "1")] pub address: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, } /// validators is the oneof that represents either allow_list or deny_list #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum Policy { /// allow_list specifies list of validator addresses to whom grantee can delegate tokens on behalf of granter's /// account. #[prost(message, tag = "2")] AllowList(Validators), /// deny_list specifies list of validator addresses to whom grantee can not delegate tokens. #[prost(message, tag = "3")] DenyList(Validators), } } /// AuthorizationType defines the type of staking module authorization type /// /// Since: cosmos-sdk 0.43 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum AuthorizationType { /// AUTHORIZATION_TYPE_UNSPECIFIED specifies an unknown authorization type Unspecified = 0, /// AUTHORIZATION_TYPE_DELEGATE defines an authorization type for Msg/Delegate Delegate = 1, /// AUTHORIZATION_TYPE_UNDELEGATE defines an authorization type for Msg/Undelegate Undelegate = 2, /// AUTHORIZATION_TYPE_REDELEGATE defines an authorization type for Msg/BeginRedelegate Redelegate = 3, } impl AuthorizationType { /// 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 { AuthorizationType::Unspecified => "AUTHORIZATION_TYPE_UNSPECIFIED", AuthorizationType::Delegate => "AUTHORIZATION_TYPE_DELEGATE", AuthorizationType::Undelegate => "AUTHORIZATION_TYPE_UNDELEGATE", AuthorizationType::Redelegate => "AUTHORIZATION_TYPE_REDELEGATE", } } /// Creates an enum from field names used in the ProtoBuf definition. pub fn from_str_name(value: &str) -> ::core::option::Option { match value { "AUTHORIZATION_TYPE_UNSPECIFIED" => Some(Self::Unspecified), "AUTHORIZATION_TYPE_DELEGATE" => Some(Self::Delegate), "AUTHORIZATION_TYPE_UNDELEGATE" => Some(Self::Undelegate), "AUTHORIZATION_TYPE_REDELEGATE" => Some(Self::Redelegate), _ => None, } } }