shared_consumer.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: interchain_security/ccv/v1/shared_consumer.proto

package types

import (
	fmt "fmt"
	types "github.com/cometbft/cometbft/abci/types"
	_ "github.com/cosmos/gogoproto/gogoproto"
	proto "github.com/cosmos/gogoproto/proto"
	github_com_cosmos_gogoproto_types "github.com/cosmos/gogoproto/types"
	_ "github.com/cosmos/ibc-go/v7/modules/core/04-channel/types"
	_07_tendermint "github.com/cosmos/ibc-go/v7/modules/light-clients/07-tendermint"
	_ "google.golang.org/protobuf/types/known/durationpb"
	_ "google.golang.org/protobuf/types/known/timestamppb"
	io "io"
	math "math"
	math_bits "math/bits"
	time "time"
)

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

// 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

// ConsumerParams defines the parameters for CCV consumer module.
//
// Note this type is referenced in both the consumer and provider CCV modules,
// and persisted on the provider, see MakeConsumerGenesis and SetConsumerGenesis.
type ConsumerParams struct {
	// TODO: Remove enabled flag and find a better way to setup integration tests
	// See: https://github.com/cosmos/interchain-security/issues/339
	Enabled bool `protobuf:"varint,1,opt,name=enabled,proto3" json:"enabled,omitempty"`
	///////////////////////
	// Distribution Params
	// Number of blocks between ibc-token-transfers from the consumer chain to
	// the provider chain. Note that at this transmission event a fraction of
	// the accumulated tokens are divided and sent consumer redistribution
	// address.
	BlocksPerDistributionTransmission int64 `protobuf:"varint,2,opt,name=blocks_per_distribution_transmission,json=blocksPerDistributionTransmission,proto3" json:"blocks_per_distribution_transmission,omitempty"`
	// Channel, and provider-chain receiving address to send distribution token
	// transfers over. These parameters is auto-set during the consumer <->
	// provider handshake procedure.
	DistributionTransmissionChannel string `protobuf:"bytes,3,opt,name=distribution_transmission_channel,json=distributionTransmissionChannel,proto3" json:"distribution_transmission_channel,omitempty"`
	ProviderFeePoolAddrStr          string `protobuf:"bytes,4,opt,name=provider_fee_pool_addr_str,json=providerFeePoolAddrStr,proto3" json:"provider_fee_pool_addr_str,omitempty"`
	// Sent CCV related IBC packets will timeout after this duration
	CcvTimeoutPeriod time.Duration `protobuf:"bytes,5,opt,name=ccv_timeout_period,json=ccvTimeoutPeriod,proto3,stdduration" json:"ccv_timeout_period"`
	// Sent transfer related IBC packets will timeout after this duration
	TransferTimeoutPeriod time.Duration `protobuf:"bytes,6,opt,name=transfer_timeout_period,json=transferTimeoutPeriod,proto3,stdduration" json:"transfer_timeout_period"`
	// The fraction of tokens allocated to the consumer redistribution address
	// during distribution events. The fraction is a string representing a
	// decimal number. For example "0.75" would represent 75%.
	ConsumerRedistributionFraction string `protobuf:"bytes,7,opt,name=consumer_redistribution_fraction,json=consumerRedistributionFraction,proto3" json:"consumer_redistribution_fraction,omitempty"`
	// The number of historical info entries to persist in store.
	// This param is a part of the cosmos sdk staking module. In the case of
	// a ccv enabled consumer chain, the ccv module acts as the staking module.
	HistoricalEntries int64 `protobuf:"varint,8,opt,name=historical_entries,json=historicalEntries,proto3" json:"historical_entries,omitempty"`
	// Unbonding period for the consumer,
	// which should be smaller than that of the provider in general.
	UnbondingPeriod time.Duration `protobuf:"bytes,9,opt,name=unbonding_period,json=unbondingPeriod,proto3,stdduration" json:"unbonding_period"`
	// The threshold for the percentage of validators at the bottom of the set who
	// can opt out of running the consumer chain without being punished. For
	// example, a value of 0.05 means that the validators in the bottom 5% of the
	// set can opt out
	SoftOptOutThreshold string `protobuf:"bytes,10,opt,name=soft_opt_out_threshold,json=softOptOutThreshold,proto3" json:"soft_opt_out_threshold,omitempty"`
	// Reward denoms. These are the denominations which are allowed to be sent to
	// the provider as rewards.
	RewardDenoms []string `protobuf:"bytes,11,rep,name=reward_denoms,json=rewardDenoms,proto3" json:"reward_denoms,omitempty"`
	// Provider-originated reward denoms. These are denoms coming from the
	// provider which are allowed to be used as rewards. e.g. "uatom"
	ProviderRewardDenoms []string `protobuf:"bytes,12,rep,name=provider_reward_denoms,json=providerRewardDenoms,proto3" json:"provider_reward_denoms,omitempty"`
}

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

