cosmos-sdk/x/distribution/types/genesis.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: cosmos/distribution/v1beta1/genesis.proto

package types

import (
	bytes "bytes"
	fmt "fmt"
	github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
	types "github.com/cosmos/cosmos-sdk/types"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	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

// DelegatorWithdrawInfo is the address for where distributions rewards are withdrawn to by default
// this struct is only used at genesis to feed in default withdraw addresses.
type DelegatorWithdrawInfo struct {
	// delegator_address is the address of the delegator.
	DelegatorAddress github_com_cosmos_cosmos_sdk_types.AccAddress `protobuf:"bytes,1,opt,name=delegator_address,json=delegatorAddress,proto3,casttype=github.com/cosmos/cosmos-sdk/types.AccAddress" json:"delegator_address,omitempty" yaml:"delegator_address"`
	// withdraw_address is the address to withdraw the delegation rewards to.
	WithdrawAddress github_com_cosmos_cosmos_sdk_types.AccAddress `protobuf:"bytes,2,opt,name=withdraw_address,json=withdrawAddress,proto3,casttype=github.com/cosmos/cosmos-sdk/types.AccAddress" json:"withdraw_address,omitempty" yaml:"withdraw_address"`
}

func (m *DelegatorWithdrawInfo) Reset()         { *m = DelegatorWithdrawInfo{} }
func (m *DelegatorWithdrawInfo) String() string { return proto.CompactTextString(m) }
func (*DelegatorWithdrawInfo) ProtoMessage()    {}
func (*DelegatorWithdrawInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_76eed0f9489db580, []int{0}
}
func (m *DelegatorWithdrawInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DelegatorWithdrawInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DelegatorWithdrawInfo.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 *DelegatorWithdrawInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DelegatorWithdrawInfo.Merge(m, src)
}
func (m *DelegatorWithdrawInfo) XXX_Size() int {
	return m.Size()
}
func (m *DelegatorWithdrawInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_DelegatorWithdrawInfo.DiscardUnknown(m)
}

var xxx_messageInfo_DelegatorWithdrawInfo proto.InternalMessageInfo

func (m *DelegatorWithdrawInfo) GetDelegatorAddress() github_com_cosmos_cosmos_sdk_types.AccAddress {
	if m != nil {
		return m.DelegatorAddress
	}
	return nil
}

func (m *DelegatorWithdrawInfo) GetWithdrawAddress() github_com_cosmos_cosmos_sdk_types.AccAddress {
	if m != nil {
		return m.WithdrawAddress
	}
	return nil
}

// ValidatorOutstandingRewardsRecord is used for import/export via genesis json.
type ValidatorOutstandingRewardsRecord struct {
	// validator_address is the address of the validator.
	ValidatorAddress github_com_cosmos_cosmos_sdk_types.ValAddress `protobuf:"bytes,1,opt,name=validator_address,json=validatorAddress,proto3,casttype=github.com/cosmos/cosmos-sdk/types.ValAddress" json:"validator_address,omitempty" yaml:"validator_address"`
	// outstanding_rewards represents the oustanding rewards of a validator.
	OutstandingRewards github_com_cosmos_cosmos_sdk_types.DecCoins `protobuf:"bytes,2,rep,name=outstanding_rewards,json=outstandingRewards,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.DecCoins" json:"outstanding_rewards" yaml:"outstanding_rewards"`
}

func (m *ValidatorOutstandingRewardsRecord) Reset()         { *m = ValidatorOutstandingRewardsRecord{} }
func (m *ValidatorOutstandingRewardsRecord) String() string { return proto.CompactTextString(m) }
func (*ValidatorOutstandingRewardsRecord) ProtoMessage()    {}
func (*ValidatorOutstandingRewardsRecord) Descriptor() ([]byte, []int) {
	return fileDescriptor_76eed0f9489db580, []int{1}
}
func (m *ValidatorOutstandingRewardsRecord) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ValidatorOutstandingRewardsRecord) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ValidatorOutstandingRewardsRecord.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 *ValidatorOutstandingRewardsRecord) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ValidatorOutstandingRewardsRecord.Merge(m, src)
}
func (m *ValidatorOutstandingRewardsRecord) XXX_Size() int {
	return m.Size()
}
func (m *ValidatorOutstandingRewardsRecord) XXX_DiscardUnknown() {
	xxx_messageInfo_ValidatorOutstandingRewardsRecord.DiscardUnknown(m)
}

var xxx_messageInfo_ValidatorOutstandingRewardsRecord proto.InternalMessageInfo

func (m *ValidatorOutstandingRewardsRecord) GetValidatorAddress() github_com_cosmos_cosmos_sdk_types.ValAddress {
	if m != nil {
		return m.ValidatorAddress
	}
	return nil
}

func (m *ValidatorOutstandingRewardsRecord) GetOutstandingRewards() github_com_cosmos_cosmos_sdk_types.DecCoins {
	if m != nil {
		return m.OutstandingRewards
	}
	return nil
}

