stake.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: penumbra/core/component/stake/v1alpha1/stake.proto

package stakev1alpha1

import (
	context "context"
	fmt "fmt"
	grpc1 "github.com/cosmos/gogoproto/grpc"
	proto "github.com/cosmos/gogoproto/proto"
	v1alpha12 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/asset/v1alpha1"
	v1alpha1 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/keys/v1alpha1"
	v1alpha11 "github.com/cosmos/relayer/v2/relayer/chains/penumbra/core/num/v1alpha1"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	io "io"
	math "math"
	math_bits "math/bits"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

type BondingState_BondingStateEnum int32

const (
	BondingState_BONDING_STATE_ENUM_UNSPECIFIED BondingState_BondingStateEnum = 0
	BondingState_BONDING_STATE_ENUM_BONDED      BondingState_BondingStateEnum = 1
	BondingState_BONDING_STATE_ENUM_UNBONDING   BondingState_BondingStateEnum = 2
	BondingState_BONDING_STATE_ENUM_UNBONDED    BondingState_BondingStateEnum = 3
)

var BondingState_BondingStateEnum_name = map[int32]string{
	0: "BONDING_STATE_ENUM_UNSPECIFIED",
	1: "BONDING_STATE_ENUM_BONDED",
	2: "BONDING_STATE_ENUM_UNBONDING",
	3: "BONDING_STATE_ENUM_UNBONDED",
}

var BondingState_BondingStateEnum_value = map[string]int32{
	"BONDING_STATE_ENUM_UNSPECIFIED": 0,
	"BONDING_STATE_ENUM_BONDED":      1,
	"BONDING_STATE_ENUM_UNBONDING":   2,
	"BONDING_STATE_ENUM_UNBONDED":    3,
}

func (x BondingState_BondingStateEnum) String() string {
	return proto.EnumName(BondingState_BondingStateEnum_name, int32(x))
}

func (BondingState_BondingStateEnum) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_b49c30b9d712baf6, []int{7, 0}
}

type ValidatorState_ValidatorStateEnum int32

const (
	ValidatorState_VALIDATOR_STATE_ENUM_UNSPECIFIED ValidatorState_ValidatorStateEnum = 0
	ValidatorState_VALIDATOR_STATE_ENUM_INACTIVE    ValidatorState_ValidatorStateEnum = 1
	ValidatorState_VALIDATOR_STATE_ENUM_ACTIVE      ValidatorState_ValidatorStateEnum = 2
	ValidatorState_VALIDATOR_STATE_ENUM_JAILED      ValidatorState_ValidatorStateEnum = 3
	ValidatorState_VALIDATOR_STATE_ENUM_TOMBSTONED  ValidatorState_ValidatorStateEnum = 4
	ValidatorState_VALIDATOR_STATE_ENUM_DISABLED    ValidatorState_ValidatorStateEnum = 5
)

var ValidatorState_ValidatorStateEnum_name = map[int32]string{
	0: "VALIDATOR_STATE_ENUM_UNSPECIFIED",
	1: "VALIDATOR_STATE_ENUM_INACTIVE",
	2: "VALIDATOR_STATE_ENUM_ACTIVE",
	3: "VALIDATOR_STATE_ENUM_JAILED",
	4: "VALIDATOR_STATE_ENUM_TOMBSTONED",
	5: "VALIDATOR_STATE_ENUM_DISABLED",
}

var ValidatorState_ValidatorStateEnum_value = map[string]int32{
	"VALIDATOR_STATE_ENUM_UNSPECIFIED": 0,
	"VALIDATOR_STATE_ENUM_INACTIVE":    1,
	"VALIDATOR_STATE_ENUM_ACTIVE":      2,
	"VALIDATOR_STATE_ENUM_JAILED":      3,
	"VALIDATOR_STATE_ENUM_TOMBSTONED":  4,
	"VALIDATOR_STATE_ENUM_DISABLED":    5,
}

func (x ValidatorState_ValidatorStateEnum) String() string {
	return proto.EnumName(ValidatorState_ValidatorStateEnum_name, int32(x))
}

func (ValidatorState_ValidatorStateEnum) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_b49c30b9d712baf6, []int{8, 0}
}

// A Penumbra ZK undelegate claim proof.
type ZKUndelegateClaimProof struct {
	Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"`
}

func (m *ZKUndelegateClaimProof) Reset()         { *m = ZKUndelegateClaimProof{} }
func (m *ZKUndelegateClaimProof) String() string { return proto.CompactTextString(m) }
func (*ZKUndelegateClaimProof) ProtoMessage()    {}
func (*ZKUndelegateClaimProof) Descriptor() ([]byte, []int) {
	return fileDescriptor_b49c30b9d712baf6, []int{0}
}
func (m *ZKUndelegateClaimProof) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ZKUndelegateClaimProof) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ZKUndelegateClaimProof.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ZKUndelegateClaimProof) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ZKUndelegateClaimProof.Merge(m, src)
}
func (m *ZKUndelegateClaimProof) XXX_Size() int {
	return m.Size()
}
func (m *ZKUndelegateClaimProof) XXX_DiscardUnknown() {
	xxx_messageInfo_ZKUndelegateClaimProof.DiscardUnknown(m)
}

var xxx_messageInfo_ZKUndelegateClaimProof proto.InternalMessageInfo

func (m *ZKUndelegateClaimProof) GetInner() []byte {
	if m != nil {
		return m.Inner
	}
	return nil
}

// Describes a validator's configuration data.
type Validator struct {
	// The validator's identity verification key.
	IdentityKey *v1alpha1.IdentityKey `protobuf:"bytes,1,opt,name=identity_key,json=identityKey,proto3" json:"identity_key,omitempty"`
	// The validator's consensus pubkey for use in Tendermint (Ed25519).
	ConsensusKey []byte `protobuf:"bytes,2,opt,name=consensus_key,json=consensusKey,proto3" json:"consensus_key,omitempty"`
	// The validator's (human-readable) name.
	Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
	// The validator's website.
	Website string `protobuf:"bytes,4,opt,name=website,proto3" json:"website,omitempty"`
	// The validator's description.
	Description string `protobuf:"bytes,5,opt,name=description,proto3" json:"description,omitempty"`
	// Whether the validator is enabled or not.
	//
	// Disabled validators cannot be delegated to, and immediately begin unbonding.
	Enabled bool `protobuf:"varint,8,opt,name=enabled,proto3" json:"enabled,omitempty"`
	// A list of funding streams describing the validator's commission.
	FundingStreams []*FundingStream `protobuf:"bytes,6,rep,name=funding_streams,json=fundingStreams,proto3" json:"funding_streams,omitempty"`
	// The sequence number determines which validator data takes priority, and
	// prevents replay attacks.  The chain only accepts new validator definitions
	// with increasing sequence numbers.
	SequenceNumber uint32 `protobuf:"varint,7,opt,name=sequence_number,json=sequenceNumber,proto3" json:"sequence_number,omitempty"`
	// The validator's governance key.
	GovernanceKey *v1alpha1.GovernanceKey `protobuf:"bytes,9,opt,name=governance_key,json=governanceKey,proto3" json:"governance_key,omitempty"`
}

func (m *Validator) Reset()         { *m = Validator{} }
func (m *Validator) String() string { return proto.CompactTextString(m) }
func (*Validator) ProtoMessage()    {}
func (*Validator) Descriptor() ([]byte, []int) {
	return fileDescriptor_b49c30b9d712baf6, []int{1}
}
func (m *Validator) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Validator) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Validator.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Validator) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Validator.Merge(m, src)
}
func (m *Validator) XXX_Size() int {
	return m.Size()
}
func (m *Validator) XXX_DiscardUnknown() {
	xxx_messageInfo_Validator.DiscardUnknown(m)
}

var xxx_messageInfo_Validator proto.InternalMessageInfo

func (m *Validator) GetIdentityKey() *v1alpha1.IdentityKey {
	if m != nil {
		return m.IdentityKey
	}
	return nil
}

func (m *Validator) GetConsensusKey() []byte {
	if m != nil {
		return m.ConsensusKey
	}
	return nil
}

func (m *Validator) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *Validator) GetWebsite() string {
	if m != nil {
		return m.Website
	}
	return ""
}

func (m *Validator) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

func (m *Validator) GetEnabled() bool {
	if m != nil {
		return m.Enabled
	}
	return false
}

func (m *Validator) GetFundingStreams() []*FundingStream {
	if m != nil {
		return m.FundingStreams
	}
	return nil
}

func (m *Validator) GetSequenceNumber() uint32 {
	if m != nil {
		return m.SequenceNumber
	}
	return 0
}

func (m *Validator) GetGovernanceKey() *v1alpha1.GovernanceKey {
	if m != nil {
		return m.GovernanceKey
	}
	return nil
}

// For storing the list of keys of known validators.
type ValidatorList struct {
	ValidatorKeys []*v1alpha1.IdentityKey `protobuf:"bytes,1,rep,name=validator_keys,json=validatorKeys,proto3" json:"validator_keys,omitempty"`
}

func (m *ValidatorList) Reset()         { *m = ValidatorList{} }
func (m *ValidatorList) String() string { return proto.CompactTextString(m) }
func (*ValidatorList) ProtoMessage()    {}
func (*ValidatorList) Descriptor() ([]byte, []int) {
	return fileDescriptor_b49c30b9d712baf6, []int{2}
}
func (m *ValidatorList) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ValidatorList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ValidatorList.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ValidatorList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ValidatorList.Merge(m, src)
}
func (m *ValidatorList) XXX_Size() int {
	return m.Size()
}
func (m *ValidatorList) XXX_DiscardUnknown() {
	xxx_messageInfo_ValidatorList.DiscardUnknown(m)
}

var xxx_messageInfo_ValidatorList proto.InternalMessageInfo

func (m *ValidatorList) GetValidatorKeys() []*v1alpha1.IdentityKey {
	if m != nil {
		return m.ValidatorKeys
	}
	return nil
}

// A portion of a validator's commission.
type FundingStream struct {
	// The recipient of the funding stream.
	//
	// Types that are valid to be assigned to Recipient:
	//
	//	*FundingStream_ToAddress_
	//	*FundingStream_ToCommunityPool_
	Recipient isFundingStream_Recipient `protobuf_oneof:"recipient"`
}

func (m *FundingStream) Reset()         { *m = FundingStream{} }
func (m *FundingStream) String() string { return proto.CompactTextString(m) }
func (*FundingStream) ProtoMessage()    {}
func (*FundingStream) Descriptor() ([]byte, []int) {
	return fileDescriptor_b49c30b9d712baf6, []int{3}
}
func (m *FundingStream) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *FundingStream) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_FundingStream.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *FundingStream) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FundingStream.Merge(m, src)
}
func (m *FundingStream) XXX_Size() int {
	return m.Size()
}
func (m *FundingStream) XXX_DiscardUnknown() {
	xxx_messageInfo_FundingStream.DiscardUnknown(m)
}

var xxx_messageInfo_FundingStream proto.InternalMessageInfo

type isFundingStream_Recipient interface {
	isFundingStream_Recipient()
	MarshalTo([]byte) (int, error)
	Size() int
}

type FundingStream_ToAddress_ struct {
	ToAddress *FundingStream_ToAddress `protobuf:"bytes,1,opt,name=to_address,json=toAddress,proto3,oneof" json:"to_address,omitempty"`
}
type FundingStream_ToCommunityPool_ struct {
	ToCommunityPool *FundingStream_ToCommunityPool `protobuf:"bytes,2,opt,name=to_community_pool,json=toCommunityPool,proto3,oneof" json:"to_community_pool,omitempty"`
}

func (*FundingStream_ToAddress_) isFundingStream_Recipient()       {}
func (*FundingStream_ToCommunityPool_) isFundingStream_Recipient() {}

func (m *FundingStream) GetRecipient() isFundingStream_Recipient {
	if m != nil {
		return m.Recipient
	}
	return nil
}

func (m *FundingStream) GetToAddress() *FundingStream_ToAddress {
	if x, ok := m.GetRecipient().(*FundingStream_ToAddress_); ok {
		return x.ToAddress
	}
	return nil
}

func (m *FundingStream) GetToCommunityPool() *FundingStream_ToCommunityPool {
	if x, ok := m.GetRecipient().(*FundingStream_ToCommunityPool_); ok {
		return x.ToCommunityPool
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*FundingStream) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*FundingStream_ToAddress_)(nil),
		(*FundingStream_ToCommunityPool_)(nil),
	}
}

type FundingStream_ToAddress struct {
	// The destination address for the funding stream.
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	// The portion of the staking reward for the entire delegation pool
	// allocated to this funding stream, specified in basis points.
	RateBps uint32 `protobuf:"varint,2,opt,name=rate_bps,json=rateBps,proto3" json:"rate_bps,omitempty"`
}

func (m *FundingStream_ToAddress) Reset()         { *m = FundingStream_ToAddress{} }
func (m *FundingStream_ToAddress) String() string { return proto.CompactTextString(m) }
func (*FundingStream_ToAddress) ProtoMessage()    {}
func (*FundingStream_ToAddress) Descriptor() ([]byte, []int) {
	return fileDescriptor_b49c30b9d712baf6, []int{3, 0}
}
func (m *FundingStream_ToAddress) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *FundingStream_ToAddress) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_FundingStream_ToAddress.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *FundingStream_ToAddress) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FundingStream_ToAddress.Merge(m, src)
}
func (m *FundingStream_ToAddress) XXX_Size() int {
	return m.Size()
}
func (m *FundingStream_ToAddress) XXX_DiscardUnknown() {
	xxx_messageInfo_FundingStream_ToAddress.DiscardUnknown(m)
}

var xxx_messageInfo_FundingStream_ToAddress proto.InternalMessageInfo

func (m *FundingStream_ToAddress) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

func (m *FundingStream_ToAddress) GetRateBps() uint32 {
	if m != nil {
		return m.RateBps
	}
	return 0
}

type FundingStream_ToCommunityPool struct {
	// The portion of the staking reward for the entire delegation pool
	// allocated to this funding stream, specified in basis points.
	RateBps uint32 `protobuf:"varint,2,opt,name=rate_bps,json=rateBps,proto3" json:"rate_bps,omitempty"`
}

func (m *FundingStream_ToCommunityPool) Reset()         { *m = FundingStream_ToCommunityPool{} }
func (m *FundingStream_ToCommunityPool) String() string { return proto.CompactTextString(m) }
func (*FundingStream_ToCommunityPool) ProtoMessage()    {}
func (*FundingStream_ToCommunityPool) Descriptor() ([]byte, []int) {
	return fileDescriptor_b49c30b9d712baf6, []int{3, 1}
}
func (m *FundingStream_ToCommunityPool) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *FundingStream_ToCommunityPool) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_FundingStream_ToCommunityPool.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *FundingStream_ToCommunityPool) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FundingStream_ToCommunityPool.Merge(m, src)
}
func (m *FundingStream_ToCommunityPool) XXX_Size() int {
	return m.Size()
}
func (m *FundingStream_ToCommunityPool) XXX_DiscardUnknown() {
	xxx_messageInfo_FundingStream_ToCommunityPool.DiscardUnknown(m)
}

var xxx_messageInfo_FundingStream_ToCommunityPool proto.InternalMessageInfo

func (m *FundingStream_ToCommunityPool) GetRateBps() uint32 {
	if m != nil {
		return m.RateBps
	}
	return 0
}

// Describes the reward and exchange rates and voting power for a validator in some epoch.
type RateData struct {
	IdentityKey           *v1alpha1.IdentityKey `protobuf:"bytes,1,opt,name=identity_key,json=identityKey,proto3" json:"identity_key,omitempty"`
	EpochIndex            uint64                `protobuf:"varint,2,opt,name=epoch_index,json=epochIndex,proto3" json:"epoch_index,omitempty"`
	ValidatorRewardRate   uint64                `protobuf:"varint,4,opt,name=validator_reward_rate,json=validatorRewardRate,proto3" json:"validator_reward_rate,omitempty"`
	ValidatorExchangeRate uint64                `protobuf:"varint,5,opt,name=validator_exchange_rate,json=validatorExchangeRate,proto3" json:"validator_exchange_rate,omitempty"`
}

func (m *RateData) Reset()         { *m = RateData{} }
func (m *RateData) String() string { return proto.CompactTextString(m) }
func (*RateData) ProtoMessage()    {}
func (*RateData) Descriptor() ([]byte, []int) {
	return fileDescriptor_b49c30b9d712baf6, []int{4}
}
func (m *RateData) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RateData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RateData.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RateData) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RateData.Merge(m, src)
}
func (m *RateData) XXX_Size() int {
	return m.Size()
}
func (m *RateData) XXX_DiscardUnknown() {
	xxx_messageInfo_RateData.DiscardUnknown(m)
}

var xxx_messageInfo_RateData proto.InternalMessageInfo

func (m *RateData) GetIdentityKey() *v1alpha1.IdentityKey {
	if m != nil {
		return m.IdentityKey
	}
	return nil
}

func (m *RateData) GetEpochIndex() uint64 {
	if m != nil {
		return m.EpochIndex
	}
	return 0
}

func (m *RateData) GetValidatorRewardRate() uint64 {
	if m != nil {
		return m.ValidatorRewardRate
	}
	return 0
}

func (m *RateData) GetValidatorExchangeRate() uint64 {
	if m != nil {
		return m.ValidatorExchangeRate
	}
	return 0
}