var xxx_messageInfo_ConsumerParams proto.InternalMessageInfo

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

func (m *ConsumerParams) GetBlocksPerDistributionTransmission() int64 {
	if m != nil {
		return m.BlocksPerDistributionTransmission
	}
	return 0
}

func (m *ConsumerParams) GetDistributionTransmissionChannel() string {
	if m != nil {
		return m.DistributionTransmissionChannel
	}
	return ""
}

func (m *ConsumerParams) GetProviderFeePoolAddrStr() string {
	if m != nil {
		return m.ProviderFeePoolAddrStr
	}
	return ""
}

func (m *ConsumerParams) GetCcvTimeoutPeriod() time.Duration {
	if m != nil {
		return m.CcvTimeoutPeriod
	}
	return 0
}

func (m *ConsumerParams) GetTransferTimeoutPeriod() time.Duration {
	if m != nil {
		return m.TransferTimeoutPeriod
	}
	return 0
}

func (m *ConsumerParams) GetConsumerRedistributionFraction() string {
	if m != nil {
		return m.ConsumerRedistributionFraction
	}
	return ""
}

func (m *ConsumerParams) GetHistoricalEntries() int64 {
	if m != nil {
		return m.HistoricalEntries
	}
	return 0
}

func (m *ConsumerParams) GetUnbondingPeriod() time.Duration {
	if m != nil {
		return m.UnbondingPeriod
	}
	return 0
}

func (m *ConsumerParams) GetSoftOptOutThreshold() string {
	if m != nil {
		return m.SoftOptOutThreshold
	}
	return ""
}

func (m *ConsumerParams) GetRewardDenoms() []string {
	if m != nil {
		return m.RewardDenoms
	}
	return nil
}

func (m *ConsumerParams) GetProviderRewardDenoms() []string {
	if m != nil {
		return m.ProviderRewardDenoms
	}
	return nil
}

// ConsumerGenesisState defines the CCV consumer chain genesis state.
//
// Note this type is referenced in both the consumer and provider CCV modules,
// and persisted on the provider, see MakeConsumerGenesis and SetConsumerGenesis.
type ConsumerGenesisState struct {
	Params            ConsumerParams `protobuf:"bytes,1,opt,name=params,proto3" json:"params"`
	ProviderClientId  string         `protobuf:"bytes,2,opt,name=provider_client_id,json=providerClientId,proto3" json:"provider_client_id,omitempty"`
	ProviderChannelId string         `protobuf:"bytes,3,opt,name=provider_channel_id,json=providerChannelId,proto3" json:"provider_channel_id,omitempty"`
	NewChain          bool           `protobuf:"varint,4,opt,name=new_chain,json=newChain,proto3" json:"new_chain,omitempty"`
	// ProviderClientState filled in on new chain, nil on restart.
	ProviderClientState *_07_tendermint.ClientState `protobuf:"bytes,5,opt,name=provider_client_state,json=providerClientState,proto3" json:"provider_client_state,omitempty"`
	// ProviderConsensusState filled in on new chain, nil on restart.
	ProviderConsensusState *_07_tendermint.ConsensusState `protobuf:"bytes,6,opt,name=provider_consensus_state,json=providerConsensusState,proto3" json:"provider_consensus_state,omitempty"`
	// MaturingPackets nil on new chain, filled in on restart.
	MaturingPackets []MaturingVSCPacket `protobuf:"bytes,7,rep,name=maturing_packets,json=maturingPackets,proto3" json:"maturing_packets"`
	// InitialValset filled in on new chain and on restart.
	InitialValSet []types.ValidatorUpdate `protobuf:"bytes,8,rep,name=initial_val_set,json=initialValSet,proto3" json:"initial_val_set"`
	// HeightToValsetUpdateId nil on new chain, filled in on restart.
	HeightToValsetUpdateId []HeightToValsetUpdateID `protobuf:"bytes,9,rep,name=height_to_valset_update_id,json=heightToValsetUpdateId,proto3" json:"height_to_valset_update_id"`
	// OutstandingDowntimes nil on new chain, filled  in on restart.
	OutstandingDowntimeSlashing []OutstandingDowntime `protobuf:"bytes,10,rep,name=outstanding_downtime_slashing,json=outstandingDowntimeSlashing,proto3" json:"outstanding_downtime_slashing"`
	// PendingConsumerPackets nil on new chain, filled in on restart.
	PendingConsumerPackets ConsumerPacketDataList `protobuf:"bytes,11,opt,name=pending_consumer_packets,json=pendingConsumerPackets,proto3" json:"pending_consumer_packets"`
	// LastTransmissionBlockHeight nil on new chain, filled in on restart.
	LastTransmissionBlockHeight LastTransmissionBlockHeight `protobuf:"bytes,12,opt,name=last_transmission_block_height,json=lastTransmissionBlockHeight,proto3" json:"last_transmission_block_height"`
	PreCCV                      bool                        `protobuf:"varint,13,opt,name=preCCV,proto3" json:"preCCV,omitempty"`
}

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