// ValidatorAccumulatedCommissionRecord is used for import / export via genesis json.
type ValidatorAccumulatedCommissionRecord struct {
	// validator_address is the address of the validator.
	ValidatorAddress github_com_cosmos_cosmos_sdk_types.ValAddress `protobuf:"bytes,1,opt,name=validator_address,json=validatorAddress,proto3,casttype=github.com/cosmos/cosmos-sdk/types.ValAddress" json:"validator_address,omitempty" yaml:"validator_address"`
	Accumulated      ValidatorAccumulatedCommission                `protobuf:"bytes,2,opt,name=accumulated,proto3" json:"accumulated" yaml:"accumulated"`
}

func (m *ValidatorAccumulatedCommissionRecord) Reset()         { *m = ValidatorAccumulatedCommissionRecord{} }
func (m *ValidatorAccumulatedCommissionRecord) String() string { return proto.CompactTextString(m) }
func (*ValidatorAccumulatedCommissionRecord) ProtoMessage()    {}
func (*ValidatorAccumulatedCommissionRecord) Descriptor() ([]byte, []int) {
	return fileDescriptor_76eed0f9489db580, []int{2}
}
func (m *ValidatorAccumulatedCommissionRecord) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ValidatorAccumulatedCommissionRecord) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ValidatorAccumulatedCommissionRecord.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 *ValidatorAccumulatedCommissionRecord) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ValidatorAccumulatedCommissionRecord.Merge(m, src)
}
func (m *ValidatorAccumulatedCommissionRecord) XXX_Size() int {
	return m.Size()
}
func (m *ValidatorAccumulatedCommissionRecord) XXX_DiscardUnknown() {
	xxx_messageInfo_ValidatorAccumulatedCommissionRecord.DiscardUnknown(m)
}

var xxx_messageInfo_ValidatorAccumulatedCommissionRecord proto.InternalMessageInfo

func (m *ValidatorAccumulatedCommissionRecord) GetValidatorAddress() github_com_cosmos_cosmos_sdk_types.ValAddress {
	if m != nil {
		return m.ValidatorAddress
	}
	return nil
}

func (m *ValidatorAccumulatedCommissionRecord) GetAccumulated() ValidatorAccumulatedCommission {
	if m != nil {
		return m.Accumulated
	}
	return ValidatorAccumulatedCommission{}
}

// ValidatorHistoricalRewardsRecord is used for import / export via genesis json.
type ValidatorHistoricalRewardsRecord struct {
	// validator_address is the address of the validator.
	ValidatorAddress github_com_cosmos_cosmos_sdk_types.ValAddress `protobuf:"bytes,1,opt,name=validator_address,json=validatorAddress,proto3,casttype=github.com/cosmos/cosmos-sdk/types.ValAddress" json:"validator_address,omitempty" yaml:"validator_address"`
	// period defines the period the historical rewards apply to.
	Period uint64 `protobuf:"varint,2,opt,name=period,proto3" json:"period,omitempty"`
	// rewards defines the historical rewards of a validator.
	Rewards ValidatorHistoricalRewards `protobuf:"bytes,3,opt,name=rewards,proto3" json:"rewards" yaml:"rewards"`
}

func (m *ValidatorHistoricalRewardsRecord) Reset()         { *m = ValidatorHistoricalRewardsRecord{} }
func (m *ValidatorHistoricalRewardsRecord) String() string { return proto.CompactTextString(m) }
func (*ValidatorHistoricalRewardsRecord) ProtoMessage()    {}
func (*ValidatorHistoricalRewardsRecord) Descriptor() ([]byte, []int) {
	return fileDescriptor_76eed0f9489db580, []int{3}
}
func (m *ValidatorHistoricalRewardsRecord) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ValidatorHistoricalRewardsRecord) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ValidatorHistoricalRewardsRecord.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 *ValidatorHistoricalRewardsRecord) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ValidatorHistoricalRewardsRecord.Merge(m, src)
}
func (m *ValidatorHistoricalRewardsRecord) XXX_Size() int {
	return m.Size()
}
func (m *ValidatorHistoricalRewardsRecord) XXX_DiscardUnknown() {
	xxx_messageInfo_ValidatorHistoricalRewardsRecord.DiscardUnknown(m)
}

var xxx_messageInfo_ValidatorHistoricalRewardsRecord proto.InternalMessageInfo

func (m *ValidatorHistoricalRewardsRecord) GetValidatorAddress() github_com_cosmos_cosmos_sdk_types.ValAddress {
	if m != nil {
		return m.ValidatorAddress
	}
	return nil
}

func (m *ValidatorHistoricalRewardsRecord) GetPeriod() uint64 {
	if m != nil {
		return m.Period
	}
	return 0
}

func (m *ValidatorHistoricalRewardsRecord) GetRewards() ValidatorHistoricalRewards {
	if m != nil {
		return m.Rewards
	}
	return ValidatorHistoricalRewards{}
}

// ValidatorCurrentRewardsRecord is used for import / export via genesis json.
type ValidatorCurrentRewardsRecord struct {
	// validator_address is the address of the validator.
	ValidatorAddress github_com_cosmos_cosmos_sdk_types.ValAddress `protobuf:"bytes,1,opt,name=validator_address,json=validatorAddress,proto3,casttype=github.com/cosmos/cosmos-sdk/types.ValAddress" json:"validator_address,omitempty" yaml:"validator_address"`
	// rewards defines the current rewards of a validator.
	Rewards ValidatorCurrentRewards `protobuf:"bytes,2,opt,name=rewards,proto3" json:"rewards" yaml:"rewards"`
}