// Describes the base reward and exchange rates in some epoch.
type BaseRateData struct {
	EpochIndex       uint64 `protobuf:"varint,1,opt,name=epoch_index,json=epochIndex,proto3" json:"epoch_index,omitempty"`
	BaseRewardRate   uint64 `protobuf:"varint,2,opt,name=base_reward_rate,json=baseRewardRate,proto3" json:"base_reward_rate,omitempty"`
	BaseExchangeRate uint64 `protobuf:"varint,3,opt,name=base_exchange_rate,json=baseExchangeRate,proto3" json:"base_exchange_rate,omitempty"`
}

func (m *BaseRateData) Reset()         { *m = BaseRateData{} }
func (m *BaseRateData) String() string { return proto.CompactTextString(m) }
func (*BaseRateData) ProtoMessage()    {}
func (*BaseRateData) Descriptor() ([]byte, []int) {
	return fileDescriptor_b49c30b9d712baf6, []int{5}
}
func (m *BaseRateData) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BaseRateData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BaseRateData.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *BaseRateData) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BaseRateData.Merge(m, src)
}
func (m *BaseRateData) XXX_Size() int {
	return m.Size()
}
func (m *BaseRateData) XXX_DiscardUnknown() {
	xxx_messageInfo_BaseRateData.DiscardUnknown(m)
}

var xxx_messageInfo_BaseRateData proto.InternalMessageInfo

func (m *BaseRateData) GetEpochIndex() uint64 {
	if m != nil {
		return m.EpochIndex
	}
	return 0
}

func (m *BaseRateData) GetBaseRewardRate() uint64 {
	if m != nil {
		return m.BaseRewardRate
	}
	return 0
}

func (m *BaseRateData) GetBaseExchangeRate() uint64 {
	if m != nil {
		return m.BaseExchangeRate
	}
	return 0
}

// Describes the current state of a validator on-chain
type ValidatorStatus struct {
	IdentityKey  *v1alpha1.IdentityKey `protobuf:"bytes,1,opt,name=identity_key,json=identityKey,proto3" json:"identity_key,omitempty"`
	State        *ValidatorState       `protobuf:"bytes,2,opt,name=state,proto3" json:"state,omitempty"`
	VotingPower  uint64                `protobuf:"varint,3,opt,name=voting_power,json=votingPower,proto3" json:"voting_power,omitempty"`
	BondingState *BondingState         `protobuf:"bytes,4,opt,name=bonding_state,json=bondingState,proto3" json:"bonding_state,omitempty"`
}

func (m *ValidatorStatus) Reset()         { *m = ValidatorStatus{} }
func (m *ValidatorStatus) String() string { return proto.CompactTextString(m) }
func (*ValidatorStatus) ProtoMessage()    {}
func (*ValidatorStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_b49c30b9d712baf6, []int{6}
}
func (m *ValidatorStatus) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ValidatorStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ValidatorStatus.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ValidatorStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ValidatorStatus.Merge(m, src)
}
func (m *ValidatorStatus) XXX_Size() int {
	return m.Size()
}
func (m *ValidatorStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_ValidatorStatus.DiscardUnknown(m)
}

var xxx_messageInfo_ValidatorStatus proto.InternalMessageInfo

func (m *ValidatorStatus) GetIdentityKey() *v1alpha1.IdentityKey {
	if m != nil {
		return m.IdentityKey
	}
	return nil
}

func (m *ValidatorStatus) GetState() *ValidatorState {
	if m != nil {
		return m.State
	}
	return nil
}

func (m *ValidatorStatus) GetVotingPower() uint64 {
	if m != nil {
		return m.VotingPower
	}
	return 0
}

func (m *ValidatorStatus) GetBondingState() *BondingState {
	if m != nil {
		return m.BondingState
	}
	return nil
}

// Describes the unbonding state of a validator's stake pool.
type BondingState struct {
	State          BondingState_BondingStateEnum `protobuf:"varint,1,opt,name=state,proto3,enum=penumbra.core.component.stake.v1alpha1.BondingState_BondingStateEnum" json:"state,omitempty"`
	UnbondingEpoch uint64                        `protobuf:"varint,2,opt,name=unbonding_epoch,json=unbondingEpoch,proto3" json:"unbonding_epoch,omitempty"`
}

func (m *BondingState) Reset()         { *m = BondingState{} }
func (m *BondingState) String() string { return proto.CompactTextString(m) }
func (*BondingState) ProtoMessage()    {}
func (*BondingState) Descriptor() ([]byte, []int) {
	return fileDescriptor_b49c30b9d712baf6, []int{7}
}
func (m *BondingState) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BondingState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BondingState.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *BondingState) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BondingState.Merge(m, src)
}
func (m *BondingState) XXX_Size() int {
	return m.Size()
}
func (m *BondingState) XXX_DiscardUnknown() {
	xxx_messageInfo_BondingState.DiscardUnknown(m)
}

var xxx_messageInfo_BondingState proto.InternalMessageInfo

func (m *BondingState) GetState() BondingState_BondingStateEnum {
	if m != nil {
		return m.State
	}
	return BondingState_BONDING_STATE_ENUM_UNSPECIFIED
}

func (m *BondingState) GetUnbondingEpoch() uint64 {
	if m != nil {
		return m.UnbondingEpoch
	}
	return 0
}

// Describes the state of a validator
type ValidatorState struct {
	State ValidatorState_ValidatorStateEnum `protobuf:"varint,1,opt,name=state,proto3,enum=penumbra.core.component.stake.v1alpha1.ValidatorState_ValidatorStateEnum" json:"state,omitempty"`
}

func (m *ValidatorState) Reset()         { *m = ValidatorState{} }
func (m *ValidatorState) String() string { return proto.CompactTextString(m) }
func (*ValidatorState) ProtoMessage()    {}
func (*ValidatorState) Descriptor() ([]byte, []int) {
	return fileDescriptor_b49c30b9d712baf6, []int{8}
}
func (m *ValidatorState) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ValidatorState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ValidatorState.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ValidatorState) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ValidatorState.Merge(m, src)
}
func (m *ValidatorState) XXX_Size() int {
	return m.Size()
}
func (m *ValidatorState) XXX_DiscardUnknown() {
	xxx_messageInfo_ValidatorState.DiscardUnknown(m)
}

var xxx_messageInfo_ValidatorState proto.InternalMessageInfo

func (m *ValidatorState) GetState() ValidatorState_ValidatorStateEnum {
	if m != nil {
		return m.State
	}
	return ValidatorState_VALIDATOR_STATE_ENUM_UNSPECIFIED
}