var xxx_messageInfo_ConsumerGenesisState proto.InternalMessageInfo

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

func (m *ConsumerGenesisState) GetProviderClientId() string {
	if m != nil {
		return m.ProviderClientId
	}
	return ""
}

func (m *ConsumerGenesisState) GetProviderChannelId() string {
	if m != nil {
		return m.ProviderChannelId
	}
	return ""
}

func (m *ConsumerGenesisState) GetNewChain() bool {
	if m != nil {
		return m.NewChain
	}
	return false
}

func (m *ConsumerGenesisState) GetProviderClientState() *_07_tendermint.ClientState {
	if m != nil {
		return m.ProviderClientState
	}
	return nil
}

func (m *ConsumerGenesisState) GetProviderConsensusState() *_07_tendermint.ConsensusState {
	if m != nil {
		return m.ProviderConsensusState
	}
	return nil
}

func (m *ConsumerGenesisState) GetMaturingPackets() []MaturingVSCPacket {
	if m != nil {
		return m.MaturingPackets
	}
	return nil
}

func (m *ConsumerGenesisState) GetInitialValSet() []types.ValidatorUpdate {
	if m != nil {
		return m.InitialValSet
	}
	return nil
}

func (m *ConsumerGenesisState) GetHeightToValsetUpdateId() []HeightToValsetUpdateID {
	if m != nil {
		return m.HeightToValsetUpdateId
	}
	return nil
}

func (m *ConsumerGenesisState) GetOutstandingDowntimeSlashing() []OutstandingDowntime {
	if m != nil {
		return m.OutstandingDowntimeSlashing
	}
	return nil
}

func (m *ConsumerGenesisState) GetPendingConsumerPackets() ConsumerPacketDataList {
	if m != nil {
		return m.PendingConsumerPackets
	}
	return ConsumerPacketDataList{}
}

func (m *ConsumerGenesisState) GetLastTransmissionBlockHeight() LastTransmissionBlockHeight {
	if m != nil {
		return m.LastTransmissionBlockHeight
	}
	return LastTransmissionBlockHeight{}
}

func (m *ConsumerGenesisState) GetPreCCV() bool {
	if m != nil {
		return m.PreCCV
	}
	return false
}

// HeightValsetUpdateID represents a mapping internal to the consumer CCV module
// AND used in shared consumer genesis state, which links a block height to each recv valset update id.
type HeightToValsetUpdateID struct {
	Height         uint64 `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"`
	ValsetUpdateId uint64 `protobuf:"varint,2,opt,name=valset_update_id,json=valsetUpdateId,proto3" json:"valset_update_id,omitempty"`
}

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

var xxx_messageInfo_HeightToValsetUpdateID proto.InternalMessageInfo

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

func (m *HeightToValsetUpdateID) GetValsetUpdateId() uint64 {
	if m != nil {
		return m.ValsetUpdateId
	}
	return 0
}