func (m *ValidatorCurrentRewardsRecord) Reset()         { *m = ValidatorCurrentRewardsRecord{} }
func (m *ValidatorCurrentRewardsRecord) String() string { return proto.CompactTextString(m) }
func (*ValidatorCurrentRewardsRecord) ProtoMessage()    {}
func (*ValidatorCurrentRewardsRecord) Descriptor() ([]byte, []int) {
	return fileDescriptor_76eed0f9489db580, []int{4}
}
func (m *ValidatorCurrentRewardsRecord) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ValidatorCurrentRewardsRecord) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ValidatorCurrentRewardsRecord.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 *ValidatorCurrentRewardsRecord) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ValidatorCurrentRewardsRecord.Merge(m, src)
}
func (m *ValidatorCurrentRewardsRecord) XXX_Size() int {
	return m.Size()
}
func (m *ValidatorCurrentRewardsRecord) XXX_DiscardUnknown() {
	xxx_messageInfo_ValidatorCurrentRewardsRecord.DiscardUnknown(m)
}

var xxx_messageInfo_ValidatorCurrentRewardsRecord proto.InternalMessageInfo

func (m *ValidatorCurrentRewardsRecord) GetValidatorAddress() github_com_cosmos_cosmos_sdk_types.ValAddress {
	if m != nil {
		return m.ValidatorAddress
	}
	return nil
}

func (m *ValidatorCurrentRewardsRecord) GetRewards() ValidatorCurrentRewards {
	if m != nil {
		return m.Rewards
	}
	return ValidatorCurrentRewards{}
}

// DelegatorStartingInfoRecord used for import / export via genesis json.
type DelegatorStartingInfoRecord struct {
	// delegator_address is the address of the delegator.
	DelegatorAddress github_com_cosmos_cosmos_sdk_types.AccAddress `protobuf:"bytes,1,opt,name=delegator_address,json=delegatorAddress,proto3,casttype=github.com/cosmos/cosmos-sdk/types.AccAddress" json:"delegator_address,omitempty" yaml:"delegator_address"`
	// validator_address is the address of the validator.
	ValidatorAddress github_com_cosmos_cosmos_sdk_types.ValAddress `protobuf:"bytes,2,opt,name=validator_address,json=validatorAddress,proto3,casttype=github.com/cosmos/cosmos-sdk/types.ValAddress" json:"validator_address,omitempty" yaml:"validator_address"`
	// starting_info defines the starting info of a delegator.
	StartingInfo DelegatorStartingInfo `protobuf:"bytes,3,opt,name=starting_info,json=startingInfo,proto3" json:"starting_info" yaml:"starting_info"`
}

func (m *DelegatorStartingInfoRecord) Reset()         { *m = DelegatorStartingInfoRecord{} }
func (m *DelegatorStartingInfoRecord) String() string { return proto.CompactTextString(m) }
func (*DelegatorStartingInfoRecord) ProtoMessage()    {}
func (*DelegatorStartingInfoRecord) Descriptor() ([]byte, []int) {
	return fileDescriptor_76eed0f9489db580, []int{5}
}
func (m *DelegatorStartingInfoRecord) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DelegatorStartingInfoRecord) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DelegatorStartingInfoRecord.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 *DelegatorStartingInfoRecord) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DelegatorStartingInfoRecord.Merge(m, src)
}
func (m *DelegatorStartingInfoRecord) XXX_Size() int {
	return m.Size()
}
func (m *DelegatorStartingInfoRecord) XXX_DiscardUnknown() {
	xxx_messageInfo_DelegatorStartingInfoRecord.DiscardUnknown(m)
}

var xxx_messageInfo_DelegatorStartingInfoRecord proto.InternalMessageInfo

func (m *DelegatorStartingInfoRecord) GetDelegatorAddress() github_com_cosmos_cosmos_sdk_types.AccAddress {
	if m != nil {
		return m.DelegatorAddress
	}
	return nil
}

func (m *DelegatorStartingInfoRecord) GetValidatorAddress() github_com_cosmos_cosmos_sdk_types.ValAddress {
	if m != nil {
		return m.ValidatorAddress
	}
	return nil
}

func (m *DelegatorStartingInfoRecord) GetStartingInfo() DelegatorStartingInfo {
	if m != nil {
		return m.StartingInfo
	}
	return DelegatorStartingInfo{}
}

// ValidatorSlashEventRecord is used for import / export via genesis json.
type ValidatorSlashEventRecord struct {
	// validator_address is the address of the validator.
	ValidatorAddress github_com_cosmos_cosmos_sdk_types.ValAddress `protobuf:"bytes,1,opt,name=validator_address,json=validatorAddress,proto3,casttype=github.com/cosmos/cosmos-sdk/types.ValAddress" json:"validator_address,omitempty" yaml:"validator_address"`
	// height defines the block height at which the slash event occured.
	Height uint64 `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"`
	// period is the period of the slash event.
	Period uint64 `protobuf:"varint,3,opt,name=period,proto3" json:"period,omitempty"`
	// event describes the slash event.
	Event ValidatorSlashEvent `protobuf:"bytes,4,opt,name=event,proto3" json:"event" yaml:"event"`
}