// Combines all validator info into a single packet.
type ValidatorInfo struct {
	Validator *Validator       `protobuf:"bytes,1,opt,name=validator,proto3" json:"validator,omitempty"`
	Status    *ValidatorStatus `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
	RateData  *RateData        `protobuf:"bytes,3,opt,name=rate_data,json=rateData,proto3" json:"rate_data,omitempty"`
}

func (m *ValidatorInfo) Reset()         { *m = ValidatorInfo{} }
func (m *ValidatorInfo) String() string { return proto.CompactTextString(m) }
func (*ValidatorInfo) ProtoMessage()    {}
func (*ValidatorInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_b49c30b9d712baf6, []int{9}
}
func (m *ValidatorInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ValidatorInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ValidatorInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ValidatorInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ValidatorInfo.Merge(m, src)
}
func (m *ValidatorInfo) XXX_Size() int {
	return m.Size()
}
func (m *ValidatorInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_ValidatorInfo.DiscardUnknown(m)
}

var xxx_messageInfo_ValidatorInfo proto.InternalMessageInfo

func (m *ValidatorInfo) GetValidator() *Validator {
	if m != nil {
		return m.Validator
	}
	return nil
}

func (m *ValidatorInfo) GetStatus() *ValidatorStatus {
	if m != nil {
		return m.Status
	}
	return nil
}

func (m *ValidatorInfo) GetRateData() *RateData {
	if m != nil {
		return m.RateData
	}
	return nil
}

// A transaction action (re)defining a validator.
type ValidatorDefinition struct {
	// The configuration data for the validator.
	Validator *Validator `protobuf:"bytes,1,opt,name=validator,proto3" json:"validator,omitempty"`
	// A signature by the validator's identity key over the validator data.
	AuthSig []byte `protobuf:"bytes,2,opt,name=auth_sig,json=authSig,proto3" json:"auth_sig,omitempty"`
}

func (m *ValidatorDefinition) Reset()         { *m = ValidatorDefinition{} }
func (m *ValidatorDefinition) String() string { return proto.CompactTextString(m) }
func (*ValidatorDefinition) ProtoMessage()    {}
func (*ValidatorDefinition) Descriptor() ([]byte, []int) {
	return fileDescriptor_b49c30b9d712baf6, []int{10}
}
func (m *ValidatorDefinition) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ValidatorDefinition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ValidatorDefinition.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ValidatorDefinition) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ValidatorDefinition.Merge(m, src)
}
func (m *ValidatorDefinition) XXX_Size() int {
	return m.Size()
}
func (m *ValidatorDefinition) XXX_DiscardUnknown() {
	xxx_messageInfo_ValidatorDefinition.DiscardUnknown(m)
}

var xxx_messageInfo_ValidatorDefinition proto.InternalMessageInfo

func (m *ValidatorDefinition) GetValidator() *Validator {
	if m != nil {
		return m.Validator
	}
	return nil
}

func (m *ValidatorDefinition) GetAuthSig() []byte {
	if m != nil {
		return m.AuthSig
	}
	return nil
}

// A transaction action adding stake to a validator's delegation pool.
type Delegate struct {
	// The identity key of the validator to delegate to.
	ValidatorIdentity *v1alpha1.IdentityKey `protobuf:"bytes,1,opt,name=validator_identity,json=validatorIdentity,proto3" json:"validator_identity,omitempty"`
	// The index of the epoch in which this delegation was performed.
	// The delegation takes effect in the next epoch.
	EpochIndex uint64 `protobuf:"varint,2,opt,name=epoch_index,json=epochIndex,proto3" json:"epoch_index,omitempty"`
	// The delegation amount, in units of unbonded stake.
	// TODO: use flow aggregation to hide this, replacing it with bytes amount_ciphertext;
	UnbondedAmount *v1alpha11.Amount `protobuf:"bytes,3,opt,name=unbonded_amount,json=unbondedAmount,proto3" json:"unbonded_amount,omitempty"`
	// The amount of delegation tokens produced by this action.
	//
	// This is implied by the validator's exchange rate in the specified epoch
	// (and should be checked in transaction validation!), but including it allows
	// stateless verification that the transaction is internally consistent.
	DelegationAmount *v1alpha11.Amount `protobuf:"bytes,4,opt,name=delegation_amount,json=delegationAmount,proto3" json:"delegation_amount,omitempty"`
}

func (m *Delegate) Reset()         { *m = Delegate{} }
func (m *Delegate) String() string { return proto.CompactTextString(m) }
func (*Delegate) ProtoMessage()    {}
func (*Delegate) Descriptor() ([]byte, []int) {
	return fileDescriptor_b49c30b9d712baf6, []int{11}
}
func (m *Delegate) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Delegate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Delegate.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Delegate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Delegate.Merge(m, src)
}
func (m *Delegate) XXX_Size() int {
	return m.Size()
}
func (m *Delegate) XXX_DiscardUnknown() {
	xxx_messageInfo_Delegate.DiscardUnknown(m)
}

var xxx_messageInfo_Delegate proto.InternalMessageInfo

func (m *Delegate) GetValidatorIdentity() *v1alpha1.IdentityKey {
	if m != nil {
		return m.ValidatorIdentity
	}
	return nil
}

func (m *Delegate) GetEpochIndex() uint64 {
	if m != nil {
		return m.EpochIndex
	}
	return 0
}

func (m *Delegate) GetUnbondedAmount() *v1alpha11.Amount {
	if m != nil {
		return m.UnbondedAmount
	}
	return nil
}

func (m *Delegate) GetDelegationAmount() *v1alpha11.Amount {
	if m != nil {
		return m.DelegationAmount
	}
	return nil
}

// A transaction action withdrawing stake from a validator's delegation pool.
type Undelegate struct {
	// The identity key of the validator to undelegate from.
	ValidatorIdentity *v1alpha1.IdentityKey `protobuf:"bytes,1,opt,name=validator_identity,json=validatorIdentity,proto3" json:"validator_identity,omitempty"`
	// The index of the epoch in which this undelegation was performed.
	StartEpochIndex uint64 `protobuf:"varint,2,opt,name=start_epoch_index,json=startEpochIndex,proto3" json:"start_epoch_index,omitempty"`
	// The amount to undelegate, in units of unbonding tokens.
	UnbondedAmount *v1alpha11.Amount `protobuf:"bytes,3,opt,name=unbonded_amount,json=unbondedAmount,proto3" json:"unbonded_amount,omitempty"`
	// The amount of delegation tokens consumed by this action.
	//
	// This is implied by the validator's exchange rate in the specified epoch
	// (and should be checked in transaction validation!), but including it allows
	// stateless verification that the transaction is internally consistent.
	DelegationAmount *v1alpha11.Amount `protobuf:"bytes,4,opt,name=delegation_amount,json=delegationAmount,proto3" json:"delegation_amount,omitempty"`
}

func (m *Undelegate) Reset()         { *m = Undelegate{} }
func (m *Undelegate) String() string { return proto.CompactTextString(m) }
func (*Undelegate) ProtoMessage()    {}
func (*Undelegate) Descriptor() ([]byte, []int) {
	return fileDescriptor_b49c30b9d712baf6, []int{12}
}
func (m *Undelegate) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Undelegate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Undelegate.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Undelegate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Undelegate.Merge(m, src)
}
func (m *Undelegate) XXX_Size() int {
	return m.Size()
}
func (m *Undelegate) XXX_DiscardUnknown() {
	xxx_messageInfo_Undelegate.DiscardUnknown(m)
}

var xxx_messageInfo_Undelegate proto.InternalMessageInfo

func (m *Undelegate) GetValidatorIdentity() *v1alpha1.IdentityKey {
	if m != nil {
		return m.ValidatorIdentity
	}
	return nil
}

func (m *Undelegate) GetStartEpochIndex() uint64 {
	if m != nil {
		return m.StartEpochIndex
	}
	return 0
}

func (m *Undelegate) GetUnbondedAmount() *v1alpha11.Amount {
	if m != nil {
		return m.UnbondedAmount
	}
	return nil
}

func (m *Undelegate) GetDelegationAmount() *v1alpha11.Amount {
	if m != nil {
		return m.DelegationAmount
	}
	return nil
}

// A transaction action finishing an undelegation, converting (slashable)
// "unbonding tokens" to (unslashable) staking tokens.
type UndelegateClaim struct {
	Body  *UndelegateClaimBody `protobuf:"bytes,1,opt,name=body,proto3" json:"body,omitempty"`
	Proof []byte               `protobuf:"bytes,2,opt,name=proof,proto3" json:"proof,omitempty"`
}

func (m *UndelegateClaim) Reset()         { *m = UndelegateClaim{} }
func (m *UndelegateClaim) String() string { return proto.CompactTextString(m) }
func (*UndelegateClaim) ProtoMessage()    {}
func (*UndelegateClaim) Descriptor() ([]byte, []int) {
	return fileDescriptor_b49c30b9d712baf6, []int{13}
}
func (m *UndelegateClaim) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UndelegateClaim) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UndelegateClaim.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *UndelegateClaim) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UndelegateClaim.Merge(m, src)
}
func (m *UndelegateClaim) XXX_Size() int {
	return m.Size()
}
func (m *UndelegateClaim) XXX_DiscardUnknown() {
	xxx_messageInfo_UndelegateClaim.DiscardUnknown(m)
}

var xxx_messageInfo_UndelegateClaim proto.InternalMessageInfo

func (m *UndelegateClaim) GetBody() *UndelegateClaimBody {
	if m != nil {
		return m.Body
	}
	return nil
}

func (m *UndelegateClaim) GetProof() []byte {
	if m != nil {
		return m.Proof
	}
	return nil
}

type UndelegateClaimBody struct {
	// The identity key of the validator to finish undelegating from.
	ValidatorIdentity *v1alpha1.IdentityKey `protobuf:"bytes,1,opt,name=validator_identity,json=validatorIdentity,proto3" json:"validator_identity,omitempty"`
	// The epoch in which unbonding began, used to verify the penalty.
	StartEpochIndex uint64 `protobuf:"varint,2,opt,name=start_epoch_index,json=startEpochIndex,proto3" json:"start_epoch_index,omitempty"`
	// The penalty applied to undelegation, in bps^2 (10e-8).
	// In the happy path (no slashing), this is 0.
	Penalty *Penalty `protobuf:"bytes,3,opt,name=penalty,proto3" json:"penalty,omitempty"`
	// The action's contribution to the transaction's value balance.
	BalanceCommitment *v1alpha12.BalanceCommitment `protobuf:"bytes,4,opt,name=balance_commitment,json=balanceCommitment,proto3" json:"balance_commitment,omitempty"`
}

func (m *UndelegateClaimBody) Reset()         { *m = UndelegateClaimBody{} }
func (m *UndelegateClaimBody) String() string { return proto.CompactTextString(m) }
func (*UndelegateClaimBody) ProtoMessage()    {}
func (*UndelegateClaimBody) Descriptor() ([]byte, []int) {
	return fileDescriptor_b49c30b9d712baf6, []int{14}
}
func (m *UndelegateClaimBody) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UndelegateClaimBody) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UndelegateClaimBody.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *UndelegateClaimBody) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UndelegateClaimBody.Merge(m, src)
}
func (m *UndelegateClaimBody) XXX_Size() int {
	return m.Size()
}
func (m *UndelegateClaimBody) XXX_DiscardUnknown() {
	xxx_messageInfo_UndelegateClaimBody.DiscardUnknown(m)
}

var xxx_messageInfo_UndelegateClaimBody proto.InternalMessageInfo

func (m *UndelegateClaimBody) GetValidatorIdentity() *v1alpha1.IdentityKey {
	if m != nil {
		return m.ValidatorIdentity
	}
	return nil
}

func (m *UndelegateClaimBody) GetStartEpochIndex() uint64 {
	if m != nil {
		return m.StartEpochIndex
	}
	return 0
}

func (m *UndelegateClaimBody) GetPenalty() *Penalty {
	if m != nil {
		return m.Penalty
	}
	return nil
}

func (m *UndelegateClaimBody) GetBalanceCommitment() *v1alpha12.BalanceCommitment {
	if m != nil {
		return m.BalanceCommitment
	}
	return nil
}

type UndelegateClaimPlan struct {
	// The identity key of the validator to finish undelegating from.
	ValidatorIdentity *v1alpha1.IdentityKey `protobuf:"bytes,1,opt,name=validator_identity,json=validatorIdentity,proto3" json:"validator_identity,omitempty"`
	// The epoch in which unbonding began, used to verify the penalty.
	StartEpochIndex uint64 `protobuf:"varint,2,opt,name=start_epoch_index,json=startEpochIndex,proto3" json:"start_epoch_index,omitempty"`
	// The penalty applied to undelegation, in bps^2 (10e-8).
	// In the happy path (no slashing), this is 0.
	Penalty *Penalty `protobuf:"bytes,4,opt,name=penalty,proto3" json:"penalty,omitempty"`
	// The amount of unbonding tokens to claim.
	// This is a bare number because its denom is determined by the preceding data.
	UnbondingAmount *v1alpha11.Amount `protobuf:"bytes,5,opt,name=unbonding_amount,json=unbondingAmount,proto3" json:"unbonding_amount,omitempty"`
	// The blinding factor to use for the balance commitment.
	BalanceBlinding []byte `protobuf:"bytes,6,opt,name=balance_blinding,json=balanceBlinding,proto3" json:"balance_blinding,omitempty"`
	// The first blinding factor to use for the ZK undelegate claim proof.
	ProofBlindingR []byte `protobuf:"bytes,7,opt,name=proof_blinding_r,json=proofBlindingR,proto3" json:"proof_blinding_r,omitempty"`
	// The second blinding factor to use for the ZK undelegate claim proof.
	ProofBlindingS []byte `protobuf:"bytes,8,opt,name=proof_blinding_s,json=proofBlindingS,proto3" json:"proof_blinding_s,omitempty"`
}

func (m *UndelegateClaimPlan) Reset()         { *m = UndelegateClaimPlan{} }
func (m *UndelegateClaimPlan) String() string { return proto.CompactTextString(m) }
func (*UndelegateClaimPlan) ProtoMessage()    {}
func (*UndelegateClaimPlan) Descriptor() ([]byte, []int) {
	return fileDescriptor_b49c30b9d712baf6, []int{15}
}
func (m *UndelegateClaimPlan) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UndelegateClaimPlan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UndelegateClaimPlan.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *UndelegateClaimPlan) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UndelegateClaimPlan.Merge(m, src)
}
func (m *UndelegateClaimPlan) XXX_Size() int {
	return m.Size()
}
func (m *UndelegateClaimPlan) XXX_DiscardUnknown() {
	xxx_messageInfo_UndelegateClaimPlan.DiscardUnknown(m)
}

var xxx_messageInfo_UndelegateClaimPlan proto.InternalMessageInfo

func (m *UndelegateClaimPlan) GetValidatorIdentity() *v1alpha1.IdentityKey {
	if m != nil {
		return m.ValidatorIdentity
	}
	return nil
}

func (m *UndelegateClaimPlan) GetStartEpochIndex() uint64 {
	if m != nil {
		return m.StartEpochIndex
	}
	return 0
}

func (m *UndelegateClaimPlan) GetPenalty() *Penalty {
	if m != nil {
		return m.Penalty
	}
	return nil
}

func (m *UndelegateClaimPlan) GetUnbondingAmount() *v1alpha11.Amount {
	if m != nil {
		return m.UnbondingAmount
	}
	return nil
}

func (m *UndelegateClaimPlan) GetBalanceBlinding() []byte {
	if m != nil {
		return m.BalanceBlinding
	}
	return nil
}

func (m *UndelegateClaimPlan) GetProofBlindingR() []byte {
	if m != nil {
		return m.ProofBlindingR
	}
	return nil
}

func (m *UndelegateClaimPlan) GetProofBlindingS() []byte {
	if m != nil {
		return m.ProofBlindingS
	}
	return nil
}

// A list of pending delegations and undelegations.
type DelegationChanges struct {
	Delegations   []*Delegate   `protobuf:"bytes,1,rep,name=delegations,proto3" json:"delegations,omitempty"`
	Undelegations []*Undelegate `protobuf:"bytes,2,rep,name=undelegations,proto3" json:"undelegations,omitempty"`
}

func (m *DelegationChanges) Reset()         { *m = DelegationChanges{} }
func (m *DelegationChanges) String() string { return proto.CompactTextString(m) }
func (*DelegationChanges) ProtoMessage()    {}
func (*DelegationChanges) Descriptor() ([]byte, []int) {
	return fileDescriptor_b49c30b9d712baf6, []int{16}
}
func (m *DelegationChanges) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DelegationChanges) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DelegationChanges.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DelegationChanges) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DelegationChanges.Merge(m, src)
}
func (m *DelegationChanges) XXX_Size() int {
	return m.Size()
}
func (m *DelegationChanges) XXX_DiscardUnknown() {
	xxx_messageInfo_DelegationChanges.DiscardUnknown(m)
}

var xxx_messageInfo_DelegationChanges proto.InternalMessageInfo

func (m *DelegationChanges) GetDelegations() []*Delegate {
	if m != nil {
		return m.Delegations
	}
	return nil
}

func (m *DelegationChanges) GetUndelegations() []*Undelegate {
	if m != nil {
		return m.Undelegations
	}
	return nil
}

// Track's a validator's uptime.
type Uptime struct {
	AsOfBlockHeight uint64 `protobuf:"varint,1,opt,name=as_of_block_height,json=asOfBlockHeight,proto3" json:"as_of_block_height,omitempty"`
	WindowLen       uint32 `protobuf:"varint,2,opt,name=window_len,json=windowLen,proto3" json:"window_len,omitempty"`
	Bitvec          []byte `protobuf:"bytes,3,opt,name=bitvec,proto3" json:"bitvec,omitempty"`
}

func (m *Uptime) Reset()         { *m = Uptime{} }
func (m *Uptime) String() string { return proto.CompactTextString(m) }
func (*Uptime) ProtoMessage()    {}
func (*Uptime) Descriptor() ([]byte, []int) {
	return fileDescriptor_b49c30b9d712baf6, []int{17}
}
func (m *Uptime) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Uptime) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Uptime.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Uptime) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Uptime.Merge(m, src)
}
func (m *Uptime) XXX_Size() int {
	return m.Size()
}
func (m *Uptime) XXX_DiscardUnknown() {
	xxx_messageInfo_Uptime.DiscardUnknown(m)
}

var xxx_messageInfo_Uptime proto.InternalMessageInfo

func (m *Uptime) GetAsOfBlockHeight() uint64 {
	if m != nil {
		return m.AsOfBlockHeight
	}
	return 0
}

func (m *Uptime) GetWindowLen() uint32 {
	if m != nil {
		return m.WindowLen
	}
	return 0
}

func (m *Uptime) GetBitvec() []byte {
	if m != nil {
		return m.Bitvec
	}
	return nil
}

// Tracks our view of Tendermint's view of the validator set, so we can keep it
// from getting confused.
type CurrentConsensusKeys struct {
	ConsensusKeys []*v1alpha1.ConsensusKey `protobuf:"bytes,1,rep,name=consensus_keys,json=consensusKeys,proto3" json:"consensus_keys,omitempty"`
}

func (m *CurrentConsensusKeys) Reset()         { *m = CurrentConsensusKeys{} }
func (m *CurrentConsensusKeys) String() string { return proto.CompactTextString(m) }
func (*CurrentConsensusKeys) ProtoMessage()    {}
func (*CurrentConsensusKeys) Descriptor() ([]byte, []int) {
	return fileDescriptor_b49c30b9d712baf6, []int{18}
}
func (m *CurrentConsensusKeys) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CurrentConsensusKeys) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CurrentConsensusKeys.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CurrentConsensusKeys) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CurrentConsensusKeys.Merge(m, src)
}
func (m *CurrentConsensusKeys) XXX_Size() int {
	return m.Size()
}
func (m *CurrentConsensusKeys) XXX_DiscardUnknown() {
	xxx_messageInfo_CurrentConsensusKeys.DiscardUnknown(m)
}

var xxx_messageInfo_CurrentConsensusKeys proto.InternalMessageInfo

func (m *CurrentConsensusKeys) GetConsensusKeys() []*v1alpha1.ConsensusKey {
	if m != nil {
		return m.ConsensusKeys
	}
	return nil
}

// Tracks slashing penalties applied to a validator in some epoch.
type Penalty struct {
	Inner []byte `protobuf:"bytes,1,opt,name=inner,proto3" json:"inner,omitempty"`
}

func (m *Penalty) Reset()         { *m = Penalty{} }
func (m *Penalty) String() string { return proto.CompactTextString(m) }
func (*Penalty) ProtoMessage()    {}
func (*Penalty) Descriptor() ([]byte, []int) {
	return fileDescriptor_b49c30b9d712baf6, []int{19}
}
func (m *Penalty) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Penalty) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Penalty.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Penalty) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Penalty.Merge(m, src)
}
func (m *Penalty) XXX_Size() int {
	return m.Size()
}
func (m *Penalty) XXX_DiscardUnknown() {
	xxx_messageInfo_Penalty.DiscardUnknown(m)
}

var xxx_messageInfo_Penalty proto.InternalMessageInfo

func (m *Penalty) GetInner() []byte {
	if m != nil {
		return m.Inner
	}
	return nil
}

// Requests information on the chain's validators.
type ValidatorInfoRequest struct {
	// The expected chain id (empty string if no expectation).
	ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
	// Whether or not to return inactive validators
	ShowInactive bool `protobuf:"varint,2,opt,name=show_inactive,json=showInactive,proto3" json:"show_inactive,omitempty"`
}

func (m *ValidatorInfoRequest) Reset()         { *m = ValidatorInfoRequest{} }
func (m *ValidatorInfoRequest) String() string { return proto.CompactTextString(m) }
func (*ValidatorInfoRequest) ProtoMessage()    {}
func (*ValidatorInfoRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_b49c30b9d712baf6, []int{20}
}
func (m *ValidatorInfoRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ValidatorInfoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ValidatorInfoRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ValidatorInfoRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ValidatorInfoRequest.Merge(m, src)
}
func (m *ValidatorInfoRequest) XXX_Size() int {
	return m.Size()
}
func (m *ValidatorInfoRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ValidatorInfoRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ValidatorInfoRequest proto.InternalMessageInfo

func (m *ValidatorInfoRequest) GetChainId() string {
	if m != nil {
		return m.ChainId
	}
	return ""
}

func (m *ValidatorInfoRequest) GetShowInactive() bool {
	if m != nil {
		return m.ShowInactive
	}
	return false
}

type ValidatorInfoResponse struct {
	ValidatorInfo *ValidatorInfo `protobuf:"bytes,1,opt,name=validator_info,json=validatorInfo,proto3" json:"validator_info,omitempty"`
}

func (m *ValidatorInfoResponse) Reset()         { *m = ValidatorInfoResponse{} }
func (m *ValidatorInfoResponse) String() string { return proto.CompactTextString(m) }
func (*ValidatorInfoResponse) ProtoMessage()    {}
func (*ValidatorInfoResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_b49c30b9d712baf6, []int{21}
}
func (m *ValidatorInfoResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ValidatorInfoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ValidatorInfoResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ValidatorInfoResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ValidatorInfoResponse.Merge(m, src)
}
func (m *ValidatorInfoResponse) XXX_Size() int {
	return m.Size()
}
func (m *ValidatorInfoResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ValidatorInfoResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ValidatorInfoResponse proto.InternalMessageInfo

func (m *ValidatorInfoResponse) GetValidatorInfo() *ValidatorInfo {
	if m != nil {
		return m.ValidatorInfo
	}
	return nil
}

type ValidatorStatusRequest struct {
	// The expected chain id (empty string if no expectation).
	ChainId     string                `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
	IdentityKey *v1alpha1.IdentityKey `protobuf:"bytes,2,opt,name=identity_key,json=identityKey,proto3" json:"identity_key,omitempty"`
}