// OutstandingDowntime defines the type used internally to the consumer CCV module,
// AND used in shared consumer genesis state, in order to not send multiple slashing
// requests for the same downtime infraction.
type OutstandingDowntime struct {
	ValidatorConsensusAddress string `protobuf:"bytes,1,opt,name=validator_consensus_address,json=validatorConsensusAddress,proto3" json:"validator_consensus_address,omitempty"`
}

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

var xxx_messageInfo_OutstandingDowntime proto.InternalMessageInfo

func (m *OutstandingDowntime) GetValidatorConsensusAddress() string {
	if m != nil {
		return m.ValidatorConsensusAddress
	}
	return ""
}

// LastTransmissionBlockHeight is the last time validator holding
// pools were transmitted to the provider chain. This type is used internally
// to the consumer CCV module AND used in shared consumer genesis state.
type LastTransmissionBlockHeight struct {
	Height int64 `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"`
}

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

var xxx_messageInfo_LastTransmissionBlockHeight proto.InternalMessageInfo

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

// MaturingVSCPacket represents a vsc packet that is maturing internal to the
// consumer CCV module, where the consumer has not yet relayed a VSCMatured packet
// back to the provider.  This type is used internally to the consumer CCV module
// AND used in shared consumer genesis state.
type MaturingVSCPacket struct {
	VscId        uint64    `protobuf:"varint,1,opt,name=vscId,proto3" json:"vscId,omitempty"`
	MaturityTime time.Time `protobuf:"bytes,2,opt,name=maturity_time,json=maturityTime,proto3,stdtime" json:"maturity_time"`
}

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

var xxx_messageInfo_MaturingVSCPacket proto.InternalMessageInfo

func (m *MaturingVSCPacket) GetVscId() uint64 {
	if m != nil {
		return m.VscId
	}
	return 0
}

func (m *MaturingVSCPacket) GetMaturityTime() time.Time {
	if m != nil {
		return m.MaturityTime
	}
	return time.Time{}
}

// ConsumerPacketDataList is a list of consumer packet data packets.
//
// Note this type is is used internally to the consumer CCV module
// for exporting / importing state in InitGenesis and ExportGenesis,
// AND included in the consumer genesis type (reffed by provider and consumer modules),
// hence this is a shared type.
type ConsumerPacketDataList struct {
	List []ConsumerPacketData `protobuf:"bytes,1,rep,name=list,proto3" json:"list"`
}

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

var xxx_messageInfo_ConsumerPacketDataList proto.InternalMessageInfo

func (m *ConsumerPacketDataList) GetList() []ConsumerPacketData {
	if m != nil {
		return m.List
	}
	return nil
}

func init() {
	proto.RegisterType((*ConsumerParams)(nil), "interchain_security.ccv.v1.ConsumerParams")
	proto.RegisterType((*ConsumerGenesisState)(nil), "interchain_security.ccv.v1.ConsumerGenesisState")
	proto.RegisterType((*HeightToValsetUpdateID)(nil), "interchain_security.ccv.v1.HeightToValsetUpdateID")
	proto.RegisterType((*OutstandingDowntime)(nil), "interchain_security.ccv.v1.OutstandingDowntime")
	proto.RegisterType((*LastTransmissionBlockHeight)(nil), "interchain_security.ccv.v1.LastTransmissionBlockHeight")
	proto.RegisterType((*MaturingVSCPacket)(nil), "interchain_security.ccv.v1.MaturingVSCPacket")
	proto.RegisterType((*ConsumerPacketDataList)(nil), "interchain_security.ccv.v1.ConsumerPacketDataList")
}

func init() {
	proto.RegisterFile("interchain_security/ccv/v1/shared_consumer.proto", fileDescriptor_d0a8be0efc64dfbc)
}

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

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