func (m *ValidatorSlashEventRecord) Reset()         { *m = ValidatorSlashEventRecord{} }
func (m *ValidatorSlashEventRecord) String() string { return proto.CompactTextString(m) }
func (*ValidatorSlashEventRecord) ProtoMessage()    {}
func (*ValidatorSlashEventRecord) Descriptor() ([]byte, []int) {
	return fileDescriptor_76eed0f9489db580, []int{6}
}
func (m *ValidatorSlashEventRecord) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ValidatorSlashEventRecord) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ValidatorSlashEventRecord.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 *ValidatorSlashEventRecord) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ValidatorSlashEventRecord.Merge(m, src)
}
func (m *ValidatorSlashEventRecord) XXX_Size() int {
	return m.Size()
}
func (m *ValidatorSlashEventRecord) XXX_DiscardUnknown() {
	xxx_messageInfo_ValidatorSlashEventRecord.DiscardUnknown(m)
}

var xxx_messageInfo_ValidatorSlashEventRecord proto.InternalMessageInfo

func (m *ValidatorSlashEventRecord) GetValidatorAddress() github_com_cosmos_cosmos_sdk_types.ValAddress {
	if m != nil {
		return m.ValidatorAddress
	}
	return nil
}

func (m *ValidatorSlashEventRecord) GetHeight() uint64 {
	if m != nil {
		return m.Height
	}
	return 0
}

func (m *ValidatorSlashEventRecord) GetPeriod() uint64 {
	if m != nil {
		return m.Period
	}
	return 0
}

func (m *ValidatorSlashEventRecord) GetEvent() ValidatorSlashEvent {
	if m != nil {
		return m.Event
	}
	return ValidatorSlashEvent{}
}

// GenesisState defines the distribution module's genesis state.
type GenesisState struct {
	// params defines all the paramaters of the module.
	Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params" yaml:"params"`
	// fee_pool defines the fee pool at genesis.
	FeePool FeePool `protobuf:"bytes,2,opt,name=fee_pool,json=feePool,proto3" json:"fee_pool" yaml:"fee_pool"`
	// fee_pool defines the delegator withdraw infos at genesis.
	DelegatorWithdrawInfos []DelegatorWithdrawInfo `protobuf:"bytes,3,rep,name=delegator_withdraw_infos,json=delegatorWithdrawInfos,proto3" json:"delegator_withdraw_infos" yaml:"delegator_withdraw_infos"`
	// fee_pool defines the previous proposer at genesis.
	PreviousProposer github_com_cosmos_cosmos_sdk_types.ConsAddress `protobuf:"bytes,4,opt,name=previous_proposer,json=previousProposer,proto3,casttype=github.com/cosmos/cosmos-sdk/types.ConsAddress" json:"previous_proposer,omitempty" yaml:"previous_proposer"`
	// fee_pool defines the outstanding rewards of all validators at genesis.
	OutstandingRewards []ValidatorOutstandingRewardsRecord `protobuf:"bytes,5,rep,name=outstanding_rewards,json=outstandingRewards,proto3" json:"outstanding_rewards" yaml:"outstanding_rewards"`
	// fee_pool defines the accumulated commisions of all validators at genesis.
	ValidatorAccumulatedCommissions []ValidatorAccumulatedCommissionRecord `protobuf:"bytes,6,rep,name=validator_accumulated_commissions,json=validatorAccumulatedCommissions,proto3" json:"validator_accumulated_commissions" yaml:"validator_accumulated_commissions"`
	// fee_pool defines the historical rewards of all validators at genesis.
	ValidatorHistoricalRewards []ValidatorHistoricalRewardsRecord `protobuf:"bytes,7,rep,name=validator_historical_rewards,json=validatorHistoricalRewards,proto3" json:"validator_historical_rewards" yaml:"validator_historical_rewards"`
	// fee_pool defines the current rewards of all validators at genesis.
	ValidatorCurrentRewards []ValidatorCurrentRewardsRecord `protobuf:"bytes,8,rep,name=validator_current_rewards,json=validatorCurrentRewards,proto3" json:"validator_current_rewards" yaml:"validator_current_rewards"`
	// fee_pool defines the delegator starting infos at genesis.
	DelegatorStartingInfos []DelegatorStartingInfoRecord `protobuf:"bytes,9,rep,name=delegator_starting_infos,json=delegatorStartingInfos,proto3" json:"delegator_starting_infos" yaml:"delegator_starting_infos"`
	// fee_pool defines the validator slash events at genesis.
	ValidatorSlashEvents []ValidatorSlashEventRecord `protobuf:"bytes,10,rep,name=validator_slash_events,json=validatorSlashEvents,proto3" json:"validator_slash_events" yaml:"validator_slash_events"`
}

func (m *GenesisState) Reset()         { *m = GenesisState{} }
func (m *GenesisState) String() string { return proto.CompactTextString(m) }
func (*GenesisState) ProtoMessage()    {}
func (*GenesisState) Descriptor() ([]byte, []int) {
	return fileDescriptor_76eed0f9489db580, []int{7}
}
func (m *GenesisState) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GenesisState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GenesisState.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 *GenesisState) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GenesisState.Merge(m, src)
}
func (m *GenesisState) XXX_Size() int {
	return m.Size()
}
func (m *GenesisState) XXX_DiscardUnknown() {
	xxx_messageInfo_GenesisState.DiscardUnknown(m)
}