func (m *ValidatorStatusRequest) Reset()         { *m = ValidatorStatusRequest{} }
func (m *ValidatorStatusRequest) String() string { return proto.CompactTextString(m) }
func (*ValidatorStatusRequest) ProtoMessage()    {}
func (*ValidatorStatusRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_b49c30b9d712baf6, []int{22}
}
func (m *ValidatorStatusRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ValidatorStatusRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ValidatorStatusRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ValidatorStatusRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ValidatorStatusRequest.Merge(m, src)
}
func (m *ValidatorStatusRequest) XXX_Size() int {
	return m.Size()
}
func (m *ValidatorStatusRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ValidatorStatusRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ValidatorStatusRequest proto.InternalMessageInfo

func (m *ValidatorStatusRequest) GetChainId() string {
	if m != nil {
		return m.ChainId
	}
	return ""
}

func (m *ValidatorStatusRequest) GetIdentityKey() *v1alpha1.IdentityKey {
	if m != nil {
		return m.IdentityKey
	}
	return nil
}

type ValidatorStatusResponse struct {
	Status *ValidatorStatus `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
}

func (m *ValidatorStatusResponse) Reset()         { *m = ValidatorStatusResponse{} }
func (m *ValidatorStatusResponse) String() string { return proto.CompactTextString(m) }
func (*ValidatorStatusResponse) ProtoMessage()    {}
func (*ValidatorStatusResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_b49c30b9d712baf6, []int{23}
}
func (m *ValidatorStatusResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ValidatorStatusResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ValidatorStatusResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ValidatorStatusResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ValidatorStatusResponse.Merge(m, src)
}
func (m *ValidatorStatusResponse) XXX_Size() int {
	return m.Size()
}
func (m *ValidatorStatusResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ValidatorStatusResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ValidatorStatusResponse proto.InternalMessageInfo

func (m *ValidatorStatusResponse) GetStatus() *ValidatorStatus {
	if m != nil {
		return m.Status
	}
	return nil
}

// Requests the compounded penalty for a validator over a range of epochs.
type ValidatorPenaltyRequest struct {
	// The expected chain id (empty string if no expectation).
	ChainId         string                `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
	IdentityKey     *v1alpha1.IdentityKey `protobuf:"bytes,2,opt,name=identity_key,json=identityKey,proto3" json:"identity_key,omitempty"`
	StartEpochIndex uint64                `protobuf:"varint,3,opt,name=start_epoch_index,json=startEpochIndex,proto3" json:"start_epoch_index,omitempty"`
	EndEpochIndex   uint64                `protobuf:"varint,4,opt,name=end_epoch_index,json=endEpochIndex,proto3" json:"end_epoch_index,omitempty"`
}

func (m *ValidatorPenaltyRequest) Reset()         { *m = ValidatorPenaltyRequest{} }
func (m *ValidatorPenaltyRequest) String() string { return proto.CompactTextString(m) }
func (*ValidatorPenaltyRequest) ProtoMessage()    {}
func (*ValidatorPenaltyRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_b49c30b9d712baf6, []int{24}
}
func (m *ValidatorPenaltyRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ValidatorPenaltyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ValidatorPenaltyRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ValidatorPenaltyRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ValidatorPenaltyRequest.Merge(m, src)
}
func (m *ValidatorPenaltyRequest) XXX_Size() int {
	return m.Size()
}
func (m *ValidatorPenaltyRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ValidatorPenaltyRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ValidatorPenaltyRequest proto.InternalMessageInfo

func (m *ValidatorPenaltyRequest) GetChainId() string {
	if m != nil {
		return m.ChainId
	}
	return ""
}

func (m *ValidatorPenaltyRequest) GetIdentityKey() *v1alpha1.IdentityKey {
	if m != nil {
		return m.IdentityKey
	}
	return nil
}

func (m *ValidatorPenaltyRequest) GetStartEpochIndex() uint64 {
	if m != nil {
		return m.StartEpochIndex
	}
	return 0
}

func (m *ValidatorPenaltyRequest) GetEndEpochIndex() uint64 {
	if m != nil {
		return m.EndEpochIndex
	}
	return 0
}

type ValidatorPenaltyResponse struct {
	Penalty *Penalty `protobuf:"bytes,1,opt,name=penalty,proto3" json:"penalty,omitempty"`
}

func (m *ValidatorPenaltyResponse) Reset()         { *m = ValidatorPenaltyResponse{} }
func (m *ValidatorPenaltyResponse) String() string { return proto.CompactTextString(m) }
func (*ValidatorPenaltyResponse) ProtoMessage()    {}
func (*ValidatorPenaltyResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_b49c30b9d712baf6, []int{25}
}
func (m *ValidatorPenaltyResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ValidatorPenaltyResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ValidatorPenaltyResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ValidatorPenaltyResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ValidatorPenaltyResponse.Merge(m, src)
}
func (m *ValidatorPenaltyResponse) XXX_Size() int {
	return m.Size()
}
func (m *ValidatorPenaltyResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ValidatorPenaltyResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ValidatorPenaltyResponse proto.InternalMessageInfo

func (m *ValidatorPenaltyResponse) GetPenalty() *Penalty {
	if m != nil {
		return m.Penalty
	}
	return nil
}

type CurrentValidatorRateRequest struct {
	// The expected chain id (empty string if no expectation).
	ChainId     string                `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
	IdentityKey *v1alpha1.IdentityKey `protobuf:"bytes,2,opt,name=identity_key,json=identityKey,proto3" json:"identity_key,omitempty"`
}

func (m *CurrentValidatorRateRequest) Reset()         { *m = CurrentValidatorRateRequest{} }
func (m *CurrentValidatorRateRequest) String() string { return proto.CompactTextString(m) }
func (*CurrentValidatorRateRequest) ProtoMessage()    {}
func (*CurrentValidatorRateRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_b49c30b9d712baf6, []int{26}
}
func (m *CurrentValidatorRateRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CurrentValidatorRateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CurrentValidatorRateRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CurrentValidatorRateRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CurrentValidatorRateRequest.Merge(m, src)
}
func (m *CurrentValidatorRateRequest) XXX_Size() int {
	return m.Size()
}
func (m *CurrentValidatorRateRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_CurrentValidatorRateRequest.DiscardUnknown(m)
}

var xxx_messageInfo_CurrentValidatorRateRequest proto.InternalMessageInfo

func (m *CurrentValidatorRateRequest) GetChainId() string {
	if m != nil {
		return m.ChainId
	}
	return ""
}

func (m *CurrentValidatorRateRequest) GetIdentityKey() *v1alpha1.IdentityKey {
	if m != nil {
		return m.IdentityKey
	}
	return nil
}

type CurrentValidatorRateResponse struct {
	Data *RateData `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
}

func (m *CurrentValidatorRateResponse) Reset()         { *m = CurrentValidatorRateResponse{} }
func (m *CurrentValidatorRateResponse) String() string { return proto.CompactTextString(m) }
func (*CurrentValidatorRateResponse) ProtoMessage()    {}
func (*CurrentValidatorRateResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_b49c30b9d712baf6, []int{27}
}
func (m *CurrentValidatorRateResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CurrentValidatorRateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CurrentValidatorRateResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CurrentValidatorRateResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CurrentValidatorRateResponse.Merge(m, src)
}
func (m *CurrentValidatorRateResponse) XXX_Size() int {
	return m.Size()
}
func (m *CurrentValidatorRateResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CurrentValidatorRateResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CurrentValidatorRateResponse proto.InternalMessageInfo

func (m *CurrentValidatorRateResponse) GetData() *RateData {
	if m != nil {
		return m.Data
	}
	return nil
}

// Staking configuration data.
type StakeParameters struct {
	// The number of epochs an unbonding note for before being released.
	UnbondingEpochs uint64 `protobuf:"varint,1,opt,name=unbonding_epochs,json=unbondingEpochs,proto3" json:"unbonding_epochs,omitempty"`
	// The maximum number of validators in the consensus set.
	ActiveValidatorLimit uint64 `protobuf:"varint,2,opt,name=active_validator_limit,json=activeValidatorLimit,proto3" json:"active_validator_limit,omitempty"`
	// The base reward rate, expressed in basis points of basis points
	BaseRewardRate uint64 `protobuf:"varint,3,opt,name=base_reward_rate,json=baseRewardRate,proto3" json:"base_reward_rate,omitempty"`
	// The penalty for slashing due to misbehavior.
	SlashingPenaltyMisbehavior uint64 `protobuf:"varint,4,opt,name=slashing_penalty_misbehavior,json=slashingPenaltyMisbehavior,proto3" json:"slashing_penalty_misbehavior,omitempty"`
	// The penalty for slashing due to downtime.
	SlashingPenaltyDowntime uint64 `protobuf:"varint,5,opt,name=slashing_penalty_downtime,json=slashingPenaltyDowntime,proto3" json:"slashing_penalty_downtime,omitempty"`
	// The number of blocks in the window to check for downtime.
	SignedBlocksWindowLen uint64 `protobuf:"varint,6,opt,name=signed_blocks_window_len,json=signedBlocksWindowLen,proto3" json:"signed_blocks_window_len,omitempty"`
	// The maximum number of blocks in the window each validator can miss signing without slashing.
	MissedBlocksMaximum uint64 `protobuf:"varint,7,opt,name=missed_blocks_maximum,json=missedBlocksMaximum,proto3" json:"missed_blocks_maximum,omitempty"`
}

func (m *StakeParameters) Reset()         { *m = StakeParameters{} }
func (m *StakeParameters) String() string { return proto.CompactTextString(m) }
func (*StakeParameters) ProtoMessage()    {}
func (*StakeParameters) Descriptor() ([]byte, []int) {
	return fileDescriptor_b49c30b9d712baf6, []int{28}
}
func (m *StakeParameters) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *StakeParameters) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_StakeParameters.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *StakeParameters) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StakeParameters.Merge(m, src)
}
func (m *StakeParameters) XXX_Size() int {
	return m.Size()
}
func (m *StakeParameters) XXX_DiscardUnknown() {
	xxx_messageInfo_StakeParameters.DiscardUnknown(m)
}

var xxx_messageInfo_StakeParameters proto.InternalMessageInfo

func (m *StakeParameters) GetUnbondingEpochs() uint64 {
	if m != nil {
		return m.UnbondingEpochs
	}
	return 0
}

func (m *StakeParameters) GetActiveValidatorLimit() uint64 {
	if m != nil {
		return m.ActiveValidatorLimit
	}
	return 0
}

func (m *StakeParameters) GetBaseRewardRate() uint64 {
	if m != nil {
		return m.BaseRewardRate
	}
	return 0
}

func (m *StakeParameters) GetSlashingPenaltyMisbehavior() uint64 {
	if m != nil {
		return m.SlashingPenaltyMisbehavior
	}
	return 0
}

func (m *StakeParameters) GetSlashingPenaltyDowntime() uint64 {
	if m != nil {
		return m.SlashingPenaltyDowntime
	}
	return 0
}

func (m *StakeParameters) GetSignedBlocksWindowLen() uint64 {
	if m != nil {
		return m.SignedBlocksWindowLen
	}
	return 0
}

func (m *StakeParameters) GetMissedBlocksMaximum() uint64 {
	if m != nil {
		return m.MissedBlocksMaximum
	}
	return 0
}

// Genesis data for the staking component.
type GenesisContent struct {
	// The configuration parameters for the staking component present at genesis
	StakeParams *StakeParameters `protobuf:"bytes,1,opt,name=stake_params,json=stakeParams,proto3" json:"stake_params,omitempty"`
	// The list of validators present at genesis.
	Validators []*Validator `protobuf:"bytes,2,rep,name=validators,proto3" json:"validators,omitempty"`
}

func (m *GenesisContent) Reset()         { *m = GenesisContent{} }
func (m *GenesisContent) String() string { return proto.CompactTextString(m) }
func (*GenesisContent) ProtoMessage()    {}
func (*GenesisContent) Descriptor() ([]byte, []int) {
	return fileDescriptor_b49c30b9d712baf6, []int{29}
}
func (m *GenesisContent) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GenesisContent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GenesisContent.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GenesisContent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GenesisContent.Merge(m, src)
}
func (m *GenesisContent) XXX_Size() int {
	return m.Size()
}
func (m *GenesisContent) XXX_DiscardUnknown() {
	xxx_messageInfo_GenesisContent.DiscardUnknown(m)
}

var xxx_messageInfo_GenesisContent proto.InternalMessageInfo

func (m *GenesisContent) GetStakeParams() *StakeParameters {
	if m != nil {
		return m.StakeParams
	}
	return nil
}

func (m *GenesisContent) GetValidators() []*Validator {
	if m != nil {
		return m.Validators
	}
	return nil
}

func init() {
	proto.RegisterEnum("penumbra.core.component.stake.v1alpha1.BondingState_BondingStateEnum", BondingState_BondingStateEnum_name, BondingState_BondingStateEnum_value)
	proto.RegisterEnum("penumbra.core.component.stake.v1alpha1.ValidatorState_ValidatorStateEnum", ValidatorState_ValidatorStateEnum_name, ValidatorState_ValidatorStateEnum_value)
	proto.RegisterType((*ZKUndelegateClaimProof)(nil), "penumbra.core.component.stake.v1alpha1.ZKUndelegateClaimProof")
	proto.RegisterType((*Validator)(nil), "penumbra.core.component.stake.v1alpha1.Validator")
	proto.RegisterType((*ValidatorList)(nil), "penumbra.core.component.stake.v1alpha1.ValidatorList")
	proto.RegisterType((*FundingStream)(nil), "penumbra.core.component.stake.v1alpha1.FundingStream")
	proto.RegisterType((*FundingStream_ToAddress)(nil), "penumbra.core.component.stake.v1alpha1.FundingStream.ToAddress")
	proto.RegisterType((*FundingStream_ToCommunityPool)(nil), "penumbra.core.component.stake.v1alpha1.FundingStream.ToCommunityPool")
	proto.RegisterType((*RateData)(nil), "penumbra.core.component.stake.v1alpha1.RateData")
	proto.RegisterType((*BaseRateData)(nil), "penumbra.core.component.stake.v1alpha1.BaseRateData")
	proto.RegisterType((*ValidatorStatus)(nil), "penumbra.core.component.stake.v1alpha1.ValidatorStatus")
	proto.RegisterType((*BondingState)(nil), "penumbra.core.component.stake.v1alpha1.BondingState")
	proto.RegisterType((*ValidatorState)(nil), "penumbra.core.component.stake.v1alpha1.ValidatorState")
	proto.RegisterType((*ValidatorInfo)(nil), "penumbra.core.component.stake.v1alpha1.ValidatorInfo")
	proto.RegisterType((*ValidatorDefinition)(nil), "penumbra.core.component.stake.v1alpha1.ValidatorDefinition")
	proto.RegisterType((*Delegate)(nil), "penumbra.core.component.stake.v1alpha1.Delegate")
	proto.RegisterType((*Undelegate)(nil), "penumbra.core.component.stake.v1alpha1.Undelegate")
	proto.RegisterType((*UndelegateClaim)(nil), "penumbra.core.component.stake.v1alpha1.UndelegateClaim")
	proto.RegisterType((*UndelegateClaimBody)(nil), "penumbra.core.component.stake.v1alpha1.UndelegateClaimBody")
	proto.RegisterType((*UndelegateClaimPlan)(nil), "penumbra.core.component.stake.v1alpha1.UndelegateClaimPlan")
	proto.RegisterType((*DelegationChanges)(nil), "penumbra.core.component.stake.v1alpha1.DelegationChanges")
	proto.RegisterType((*Uptime)(nil), "penumbra.core.component.stake.v1alpha1.Uptime")
	proto.RegisterType((*CurrentConsensusKeys)(nil), "penumbra.core.component.stake.v1alpha1.CurrentConsensusKeys")
	proto.RegisterType((*Penalty)(nil), "penumbra.core.component.stake.v1alpha1.Penalty")
	proto.RegisterType((*ValidatorInfoRequest)(nil), "penumbra.core.component.stake.v1alpha1.ValidatorInfoRequest")
	proto.RegisterType((*ValidatorInfoResponse)(nil), "penumbra.core.component.stake.v1alpha1.ValidatorInfoResponse")
	proto.RegisterType((*ValidatorStatusRequest)(nil), "penumbra.core.component.stake.v1alpha1.ValidatorStatusRequest")
	proto.RegisterType((*ValidatorStatusResponse)(nil), "penumbra.core.component.stake.v1alpha1.ValidatorStatusResponse")
	proto.RegisterType((*ValidatorPenaltyRequest)(nil), "penumbra.core.component.stake.v1alpha1.ValidatorPenaltyRequest")
	proto.RegisterType((*ValidatorPenaltyResponse)(nil), "penumbra.core.component.stake.v1alpha1.ValidatorPenaltyResponse")
	proto.RegisterType((*CurrentValidatorRateRequest)(nil), "penumbra.core.component.stake.v1alpha1.CurrentValidatorRateRequest")
	proto.RegisterType((*CurrentValidatorRateResponse)(nil), "penumbra.core.component.stake.v1alpha1.CurrentValidatorRateResponse")
	proto.RegisterType((*StakeParameters)(nil), "penumbra.core.component.stake.v1alpha1.StakeParameters")
	proto.RegisterType((*GenesisContent)(nil), "penumbra.core.component.stake.v1alpha1.GenesisContent")
}

func init() {
	proto.RegisterFile("penumbra/core/component/stake/v1alpha1/stake.proto", fileDescriptor_b49c30b9d712baf6)
}