func (m *ConsumerParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ProviderRewardDenoms) > 0 {
		for iNdEx := len(m.ProviderRewardDenoms) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.ProviderRewardDenoms[iNdEx])
			copy(dAtA[i:], m.ProviderRewardDenoms[iNdEx])
			i = encodeVarintSharedConsumer(dAtA, i, uint64(len(m.ProviderRewardDenoms[iNdEx])))
			i--
			dAtA[i] = 0x62
		}
	}
	if len(m.RewardDenoms) > 0 {
		for iNdEx := len(m.RewardDenoms) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.RewardDenoms[iNdEx])
			copy(dAtA[i:], m.RewardDenoms[iNdEx])
			i = encodeVarintSharedConsumer(dAtA, i, uint64(len(m.RewardDenoms[iNdEx])))
			i--
			dAtA[i] = 0x5a
		}
	}
	if len(m.SoftOptOutThreshold) > 0 {
		i -= len(m.SoftOptOutThreshold)
		copy(dAtA[i:], m.SoftOptOutThreshold)
		i = encodeVarintSharedConsumer(dAtA, i, uint64(len(m.SoftOptOutThreshold)))
		i--
		dAtA[i] = 0x52
	}
	n1, err1 := github_com_cosmos_gogoproto_types.StdDurationMarshalTo(m.UnbondingPeriod, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdDuration(m.UnbondingPeriod):])
	if err1 != nil {
		return 0, err1
	}
	i -= n1
	i = encodeVarintSharedConsumer(dAtA, i, uint64(n1))
	i--
	dAtA[i] = 0x4a
	if m.HistoricalEntries != 0 {
		i = encodeVarintSharedConsumer(dAtA, i, uint64(m.HistoricalEntries))
		i--
		dAtA[i] = 0x40
	}
	if len(m.ConsumerRedistributionFraction) > 0 {
		i -= len(m.ConsumerRedistributionFraction)
		copy(dAtA[i:], m.ConsumerRedistributionFraction)
		i = encodeVarintSharedConsumer(dAtA, i, uint64(len(m.ConsumerRedistributionFraction)))
		i--
		dAtA[i] = 0x3a
	}
	n2, err2 := github_com_cosmos_gogoproto_types.StdDurationMarshalTo(m.TransferTimeoutPeriod, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdDuration(m.TransferTimeoutPeriod):])
	if err2 != nil {
		return 0, err2
	}
	i -= n2
	i = encodeVarintSharedConsumer(dAtA, i, uint64(n2))
	i--
	dAtA[i] = 0x32
	n3, err3 := github_com_cosmos_gogoproto_types.StdDurationMarshalTo(m.CcvTimeoutPeriod, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdDuration(m.CcvTimeoutPeriod):])
	if err3 != nil {
		return 0, err3
	}
	i -= n3
	i = encodeVarintSharedConsumer(dAtA, i, uint64(n3))
	i--
	dAtA[i] = 0x2a
	if len(m.ProviderFeePoolAddrStr) > 0 {
		i -= len(m.ProviderFeePoolAddrStr)
		copy(dAtA[i:], m.ProviderFeePoolAddrStr)
		i = encodeVarintSharedConsumer(dAtA, i, uint64(len(m.ProviderFeePoolAddrStr)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.DistributionTransmissionChannel) > 0 {
		i -= len(m.DistributionTransmissionChannel)
		copy(dAtA[i:], m.DistributionTransmissionChannel)
		i = encodeVarintSharedConsumer(dAtA, i, uint64(len(m.DistributionTransmissionChannel)))
		i--
		dAtA[i] = 0x1a
	}
	if m.BlocksPerDistributionTransmission != 0 {
		i = encodeVarintSharedConsumer(dAtA, i, uint64(m.BlocksPerDistributionTransmission))
		i--
		dAtA[i] = 0x10
	}
	if m.Enabled {
		i--
		if m.Enabled {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *ConsumerGenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.PreCCV {
		i--
		if m.PreCCV {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x68
	}
	{
		size, err := m.LastTransmissionBlockHeight.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintSharedConsumer(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x62
	{
		size, err := m.PendingConsumerPackets.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintSharedConsumer(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x5a
	if len(m.OutstandingDowntimeSlashing) > 0 {
		for iNdEx := len(m.OutstandingDowntimeSlashing) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.OutstandingDowntimeSlashing[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSharedConsumer(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x52
		}
	}
	if len(m.HeightToValsetUpdateId) > 0 {
		for iNdEx := len(m.HeightToValsetUpdateId) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.HeightToValsetUpdateId[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSharedConsumer(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x4a
		}
	}
	if len(m.InitialValSet) > 0 {
		for iNdEx := len(m.InitialValSet) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.InitialValSet[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSharedConsumer(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x42
		}
	}
	if len(m.MaturingPackets) > 0 {
		for iNdEx := len(m.MaturingPackets) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.MaturingPackets[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSharedConsumer(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3a
		}
	}
	if m.ProviderConsensusState != nil {
		{
			size, err := m.ProviderConsensusState.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSharedConsumer(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.ProviderClientState != nil {
		{
			size, err := m.ProviderClientState.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSharedConsumer(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.NewChain {
		i--
		if m.NewChain {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if len(m.ProviderChannelId) > 0 {
		i -= len(m.ProviderChannelId)
		copy(dAtA[i:], m.ProviderChannelId)
		i = encodeVarintSharedConsumer(dAtA, i, uint64(len(m.ProviderChannelId)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.ProviderClientId) > 0 {
		i -= len(m.ProviderClientId)
		copy(dAtA[i:], m.ProviderClientId)
		i = encodeVarintSharedConsumer(dAtA, i, uint64(len(m.ProviderClientId)))
		i--
		dAtA[i] = 0x12
	}
	{
		size, err := m.Params.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintSharedConsumer(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

func (m *MaturingVSCPacket) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	n9, err9 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.MaturityTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.MaturityTime):])
	if err9 != nil {
		return 0, err9
	}
	i -= n9
	i = encodeVarintSharedConsumer(dAtA, i, uint64(n9))
	i--
	dAtA[i] = 0x12
	if m.VscId != 0 {
		i = encodeVarintSharedConsumer(dAtA, i, uint64(m.VscId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func encodeVarintSharedConsumer(dAtA []byte, offset int, v uint64) int {
	offset -= sovSharedConsumer(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *ConsumerParams) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Enabled {
		n += 2
	}
	if m.BlocksPerDistributionTransmission != 0 {
		n += 1 + sovSharedConsumer(uint64(m.BlocksPerDistributionTransmission))
	}
	l = len(m.DistributionTransmissionChannel)
	if l > 0 {
		n += 1 + l + sovSharedConsumer(uint64(l))
	}
	l = len(m.ProviderFeePoolAddrStr)
	if l > 0 {
		n += 1 + l + sovSharedConsumer(uint64(l))
	}
	l = github_com_cosmos_gogoproto_types.SizeOfStdDuration(m.CcvTimeoutPeriod)
	n += 1 + l + sovSharedConsumer(uint64(l))
	l = github_com_cosmos_gogoproto_types.SizeOfStdDuration(m.TransferTimeoutPeriod)
	n += 1 + l + sovSharedConsumer(uint64(l))
	l = len(m.ConsumerRedistributionFraction)
	if l > 0 {
		n += 1 + l + sovSharedConsumer(uint64(l))
	}
	if m.HistoricalEntries != 0 {
		n += 1 + sovSharedConsumer(uint64(m.HistoricalEntries))
	}
	l = github_com_cosmos_gogoproto_types.SizeOfStdDuration(m.UnbondingPeriod)
	n += 1 + l + sovSharedConsumer(uint64(l))
	l = len(m.SoftOptOutThreshold)
	if l > 0 {
		n += 1 + l + sovSharedConsumer(uint64(l))
	}
	if len(m.RewardDenoms) > 0 {
		for _, s := range m.RewardDenoms {
			l = len(s)
			n += 1 + l + sovSharedConsumer(uint64(l))
		}
	}
	if len(m.ProviderRewardDenoms) > 0 {
		for _, s := range m.ProviderRewardDenoms {
			l = len(s)
			n += 1 + l + sovSharedConsumer(uint64(l))
		}
	}
	return n
}

func (m *ConsumerGenesisState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Params.Size()
	n += 1 + l + sovSharedConsumer(uint64(l))
	l = len(m.ProviderClientId)
	if l > 0 {
		n += 1 + l + sovSharedConsumer(uint64(l))
	}
	l = len(m.ProviderChannelId)
	if l > 0 {
		n += 1 + l + sovSharedConsumer(uint64(l))
	}
	if m.NewChain {
		n += 2
	}
	if m.ProviderClientState != nil {
		l = m.ProviderClientState.Size()
		n += 1 + l + sovSharedConsumer(uint64(l))
	}
	if m.ProviderConsensusState != nil {
		l = m.ProviderConsensusState.Size()
		n += 1 + l + sovSharedConsumer(uint64(l))
	}
	if len(m.MaturingPackets) > 0 {
		for _, e := range m.MaturingPackets {
			l = e.Size()
			n += 1 + l + sovSharedConsumer(uint64(l))
		}
	}
	if len(m.InitialValSet) > 0 {
		for _, e := range m.InitialValSet {
			l = e.Size()
			n += 1 + l + sovSharedConsumer(uint64(l))
		}
	}
	if len(m.HeightToValsetUpdateId) > 0 {
		for _, e := range m.HeightToValsetUpdateId {
			l = e.Size()
			n += 1 + l + sovSharedConsumer(uint64(l))
		}
	}
	if len(m.OutstandingDowntimeSlashing) > 0 {
		for _, e := range m.OutstandingDowntimeSlashing {
			l = e.Size()
			n += 1 + l + sovSharedConsumer(uint64(l))
		}
	}
	l = m.PendingConsumerPackets.Size()
	n += 1 + l + sovSharedConsumer(uint64(l))
	l = m.LastTransmissionBlockHeight.Size()
	n += 1 + l + sovSharedConsumer(uint64(l))
	if m.PreCCV {
		n += 2
	}
	return n
}

func (m *HeightToValsetUpdateID) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Height != 0 {
		n += 1 + sovSharedConsumer(uint64(m.Height))
	}
	if m.ValsetUpdateId != 0 {
		n += 1 + sovSharedConsumer(uint64(m.ValsetUpdateId))
	}
	return n
}

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

func (m *LastTransmissionBlockHeight) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Height != 0 {
		n += 1 + sovSharedConsumer(uint64(m.Height))
	}
	return n
}

func (m *MaturingVSCPacket) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.VscId != 0 {
		n += 1 + sovSharedConsumer(uint64(m.VscId))
	}
	l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.MaturityTime)
	n += 1 + l + sovSharedConsumer(uint64(l))
	return n
}

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

func sovSharedConsumer(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozSharedConsumer(x uint64) (n int) {
	return sovSharedConsumer(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *ConsumerParams) 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 ErrIntOverflowSharedConsumer
			}
			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: ConsumerParams: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ConsumerParams: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowSharedConsumer
				}
				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 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlocksPerDistributionTransmission", wireType)
			}
			m.BlocksPerDistributionTransmission = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSharedConsumer
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BlocksPerDistributionTransmission |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DistributionTransmissionChannel", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSharedConsumer
				}
				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 ErrInvalidLengthSharedConsumer
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSharedConsumer
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DistributionTransmissionChannel = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProviderFeePoolAddrStr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSharedConsumer
				}
				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 ErrInvalidLengthSharedConsumer
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSharedConsumer
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ProviderFeePoolAddrStr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CcvTimeoutPeriod", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSharedConsumer
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSharedConsumer
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSharedConsumer
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_cosmos_gogoproto_types.StdDurationUnmarshal(&m.CcvTimeoutPeriod, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TransferTimeoutPeriod", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSharedConsumer
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSharedConsumer
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSharedConsumer
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_cosmos_gogoproto_types.StdDurationUnmarshal(&m.TransferTimeoutPeriod, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConsumerRedistributionFraction", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSharedConsumer
				}
				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 ErrInvalidLengthSharedConsumer
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSharedConsumer
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ConsumerRedistributionFraction = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field HistoricalEntries", wireType)
			}
			m.HistoricalEntries = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSharedConsumer
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.HistoricalEntries |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UnbondingPeriod", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSharedConsumer
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSharedConsumer
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSharedConsumer
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_cosmos_gogoproto_types.StdDurationUnmarshal(&m.UnbondingPeriod, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SoftOptOutThreshold", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSharedConsumer
				}
				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 ErrInvalidLengthSharedConsumer
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSharedConsumer
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SoftOptOutThreshold = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RewardDenoms", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSharedConsumer
				}
				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 ErrInvalidLengthSharedConsumer
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSharedConsumer
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RewardDenoms = append(m.RewardDenoms, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProviderRewardDenoms", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSharedConsumer
				}
				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 ErrInvalidLengthSharedConsumer
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSharedConsumer
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ProviderRewardDenoms = append(m.ProviderRewardDenoms, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSharedConsumer(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSharedConsumer
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ConsumerGenesisState) 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 ErrIntOverflowSharedConsumer
			}
			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: ConsumerGenesisState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ConsumerGenesisState: 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 ErrIntOverflowSharedConsumer
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSharedConsumer
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSharedConsumer
			}
			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 ProviderClientId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSharedConsumer
				}
				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 ErrInvalidLengthSharedConsumer
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSharedConsumer
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ProviderClientId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProviderChannelId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSharedConsumer
				}
				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 ErrInvalidLengthSharedConsumer
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSharedConsumer
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ProviderChannelId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NewChain", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSharedConsumer
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.NewChain = bool(v != 0)
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProviderClientState", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSharedConsumer
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSharedConsumer
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSharedConsumer
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ProviderClientState == nil {
				m.ProviderClientState = &_07_tendermint.ClientState{}
			}
			if err := m.ProviderClientState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProviderConsensusState", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSharedConsumer
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSharedConsumer
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSharedConsumer
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ProviderConsensusState == nil {
				m.ProviderConsensusState = &_07_tendermint.ConsensusState{}
			}
			if err := m.ProviderConsensusState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaturingPackets", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSharedConsumer
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSharedConsumer
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSharedConsumer
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MaturingPackets = append(m.MaturingPackets, MaturingVSCPacket{})
			if err := m.MaturingPackets[len(m.MaturingPackets)-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 InitialValSet", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSharedConsumer
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSharedConsumer
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSharedConsumer
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.InitialValSet = append(m.InitialValSet, types.ValidatorUpdate{})
			if err := m.InitialValSet[len(m.InitialValSet)-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 HeightToValsetUpdateId", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSharedConsumer
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSharedConsumer
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSharedConsumer
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.HeightToValsetUpdateId = append(m.HeightToValsetUpdateId, HeightToValsetUpdateID{})
			if err := m.HeightToValsetUpdateId[len(m.HeightToValsetUpdateId)-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 OutstandingDowntimeSlashing", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSharedConsumer
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSharedConsumer
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSharedConsumer
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OutstandingDowntimeSlashing = append(m.OutstandingDowntimeSlashing, OutstandingDowntime{})
			if err := m.OutstandingDowntimeSlashing[len(m.OutstandingDowntimeSlashing)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PendingConsumerPackets", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSharedConsumer
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSharedConsumer
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSharedConsumer
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.PendingConsumerPackets.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastTransmissionBlockHeight", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSharedConsumer
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSharedConsumer
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSharedConsumer
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.LastTransmissionBlockHeight.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PreCCV", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSharedConsumer
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.PreCCV = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipSharedConsumer(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSharedConsumer
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HeightToValsetUpdateID) 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 ErrIntOverflowSharedConsumer
			}
			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: HeightToValsetUpdateID: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HeightToValsetUpdateID: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowSharedConsumer
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Height |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValsetUpdateId", wireType)
			}
			m.ValsetUpdateId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSharedConsumer
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ValsetUpdateId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipSharedConsumer(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSharedConsumer
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *OutstandingDowntime) 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 ErrIntOverflowSharedConsumer
			}
			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: OutstandingDowntime: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OutstandingDowntime: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorConsensusAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSharedConsumer
				}
				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 ErrInvalidLengthSharedConsumer
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSharedConsumer
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ValidatorConsensusAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSharedConsumer(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSharedConsumer
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LastTransmissionBlockHeight) 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 ErrIntOverflowSharedConsumer
			}
			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: LastTransmissionBlockHeight: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LastTransmissionBlockHeight: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowSharedConsumer
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Height |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipSharedConsumer(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSharedConsumer
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MaturingVSCPacket) 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 ErrIntOverflowSharedConsumer
			}
			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: MaturingVSCPacket: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MaturingVSCPacket: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field VscId", wireType)
			}
			m.VscId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSharedConsumer
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.VscId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaturityTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSharedConsumer
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSharedConsumer
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSharedConsumer
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.MaturityTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSharedConsumer(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSharedConsumer
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

var (
	ErrInvalidLengthSharedConsumer        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowSharedConsumer          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupSharedConsumer = fmt.Errorf("proto: unexpected end of group")
)