var xxx_messageInfo_GenesisState proto.InternalMessageInfo

func (m *GenesisState) GetParams() Params {
	if m != nil {
		return m.Params
	}
	return Params{}
}

func (m *GenesisState) GetFeePool() FeePool {
	if m != nil {
		return m.FeePool
	}
	return FeePool{}
}

func (m *GenesisState) GetDelegatorWithdrawInfos() []DelegatorWithdrawInfo {
	if m != nil {
		return m.DelegatorWithdrawInfos
	}
	return nil
}

func (m *GenesisState) GetPreviousProposer() github_com_cosmos_cosmos_sdk_types.ConsAddress {
	if m != nil {
		return m.PreviousProposer
	}
	return nil
}

func (m *GenesisState) GetOutstandingRewards() []ValidatorOutstandingRewardsRecord {
	if m != nil {
		return m.OutstandingRewards
	}
	return nil
}

func (m *GenesisState) GetValidatorAccumulatedCommissions() []ValidatorAccumulatedCommissionRecord {
	if m != nil {
		return m.ValidatorAccumulatedCommissions
	}
	return nil
}

func (m *GenesisState) GetValidatorHistoricalRewards() []ValidatorHistoricalRewardsRecord {
	if m != nil {
		return m.ValidatorHistoricalRewards
	}
	return nil
}

func (m *GenesisState) GetValidatorCurrentRewards() []ValidatorCurrentRewardsRecord {
	if m != nil {
		return m.ValidatorCurrentRewards
	}
	return nil
}

func (m *GenesisState) GetDelegatorStartingInfos() []DelegatorStartingInfoRecord {
	if m != nil {
		return m.DelegatorStartingInfos
	}
	return nil
}

func (m *GenesisState) GetValidatorSlashEvents() []ValidatorSlashEventRecord {
	if m != nil {
		return m.ValidatorSlashEvents
	}
	return nil
}

func init() {
	proto.RegisterType((*DelegatorWithdrawInfo)(nil), "cosmos.distribution.v1beta1.DelegatorWithdrawInfo")
	proto.RegisterType((*ValidatorOutstandingRewardsRecord)(nil), "cosmos.distribution.v1beta1.ValidatorOutstandingRewardsRecord")
	proto.RegisterType((*ValidatorAccumulatedCommissionRecord)(nil), "cosmos.distribution.v1beta1.ValidatorAccumulatedCommissionRecord")
	proto.RegisterType((*ValidatorHistoricalRewardsRecord)(nil), "cosmos.distribution.v1beta1.ValidatorHistoricalRewardsRecord")
	proto.RegisterType((*ValidatorCurrentRewardsRecord)(nil), "cosmos.distribution.v1beta1.ValidatorCurrentRewardsRecord")
	proto.RegisterType((*DelegatorStartingInfoRecord)(nil), "cosmos.distribution.v1beta1.DelegatorStartingInfoRecord")
	proto.RegisterType((*ValidatorSlashEventRecord)(nil), "cosmos.distribution.v1beta1.ValidatorSlashEventRecord")
	proto.RegisterType((*GenesisState)(nil), "cosmos.distribution.v1beta1.GenesisState")
}

func init() {
	proto.RegisterFile("cosmos/distribution/v1beta1/genesis.proto", fileDescriptor_76eed0f9489db580)
}

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