var fileDescriptor_b49c30b9d712baf6 = []byte{
	// 2141 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x59, 0xcd, 0x6f, 0x1b, 0xc7,
	0x15, 0xd7, 0x52, 0xd4, 0xd7, 0x23, 0x29, 0x52, 0xe3, 0x2f, 0x5a, 0xb1, 0x65, 0x65, 0x1d, 0x38,
	0x8a, 0x1b, 0x50, 0x31, 0x9b, 0x0f, 0x40, 0x69, 0x1b, 0x8b, 0x1f, 0xb1, 0x59, 0x5b, 0x12, 0xbd,
	0x94, 0x9d, 0xd6, 0x15, 0xb2, 0x5e, 0x72, 0x47, 0xe4, 0xd6, 0xdc, 0x19, 0x66, 0x67, 0x28, 0x59,
	0xb7, 0xf4, 0x50, 0xe4, 0x56, 0x14, 0x05, 0x0a, 0xf4, 0xda, 0x1c, 0x73, 0xe9, 0xa1, 0x7f, 0x40,
	0x51, 0x14, 0x05, 0x8a, 0x9e, 0x72, 0x29, 0x50, 0xa0, 0x97, 0xc2, 0x2e, 0x50, 0xa0, 0x97, 0xf6,
	0x4f, 0x28, 0x66, 0x76, 0xf6, 0x83, 0x14, 0xe5, 0x50, 0xb4, 0x1b, 0xa4, 0x17, 0x81, 0xef, 0xcd,
	0xef, 0xbd, 0x7d, 0xf3, 0xe6, 0xbd, 0x37, 0xef, 0x8d, 0xa0, 0xd8, 0xc3, 0xa4, 0xef, 0x36, 0x3d,
	0x6b, 0xbd, 0x45, 0x3d, 0xbc, 0xde, 0xa2, 0x6e, 0x8f, 0x12, 0x4c, 0xf8, 0x3a, 0xe3, 0xd6, 0x63,
	0xbc, 0x7e, 0x70, 0xc3, 0xea, 0xf6, 0x3a, 0xd6, 0x0d, 0x9f, 0x2c, 0xf4, 0x3c, 0xca, 0x29, 0xba,
	0x16, 0xc8, 0x14, 0x84, 0x4c, 0x21, 0x94, 0x29, 0xf8, 0xa0, 0x40, 0x66, 0x79, 0x6d, 0x50, 0xb7,
	0xc5, 0x18, 0xe6, 0x91, 0x46, 0x49, 0xfa, 0x1a, 0x97, 0xaf, 0x0d, 0x22, 0x1f, 0xe3, 0x23, 0x16,
	0x01, 0x05, 0xa5, 0x70, 0xaf, 0x0d, 0xe2, 0x48, 0xdf, 0x8d, 0x60, 0xa4, 0xef, 0xfa, 0x28, 0xbd,
	0x00, 0xe7, 0x1f, 0xde, 0xb9, 0x4f, 0x6c, 0xdc, 0xc5, 0x6d, 0x8b, 0xe3, 0x72, 0xd7, 0x72, 0xdc,
	0xba, 0x47, 0xe9, 0x3e, 0x3a, 0x0b, 0x33, 0x0e, 0x21, 0xd8, 0xcb, 0x6b, 0xab, 0xda, 0x5a, 0xda,
	0xf0, 0x09, 0xfd, 0x0f, 0xd3, 0xb0, 0xf0, 0xc0, 0xea, 0x3a, 0xb6, 0xc5, 0xa9, 0x87, 0xee, 0x40,
	0xda, 0xb1, 0x31, 0xe1, 0x0e, 0x3f, 0x32, 0x1f, 0xe3, 0x23, 0x09, 0x4d, 0x15, 0xd7, 0x0a, 0x83,
	0x9b, 0x96, 0x46, 0x05, 0xdf, 0x2e, 0xd4, 0x94, 0xc0, 0x1d, 0x7c, 0x64, 0xa4, 0x9c, 0x88, 0x40,
	0x57, 0x21, 0xd3, 0xa2, 0x84, 0x61, 0xc2, 0xfa, 0x4c, 0x6a, 0x4b, 0xc8, 0x0f, 0xa7, 0x43, 0xa6,
	0x00, 0x21, 0x48, 0x12, 0xcb, 0xc5, 0xf9, 0xe9, 0x55, 0x6d, 0x6d, 0xc1, 0x90, 0xbf, 0x51, 0x1e,
	0xe6, 0x0e, 0x71, 0x93, 0x39, 0x1c, 0xe7, 0x93, 0x92, 0x1d, 0x90, 0x68, 0x15, 0x52, 0x36, 0x66,
	0x2d, 0xcf, 0xe9, 0x71, 0x87, 0x92, 0xfc, 0x8c, 0x5c, 0x8d, 0xb3, 0x84, 0x2c, 0x26, 0x56, 0xb3,
	0x8b, 0xed, 0xfc, 0xfc, 0xaa, 0xb6, 0x36, 0x6f, 0x04, 0x24, 0xfa, 0x18, 0xb2, 0xfb, 0x7d, 0x62,
	0x3b, 0xa4, 0x6d, 0x32, 0xee, 0x61, 0xcb, 0x65, 0xf9, 0xd9, 0xd5, 0xe9, 0xb5, 0x54, 0xf1, 0x9d,
	0xc2, 0x78, 0x67, 0x5a, 0xf8, 0xd0, 0x17, 0x6f, 0x48, 0x69, 0x63, 0x71, 0x3f, 0x4e, 0x32, 0xf4,
	0x3a, 0x64, 0x19, 0xfe, 0xa4, 0x8f, 0x49, 0x0b, 0x9b, 0x42, 0x1d, 0xf6, 0xf2, 0x73, 0xab, 0xda,
	0x5a, 0xc6, 0x58, 0x0c, 0xd8, 0xdb, 0x92, 0x8b, 0xee, 0xc1, 0x62, 0x9b, 0x1e, 0x60, 0x8f, 0x58,
	0x02, 0x2a, 0x1c, 0xb3, 0x20, 0xdd, 0x7c, 0xfd, 0xb9, 0x6e, 0xbe, 0x15, 0x8a, 0x08, 0x47, 0x67,
	0xda, 0x71, 0x52, 0x7f, 0x04, 0x99, 0xf0, 0x10, 0xef, 0x3a, 0x8c, 0xa3, 0x1d, 0x58, 0x3c, 0x08,
	0x18, 0xe2, 0x13, 0x2c, 0xaf, 0xc9, 0xbd, 0x8e, 0x7f, 0x94, 0x99, 0x50, 0xfe, 0x0e, 0x3e, 0x62,
	0xfa, 0xb3, 0x04, 0x64, 0x06, 0xf6, 0x8f, 0x1e, 0x01, 0x70, 0x6a, 0x5a, 0xb6, 0xed, 0x61, 0xc6,
	0x54, 0xa4, 0x7c, 0x30, 0x91, 0x2b, 0x0b, 0xbb, 0x74, 0xd3, 0x57, 0x73, 0x7b, 0xca, 0x58, 0xe0,
	0x01, 0x81, 0x18, 0x2c, 0x71, 0x6a, 0xb6, 0xa8, 0xeb, 0xf6, 0x89, 0x88, 0xc8, 0x1e, 0xa5, 0x5d,
	0x19, 0x44, 0xa9, 0x62, 0x75, 0xd2, 0x0f, 0x95, 0x03, 0x6d, 0x75, 0x4a, 0xbb, 0xb7, 0xa7, 0x8c,
	0x2c, 0x1f, 0x64, 0x2d, 0xdf, 0x84, 0x85, 0xd0, 0x1c, 0x11, 0x4d, 0xf1, 0x0d, 0x2e, 0x18, 0x01,
	0x89, 0x2e, 0xc2, 0xbc, 0x67, 0x71, 0x6c, 0x36, 0x7b, 0x4c, 0x9a, 0x94, 0x31, 0xe6, 0x04, 0x5d,
	0xea, 0xb1, 0xe5, 0x37, 0x21, 0x3b, 0xf4, 0x9d, 0xe7, 0xa0, 0x4b, 0x29, 0x58, 0xf0, 0x70, 0xcb,
	0xe9, 0x39, 0x98, 0x70, 0xfd, 0x1f, 0x1a, 0xcc, 0x1b, 0x16, 0xc7, 0x15, 0x8b, 0x5b, 0x2f, 0x37,
	0x19, 0xaf, 0x40, 0x0a, 0xf7, 0x68, 0xab, 0x63, 0x3a, 0xc4, 0xc6, 0x4f, 0xa4, 0x11, 0x49, 0x03,
	0x24, 0xab, 0x26, 0x38, 0xa8, 0x08, 0xe7, 0xa2, 0x88, 0xf1, 0xf0, 0xa1, 0xe5, 0xd9, 0xa6, 0xb0,
	0x51, 0xa6, 0x60, 0xd2, 0x38, 0x13, 0x2e, 0x1a, 0x72, 0x4d, 0x58, 0x89, 0xde, 0x85, 0x0b, 0x91,
	0x0c, 0x7e, 0xd2, 0xea, 0x58, 0xa4, 0x8d, 0x7d, 0xa9, 0x19, 0x29, 0x15, 0xa9, 0xac, 0xaa, 0x55,
	0x21, 0xa7, 0x7f, 0xa6, 0x41, 0xba, 0x64, 0x31, 0x1c, 0x6e, 0x75, 0xc8, 0x3a, 0xed, 0x98, 0x75,
	0x6b, 0x90, 0x6b, 0x5a, 0x0c, 0x0f, 0x18, 0xe6, 0xef, 0x61, 0x51, 0xf0, 0x63, 0x36, 0xbd, 0x09,
	0x48, 0x22, 0x07, 0xcd, 0x99, 0x96, 0x58, 0xa9, 0x63, 0xc0, 0x92, 0x2f, 0x12, 0x90, 0x0d, 0x33,
	0xa7, 0xc1, 0x2d, 0xde, 0x67, 0x2f, 0xd7, 0xef, 0x77, 0x61, 0x86, 0xf1, 0xc0, 0xda, 0x54, 0xf1,
	0xdd, 0x71, 0xe3, 0x76, 0xc0, 0x28, 0x6c, 0xf8, 0x4a, 0xd0, 0xab, 0x90, 0x3e, 0xa0, 0x5c, 0x94,
	0xb0, 0x1e, 0x3d, 0xc4, 0x9e, 0xda, 0x56, 0xca, 0xe7, 0xd5, 0x05, 0x0b, 0xfd, 0x10, 0x32, 0x4d,
	0x1a, 0x94, 0xb9, 0xe0, 0xfc, 0x52, 0xc5, 0xb7, 0xc7, 0xfd, 0x70, 0x89, 0xaa, 0x84, 0x11, 0x9f,
	0x4d, 0x37, 0x63, 0x94, 0xfe, 0x9b, 0x04, 0xa4, 0xe3, 0xcb, 0xe8, 0x47, 0xc1, 0xe6, 0x84, 0x8b,
	0x16, 0xc7, 0x4f, 0xca, 0xb8, 0x92, 0x01, 0xa2, 0x4a, 0xfa, 0x6e, 0xb0, 0xd7, 0xd7, 0x21, 0xdb,
	0x27, 0xc1, 0x56, 0x64, 0x28, 0x04, 0x27, 0x1e, 0xb2, 0xab, 0x82, 0xab, 0xff, 0x4a, 0x83, 0xdc,
	0xb0, 0x12, 0xa4, 0xc3, 0x4a, 0x69, 0x67, 0xbb, 0x52, 0xdb, 0xbe, 0x65, 0x36, 0x76, 0x37, 0x77,
	0xab, 0x66, 0x75, 0xfb, 0xfe, 0x96, 0x79, 0x7f, 0xbb, 0x51, 0xaf, 0x96, 0x6b, 0x1f, 0xd6, 0xaa,
	0x95, 0xdc, 0x14, 0xba, 0x0c, 0x17, 0x47, 0x60, 0x04, 0xab, 0x5a, 0xc9, 0x69, 0x68, 0x15, 0x2e,
	0x8d, 0x54, 0xa1, 0x98, 0xb9, 0x04, 0xba, 0x02, 0xaf, 0x9c, 0x88, 0xa8, 0x56, 0x72, 0xd3, 0xfa,
	0xdf, 0x12, 0xb0, 0x38, 0x78, 0x92, 0xc8, 0x1c, 0xf4, 0x59, 0x6d, 0xb2, 0x80, 0x18, 0x22, 0x63,
	0x7e, 0xd3, 0xff, 0xa9, 0x01, 0x3a, 0xbe, 0x8a, 0x5e, 0x83, 0xd5, 0x07, 0x9b, 0x77, 0x6b, 0x95,
	0xcd, 0xdd, 0x1d, 0xe3, 0x64, 0x97, 0xbc, 0x0a, 0x97, 0x47, 0xa2, 0x6a, 0xdb, 0x9b, 0xe5, 0xdd,
	0xda, 0x83, 0x6a, 0x4e, 0x13, 0x9b, 0x1e, 0x09, 0x51, 0x80, 0xc4, 0x89, 0x80, 0xef, 0x6f, 0xd6,
	0xee, 0x0a, 0xaf, 0xa0, 0xab, 0x70, 0x65, 0x24, 0x60, 0x77, 0x67, 0xab, 0xd4, 0xd8, 0xdd, 0xd9,
	0xae, 0x56, 0x72, 0xc9, 0x13, 0x2d, 0xa9, 0xd4, 0x1a, 0x9b, 0x25, 0xa1, 0x67, 0x46, 0xff, 0x34,
	0x11, 0xbb, 0xf6, 0x6a, 0x64, 0x9f, 0xa2, 0x1d, 0x58, 0x08, 0x2b, 0x8e, 0xca, 0xdb, 0x1b, 0xa7,
	0x76, 0xb0, 0x11, 0xe9, 0x40, 0x3b, 0x30, 0xcb, 0x64, 0x55, 0x50, 0xf9, 0xfb, 0xde, 0x44, 0xc7,
	0xd5, 0x67, 0x86, 0x52, 0x83, 0xb6, 0x60, 0x41, 0xde, 0x04, 0xb6, 0xc5, 0x2d, 0x99, 0xbe, 0xa9,
	0xe2, 0x5b, 0xe3, 0xea, 0x0c, 0xca, 0xa5, 0x21, 0x2f, 0x13, 0xf1, 0x4b, 0xff, 0x89, 0x06, 0x67,
	0xc2, 0x4f, 0x55, 0xf0, 0xbe, 0x43, 0x1c, 0xd9, 0x06, 0xbd, 0x74, 0x47, 0x5c, 0x84, 0x79, 0xab,
	0xcf, 0x3b, 0x26, 0x73, 0xda, 0xaa, 0x8f, 0x9b, 0x13, 0x74, 0xc3, 0x69, 0xeb, 0x9f, 0x27, 0x60,
	0xbe, 0xa2, 0xfa, 0x4d, 0xf4, 0x11, 0xa0, 0xe8, 0x4a, 0x08, 0x0a, 0xe1, 0xa9, 0x4b, 0xe8, 0x52,
	0xa8, 0x23, 0xe0, 0x7e, 0xf5, 0x05, 0x76, 0x27, 0xa8, 0x17, 0xd8, 0x36, 0x2d, 0x97, 0xf6, 0x09,
	0x57, 0xfe, 0xd5, 0x87, 0x3e, 0x2b, 0x9a, 0xe5, 0xf0, 0xab, 0x9b, 0x12, 0x19, 0xd4, 0x14, 0x6c,
	0xfb, 0x34, 0xda, 0x81, 0x25, 0xd5, 0x42, 0x3b, 0x94, 0x04, 0xea, 0x92, 0x63, 0xab, 0xcb, 0x45,
	0xc2, 0x3e, 0x47, 0xd4, 0x4e, 0x88, 0xda, 0xf2, 0xff, 0x9d, 0x9b, 0xae, 0xc3, 0x12, 0xe3, 0x96,
	0xc7, 0xcd, 0xe3, 0xce, 0xca, 0xca, 0x85, 0xea, 0xff, 0x8b, 0xc7, 0x9e, 0x40, 0x76, 0x68, 0x8e,
	0x41, 0x3b, 0x90, 0x6c, 0x52, 0x3b, 0xf0, 0xd3, 0xfb, 0xe3, 0x06, 0xf4, 0x90, 0x9a, 0x12, 0xb5,
	0x8f, 0x0c, 0xa9, 0x48, 0xcc, 0x44, 0x3d, 0x31, 0x1c, 0xa9, 0x90, 0xf6, 0x09, 0xfd, 0x8f, 0x09,
	0x38, 0x33, 0x42, 0xe6, 0x9b, 0x71, 0x68, 0x35, 0x98, 0xeb, 0x61, 0x62, 0x75, 0xf9, 0x91, 0x3a,
	0xac, 0xf5, 0x71, 0xdd, 0x50, 0xf7, 0xc5, 0x8c, 0x40, 0x1e, 0x7d, 0x2c, 0x5a, 0xa5, 0xae, 0x9c,
	0x42, 0x44, 0x93, 0xed, 0x70, 0x17, 0x87, 0x67, 0x36, 0xac, 0xd5, 0x9f, 0x58, 0xa3, 0x1b, 0xdc,
	0x97, 0x2b, 0x87, 0x62, 0xc6, 0x52, 0x73, 0x98, 0xa5, 0xff, 0x76, 0xfa, 0x98, 0x1f, 0xeb, 0x5d,
	0x8b, 0x7c, 0xe3, 0xfc, 0x98, 0x7c, 0x41, 0x3f, 0x6e, 0x41, 0x2e, 0xea, 0x54, 0x54, 0xe4, 0xcf,
	0x8c, 0x1d, 0xf9, 0x51, 0x97, 0xa3, 0x32, 0xe9, 0x0d, 0xd1, 0xeb, 0xfa, 0xc7, 0xd2, 0xec, 0x3a,
	0x72, 0x25, 0x3f, 0x2b, 0xe3, 0x33, 0xab, 0xf8, 0x25, 0xc5, 0x16, 0x6d, 0xb1, 0x0c, 0xd9, 0x10,
	0x68, 0xfa, 0x43, 0x67, 0xda, 0x58, 0x94, 0xfc, 0x00, 0x68, 0x8c, 0x40, 0x32, 0x39, 0x20, 0x0f,
	0x23, 0x1b, 0xfa, 0xef, 0x35, 0x58, 0xaa, 0x84, 0xc9, 0x58, 0x96, 0xbd, 0x32, 0x43, 0x86, 0x98,
	0xbc, 0x03, 0x66, 0x30, 0x4d, 0x8e, 0x7d, 0x73, 0x05, 0xd7, 0x83, 0x11, 0x57, 0x82, 0x7e, 0x00,
	0x99, 0x3e, 0x89, 0x6b, 0x4d, 0x48, 0xad, 0xc5, 0xd3, 0xe7, 0xb5, 0x31, 0xa8, 0x48, 0xef, 0xc2,
	0xec, 0xfd, 0x1e, 0x77, 0x5c, 0x8c, 0xbe, 0x05, 0xc8, 0x62, 0xa6, 0xdc, 0x37, 0x6d, 0x3d, 0x36,
	0x3b, 0xd8, 0x69, 0x77, 0xb8, 0x1a, 0x30, 0xb2, 0x16, 0xdb, 0xd9, 0x2f, 0x09, 0xfe, 0x6d, 0xc9,
	0x46, 0x97, 0x01, 0x0e, 0x1d, 0x62, 0xd3, 0x43, 0xb3, 0x8b, 0x89, 0x1a, 0xd4, 0x16, 0x7c, 0xce,
	0x5d, 0x4c, 0xd0, 0x79, 0x98, 0x6d, 0x3a, 0xfc, 0x00, 0xb7, 0x64, 0xe6, 0xa5, 0x0d, 0x45, 0xe9,
	0x1d, 0x38, 0x5b, 0xee, 0x7b, 0x1e, 0x26, 0xbc, 0x1c, 0x7b, 0xda, 0x60, 0xa8, 0x0e, 0x8b, 0x03,
	0x0f, 0x20, 0x81, 0xdb, 0xde, 0x78, 0x6e, 0x8c, 0xc7, 0x75, 0x18, 0x99, 0xf8, 0x63, 0x09, 0xd3,
	0xaf, 0xc0, 0x9c, 0x8a, 0xbe, 0x13, 0x9e, 0x73, 0x1e, 0xc0, 0xd9, 0x81, 0x8e, 0xc8, 0xc0, 0x9f,
	0xf4, 0x31, 0xe3, 0xe2, 0xfa, 0x6e, 0x75, 0x2c, 0x87, 0x98, 0x8e, 0x1d, 0x4c, 0xb2, 0x92, 0xae,
	0xd9, 0xe8, 0x2a, 0x64, 0x58, 0x87, 0x1e, 0x9a, 0x0e, 0xb1, 0x5a, 0xdc, 0x39, 0xf0, 0x27, 0x95,
	0x79, 0x23, 0x2d, 0x98, 0x35, 0xc5, 0xd3, 0xfb, 0x70, 0x6e, 0x48, 0x2f, 0xeb, 0x09, 0xcb, 0xd0,
	0x5e, 0xfc, 0xa1, 0xc1, 0x21, 0xfb, 0x54, 0xe5, 0xf1, 0x3b, 0xa7, 0xee, 0x36, 0xa4, 0xda, 0xe8,
	0xd5, 0x41, 0x90, 0xfa, 0xa7, 0x1a, 0x9c, 0x1f, 0xee, 0xa4, 0xbe, 0x7a, 0x47, 0xc3, 0x03, 0x5c,
	0xe2, 0x05, 0x06, 0x38, 0xfd, 0xc7, 0x70, 0xe1, 0x98, 0x05, 0x6a, 0xef, 0x51, 0x73, 0xa8, 0xbd,
	0x94, 0xe6, 0x50, 0xff, 0x8b, 0x16, 0xfb, 0x58, 0x50, 0x66, 0xbe, 0xde, 0xfd, 0x8e, 0xae, 0xa1,
	0xd3, 0xa3, 0x6b, 0xe8, 0x35, 0xc8, 0x62, 0x62, 0x0f, 0x20, 0xfd, 0xd7, 0x82, 0x0c, 0x26, 0x76,
	0x84, 0xd3, 0x31, 0xe4, 0x8f, 0x6f, 0x4b, 0x39, 0x31, 0x56, 0x87, 0xb5, 0x17, 0xab, 0xc3, 0xfa,
	0x4f, 0x35, 0x78, 0x45, 0x25, 0x62, 0xd4, 0xc3, 0x8a, 0xea, 0xf0, 0x35, 0x87, 0x8c, 0x0d, 0x97,
	0x46, 0x9b, 0xa1, 0xb6, 0x5c, 0x81, 0xa4, 0x6c, 0xff, 0xb5, 0x09, 0xdb, 0x7f, 0x29, 0xad, 0x7f,
	0x36, 0x0d, 0xd9, 0x86, 0x40, 0xd4, 0x2d, 0xcf, 0x72, 0x31, 0xc7, 0x1e, 0x13, 0x57, 0xc7, 0xd0,
	0xcc, 0xcc, 0x82, 0x5a, 0x37, 0x38, 0x34, 0x33, 0xf4, 0x36, 0x9c, 0xf7, 0x73, 0xdb, 0x8c, 0xf2,
	0xb7, 0xeb, 0xb8, 0x0e, 0x57, 0x17, 0xe6, 0x59, 0x7f, 0x35, 0xf6, 0xac, 0xe8, 0x3a, 0x7c, 0xe4,
	0x3b, 0xcc, 0xf4, 0xc8, 0x77, 0x98, 0x9b, 0x70, 0x89, 0x75, 0x2d, 0xd6, 0x91, 0x8f, 0x15, 0xfe,
	0x01, 0x99, 0xae, 0xc3, 0x9a, 0xb8, 0x63, 0x1d, 0x38, 0xd4, 0x53, 0x81, 0xb2, 0x1c, 0x60, 0xd4,
	0x61, 0x6e, 0x45, 0x08, 0xb4, 0x01, 0x17, 0x8f, 0x69, 0xb0, 0xe9, 0x21, 0x11, 0x75, 0x5d, 0xbd,
	0x2f, 0x5d, 0x18, 0x12, 0xaf, 0xa8, 0x65, 0xf4, 0x1e, 0xe4, 0x99, 0xd3, 0x26, 0xd8, 0xf6, 0xeb,
	0x3e, 0x33, 0x63, 0x75, 0x7d, 0xd6, 0x7f, 0x9a, 0xf2, 0xd7, 0x65, 0xf9, 0x67, 0x1f, 0x85, 0x35,
	0xbe, 0x08, 0xe7, 0x5c, 0x87, 0xb1, 0x48, 0xd0, 0xb5, 0x9e, 0x38, 0x6e, 0xdf, 0x95, 0xd7, 0x6a,
	0xd2, 0x38, 0xe3, 0x2f, 0xfa, 0x52, 0x5b, 0xfe, 0x92, 0xfe, 0x3b, 0x0d, 0x16, 0x6f, 0x61, 0x82,
	0x99, 0xc3, 0xca, 0x94, 0x70, 0x4c, 0x38, 0x7a, 0x08, 0x69, 0x79, 0x7a, 0x66, 0x4f, 0x1c, 0xce,
	0xa9, 0x0b, 0xc4, 0xd0, 0xb9, 0x1a, 0x29, 0x16, 0x32, 0x18, 0xba, 0x07, 0x10, 0x1e, 0x59, 0x70,
	0x67, 0x4e, 0x30, 0xdc, 0xc5, 0x94, 0x14, 0xff, 0x93, 0x84, 0xf4, 0xbd, 0x3e, 0xf6, 0x8e, 0x1a,
	0xd8, 0x3b, 0x70, 0x5a, 0x18, 0xfd, 0x4c, 0x1b, 0x1e, 0xad, 0xbf, 0x33, 0x59, 0x41, 0xf7, 0x53,
	0x6f, 0xf9, 0xbb, 0x13, 0x4a, 0xfb, 0x19, 0xf3, 0x96, 0x86, 0x7e, 0xa1, 0x1d, 0x7f, 0xa8, 0xfb,
	0xde, 0xa4, 0xf5, 0x56, 0x19, 0xf5, 0xc1, 0xc4, 0xf2, 0x2a, 0x91, 0x7f, 0xa9, 0x41, 0x6e, 0xb8,
	0xb0, 0xa1, 0xd3, 0x6b, 0x1d, 0xac, 0xf4, 0xcb, 0x37, 0x27, 0x57, 0xa0, 0xec, 0xfa, 0xb5, 0x16,
	0x76, 0x24, 0x03, 0x15, 0x08, 0x95, 0xc7, 0x55, 0xfd, 0x9c, 0x32, 0xba, 0x5c, 0x79, 0x31, 0x25,
	0xbe, 0x8d, 0xa5, 0x7f, 0x27, 0xfe, 0xf4, 0x74, 0x45, 0xfb, 0xf2, 0xe9, 0x8a, 0xf6, 0xf7, 0xa7,
	0x2b, 0xda, 0xcf, 0x9f, 0xad, 0x4c, 0x7d, 0xf9, 0x6c, 0x65, 0xea, 0xaf, 0xcf, 0x56, 0xa6, 0xe0,
	0x7a, 0x8b, 0xba, 0x63, 0x7e, 0xa3, 0x04, 0x7e, 0xaa, 0x78, 0x94, 0xd3, 0xba, 0xf6, 0xf0, 0x51,
	0xdb, 0xe1, 0x9d, 0x7e, 0x53, 0xc0, 0xd7, 0x5b, 0x94, 0xb9, 0x94, 0xad, 0x7b, 0xb8, 0x6b, 0x1d,
	0x61, 0x6f, 0xfd, 0xa0, 0x18, 0xfe, 0x94, 0x45, 0x9f, 0xad, 0x8f, 0xf7, 0xdf, 0xbf, 0xf7, 0x25,
	0x19, 0x50, 0x9f, 0x27, 0x92, 0xf5, 0x72, 0xb9, 0xf1, 0x45, 0xe2, 0x5a, 0x3d, 0xb0, 0xaf, 0x2c,
	0xec, 0x2b, 0x87, 0xf6, 0x49, 0x7b, 0x0a, 0x0f, 0x14, 0xfe, 0xcf, 0x11, 0x70, 0x4f, 0x00, 0xf7,
	0x42, 0xe0, 0x9e, 0x04, 0xee, 0x05, 0xc0, 0xa7, 0x89, 0xe2, 0x78, 0xc0, 0xbd, 0x5b, 0xf5, 0xd2,
	0x16, 0xe6, 0x96, 0xb8, 0x03, 0xfe, 0x95, 0xb8, 0x1e, 0x08, 0x6d, 0x6c, 0x08, 0x29, 0xf1, 0x57,
	0x89, 0x6d, 0x6c, 0x48, 0xb9, 0x8d, 0x8d, 0x40, 0xb0, 0x39, 0x2b, 0xff, 0x43, 0xf8, 0xed, 0xff,
	0x06, 0x00, 0x00, 0xff, 0xff, 0x89, 0x5e, 0xeb, 0x27, 0xf7, 0x1c, 0x00, 0x00,
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// QueryServiceClient is the client API for QueryService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type QueryServiceClient interface {
	// Queries the current validator set, with filtering.
	ValidatorInfo(ctx context.Context, in *ValidatorInfoRequest, opts ...grpc.CallOption) (QueryService_ValidatorInfoClient, error)
	ValidatorStatus(ctx context.Context, in *ValidatorStatusRequest, opts ...grpc.CallOption) (*ValidatorStatusResponse, error)
	ValidatorPenalty(ctx context.Context, in *ValidatorPenaltyRequest, opts ...grpc.CallOption) (*ValidatorPenaltyResponse, error)
	CurrentValidatorRate(ctx context.Context, in *CurrentValidatorRateRequest, opts ...grpc.CallOption) (*CurrentValidatorRateResponse, error)
}