func (this *DelegatorWithdrawInfo) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DelegatorWithdrawInfo)
	if !ok {
		that2, ok := that.(DelegatorWithdrawInfo)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.DelegatorAddress, that1.DelegatorAddress) {
		return false
	}
	if !bytes.Equal(this.WithdrawAddress, that1.WithdrawAddress) {
		return false
	}
	return true
}
func (this *ValidatorOutstandingRewardsRecord) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ValidatorOutstandingRewardsRecord)
	if !ok {
		that2, ok := that.(ValidatorOutstandingRewardsRecord)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.ValidatorAddress, that1.ValidatorAddress) {
		return false
	}
	if len(this.OutstandingRewards) != len(that1.OutstandingRewards) {
		return false
	}
	for i := range this.OutstandingRewards {
		if !this.OutstandingRewards[i].Equal(&that1.OutstandingRewards[i]) {
			return false
		}
	}
	return true
}
func (this *ValidatorAccumulatedCommissionRecord) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ValidatorAccumulatedCommissionRecord)
	if !ok {
		that2, ok := that.(ValidatorAccumulatedCommissionRecord)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.ValidatorAddress, that1.ValidatorAddress) {
		return false
	}
	if !this.Accumulated.Equal(&that1.Accumulated) {
		return false
	}
	return true
}
func (this *ValidatorHistoricalRewardsRecord) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ValidatorHistoricalRewardsRecord)
	if !ok {
		that2, ok := that.(ValidatorHistoricalRewardsRecord)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.ValidatorAddress, that1.ValidatorAddress) {
		return false
	}
	if this.Period != that1.Period {
		return false
	}
	if !this.Rewards.Equal(&that1.Rewards) {
		return false
	}
	return true
}
func (this *ValidatorCurrentRewardsRecord) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ValidatorCurrentRewardsRecord)
	if !ok {
		that2, ok := that.(ValidatorCurrentRewardsRecord)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.ValidatorAddress, that1.ValidatorAddress) {
		return false
	}
	if !this.Rewards.Equal(&that1.Rewards) {
		return false
	}
	return true
}
func (this *DelegatorStartingInfoRecord) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DelegatorStartingInfoRecord)
	if !ok {
		that2, ok := that.(DelegatorStartingInfoRecord)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.DelegatorAddress, that1.DelegatorAddress) {
		return false
	}
	if !bytes.Equal(this.ValidatorAddress, that1.ValidatorAddress) {
		return false
	}
	if !this.StartingInfo.Equal(&that1.StartingInfo) {
		return false
	}
	return true
}
func (this *ValidatorSlashEventRecord) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ValidatorSlashEventRecord)
	if !ok {
		that2, ok := that.(ValidatorSlashEventRecord)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.ValidatorAddress, that1.ValidatorAddress) {
		return false
	}
	if this.Height != that1.Height {
		return false
	}
	if this.Period != that1.Period {
		return false
	}
	if !this.Event.Equal(&that1.Event) {
		return false
	}
	return true
}
func (this *GenesisState) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GenesisState)
	if !ok {
		that2, ok := that.(GenesisState)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Params.Equal(&that1.Params) {
		return false
	}
	if !this.FeePool.Equal(&that1.FeePool) {
		return false
	}
	if len(this.DelegatorWithdrawInfos) != len(that1.DelegatorWithdrawInfos) {
		return false
	}
	for i := range this.DelegatorWithdrawInfos {
		if !this.DelegatorWithdrawInfos[i].Equal(&that1.DelegatorWithdrawInfos[i]) {
			return false
		}
	}
	if !bytes.Equal(this.PreviousProposer, that1.PreviousProposer) {
		return false
	}
	if len(this.OutstandingRewards) != len(that1.OutstandingRewards) {
		return false
	}
	for i := range this.OutstandingRewards {
		if !this.OutstandingRewards[i].Equal(&that1.OutstandingRewards[i]) {
			return false
		}
	}
	if len(this.ValidatorAccumulatedCommissions) != len(that1.ValidatorAccumulatedCommissions) {
		return false
	}
	for i := range this.ValidatorAccumulatedCommissions {
		if !this.ValidatorAccumulatedCommissions[i].Equal(&that1.ValidatorAccumulatedCommissions[i]) {
			return false
		}
	}
	if len(this.ValidatorHistoricalRewards) != len(that1.ValidatorHistoricalRewards) {
		return false
	}
	for i := range this.ValidatorHistoricalRewards {
		if !this.ValidatorHistoricalRewards[i].Equal(&that1.ValidatorHistoricalRewards[i]) {
			return false
		}
	}
	if len(this.ValidatorCurrentRewards) != len(that1.ValidatorCurrentRewards) {
		return false
	}
	for i := range this.ValidatorCurrentRewards {
		if !this.ValidatorCurrentRewards[i].Equal(&that1.ValidatorCurrentRewards[i]) {
			return false
		}
	}
	if len(this.DelegatorStartingInfos) != len(that1.DelegatorStartingInfos) {
		return false
	}
	for i := range this.DelegatorStartingInfos {
		if !this.DelegatorStartingInfos[i].Equal(&that1.DelegatorStartingInfos[i]) {
			return false
		}
	}
	if len(this.ValidatorSlashEvents) != len(that1.ValidatorSlashEvents) {
		return false
	}
	for i := range this.ValidatorSlashEvents {
		if !this.ValidatorSlashEvents[i].Equal(&that1.ValidatorSlashEvents[i]) {
			return false
		}
	}
	return true
}
func (m *DelegatorWithdrawInfo) 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 *DelegatorWithdrawInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *ValidatorOutstandingRewardsRecord) 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 *ValidatorOutstandingRewardsRecord) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *ValidatorAccumulatedCommissionRecord) 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 *ValidatorAccumulatedCommissionRecord) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *ValidatorHistoricalRewardsRecord) 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 *ValidatorHistoricalRewardsRecord) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ValidatorHistoricalRewardsRecord) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Rewards.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenesis(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if m.Period != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.Period))
		i--
		dAtA[i] = 0x10
	}
	if len(m.ValidatorAddress) > 0 {
		i -= len(m.ValidatorAddress)
		copy(dAtA[i:], m.ValidatorAddress)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.ValidatorAddress)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ValidatorCurrentRewardsRecord) 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 *ValidatorCurrentRewardsRecord) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *DelegatorStartingInfoRecord) 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 *DelegatorStartingInfoRecord) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DelegatorStartingInfoRecord) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.StartingInfo.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenesis(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if len(m.ValidatorAddress) > 0 {
		i -= len(m.ValidatorAddress)
		copy(dAtA[i:], m.ValidatorAddress)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.ValidatorAddress)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.DelegatorAddress) > 0 {
		i -= len(m.DelegatorAddress)
		copy(dAtA[i:], m.DelegatorAddress)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.DelegatorAddress)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ValidatorSlashEventRecord) 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 *ValidatorSlashEventRecord) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ValidatorSlashEventRecord) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Event.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenesis(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if m.Period != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.Period))
		i--
		dAtA[i] = 0x18
	}
	if m.Height != 0 {
		i = encodeVarintGenesis(dAtA, i, uint64(m.Height))
		i--
		dAtA[i] = 0x10
	}
	if len(m.ValidatorAddress) > 0 {
		i -= len(m.ValidatorAddress)
		copy(dAtA[i:], m.ValidatorAddress)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.ValidatorAddress)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *GenesisState) 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 *GenesisState) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ValidatorSlashEvents) > 0 {
		for iNdEx := len(m.ValidatorSlashEvents) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ValidatorSlashEvents[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x52
		}
	}
	if len(m.DelegatorStartingInfos) > 0 {
		for iNdEx := len(m.DelegatorStartingInfos) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.DelegatorStartingInfos[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x4a
		}
	}
	if len(m.ValidatorCurrentRewards) > 0 {
		for iNdEx := len(m.ValidatorCurrentRewards) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ValidatorCurrentRewards[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x42
		}
	}
	if len(m.ValidatorHistoricalRewards) > 0 {
		for iNdEx := len(m.ValidatorHistoricalRewards) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ValidatorHistoricalRewards[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3a
		}
	}
	if len(m.ValidatorAccumulatedCommissions) > 0 {
		for iNdEx := len(m.ValidatorAccumulatedCommissions) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ValidatorAccumulatedCommissions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x32
		}
	}
	if len(m.OutstandingRewards) > 0 {
		for iNdEx := len(m.OutstandingRewards) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.OutstandingRewards[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.PreviousProposer) > 0 {
		i -= len(m.PreviousProposer)
		copy(dAtA[i:], m.PreviousProposer)
		i = encodeVarintGenesis(dAtA, i, uint64(len(m.PreviousProposer)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.DelegatorWithdrawInfos) > 0 {
		for iNdEx := len(m.DelegatorWithdrawInfos) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.DelegatorWithdrawInfos[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintGenesis(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	{
		size, err := m.FeePool.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenesis(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.Params.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintGenesis(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

func (m *ValidatorAccumulatedCommissionRecord) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ValidatorAddress)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	l = m.Accumulated.Size()
	n += 1 + l + sovGenesis(uint64(l))
	return n
}

func (m *ValidatorHistoricalRewardsRecord) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ValidatorAddress)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	if m.Period != 0 {
		n += 1 + sovGenesis(uint64(m.Period))
	}
	l = m.Rewards.Size()
	n += 1 + l + sovGenesis(uint64(l))
	return n
}

func (m *ValidatorCurrentRewardsRecord) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ValidatorAddress)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	l = m.Rewards.Size()
	n += 1 + l + sovGenesis(uint64(l))
	return n
}

func (m *DelegatorStartingInfoRecord) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.DelegatorAddress)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	l = len(m.ValidatorAddress)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	l = m.StartingInfo.Size()
	n += 1 + l + sovGenesis(uint64(l))
	return n
}

func (m *ValidatorSlashEventRecord) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ValidatorAddress)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	if m.Height != 0 {
		n += 1 + sovGenesis(uint64(m.Height))
	}
	if m.Period != 0 {
		n += 1 + sovGenesis(uint64(m.Period))
	}
	l = m.Event.Size()
	n += 1 + l + sovGenesis(uint64(l))
	return n
}

func (m *GenesisState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Params.Size()
	n += 1 + l + sovGenesis(uint64(l))
	l = m.FeePool.Size()
	n += 1 + l + sovGenesis(uint64(l))
	if len(m.DelegatorWithdrawInfos) > 0 {
		for _, e := range m.DelegatorWithdrawInfos {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	l = len(m.PreviousProposer)
	if l > 0 {
		n += 1 + l + sovGenesis(uint64(l))
	}
	if len(m.OutstandingRewards) > 0 {
		for _, e := range m.OutstandingRewards {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.ValidatorAccumulatedCommissions) > 0 {
		for _, e := range m.ValidatorAccumulatedCommissions {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.ValidatorHistoricalRewards) > 0 {
		for _, e := range m.ValidatorHistoricalRewards {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.ValidatorCurrentRewards) > 0 {
		for _, e := range m.ValidatorCurrentRewards {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.DelegatorStartingInfos) > 0 {
		for _, e := range m.DelegatorStartingInfos {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	if len(m.ValidatorSlashEvents) > 0 {
		for _, e := range m.ValidatorSlashEvents {
			l = e.Size()
			n += 1 + l + sovGenesis(uint64(l))
		}
	}
	return n
}

func sovGenesis(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozGenesis(x uint64) (n int) {
	return sovGenesis(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *DelegatorWithdrawInfo) 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 ErrIntOverflowGenesis
			}
			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: DelegatorWithdrawInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DelegatorWithdrawInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddress", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DelegatorAddress = append(m.DelegatorAddress[:0], dAtA[iNdEx:postIndex]...)
			if m.DelegatorAddress == nil {
				m.DelegatorAddress = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WithdrawAddress", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.WithdrawAddress = append(m.WithdrawAddress[:0], dAtA[iNdEx:postIndex]...)
			if m.WithdrawAddress == nil {
				m.WithdrawAddress = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ValidatorOutstandingRewardsRecord) 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 ErrIntOverflowGenesis
			}
			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: ValidatorOutstandingRewardsRecord: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ValidatorOutstandingRewardsRecord: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddress", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ValidatorAddress = append(m.ValidatorAddress[:0], dAtA[iNdEx:postIndex]...)
			if m.ValidatorAddress == nil {
				m.ValidatorAddress = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OutstandingRewards", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OutstandingRewards = append(m.OutstandingRewards, types.DecCoin{})
			if err := m.OutstandingRewards[len(m.OutstandingRewards)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ValidatorAccumulatedCommissionRecord) 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 ErrIntOverflowGenesis
			}
			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: ValidatorAccumulatedCommissionRecord: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ValidatorAccumulatedCommissionRecord: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddress", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ValidatorAddress = append(m.ValidatorAddress[:0], dAtA[iNdEx:postIndex]...)
			if m.ValidatorAddress == nil {
				m.ValidatorAddress = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Accumulated", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Accumulated.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ValidatorHistoricalRewardsRecord) 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 ErrIntOverflowGenesis
			}
			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: ValidatorHistoricalRewardsRecord: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ValidatorHistoricalRewardsRecord: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddress", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ValidatorAddress = append(m.ValidatorAddress[:0], dAtA[iNdEx:postIndex]...)
			if m.ValidatorAddress == nil {
				m.ValidatorAddress = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Period", wireType)
			}
			m.Period = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Period |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Rewards", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Rewards.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ValidatorCurrentRewardsRecord) 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 ErrIntOverflowGenesis
			}
			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: ValidatorCurrentRewardsRecord: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ValidatorCurrentRewardsRecord: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddress", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ValidatorAddress = append(m.ValidatorAddress[:0], dAtA[iNdEx:postIndex]...)
			if m.ValidatorAddress == nil {
				m.ValidatorAddress = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Rewards", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Rewards.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DelegatorStartingInfoRecord) 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 ErrIntOverflowGenesis
			}
			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: DelegatorStartingInfoRecord: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DelegatorStartingInfoRecord: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DelegatorAddress", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DelegatorAddress = append(m.DelegatorAddress[:0], dAtA[iNdEx:postIndex]...)
			if m.DelegatorAddress == nil {
				m.DelegatorAddress = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddress", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ValidatorAddress = append(m.ValidatorAddress[:0], dAtA[iNdEx:postIndex]...)
			if m.ValidatorAddress == nil {
				m.ValidatorAddress = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartingInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.StartingInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ValidatorSlashEventRecord) 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 ErrIntOverflowGenesis
			}
			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: ValidatorSlashEventRecord: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ValidatorSlashEventRecord: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddress", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ValidatorAddress = append(m.ValidatorAddress[:0], dAtA[iNdEx:postIndex]...)
			if m.ValidatorAddress == nil {
				m.ValidatorAddress = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
			}
			m.Height = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Height |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Period", wireType)
			}
			m.Period = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Period |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GenesisState) 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 ErrIntOverflowGenesis
			}
			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: GenesisState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GenesisState: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FeePool", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.FeePool.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DelegatorWithdrawInfos", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DelegatorWithdrawInfos = append(m.DelegatorWithdrawInfos, DelegatorWithdrawInfo{})
			if err := m.DelegatorWithdrawInfos[len(m.DelegatorWithdrawInfos)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PreviousProposer", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PreviousProposer = append(m.PreviousProposer[:0], dAtA[iNdEx:postIndex]...)
			if m.PreviousProposer == nil {
				m.PreviousProposer = []byte{}
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OutstandingRewards", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OutstandingRewards = append(m.OutstandingRewards, ValidatorOutstandingRewardsRecord{})
			if err := m.OutstandingRewards[len(m.OutstandingRewards)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorAccumulatedCommissions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ValidatorAccumulatedCommissions = append(m.ValidatorAccumulatedCommissions, ValidatorAccumulatedCommissionRecord{})
			if err := m.ValidatorAccumulatedCommissions[len(m.ValidatorAccumulatedCommissions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorHistoricalRewards", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ValidatorHistoricalRewards = append(m.ValidatorHistoricalRewards, ValidatorHistoricalRewardsRecord{})
			if err := m.ValidatorHistoricalRewards[len(m.ValidatorHistoricalRewards)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorCurrentRewards", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ValidatorCurrentRewards = append(m.ValidatorCurrentRewards, ValidatorCurrentRewardsRecord{})
			if err := m.ValidatorCurrentRewards[len(m.ValidatorCurrentRewards)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DelegatorStartingInfos", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DelegatorStartingInfos = append(m.DelegatorStartingInfos, DelegatorStartingInfoRecord{})
			if err := m.DelegatorStartingInfos[len(m.DelegatorStartingInfos)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorSlashEvents", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGenesis
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGenesis
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGenesis
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ValidatorSlashEvents = append(m.ValidatorSlashEvents, ValidatorSlashEventRecord{})
			if err := m.ValidatorSlashEvents[len(m.ValidatorSlashEvents)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGenesis(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthGenesis
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipGenesis(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, ErrIntOverflowGenesis
			}
			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, ErrIntOverflowGenesis
				}
				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, ErrIntOverflowGenesis
				}
				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, ErrInvalidLengthGenesis
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupGenesis
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthGenesis
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthGenesis        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowGenesis          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupGenesis = fmt.Errorf("proto: unexpected end of group")
)