type queryServiceClient struct {
	cc grpc1.ClientConn
}

func NewQueryServiceClient(cc grpc1.ClientConn) QueryServiceClient {
	return &queryServiceClient{cc}
}

func (c *queryServiceClient) ValidatorInfo(ctx context.Context, in *ValidatorInfoRequest, opts ...grpc.CallOption) (QueryService_ValidatorInfoClient, error) {
	stream, err := c.cc.NewStream(ctx, &_QueryService_serviceDesc.Streams[0], "/penumbra.core.component.stake.v1alpha1.QueryService/ValidatorInfo", opts...)
	if err != nil {
		return nil, err
	}
	x := &queryServiceValidatorInfoClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type QueryService_ValidatorInfoClient interface {
	Recv() (*ValidatorInfoResponse, error)
	grpc.ClientStream
}

type queryServiceValidatorInfoClient struct {
	grpc.ClientStream
}

func (x *queryServiceValidatorInfoClient) Recv() (*ValidatorInfoResponse, error) {
	m := new(ValidatorInfoResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *queryServiceClient) ValidatorStatus(ctx context.Context, in *ValidatorStatusRequest, opts ...grpc.CallOption) (*ValidatorStatusResponse, error) {
	out := new(ValidatorStatusResponse)
	err := c.cc.Invoke(ctx, "/penumbra.core.component.stake.v1alpha1.QueryService/ValidatorStatus", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryServiceClient) ValidatorPenalty(ctx context.Context, in *ValidatorPenaltyRequest, opts ...grpc.CallOption) (*ValidatorPenaltyResponse, error) {
	out := new(ValidatorPenaltyResponse)
	err := c.cc.Invoke(ctx, "/penumbra.core.component.stake.v1alpha1.QueryService/ValidatorPenalty", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryServiceClient) CurrentValidatorRate(ctx context.Context, in *CurrentValidatorRateRequest, opts ...grpc.CallOption) (*CurrentValidatorRateResponse, error) {
	out := new(CurrentValidatorRateResponse)
	err := c.cc.Invoke(ctx, "/penumbra.core.component.stake.v1alpha1.QueryService/CurrentValidatorRate", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// QueryServiceServer is the server API for QueryService service.
type QueryServiceServer interface {
	// Queries the current validator set, with filtering.
	ValidatorInfo(*ValidatorInfoRequest, QueryService_ValidatorInfoServer) error
	ValidatorStatus(context.Context, *ValidatorStatusRequest) (*ValidatorStatusResponse, error)
	ValidatorPenalty(context.Context, *ValidatorPenaltyRequest) (*ValidatorPenaltyResponse, error)
	CurrentValidatorRate(context.Context, *CurrentValidatorRateRequest) (*CurrentValidatorRateResponse, error)
}

// UnimplementedQueryServiceServer can be embedded to have forward compatible implementations.
type UnimplementedQueryServiceServer struct {
}

func (*UnimplementedQueryServiceServer) ValidatorInfo(req *ValidatorInfoRequest, srv QueryService_ValidatorInfoServer) error {
	return status.Errorf(codes.Unimplemented, "method ValidatorInfo not implemented")
}
func (*UnimplementedQueryServiceServer) ValidatorStatus(ctx context.Context, req *ValidatorStatusRequest) (*ValidatorStatusResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ValidatorStatus not implemented")
}
func (*UnimplementedQueryServiceServer) ValidatorPenalty(ctx context.Context, req *ValidatorPenaltyRequest) (*ValidatorPenaltyResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ValidatorPenalty not implemented")
}
func (*UnimplementedQueryServiceServer) CurrentValidatorRate(ctx context.Context, req *CurrentValidatorRateRequest) (*CurrentValidatorRateResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CurrentValidatorRate not implemented")
}

func RegisterQueryServiceServer(s grpc1.Server, srv QueryServiceServer) {
	s.RegisterService(&_QueryService_serviceDesc, srv)
}

func _QueryService_ValidatorInfo_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ValidatorInfoRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(QueryServiceServer).ValidatorInfo(m, &queryServiceValidatorInfoServer{stream})
}

type QueryService_ValidatorInfoServer interface {
	Send(*ValidatorInfoResponse) error
	grpc.ServerStream
}

type queryServiceValidatorInfoServer struct {
	grpc.ServerStream
}

func (x *queryServiceValidatorInfoServer) Send(m *ValidatorInfoResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _QueryService_ValidatorStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ValidatorStatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServiceServer).ValidatorStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/penumbra.core.component.stake.v1alpha1.QueryService/ValidatorStatus",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServiceServer).ValidatorStatus(ctx, req.(*ValidatorStatusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _QueryService_ValidatorPenalty_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ValidatorPenaltyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServiceServer).ValidatorPenalty(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/penumbra.core.component.stake.v1alpha1.QueryService/ValidatorPenalty",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServiceServer).ValidatorPenalty(ctx, req.(*ValidatorPenaltyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _QueryService_CurrentValidatorRate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CurrentValidatorRateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServiceServer).CurrentValidatorRate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/penumbra.core.component.stake.v1alpha1.QueryService/CurrentValidatorRate",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServiceServer).CurrentValidatorRate(ctx, req.(*CurrentValidatorRateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _QueryService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "penumbra.core.component.stake.v1alpha1.QueryService",
	HandlerType: (*QueryServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ValidatorStatus",
			Handler:    _QueryService_ValidatorStatus_Handler,
		},
		{
			MethodName: "ValidatorPenalty",
			Handler:    _QueryService_ValidatorPenalty_Handler,
		},
		{
			MethodName: "CurrentValidatorRate",
			Handler:    _QueryService_CurrentValidatorRate_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "ValidatorInfo",
			Handler:       _QueryService_ValidatorInfo_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "penumbra/core/component/stake/v1alpha1/stake.proto",
}

func (m *ZKUndelegateClaimProof) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ZKUndelegateClaimProof) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ZKUndelegateClaimProof) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Inner) > 0 {
		i -= len(m.Inner)
		copy(dAtA[i:], m.Inner)
		i = encodeVarintStake(dAtA, i, uint64(len(m.Inner)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Validator) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Validator) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Validator) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.GovernanceKey != nil {
		{
			size, err := m.GovernanceKey.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStake(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	if m.Enabled {
		i--
		if m.Enabled {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x40
	}
	if m.SequenceNumber != 0 {
		i = encodeVarintStake(dAtA, i, uint64(m.SequenceNumber))
		i--
		dAtA[i] = 0x38
	}
	if len(m.FundingStreams) > 0 {
		for iNdEx := len(m.FundingStreams) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.FundingStreams[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintStake(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x32
		}
	}
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintStake(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Website) > 0 {
		i -= len(m.Website)
		copy(dAtA[i:], m.Website)
		i = encodeVarintStake(dAtA, i, uint64(len(m.Website)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintStake(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.ConsensusKey) > 0 {
		i -= len(m.ConsensusKey)
		copy(dAtA[i:], m.ConsensusKey)
		i = encodeVarintStake(dAtA, i, uint64(len(m.ConsensusKey)))
		i--
		dAtA[i] = 0x12
	}
	if m.IdentityKey != nil {
		{
			size, err := m.IdentityKey.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStake(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ValidatorList) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ValidatorList) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ValidatorList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ValidatorKeys) > 0 {
		for iNdEx := len(m.ValidatorKeys) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ValidatorKeys[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintStake(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *FundingStream) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *FundingStream) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FundingStream) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Recipient != nil {
		{
			size := m.Recipient.Size()
			i -= size
			if _, err := m.Recipient.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

func (m *FundingStream_ToAddress_) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FundingStream_ToAddress_) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ToAddress != nil {
		{
			size, err := m.ToAddress.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStake(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *FundingStream_ToCommunityPool_) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FundingStream_ToCommunityPool_) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ToCommunityPool != nil {
		{
			size, err := m.ToCommunityPool.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStake(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *FundingStream_ToAddress) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *FundingStream_ToAddress) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FundingStream_ToAddress) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.RateBps != 0 {
		i = encodeVarintStake(dAtA, i, uint64(m.RateBps))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Address) > 0 {
		i -= len(m.Address)
		copy(dAtA[i:], m.Address)
		i = encodeVarintStake(dAtA, i, uint64(len(m.Address)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *FundingStream_ToCommunityPool) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *FundingStream_ToCommunityPool) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FundingStream_ToCommunityPool) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.RateBps != 0 {
		i = encodeVarintStake(dAtA, i, uint64(m.RateBps))
		i--
		dAtA[i] = 0x10
	}
	return len(dAtA) - i, nil
}

func (m *RateData) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RateData) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RateData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ValidatorExchangeRate != 0 {
		i = encodeVarintStake(dAtA, i, uint64(m.ValidatorExchangeRate))
		i--
		dAtA[i] = 0x28
	}
	if m.ValidatorRewardRate != 0 {
		i = encodeVarintStake(dAtA, i, uint64(m.ValidatorRewardRate))
		i--
		dAtA[i] = 0x20
	}
	if m.EpochIndex != 0 {
		i = encodeVarintStake(dAtA, i, uint64(m.EpochIndex))
		i--
		dAtA[i] = 0x10
	}
	if m.IdentityKey != nil {
		{
			size, err := m.IdentityKey.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStake(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *BaseRateData) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *BaseRateData) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BaseRateData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.BaseExchangeRate != 0 {
		i = encodeVarintStake(dAtA, i, uint64(m.BaseExchangeRate))
		i--
		dAtA[i] = 0x18
	}
	if m.BaseRewardRate != 0 {
		i = encodeVarintStake(dAtA, i, uint64(m.BaseRewardRate))
		i--
		dAtA[i] = 0x10
	}
	if m.EpochIndex != 0 {
		i = encodeVarintStake(dAtA, i, uint64(m.EpochIndex))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ValidatorStatus) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ValidatorStatus) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ValidatorStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.BondingState != nil {
		{
			size, err := m.BondingState.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStake(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.VotingPower != 0 {
		i = encodeVarintStake(dAtA, i, uint64(m.VotingPower))
		i--
		dAtA[i] = 0x18
	}
	if m.State != nil {
		{
			size, err := m.State.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStake(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.IdentityKey != nil {
		{
			size, err := m.IdentityKey.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStake(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *BondingState) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *BondingState) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BondingState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.UnbondingEpoch != 0 {
		i = encodeVarintStake(dAtA, i, uint64(m.UnbondingEpoch))
		i--
		dAtA[i] = 0x10
	}
	if m.State != 0 {
		i = encodeVarintStake(dAtA, i, uint64(m.State))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ValidatorState) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ValidatorState) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ValidatorState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.State != 0 {
		i = encodeVarintStake(dAtA, i, uint64(m.State))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *ValidatorInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ValidatorInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ValidatorInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.RateData != nil {
		{
			size, err := m.RateData.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStake(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Status != nil {
		{
			size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStake(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Validator != nil {
		{
			size, err := m.Validator.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStake(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ValidatorDefinition) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ValidatorDefinition) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ValidatorDefinition) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.AuthSig) > 0 {
		i -= len(m.AuthSig)
		copy(dAtA[i:], m.AuthSig)
		i = encodeVarintStake(dAtA, i, uint64(len(m.AuthSig)))
		i--
		dAtA[i] = 0x12
	}
	if m.Validator != nil {
		{
			size, err := m.Validator.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStake(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Delegate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Delegate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Delegate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.DelegationAmount != nil {
		{
			size, err := m.DelegationAmount.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStake(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.UnbondedAmount != nil {
		{
			size, err := m.UnbondedAmount.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStake(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.EpochIndex != 0 {
		i = encodeVarintStake(dAtA, i, uint64(m.EpochIndex))
		i--
		dAtA[i] = 0x10
	}
	if m.ValidatorIdentity != nil {
		{
			size, err := m.ValidatorIdentity.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStake(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Undelegate) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Undelegate) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Undelegate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.DelegationAmount != nil {
		{
			size, err := m.DelegationAmount.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStake(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.UnbondedAmount != nil {
		{
			size, err := m.UnbondedAmount.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStake(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.StartEpochIndex != 0 {
		i = encodeVarintStake(dAtA, i, uint64(m.StartEpochIndex))
		i--
		dAtA[i] = 0x10
	}
	if m.ValidatorIdentity != nil {
		{
			size, err := m.ValidatorIdentity.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStake(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *UndelegateClaim) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *UndelegateClaim) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *UndelegateClaim) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Proof) > 0 {
		i -= len(m.Proof)
		copy(dAtA[i:], m.Proof)
		i = encodeVarintStake(dAtA, i, uint64(len(m.Proof)))
		i--
		dAtA[i] = 0x12
	}
	if m.Body != nil {
		{
			size, err := m.Body.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStake(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *UndelegateClaimBody) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *UndelegateClaimBody) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *UndelegateClaimBody) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.BalanceCommitment != nil {
		{
			size, err := m.BalanceCommitment.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStake(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.Penalty != nil {
		{
			size, err := m.Penalty.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStake(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.StartEpochIndex != 0 {
		i = encodeVarintStake(dAtA, i, uint64(m.StartEpochIndex))
		i--
		dAtA[i] = 0x10
	}
	if m.ValidatorIdentity != nil {
		{
			size, err := m.ValidatorIdentity.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStake(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *UndelegateClaimPlan) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *UndelegateClaimPlan) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *UndelegateClaimPlan) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ProofBlindingS) > 0 {
		i -= len(m.ProofBlindingS)
		copy(dAtA[i:], m.ProofBlindingS)
		i = encodeVarintStake(dAtA, i, uint64(len(m.ProofBlindingS)))
		i--
		dAtA[i] = 0x42
	}
	if len(m.ProofBlindingR) > 0 {
		i -= len(m.ProofBlindingR)
		copy(dAtA[i:], m.ProofBlindingR)
		i = encodeVarintStake(dAtA, i, uint64(len(m.ProofBlindingR)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.BalanceBlinding) > 0 {
		i -= len(m.BalanceBlinding)
		copy(dAtA[i:], m.BalanceBlinding)
		i = encodeVarintStake(dAtA, i, uint64(len(m.BalanceBlinding)))
		i--
		dAtA[i] = 0x32
	}
	if m.UnbondingAmount != nil {
		{
			size, err := m.UnbondingAmount.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStake(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.Penalty != nil {
		{
			size, err := m.Penalty.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStake(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.StartEpochIndex != 0 {
		i = encodeVarintStake(dAtA, i, uint64(m.StartEpochIndex))
		i--
		dAtA[i] = 0x10
	}
	if m.ValidatorIdentity != nil {
		{
			size, err := m.ValidatorIdentity.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStake(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *DelegationChanges) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DelegationChanges) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DelegationChanges) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Undelegations) > 0 {
		for iNdEx := len(m.Undelegations) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Undelegations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintStake(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Delegations) > 0 {
		for iNdEx := len(m.Delegations) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Delegations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintStake(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *Uptime) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Uptime) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Uptime) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Bitvec) > 0 {
		i -= len(m.Bitvec)
		copy(dAtA[i:], m.Bitvec)
		i = encodeVarintStake(dAtA, i, uint64(len(m.Bitvec)))
		i--
		dAtA[i] = 0x1a
	}
	if m.WindowLen != 0 {
		i = encodeVarintStake(dAtA, i, uint64(m.WindowLen))
		i--
		dAtA[i] = 0x10
	}
	if m.AsOfBlockHeight != 0 {
		i = encodeVarintStake(dAtA, i, uint64(m.AsOfBlockHeight))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *CurrentConsensusKeys) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CurrentConsensusKeys) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CurrentConsensusKeys) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ConsensusKeys) > 0 {
		for iNdEx := len(m.ConsensusKeys) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ConsensusKeys[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintStake(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *Penalty) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Penalty) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Penalty) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Inner) > 0 {
		i -= len(m.Inner)
		copy(dAtA[i:], m.Inner)
		i = encodeVarintStake(dAtA, i, uint64(len(m.Inner)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ValidatorInfoRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ValidatorInfoRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ValidatorInfoRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ShowInactive {
		i--
		if m.ShowInactive {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if len(m.ChainId) > 0 {
		i -= len(m.ChainId)
		copy(dAtA[i:], m.ChainId)
		i = encodeVarintStake(dAtA, i, uint64(len(m.ChainId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ValidatorInfoResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ValidatorInfoResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ValidatorInfoResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ValidatorInfo != nil {
		{
			size, err := m.ValidatorInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStake(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ValidatorStatusRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ValidatorStatusRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ValidatorStatusRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IdentityKey != nil {
		{
			size, err := m.IdentityKey.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStake(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.ChainId) > 0 {
		i -= len(m.ChainId)
		copy(dAtA[i:], m.ChainId)
		i = encodeVarintStake(dAtA, i, uint64(len(m.ChainId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ValidatorStatusResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ValidatorStatusResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ValidatorStatusResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Status != nil {
		{
			size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStake(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ValidatorPenaltyRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ValidatorPenaltyRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ValidatorPenaltyRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.EndEpochIndex != 0 {
		i = encodeVarintStake(dAtA, i, uint64(m.EndEpochIndex))
		i--
		dAtA[i] = 0x20
	}
	if m.StartEpochIndex != 0 {
		i = encodeVarintStake(dAtA, i, uint64(m.StartEpochIndex))
		i--
		dAtA[i] = 0x18
	}
	if m.IdentityKey != nil {
		{
			size, err := m.IdentityKey.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStake(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.ChainId) > 0 {
		i -= len(m.ChainId)
		copy(dAtA[i:], m.ChainId)
		i = encodeVarintStake(dAtA, i, uint64(len(m.ChainId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ValidatorPenaltyResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ValidatorPenaltyResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ValidatorPenaltyResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Penalty != nil {
		{
			size, err := m.Penalty.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStake(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *CurrentValidatorRateRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CurrentValidatorRateRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CurrentValidatorRateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IdentityKey != nil {
		{
			size, err := m.IdentityKey.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStake(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.ChainId) > 0 {
		i -= len(m.ChainId)
		copy(dAtA[i:], m.ChainId)
		i = encodeVarintStake(dAtA, i, uint64(len(m.ChainId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *CurrentValidatorRateResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CurrentValidatorRateResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CurrentValidatorRateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Data != nil {
		{
			size, err := m.Data.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStake(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *StakeParameters) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *StakeParameters) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *StakeParameters) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.MissedBlocksMaximum != 0 {
		i = encodeVarintStake(dAtA, i, uint64(m.MissedBlocksMaximum))
		i--
		dAtA[i] = 0x38
	}
	if m.SignedBlocksWindowLen != 0 {
		i = encodeVarintStake(dAtA, i, uint64(m.SignedBlocksWindowLen))
		i--
		dAtA[i] = 0x30
	}
	if m.SlashingPenaltyDowntime != 0 {
		i = encodeVarintStake(dAtA, i, uint64(m.SlashingPenaltyDowntime))
		i--
		dAtA[i] = 0x28
	}
	if m.SlashingPenaltyMisbehavior != 0 {
		i = encodeVarintStake(dAtA, i, uint64(m.SlashingPenaltyMisbehavior))
		i--
		dAtA[i] = 0x20
	}
	if m.BaseRewardRate != 0 {
		i = encodeVarintStake(dAtA, i, uint64(m.BaseRewardRate))
		i--
		dAtA[i] = 0x18
	}
	if m.ActiveValidatorLimit != 0 {
		i = encodeVarintStake(dAtA, i, uint64(m.ActiveValidatorLimit))
		i--
		dAtA[i] = 0x10
	}
	if m.UnbondingEpochs != 0 {
		i = encodeVarintStake(dAtA, i, uint64(m.UnbondingEpochs))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *GenesisContent) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GenesisContent) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GenesisContent) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Validators) > 0 {
		for iNdEx := len(m.Validators) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Validators[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintStake(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.StakeParams != nil {
		{
			size, err := m.StakeParams.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintStake(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintStake(dAtA []byte, offset int, v uint64) int {
	offset -= sovStake(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *ZKUndelegateClaimProof) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Inner)
	if l > 0 {
		n += 1 + l + sovStake(uint64(l))
	}
	return n
}

func (m *Validator) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.IdentityKey != nil {
		l = m.IdentityKey.Size()
		n += 1 + l + sovStake(uint64(l))
	}
	l = len(m.ConsensusKey)
	if l > 0 {
		n += 1 + l + sovStake(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovStake(uint64(l))
	}
	l = len(m.Website)
	if l > 0 {
		n += 1 + l + sovStake(uint64(l))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovStake(uint64(l))
	}
	if len(m.FundingStreams) > 0 {
		for _, e := range m.FundingStreams {
			l = e.Size()
			n += 1 + l + sovStake(uint64(l))
		}
	}
	if m.SequenceNumber != 0 {
		n += 1 + sovStake(uint64(m.SequenceNumber))
	}
	if m.Enabled {
		n += 2
	}
	if m.GovernanceKey != nil {
		l = m.GovernanceKey.Size()
		n += 1 + l + sovStake(uint64(l))
	}
	return n
}

func (m *ValidatorList) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.ValidatorKeys) > 0 {
		for _, e := range m.ValidatorKeys {
			l = e.Size()
			n += 1 + l + sovStake(uint64(l))
		}
	}
	return n
}

func (m *FundingStream) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Recipient != nil {
		n += m.Recipient.Size()
	}
	return n
}

func (m *FundingStream_ToAddress_) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ToAddress != nil {
		l = m.ToAddress.Size()
		n += 1 + l + sovStake(uint64(l))
	}
	return n
}
func (m *FundingStream_ToCommunityPool_) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ToCommunityPool != nil {
		l = m.ToCommunityPool.Size()
		n += 1 + l + sovStake(uint64(l))
	}
	return n
}
func (m *FundingStream_ToAddress) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovStake(uint64(l))
	}
	if m.RateBps != 0 {
		n += 1 + sovStake(uint64(m.RateBps))
	}
	return n
}

func (m *FundingStream_ToCommunityPool) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RateBps != 0 {
		n += 1 + sovStake(uint64(m.RateBps))
	}
	return n
}

func (m *RateData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.IdentityKey != nil {
		l = m.IdentityKey.Size()
		n += 1 + l + sovStake(uint64(l))
	}
	if m.EpochIndex != 0 {
		n += 1 + sovStake(uint64(m.EpochIndex))
	}
	if m.ValidatorRewardRate != 0 {
		n += 1 + sovStake(uint64(m.ValidatorRewardRate))
	}
	if m.ValidatorExchangeRate != 0 {
		n += 1 + sovStake(uint64(m.ValidatorExchangeRate))
	}
	return n
}

func (m *BaseRateData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.EpochIndex != 0 {
		n += 1 + sovStake(uint64(m.EpochIndex))
	}
	if m.BaseRewardRate != 0 {
		n += 1 + sovStake(uint64(m.BaseRewardRate))
	}
	if m.BaseExchangeRate != 0 {
		n += 1 + sovStake(uint64(m.BaseExchangeRate))
	}
	return n
}

func (m *ValidatorStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.IdentityKey != nil {
		l = m.IdentityKey.Size()
		n += 1 + l + sovStake(uint64(l))
	}
	if m.State != nil {
		l = m.State.Size()
		n += 1 + l + sovStake(uint64(l))
	}
	if m.VotingPower != 0 {
		n += 1 + sovStake(uint64(m.VotingPower))
	}
	if m.BondingState != nil {
		l = m.BondingState.Size()
		n += 1 + l + sovStake(uint64(l))
	}
	return n
}

func (m *BondingState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.State != 0 {
		n += 1 + sovStake(uint64(m.State))
	}
	if m.UnbondingEpoch != 0 {
		n += 1 + sovStake(uint64(m.UnbondingEpoch))
	}
	return n
}

func (m *ValidatorState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.State != 0 {
		n += 1 + sovStake(uint64(m.State))
	}
	return n
}

func (m *ValidatorInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Validator != nil {
		l = m.Validator.Size()
		n += 1 + l + sovStake(uint64(l))
	}
	if m.Status != nil {
		l = m.Status.Size()
		n += 1 + l + sovStake(uint64(l))
	}
	if m.RateData != nil {
		l = m.RateData.Size()
		n += 1 + l + sovStake(uint64(l))
	}
	return n
}

func (m *ValidatorDefinition) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Validator != nil {
		l = m.Validator.Size()
		n += 1 + l + sovStake(uint64(l))
	}
	l = len(m.AuthSig)
	if l > 0 {
		n += 1 + l + sovStake(uint64(l))
	}
	return n
}

func (m *Delegate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ValidatorIdentity != nil {
		l = m.ValidatorIdentity.Size()
		n += 1 + l + sovStake(uint64(l))
	}
	if m.EpochIndex != 0 {
		n += 1 + sovStake(uint64(m.EpochIndex))
	}
	if m.UnbondedAmount != nil {
		l = m.UnbondedAmount.Size()
		n += 1 + l + sovStake(uint64(l))
	}
	if m.DelegationAmount != nil {
		l = m.DelegationAmount.Size()
		n += 1 + l + sovStake(uint64(l))
	}
	return n
}

func (m *Undelegate) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ValidatorIdentity != nil {
		l = m.ValidatorIdentity.Size()
		n += 1 + l + sovStake(uint64(l))
	}
	if m.StartEpochIndex != 0 {
		n += 1 + sovStake(uint64(m.StartEpochIndex))
	}
	if m.UnbondedAmount != nil {
		l = m.UnbondedAmount.Size()
		n += 1 + l + sovStake(uint64(l))
	}
	if m.DelegationAmount != nil {
		l = m.DelegationAmount.Size()
		n += 1 + l + sovStake(uint64(l))
	}
	return n
}

func (m *UndelegateClaim) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Body != nil {
		l = m.Body.Size()
		n += 1 + l + sovStake(uint64(l))
	}
	l = len(m.Proof)
	if l > 0 {
		n += 1 + l + sovStake(uint64(l))
	}
	return n
}

func (m *UndelegateClaimBody) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ValidatorIdentity != nil {
		l = m.ValidatorIdentity.Size()
		n += 1 + l + sovStake(uint64(l))
	}
	if m.StartEpochIndex != 0 {
		n += 1 + sovStake(uint64(m.StartEpochIndex))
	}
	if m.Penalty != nil {
		l = m.Penalty.Size()
		n += 1 + l + sovStake(uint64(l))
	}
	if m.BalanceCommitment != nil {
		l = m.BalanceCommitment.Size()
		n += 1 + l + sovStake(uint64(l))
	}
	return n
}

func (m *UndelegateClaimPlan) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ValidatorIdentity != nil {
		l = m.ValidatorIdentity.Size()
		n += 1 + l + sovStake(uint64(l))
	}
	if m.StartEpochIndex != 0 {
		n += 1 + sovStake(uint64(m.StartEpochIndex))
	}
	if m.Penalty != nil {
		l = m.Penalty.Size()
		n += 1 + l + sovStake(uint64(l))
	}
	if m.UnbondingAmount != nil {
		l = m.UnbondingAmount.Size()
		n += 1 + l + sovStake(uint64(l))
	}
	l = len(m.BalanceBlinding)
	if l > 0 {
		n += 1 + l + sovStake(uint64(l))
	}
	l = len(m.ProofBlindingR)
	if l > 0 {
		n += 1 + l + sovStake(uint64(l))
	}
	l = len(m.ProofBlindingS)
	if l > 0 {
		n += 1 + l + sovStake(uint64(l))
	}
	return n
}

func (m *DelegationChanges) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Delegations) > 0 {
		for _, e := range m.Delegations {
			l = e.Size()
			n += 1 + l + sovStake(uint64(l))
		}
	}
	if len(m.Undelegations) > 0 {
		for _, e := range m.Undelegations {
			l = e.Size()
			n += 1 + l + sovStake(uint64(l))
		}
	}
	return n
}

func (m *Uptime) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.AsOfBlockHeight != 0 {
		n += 1 + sovStake(uint64(m.AsOfBlockHeight))
	}
	if m.WindowLen != 0 {
		n += 1 + sovStake(uint64(m.WindowLen))
	}
	l = len(m.Bitvec)
	if l > 0 {
		n += 1 + l + sovStake(uint64(l))
	}
	return n
}

func (m *CurrentConsensusKeys) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.ConsensusKeys) > 0 {
		for _, e := range m.ConsensusKeys {
			l = e.Size()
			n += 1 + l + sovStake(uint64(l))
		}
	}
	return n
}

func (m *Penalty) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Inner)
	if l > 0 {
		n += 1 + l + sovStake(uint64(l))
	}
	return n
}

func (m *ValidatorInfoRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ChainId)
	if l > 0 {
		n += 1 + l + sovStake(uint64(l))
	}
	if m.ShowInactive {
		n += 2
	}
	return n
}

func (m *ValidatorInfoResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ValidatorInfo != nil {
		l = m.ValidatorInfo.Size()
		n += 1 + l + sovStake(uint64(l))
	}
	return n
}

func (m *ValidatorStatusRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ChainId)
	if l > 0 {
		n += 1 + l + sovStake(uint64(l))
	}
	if m.IdentityKey != nil {
		l = m.IdentityKey.Size()
		n += 1 + l + sovStake(uint64(l))
	}
	return n
}

func (m *ValidatorStatusResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Status != nil {
		l = m.Status.Size()
		n += 1 + l + sovStake(uint64(l))
	}
	return n
}

func (m *ValidatorPenaltyRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ChainId)
	if l > 0 {
		n += 1 + l + sovStake(uint64(l))
	}
	if m.IdentityKey != nil {
		l = m.IdentityKey.Size()
		n += 1 + l + sovStake(uint64(l))
	}
	if m.StartEpochIndex != 0 {
		n += 1 + sovStake(uint64(m.StartEpochIndex))
	}
	if m.EndEpochIndex != 0 {
		n += 1 + sovStake(uint64(m.EndEpochIndex))
	}
	return n
}

func (m *ValidatorPenaltyResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Penalty != nil {
		l = m.Penalty.Size()
		n += 1 + l + sovStake(uint64(l))
	}
	return n
}

func (m *CurrentValidatorRateRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ChainId)
	if l > 0 {
		n += 1 + l + sovStake(uint64(l))
	}
	if m.IdentityKey != nil {
		l = m.IdentityKey.Size()
		n += 1 + l + sovStake(uint64(l))
	}
	return n
}

func (m *CurrentValidatorRateResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Data != nil {
		l = m.Data.Size()
		n += 1 + l + sovStake(uint64(l))
	}
	return n
}

func (m *StakeParameters) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.UnbondingEpochs != 0 {
		n += 1 + sovStake(uint64(m.UnbondingEpochs))
	}
	if m.ActiveValidatorLimit != 0 {
		n += 1 + sovStake(uint64(m.ActiveValidatorLimit))
	}
	if m.BaseRewardRate != 0 {
		n += 1 + sovStake(uint64(m.BaseRewardRate))
	}
	if m.SlashingPenaltyMisbehavior != 0 {
		n += 1 + sovStake(uint64(m.SlashingPenaltyMisbehavior))
	}
	if m.SlashingPenaltyDowntime != 0 {
		n += 1 + sovStake(uint64(m.SlashingPenaltyDowntime))
	}
	if m.SignedBlocksWindowLen != 0 {
		n += 1 + sovStake(uint64(m.SignedBlocksWindowLen))
	}
	if m.MissedBlocksMaximum != 0 {
		n += 1 + sovStake(uint64(m.MissedBlocksMaximum))
	}
	return n
}

func (m *GenesisContent) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.StakeParams != nil {
		l = m.StakeParams.Size()
		n += 1 + l + sovStake(uint64(l))
	}
	if len(m.Validators) > 0 {
		for _, e := range m.Validators {
			l = e.Size()
			n += 1 + l + sovStake(uint64(l))
		}
	}
	return n
}

func sovStake(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozStake(x uint64) (n int) {
	return sovStake(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *ZKUndelegateClaimProof) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStake
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ZKUndelegateClaimProof: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ZKUndelegateClaimProof: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...)
			if m.Inner == nil {
				m.Inner = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStake(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStake
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Validator) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStake
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Validator: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Validator: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IdentityKey", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.IdentityKey == nil {
				m.IdentityKey = &v1alpha1.IdentityKey{}
			}
			if err := m.IdentityKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConsensusKey", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ConsensusKey = append(m.ConsensusKey[:0], dAtA[iNdEx:postIndex]...)
			if m.ConsensusKey == nil {
				m.ConsensusKey = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Website", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Website = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FundingStreams", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FundingStreams = append(m.FundingStreams, &FundingStream{})
			if err := m.FundingStreams[len(m.FundingStreams)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SequenceNumber", wireType)
			}
			m.SequenceNumber = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SequenceNumber |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Enabled", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Enabled = bool(v != 0)
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GovernanceKey", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.GovernanceKey == nil {
				m.GovernanceKey = &v1alpha1.GovernanceKey{}
			}
			if err := m.GovernanceKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStake(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStake
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ValidatorList) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStake
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ValidatorList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ValidatorList: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorKeys", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ValidatorKeys = append(m.ValidatorKeys, &v1alpha1.IdentityKey{})
			if err := m.ValidatorKeys[len(m.ValidatorKeys)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStake(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStake
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FundingStream) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStake
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: FundingStream: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FundingStream: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ToAddress", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &FundingStream_ToAddress{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Recipient = &FundingStream_ToAddress_{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ToCommunityPool", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &FundingStream_ToCommunityPool{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Recipient = &FundingStream_ToCommunityPool_{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStake(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStake
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FundingStream_ToAddress) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStake
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ToAddress: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ToAddress: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RateBps", wireType)
			}
			m.RateBps = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RateBps |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipStake(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStake
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FundingStream_ToCommunityPool) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStake
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ToCommunityPool: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ToCommunityPool: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RateBps", wireType)
			}
			m.RateBps = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RateBps |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipStake(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStake
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RateData) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStake
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RateData: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RateData: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IdentityKey", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.IdentityKey == nil {
				m.IdentityKey = &v1alpha1.IdentityKey{}
			}
			if err := m.IdentityKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
			}
			m.EpochIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EpochIndex |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorRewardRate", wireType)
			}
			m.ValidatorRewardRate = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ValidatorRewardRate |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorExchangeRate", wireType)
			}
			m.ValidatorExchangeRate = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ValidatorExchangeRate |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipStake(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStake
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BaseRateData) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStake
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: BaseRateData: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BaseRateData: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
			}
			m.EpochIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EpochIndex |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BaseRewardRate", wireType)
			}
			m.BaseRewardRate = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BaseRewardRate |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BaseExchangeRate", wireType)
			}
			m.BaseExchangeRate = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BaseExchangeRate |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipStake(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStake
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ValidatorStatus) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStake
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ValidatorStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ValidatorStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IdentityKey", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.IdentityKey == nil {
				m.IdentityKey = &v1alpha1.IdentityKey{}
			}
			if err := m.IdentityKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.State == nil {
				m.State = &ValidatorState{}
			}
			if err := m.State.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field VotingPower", wireType)
			}
			m.VotingPower = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.VotingPower |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BondingState", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.BondingState == nil {
				m.BondingState = &BondingState{}
			}
			if err := m.BondingState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStake(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStake
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BondingState) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStake
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: BondingState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BondingState: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			m.State = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.State |= BondingState_BondingStateEnum(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UnbondingEpoch", wireType)
			}
			m.UnbondingEpoch = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UnbondingEpoch |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipStake(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStake
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ValidatorState) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStake
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ValidatorState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ValidatorState: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			m.State = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.State |= ValidatorState_ValidatorStateEnum(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipStake(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStake
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ValidatorInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStake
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ValidatorInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ValidatorInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Validator", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Validator == nil {
				m.Validator = &Validator{}
			}
			if err := m.Validator.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Status == nil {
				m.Status = &ValidatorStatus{}
			}
			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RateData", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RateData == nil {
				m.RateData = &RateData{}
			}
			if err := m.RateData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStake(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStake
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ValidatorDefinition) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStake
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ValidatorDefinition: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ValidatorDefinition: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Validator", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Validator == nil {
				m.Validator = &Validator{}
			}
			if err := m.Validator.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AuthSig", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AuthSig = append(m.AuthSig[:0], dAtA[iNdEx:postIndex]...)
			if m.AuthSig == nil {
				m.AuthSig = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStake(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStake
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Delegate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStake
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Delegate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Delegate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorIdentity", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ValidatorIdentity == nil {
				m.ValidatorIdentity = &v1alpha1.IdentityKey{}
			}
			if err := m.ValidatorIdentity.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EpochIndex", wireType)
			}
			m.EpochIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EpochIndex |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UnbondedAmount", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.UnbondedAmount == nil {
				m.UnbondedAmount = &v1alpha11.Amount{}
			}
			if err := m.UnbondedAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DelegationAmount", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DelegationAmount == nil {
				m.DelegationAmount = &v1alpha11.Amount{}
			}
			if err := m.DelegationAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStake(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStake
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Undelegate) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStake
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Undelegate: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Undelegate: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorIdentity", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ValidatorIdentity == nil {
				m.ValidatorIdentity = &v1alpha1.IdentityKey{}
			}
			if err := m.ValidatorIdentity.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartEpochIndex", wireType)
			}
			m.StartEpochIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StartEpochIndex |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UnbondedAmount", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.UnbondedAmount == nil {
				m.UnbondedAmount = &v1alpha11.Amount{}
			}
			if err := m.UnbondedAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DelegationAmount", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DelegationAmount == nil {
				m.DelegationAmount = &v1alpha11.Amount{}
			}
			if err := m.DelegationAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStake(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStake
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UndelegateClaim) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStake
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: UndelegateClaim: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UndelegateClaim: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Body == nil {
				m.Body = &UndelegateClaimBody{}
			}
			if err := m.Body.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Proof = append(m.Proof[:0], dAtA[iNdEx:postIndex]...)
			if m.Proof == nil {
				m.Proof = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStake(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStake
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UndelegateClaimBody) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStake
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: UndelegateClaimBody: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UndelegateClaimBody: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorIdentity", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ValidatorIdentity == nil {
				m.ValidatorIdentity = &v1alpha1.IdentityKey{}
			}
			if err := m.ValidatorIdentity.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartEpochIndex", wireType)
			}
			m.StartEpochIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StartEpochIndex |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Penalty", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Penalty == nil {
				m.Penalty = &Penalty{}
			}
			if err := m.Penalty.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BalanceCommitment", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.BalanceCommitment == nil {
				m.BalanceCommitment = &v1alpha12.BalanceCommitment{}
			}
			if err := m.BalanceCommitment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStake(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStake
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UndelegateClaimPlan) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStake
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: UndelegateClaimPlan: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UndelegateClaimPlan: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorIdentity", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ValidatorIdentity == nil {
				m.ValidatorIdentity = &v1alpha1.IdentityKey{}
			}
			if err := m.ValidatorIdentity.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartEpochIndex", wireType)
			}
			m.StartEpochIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StartEpochIndex |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Penalty", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Penalty == nil {
				m.Penalty = &Penalty{}
			}
			if err := m.Penalty.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UnbondingAmount", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.UnbondingAmount == nil {
				m.UnbondingAmount = &v1alpha11.Amount{}
			}
			if err := m.UnbondingAmount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BalanceBlinding", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BalanceBlinding = append(m.BalanceBlinding[:0], dAtA[iNdEx:postIndex]...)
			if m.BalanceBlinding == nil {
				m.BalanceBlinding = []byte{}
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProofBlindingR", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ProofBlindingR = append(m.ProofBlindingR[:0], dAtA[iNdEx:postIndex]...)
			if m.ProofBlindingR == nil {
				m.ProofBlindingR = []byte{}
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProofBlindingS", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ProofBlindingS = append(m.ProofBlindingS[:0], dAtA[iNdEx:postIndex]...)
			if m.ProofBlindingS == nil {
				m.ProofBlindingS = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStake(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStake
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DelegationChanges) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStake
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DelegationChanges: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DelegationChanges: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Delegations", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Delegations = append(m.Delegations, &Delegate{})
			if err := m.Delegations[len(m.Delegations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Undelegations", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Undelegations = append(m.Undelegations, &Undelegate{})
			if err := m.Undelegations[len(m.Undelegations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStake(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStake
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Uptime) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStake
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Uptime: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Uptime: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AsOfBlockHeight", wireType)
			}
			m.AsOfBlockHeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AsOfBlockHeight |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field WindowLen", wireType)
			}
			m.WindowLen = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.WindowLen |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Bitvec", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Bitvec = append(m.Bitvec[:0], dAtA[iNdEx:postIndex]...)
			if m.Bitvec == nil {
				m.Bitvec = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStake(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStake
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CurrentConsensusKeys) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStake
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CurrentConsensusKeys: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CurrentConsensusKeys: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConsensusKeys", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ConsensusKeys = append(m.ConsensusKeys, &v1alpha1.ConsensusKey{})
			if err := m.ConsensusKeys[len(m.ConsensusKeys)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStake(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStake
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Penalty) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStake
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Penalty: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Penalty: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Inner = append(m.Inner[:0], dAtA[iNdEx:postIndex]...)
			if m.Inner == nil {
				m.Inner = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStake(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStake
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ValidatorInfoRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStake
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ValidatorInfoRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ValidatorInfoRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ChainId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ShowInactive", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ShowInactive = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipStake(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStake
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ValidatorInfoResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStake
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ValidatorInfoResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ValidatorInfoResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ValidatorInfo == nil {
				m.ValidatorInfo = &ValidatorInfo{}
			}
			if err := m.ValidatorInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStake(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStake
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ValidatorStatusRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStake
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ValidatorStatusRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ValidatorStatusRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ChainId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IdentityKey", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.IdentityKey == nil {
				m.IdentityKey = &v1alpha1.IdentityKey{}
			}
			if err := m.IdentityKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStake(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStake
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ValidatorStatusResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStake
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ValidatorStatusResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ValidatorStatusResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Status == nil {
				m.Status = &ValidatorStatus{}
			}
			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStake(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStake
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ValidatorPenaltyRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStake
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ValidatorPenaltyRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ValidatorPenaltyRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ChainId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IdentityKey", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.IdentityKey == nil {
				m.IdentityKey = &v1alpha1.IdentityKey{}
			}
			if err := m.IdentityKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartEpochIndex", wireType)
			}
			m.StartEpochIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StartEpochIndex |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EndEpochIndex", wireType)
			}
			m.EndEpochIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EndEpochIndex |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipStake(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStake
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ValidatorPenaltyResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStake
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ValidatorPenaltyResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ValidatorPenaltyResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Penalty", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Penalty == nil {
				m.Penalty = &Penalty{}
			}
			if err := m.Penalty.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStake(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStake
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CurrentValidatorRateRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStake
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CurrentValidatorRateRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CurrentValidatorRateRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ChainId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IdentityKey", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.IdentityKey == nil {
				m.IdentityKey = &v1alpha1.IdentityKey{}
			}
			if err := m.IdentityKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStake(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStake
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CurrentValidatorRateResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStake
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CurrentValidatorRateResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CurrentValidatorRateResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Data == nil {
				m.Data = &RateData{}
			}
			if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStake(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStake
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *StakeParameters) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStake
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: StakeParameters: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StakeParameters: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UnbondingEpochs", wireType)
			}
			m.UnbondingEpochs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UnbondingEpochs |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ActiveValidatorLimit", wireType)
			}
			m.ActiveValidatorLimit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ActiveValidatorLimit |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BaseRewardRate", wireType)
			}
			m.BaseRewardRate = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BaseRewardRate |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SlashingPenaltyMisbehavior", wireType)
			}
			m.SlashingPenaltyMisbehavior = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SlashingPenaltyMisbehavior |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SlashingPenaltyDowntime", wireType)
			}
			m.SlashingPenaltyDowntime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SlashingPenaltyDowntime |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SignedBlocksWindowLen", wireType)
			}
			m.SignedBlocksWindowLen = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SignedBlocksWindowLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MissedBlocksMaximum", wireType)
			}
			m.MissedBlocksMaximum = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MissedBlocksMaximum |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipStake(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStake
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GenesisContent) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowStake
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GenesisContent: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GenesisContent: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StakeParams", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.StakeParams == nil {
				m.StakeParams = &StakeParameters{}
			}
			if err := m.StakeParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Validators", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowStake
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthStake
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthStake
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Validators = append(m.Validators, &Validator{})
			if err := m.Validators[len(m.Validators)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipStake(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthStake
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipStake(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowStake
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowStake
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowStake
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthStake
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupStake
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthStake
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthStake        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowStake          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupStake = fmt.Errorf("proto: unexpected end of group")
)