provider.pb.go

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

package types

import (
	fmt "fmt"
	types2 "github.com/cosmos/cosmos-sdk/types"
	types "github.com/cosmos/ibc-go/v4/modules/core/02-client/types"
	types1 "github.com/cosmos/ibc-go/v4/modules/light-clients/07-tendermint/types"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
	crypto "github.com/tendermint/tendermint/proto/tendermint/crypto"
	_ "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

// ConsumerAdditionProposal is a governance proposal on the provider chain to spawn a new consumer chain.
// If it passes, then all validators on the provider chain are expected to validate the consumer chain at spawn time
// or get slashed. It is recommended that spawn time occurs after the proposal end time.
type ConsumerAdditionProposal struct {
	// the title of the proposal
	Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"`
	// the description of the proposal
	Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
	// the proposed chain-id of the new consumer chain, must be different from all other consumer chain ids of the executing
	// provider chain.
	ChainId string `protobuf:"bytes,3,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
	// the proposed initial height of new consumer chain.
	// For a completely new chain, this will be {0,1}. However, it may be different if this is a chain that is converting to a consumer chain.
	InitialHeight types.Height `protobuf:"bytes,4,opt,name=initial_height,json=initialHeight,proto3" json:"initial_height"`
	// The hash of the consumer chain genesis state without the consumer CCV module genesis params.
	// It is used for off-chain confirmation of genesis.json validity by validators and other parties.
	GenesisHash []byte `protobuf:"bytes,5,opt,name=genesis_hash,json=genesisHash,proto3" json:"genesis_hash,omitempty"`
	// The hash of the consumer chain binary that should be run by validators on chain initialization.
	// It is used for off-chain confirmation of binary validity by validators and other parties.
	BinaryHash []byte `protobuf:"bytes,6,opt,name=binary_hash,json=binaryHash,proto3" json:"binary_hash,omitempty"`
	// spawn time is the time on the provider chain at which the consumer chain genesis is finalized and all validators
	// will be responsible for starting their consumer chain validator node.
	SpawnTime time.Time `protobuf:"bytes,7,opt,name=spawn_time,json=spawnTime,proto3,stdtime" json:"spawn_time"`
	// Unbonding period for the consumer,
	// which should be smaller than that of the provider in general.
	UnbondingPeriod time.Duration `protobuf:"bytes,8,opt,name=unbonding_period,json=unbondingPeriod,proto3,stdduration" json:"unbonding_period"`
	// Sent CCV related IBC packets will timeout after this duration
	CcvTimeoutPeriod time.Duration `protobuf:"bytes,9,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,10,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,11,opt,name=consumer_redistribution_fraction,json=consumerRedistributionFraction,proto3" json:"consumer_redistribution_fraction,omitempty"`
	// BlocksPerDistributionTransmission is the number of blocks between ibc-token-transfers from the consumer chain to the provider chain.
	// On sending transmission event, `consumer_redistribution_fraction` of the accumulated tokens are sent to the consumer redistribution address.
	BlocksPerDistributionTransmission int64 `protobuf:"varint,12,opt,name=blocks_per_distribution_transmission,json=blocksPerDistributionTransmission,proto3" json:"blocks_per_distribution_transmission,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,13,opt,name=historical_entries,json=historicalEntries,proto3" json:"historical_entries,omitempty"`
	// The ID of a token transfer channel used for the Reward Distribution
	// sub-protocol. If DistributionTransmissionChannel == "", a new transfer
	// channel is created on top of the same connection as the CCV channel.
	// Note that transfer_channel_id is the ID of the channel end on the consumer chain.
	// it is most relevant for chains performing a sovereign to consumer changeover
	// in order to maintan the existing ibc transfer channel
	DistributionTransmissionChannel string `protobuf:"bytes,14,opt,name=distribution_transmission_channel,json=distributionTransmissionChannel,proto3" json:"distribution_transmission_channel,omitempty"`
}

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

var xxx_messageInfo_ConsumerAdditionProposal proto.InternalMessageInfo

// ConsumerRemovalProposal is a governance proposal on the provider chain to remove (and stop) a consumer chain.
// If it passes, all the consumer chain's state is removed from the provider chain. The outstanding unbonding
// operation funds are released.
type ConsumerRemovalProposal struct {
	// the title of the proposal
	Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"`
	// the description of the proposal
	Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
	// the chain-id of the consumer chain to be stopped
	ChainId string `protobuf:"bytes,3,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
	// the time on the provider chain at which all validators are responsible to stop their consumer chain validator node
	StopTime time.Time `protobuf:"bytes,4,opt,name=stop_time,json=stopTime,proto3,stdtime" json:"stop_time"`
}

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

var xxx_messageInfo_ConsumerRemovalProposal proto.InternalMessageInfo

func (m *ConsumerRemovalProposal) GetTitle() string {
	if m != nil {
		return m.Title
	}
	return ""
}

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

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

func (m *ConsumerRemovalProposal) GetStopTime() time.Time {
	if m != nil {
		return m.StopTime
	}
	return time.Time{}
}

// ChangeRewardDenomsProposal is a governance proposal on the provider chain to
// mutate the set of denoms accepted by the provider as rewards.
type ChangeRewardDenomsProposal struct {
	// the title of the proposal
	Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"`
	// the description of the proposal
	Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
	// the list of consumer reward denoms to add
	DenomsToAdd []string `protobuf:"bytes,3,rep,name=denoms_to_add,json=denomsToAdd,proto3" json:"denoms_to_add,omitempty"`
	// the list of consumer reward denoms to remove
	DenomsToRemove []string `protobuf:"bytes,4,rep,name=denoms_to_remove,json=denomsToRemove,proto3" json:"denoms_to_remove,omitempty"`
}

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

var xxx_messageInfo_ChangeRewardDenomsProposal proto.InternalMessageInfo

func (m *ChangeRewardDenomsProposal) GetTitle() string {
	if m != nil {
		return m.Title
	}
	return ""
}

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

func (m *ChangeRewardDenomsProposal) GetDenomsToAdd() []string {
	if m != nil {
		return m.DenomsToAdd
	}
	return nil
}

func (m *ChangeRewardDenomsProposal) GetDenomsToRemove() []string {
	if m != nil {
		return m.DenomsToRemove
	}
	return nil
}

// A persisted queue entry indicating that a slash packet data instance needs to be handled.
// This type belongs in the "global" queue, to coordinate slash packet handling times between consumers.
type GlobalSlashEntry struct {
	// Block time that slash packet was received by provider chain.
	// This field is used for store key iteration ordering.
	RecvTime time.Time `protobuf:"bytes,1,opt,name=recv_time,json=recvTime,proto3,stdtime" json:"recv_time"`
	// The consumer that sent a slash packet.
	ConsumerChainID string `protobuf:"bytes,2,opt,name=consumer_chain_id,json=consumerChainId,proto3" json:"consumer_chain_id,omitempty"`
	// The IBC sequence number of the recv packet.
	// This field is used in the store key to ensure uniqueness.
	IbcSeqNum uint64 `protobuf:"varint,3,opt,name=ibc_seq_num,json=ibcSeqNum,proto3" json:"ibc_seq_num,omitempty"`
	// The provider's consensus address of the validator being slashed.
	// This field is used to obtain validator power in HandleThrottleQueues.
	//
	// This field is not used in the store key, but is persisted in value bytes, see QueueGlobalSlashEntry.
	ProviderValConsAddr []byte `protobuf:"bytes,4,opt,name=provider_val_cons_addr,json=providerValConsAddr,proto3" json:"provider_val_cons_addr,omitempty"`
}

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

var xxx_messageInfo_GlobalSlashEntry proto.InternalMessageInfo

func (m *GlobalSlashEntry) GetRecvTime() time.Time {
	if m != nil {
		return m.RecvTime
	}
	return time.Time{}
}

func (m *GlobalSlashEntry) GetConsumerChainID() string {
	if m != nil {
		return m.ConsumerChainID
	}
	return ""
}

func (m *GlobalSlashEntry) GetIbcSeqNum() uint64 {
	if m != nil {
		return m.IbcSeqNum
	}
	return 0
}

func (m *GlobalSlashEntry) GetProviderValConsAddr() []byte {
	if m != nil {
		return m.ProviderValConsAddr
	}
	return nil
}

// Params defines the parameters for CCV Provider module
type Params struct {
	TemplateClient *types1.ClientState `protobuf:"bytes,1,opt,name=template_client,json=templateClient,proto3" json:"template_client,omitempty"`
	// TrustingPeriodFraction is used to compute the consumer and provider IBC client's TrustingPeriod from the chain defined UnbondingPeriod
	TrustingPeriodFraction string `protobuf:"bytes,2,opt,name=trusting_period_fraction,json=trustingPeriodFraction,proto3" json:"trusting_period_fraction,omitempty"`
	// Sent IBC packets will timeout after this duration
	CcvTimeoutPeriod time.Duration `protobuf:"bytes,3,opt,name=ccv_timeout_period,json=ccvTimeoutPeriod,proto3,stdduration" json:"ccv_timeout_period"`
	// The channel initialization (IBC channel opening handshake) will timeout after this duration
	InitTimeoutPeriod time.Duration `protobuf:"bytes,4,opt,name=init_timeout_period,json=initTimeoutPeriod,proto3,stdduration" json:"init_timeout_period"`
	// The VSC packets sent by the provider will timeout after this duration.
	// Note that unlike ccv_timeout_period which is an IBC param,
	// the vsc_timeout_period is a provider-side param that enables the provider
	// to timeout VSC packets even when a consumer chain is not live.
	VscTimeoutPeriod time.Duration `protobuf:"bytes,5,opt,name=vsc_timeout_period,json=vscTimeoutPeriod,proto3,stdduration" json:"vsc_timeout_period"`
	// The period for which the slash meter is replenished
	SlashMeterReplenishPeriod time.Duration `protobuf:"bytes,6,opt,name=slash_meter_replenish_period,json=slashMeterReplenishPeriod,proto3,stdduration" json:"slash_meter_replenish_period"`
	// The fraction of total voting power that is replenished to the slash meter every replenish period.
	// This param also serves as a maximum fraction of total voting power that the slash meter can hold.
	SlashMeterReplenishFraction string `protobuf:"bytes,7,opt,name=slash_meter_replenish_fraction,json=slashMeterReplenishFraction,proto3" json:"slash_meter_replenish_fraction,omitempty"`
	// The maximum amount of throttled slash or vsc matured packets
	// that can be queued for a single consumer before the provider chain halts.
	MaxThrottledPackets int64 `protobuf:"varint,8,opt,name=max_throttled_packets,json=maxThrottledPackets,proto3" json:"max_throttled_packets,omitempty"`
	// The fee required to be paid to add a reward denom
	ConsumerRewardDenomRegistrationFee types2.Coin `protobuf:"bytes,9,opt,name=consumer_reward_denom_registration_fee,json=consumerRewardDenomRegistrationFee,proto3" json:"consumer_reward_denom_registration_fee"`
}

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

var xxx_messageInfo_Params proto.InternalMessageInfo

func (m *Params) GetTemplateClient() *types1.ClientState {
	if m != nil {
		return m.TemplateClient
	}
	return nil
}

func (m *Params) GetTrustingPeriodFraction() string {
	if m != nil {
		return m.TrustingPeriodFraction
	}
	return ""
}

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

func (m *Params) GetInitTimeoutPeriod() time.Duration {
	if m != nil {
		return m.InitTimeoutPeriod
	}
	return 0
}

func (m *Params) GetVscTimeoutPeriod() time.Duration {
	if m != nil {
		return m.VscTimeoutPeriod
	}
	return 0
}

func (m *Params) GetSlashMeterReplenishPeriod() time.Duration {
	if m != nil {
		return m.SlashMeterReplenishPeriod
	}
	return 0
}

func (m *Params) GetSlashMeterReplenishFraction() string {
	if m != nil {
		return m.SlashMeterReplenishFraction
	}
	return ""
}

func (m *Params) GetMaxThrottledPackets() int64 {
	if m != nil {
		return m.MaxThrottledPackets
	}
	return 0
}

func (m *Params) GetConsumerRewardDenomRegistrationFee() types2.Coin {
	if m != nil {
		return m.ConsumerRewardDenomRegistrationFee
	}
	return types2.Coin{}
}

type HandshakeMetadata struct {
	ProviderFeePoolAddr string `protobuf:"bytes,1,opt,name=provider_fee_pool_addr,json=providerFeePoolAddr,proto3" json:"provider_fee_pool_addr,omitempty"`
	Version             string `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"`
}

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

var xxx_messageInfo_HandshakeMetadata proto.InternalMessageInfo

func (m *HandshakeMetadata) GetProviderFeePoolAddr() string {
	if m != nil {
		return m.ProviderFeePoolAddr
	}
	return ""
}

func (m *HandshakeMetadata) GetVersion() string {
	if m != nil {
		return m.Version
	}
	return ""
}

// SlashAcks contains cons addresses of consumer chain validators
// successfully slashed on the provider chain
type SlashAcks struct {
	Addresses []string `protobuf:"bytes,1,rep,name=addresses,proto3" json:"addresses,omitempty"`
}

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

var xxx_messageInfo_SlashAcks proto.InternalMessageInfo

func (m *SlashAcks) GetAddresses() []string {
	if m != nil {
		return m.Addresses
	}
	return nil
}

// ConsumerAdditionProposals holds pending governance proposals on the provider chain to spawn a new chain.
type ConsumerAdditionProposals struct {
	// proposals waiting for spawn_time to pass
	Pending []*ConsumerAdditionProposal `protobuf:"bytes,1,rep,name=pending,proto3" json:"pending,omitempty"`
}

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

var xxx_messageInfo_ConsumerAdditionProposals proto.InternalMessageInfo

func (m *ConsumerAdditionProposals) GetPending() []*ConsumerAdditionProposal {
	if m != nil {
		return m.Pending
	}
	return nil
}

// ConsumerRemovalProposals holds pending governance proposals on the provider chain to remove (and stop) a consumer chain.
type ConsumerRemovalProposals struct {
	// proposals waiting for stop_time to pass
	Pending []*ConsumerRemovalProposal `protobuf:"bytes,1,rep,name=pending,proto3" json:"pending,omitempty"`
}

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

var xxx_messageInfo_ConsumerRemovalProposals proto.InternalMessageInfo

func (m *ConsumerRemovalProposals) GetPending() []*ConsumerRemovalProposal {
	if m != nil {
		return m.Pending
	}
	return nil
}

// AddressList contains a list of consensus addresses
type AddressList struct {
	Addresses [][]byte `protobuf:"bytes,1,rep,name=addresses,proto3" json:"addresses,omitempty"`
}

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

var xxx_messageInfo_AddressList proto.InternalMessageInfo

func (m *AddressList) GetAddresses() [][]byte {
	if m != nil {
		return m.Addresses
	}
	return nil
}

type ChannelToChain struct {
	ChannelId string `protobuf:"bytes,1,opt,name=channel_id,json=channelId,proto3" json:"channel_id,omitempty"`
	ChainId   string `protobuf:"bytes,2,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
}

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

var xxx_messageInfo_ChannelToChain proto.InternalMessageInfo

func (m *ChannelToChain) GetChannelId() string {
	if m != nil {
		return m.ChannelId
	}
	return ""
}

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

// VscUnbondingOps contains the IDs of unbonding operations that are waiting for
// at least one VSCMaturedPacket with vscID from a consumer chain
type VscUnbondingOps struct {
	VscId          uint64   `protobuf:"varint,1,opt,name=vsc_id,json=vscId,proto3" json:"vsc_id,omitempty"`
	UnbondingOpIds []uint64 `protobuf:"varint,2,rep,packed,name=unbonding_op_ids,json=unbondingOpIds,proto3" json:"unbonding_op_ids,omitempty"`
}

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

var xxx_messageInfo_VscUnbondingOps proto.InternalMessageInfo

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

func (m *VscUnbondingOps) GetUnbondingOpIds() []uint64 {
	if m != nil {
		return m.UnbondingOpIds
	}
	return nil
}

// UnbondingOp contains the ids of consumer chains that need to unbond before
// the unbonding operation with the given ID can unbond
type UnbondingOp struct {
	Id uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	// consumer chains that are still unbonding
	UnbondingConsumerChains []string `protobuf:"bytes,2,rep,name=unbonding_consumer_chains,json=unbondingConsumerChains,proto3" json:"unbonding_consumer_chains,omitempty"`
}

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

var xxx_messageInfo_UnbondingOp proto.InternalMessageInfo

func (m *UnbondingOp) GetId() uint64 {
	if m != nil {
		return m.Id
	}
	return 0
}

func (m *UnbondingOp) GetUnbondingConsumerChains() []string {
	if m != nil {
		return m.UnbondingConsumerChains
	}
	return nil
}

type InitTimeoutTimestamp struct {
	ChainId   string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
	Timestamp uint64 `protobuf:"varint,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
}

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

var xxx_messageInfo_InitTimeoutTimestamp proto.InternalMessageInfo

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

func (m *InitTimeoutTimestamp) GetTimestamp() uint64 {
	if m != nil {
		return m.Timestamp
	}
	return 0
}

type VscSendTimestamp struct {
	VscId     uint64    `protobuf:"varint,1,opt,name=vsc_id,json=vscId,proto3" json:"vsc_id,omitempty"`
	Timestamp time.Time `protobuf:"bytes,2,opt,name=timestamp,proto3,stdtime" json:"timestamp"`
}

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

var xxx_messageInfo_VscSendTimestamp proto.InternalMessageInfo

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

func (m *VscSendTimestamp) GetTimestamp() time.Time {
	if m != nil {
		return m.Timestamp
	}
	return time.Time{}
}

type KeyAssignmentReplacement struct {
	ProviderAddr []byte            `protobuf:"bytes,1,opt,name=provider_addr,json=providerAddr,proto3" json:"provider_addr,omitempty"`
	PrevCKey     *crypto.PublicKey `protobuf:"bytes,2,opt,name=prev_c_key,json=prevCKey,proto3" json:"prev_c_key,omitempty"`
	Power        int64             `protobuf:"varint,3,opt,name=power,proto3" json:"power,omitempty"`
}

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

var xxx_messageInfo_KeyAssignmentReplacement proto.InternalMessageInfo

func (m *KeyAssignmentReplacement) GetProviderAddr() []byte {
	if m != nil {
		return m.ProviderAddr
	}
	return nil
}

func (m *KeyAssignmentReplacement) GetPrevCKey() *crypto.PublicKey {
	if m != nil {
		return m.PrevCKey
	}
	return nil
}

func (m *KeyAssignmentReplacement) GetPower() int64 {
	if m != nil {
		return m.Power
	}
	return 0
}

// Used to serialize the ValidatorConsumerPubKey index from key assignment
// ValidatorConsumerPubKey: (chainID, providerAddr consAddr) -> consumerKey tmprotocrypto.PublicKey
type ValidatorConsumerPubKey struct {
	ChainId      string            `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
	ProviderAddr []byte            `protobuf:"bytes,2,opt,name=provider_addr,json=providerAddr,proto3" json:"provider_addr,omitempty"`
	ConsumerKey  *crypto.PublicKey `protobuf:"bytes,3,opt,name=consumer_key,json=consumerKey,proto3" json:"consumer_key,omitempty"`
}

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

var xxx_messageInfo_ValidatorConsumerPubKey proto.InternalMessageInfo

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

func (m *ValidatorConsumerPubKey) GetProviderAddr() []byte {
	if m != nil {
		return m.ProviderAddr
	}
	return nil
}

func (m *ValidatorConsumerPubKey) GetConsumerKey() *crypto.PublicKey {
	if m != nil {
		return m.ConsumerKey
	}
	return nil
}

// Used to serialize the ValidatorConsumerAddr index from key assignment
// ValidatorByConsumerAddr: (chainID, consumerAddr consAddr) -> providerAddr consAddr
type ValidatorByConsumerAddr struct {
	ChainId      string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
	ConsumerAddr []byte `protobuf:"bytes,2,opt,name=consumer_addr,json=consumerAddr,proto3" json:"consumer_addr,omitempty"`
	ProviderAddr []byte `protobuf:"bytes,3,opt,name=provider_addr,json=providerAddr,proto3" json:"provider_addr,omitempty"`
}

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

var xxx_messageInfo_ValidatorByConsumerAddr proto.InternalMessageInfo

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

func (m *ValidatorByConsumerAddr) GetConsumerAddr() []byte {
	if m != nil {
		return m.ConsumerAddr
	}
	return nil
}

func (m *ValidatorByConsumerAddr) GetProviderAddr() []byte {
	if m != nil {
		return m.ProviderAddr
	}
	return nil
}

// Used to serialize the ConsumerAddrsToPrune index from key assignment
// ConsumerAddrsToPrune: (chainID, vscID uint64) -> consumerAddrs AddressList
type ConsumerAddrsToPrune struct {
	ChainId       string       `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
	VscId         uint64       `protobuf:"varint,2,opt,name=vsc_id,json=vscId,proto3" json:"vsc_id,omitempty"`
	ConsumerAddrs *AddressList `protobuf:"bytes,3,opt,name=consumer_addrs,json=consumerAddrs,proto3" json:"consumer_addrs,omitempty"`
}

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

var xxx_messageInfo_ConsumerAddrsToPrune proto.InternalMessageInfo

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

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

func (m *ConsumerAddrsToPrune) GetConsumerAddrs() *AddressList {
	if m != nil {
		return m.ConsumerAddrs
	}
	return nil
}

func init() {
	proto.RegisterType((*ConsumerAdditionProposal)(nil), "interchain_security.ccv.provider.v1.ConsumerAdditionProposal")
	proto.RegisterType((*ConsumerRemovalProposal)(nil), "interchain_security.ccv.provider.v1.ConsumerRemovalProposal")
	proto.RegisterType((*ChangeRewardDenomsProposal)(nil), "interchain_security.ccv.provider.v1.ChangeRewardDenomsProposal")
	proto.RegisterType((*GlobalSlashEntry)(nil), "interchain_security.ccv.provider.v1.GlobalSlashEntry")
	proto.RegisterType((*Params)(nil), "interchain_security.ccv.provider.v1.Params")
	proto.RegisterType((*HandshakeMetadata)(nil), "interchain_security.ccv.provider.v1.HandshakeMetadata")
	proto.RegisterType((*SlashAcks)(nil), "interchain_security.ccv.provider.v1.SlashAcks")
	proto.RegisterType((*ConsumerAdditionProposals)(nil), "interchain_security.ccv.provider.v1.ConsumerAdditionProposals")
	proto.RegisterType((*ConsumerRemovalProposals)(nil), "interchain_security.ccv.provider.v1.ConsumerRemovalProposals")
	proto.RegisterType((*AddressList)(nil), "interchain_security.ccv.provider.v1.AddressList")
	proto.RegisterType((*ChannelToChain)(nil), "interchain_security.ccv.provider.v1.ChannelToChain")
	proto.RegisterType((*VscUnbondingOps)(nil), "interchain_security.ccv.provider.v1.VscUnbondingOps")
	proto.RegisterType((*UnbondingOp)(nil), "interchain_security.ccv.provider.v1.UnbondingOp")
	proto.RegisterType((*InitTimeoutTimestamp)(nil), "interchain_security.ccv.provider.v1.InitTimeoutTimestamp")
	proto.RegisterType((*VscSendTimestamp)(nil), "interchain_security.ccv.provider.v1.VscSendTimestamp")
	proto.RegisterType((*KeyAssignmentReplacement)(nil), "interchain_security.ccv.provider.v1.KeyAssignmentReplacement")
	proto.RegisterType((*ValidatorConsumerPubKey)(nil), "interchain_security.ccv.provider.v1.ValidatorConsumerPubKey")
	proto.RegisterType((*ValidatorByConsumerAddr)(nil), "interchain_security.ccv.provider.v1.ValidatorByConsumerAddr")
	proto.RegisterType((*ConsumerAddrsToPrune)(nil), "interchain_security.ccv.provider.v1.ConsumerAddrsToPrune")
}

func init() {
	proto.RegisterFile("interchain_security/ccv/provider/v1/provider.proto", fileDescriptor_f22ec409a72b7b72)
}

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

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

func (m *ConsumerAdditionProposal) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.DistributionTransmissionChannel) > 0 {
		i -= len(m.DistributionTransmissionChannel)
		copy(dAtA[i:], m.DistributionTransmissionChannel)
		i = encodeVarintProvider(dAtA, i, uint64(len(m.DistributionTransmissionChannel)))
		i--
		dAtA[i] = 0x72
	}
	if m.HistoricalEntries != 0 {
		i = encodeVarintProvider(dAtA, i, uint64(m.HistoricalEntries))
		i--
		dAtA[i] = 0x68
	}
	if m.BlocksPerDistributionTransmission != 0 {
		i = encodeVarintProvider(dAtA, i, uint64(m.BlocksPerDistributionTransmission))
		i--
		dAtA[i] = 0x60
	}
	if len(m.ConsumerRedistributionFraction) > 0 {
		i -= len(m.ConsumerRedistributionFraction)
		copy(dAtA[i:], m.ConsumerRedistributionFraction)
		i = encodeVarintProvider(dAtA, i, uint64(len(m.ConsumerRedistributionFraction)))
		i--
		dAtA[i] = 0x5a
	}
	n1, err1 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.TransferTimeoutPeriod, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.TransferTimeoutPeriod):])
	if err1 != nil {
		return 0, err1
	}
	i -= n1
	i = encodeVarintProvider(dAtA, i, uint64(n1))
	i--
	dAtA[i] = 0x52
	n2, err2 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.CcvTimeoutPeriod, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.CcvTimeoutPeriod):])
	if err2 != nil {
		return 0, err2
	}
	i -= n2
	i = encodeVarintProvider(dAtA, i, uint64(n2))
	i--
	dAtA[i] = 0x4a
	n3, err3 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.UnbondingPeriod, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.UnbondingPeriod):])
	if err3 != nil {
		return 0, err3
	}
	i -= n3
	i = encodeVarintProvider(dAtA, i, uint64(n3))
	i--
	dAtA[i] = 0x42
	n4, err4 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.SpawnTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.SpawnTime):])
	if err4 != nil {
		return 0, err4
	}
	i -= n4
	i = encodeVarintProvider(dAtA, i, uint64(n4))
	i--
	dAtA[i] = 0x3a
	if len(m.BinaryHash) > 0 {
		i -= len(m.BinaryHash)
		copy(dAtA[i:], m.BinaryHash)
		i = encodeVarintProvider(dAtA, i, uint64(len(m.BinaryHash)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.GenesisHash) > 0 {
		i -= len(m.GenesisHash)
		copy(dAtA[i:], m.GenesisHash)
		i = encodeVarintProvider(dAtA, i, uint64(len(m.GenesisHash)))
		i--
		dAtA[i] = 0x2a
	}
	{
		size, err := m.InitialHeight.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintProvider(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if len(m.ChainId) > 0 {
		i -= len(m.ChainId)
		copy(dAtA[i:], m.ChainId)
		i = encodeVarintProvider(dAtA, i, uint64(len(m.ChainId)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintProvider(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Title) > 0 {
		i -= len(m.Title)
		copy(dAtA[i:], m.Title)
		i = encodeVarintProvider(dAtA, i, uint64(len(m.Title)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *ConsumerRemovalProposal) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	n6, err6 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.StopTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.StopTime):])
	if err6 != nil {
		return 0, err6
	}
	i -= n6
	i = encodeVarintProvider(dAtA, i, uint64(n6))
	i--
	dAtA[i] = 0x22
	if len(m.ChainId) > 0 {
		i -= len(m.ChainId)
		copy(dAtA[i:], m.ChainId)
		i = encodeVarintProvider(dAtA, i, uint64(len(m.ChainId)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintProvider(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Title) > 0 {
		i -= len(m.Title)
		copy(dAtA[i:], m.Title)
		i = encodeVarintProvider(dAtA, i, uint64(len(m.Title)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *ChangeRewardDenomsProposal) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.DenomsToRemove) > 0 {
		for iNdEx := len(m.DenomsToRemove) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.DenomsToRemove[iNdEx])
			copy(dAtA[i:], m.DenomsToRemove[iNdEx])
			i = encodeVarintProvider(dAtA, i, uint64(len(m.DenomsToRemove[iNdEx])))
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.DenomsToAdd) > 0 {
		for iNdEx := len(m.DenomsToAdd) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.DenomsToAdd[iNdEx])
			copy(dAtA[i:], m.DenomsToAdd[iNdEx])
			i = encodeVarintProvider(dAtA, i, uint64(len(m.DenomsToAdd[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintProvider(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Title) > 0 {
		i -= len(m.Title)
		copy(dAtA[i:], m.Title)
		i = encodeVarintProvider(dAtA, i, uint64(len(m.Title)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *GlobalSlashEntry) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ProviderValConsAddr) > 0 {
		i -= len(m.ProviderValConsAddr)
		copy(dAtA[i:], m.ProviderValConsAddr)
		i = encodeVarintProvider(dAtA, i, uint64(len(m.ProviderValConsAddr)))
		i--
		dAtA[i] = 0x22
	}
	if m.IbcSeqNum != 0 {
		i = encodeVarintProvider(dAtA, i, uint64(m.IbcSeqNum))
		i--
		dAtA[i] = 0x18
	}
	if len(m.ConsumerChainID) > 0 {
		i -= len(m.ConsumerChainID)
		copy(dAtA[i:], m.ConsumerChainID)
		i = encodeVarintProvider(dAtA, i, uint64(len(m.ConsumerChainID)))
		i--
		dAtA[i] = 0x12
	}
	n7, err7 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.RecvTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.RecvTime):])
	if err7 != nil {
		return 0, err7
	}
	i -= n7
	i = encodeVarintProvider(dAtA, i, uint64(n7))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.ConsumerRewardDenomRegistrationFee.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintProvider(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x4a
	if m.MaxThrottledPackets != 0 {
		i = encodeVarintProvider(dAtA, i, uint64(m.MaxThrottledPackets))
		i--
		dAtA[i] = 0x40
	}
	if len(m.SlashMeterReplenishFraction) > 0 {
		i -= len(m.SlashMeterReplenishFraction)
		copy(dAtA[i:], m.SlashMeterReplenishFraction)
		i = encodeVarintProvider(dAtA, i, uint64(len(m.SlashMeterReplenishFraction)))
		i--
		dAtA[i] = 0x3a
	}
	n9, err9 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.SlashMeterReplenishPeriod, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.SlashMeterReplenishPeriod):])
	if err9 != nil {
		return 0, err9
	}
	i -= n9
	i = encodeVarintProvider(dAtA, i, uint64(n9))
	i--
	dAtA[i] = 0x32
	n10, err10 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.VscTimeoutPeriod, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.VscTimeoutPeriod):])
	if err10 != nil {
		return 0, err10
	}
	i -= n10
	i = encodeVarintProvider(dAtA, i, uint64(n10))
	i--
	dAtA[i] = 0x2a
	n11, err11 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.InitTimeoutPeriod, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.InitTimeoutPeriod):])
	if err11 != nil {
		return 0, err11
	}
	i -= n11
	i = encodeVarintProvider(dAtA, i, uint64(n11))
	i--
	dAtA[i] = 0x22
	n12, err12 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.CcvTimeoutPeriod, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.CcvTimeoutPeriod):])
	if err12 != nil {
		return 0, err12
	}
	i -= n12
	i = encodeVarintProvider(dAtA, i, uint64(n12))
	i--
	dAtA[i] = 0x1a
	if len(m.TrustingPeriodFraction) > 0 {
		i -= len(m.TrustingPeriodFraction)
		copy(dAtA[i:], m.TrustingPeriodFraction)
		i = encodeVarintProvider(dAtA, i, uint64(len(m.TrustingPeriodFraction)))
		i--
		dAtA[i] = 0x12
	}
	if m.TemplateClient != nil {
		{
			size, err := m.TemplateClient.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintProvider(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *SlashAcks) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Addresses) > 0 {
		for iNdEx := len(m.Addresses) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Addresses[iNdEx])
			copy(dAtA[i:], m.Addresses[iNdEx])
			i = encodeVarintProvider(dAtA, i, uint64(len(m.Addresses[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *AddressList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Addresses) > 0 {
		for iNdEx := len(m.Addresses) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Addresses[iNdEx])
			copy(dAtA[i:], m.Addresses[iNdEx])
			i = encodeVarintProvider(dAtA, i, uint64(len(m.Addresses[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *VscUnbondingOps) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.UnbondingOpIds) > 0 {
		dAtA15 := make([]byte, len(m.UnbondingOpIds)*10)
		var j14 int
		for _, num := range m.UnbondingOpIds {
			for num >= 1<<7 {
				dAtA15[j14] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j14++
			}
			dAtA15[j14] = uint8(num)
			j14++
		}
		i -= j14
		copy(dAtA[i:], dAtA15[:j14])
		i = encodeVarintProvider(dAtA, i, uint64(j14))
		i--
		dAtA[i] = 0x12
	}
	if m.VscId != 0 {
		i = encodeVarintProvider(dAtA, i, uint64(m.VscId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *UnbondingOp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.UnbondingConsumerChains) > 0 {
		for iNdEx := len(m.UnbondingConsumerChains) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.UnbondingConsumerChains[iNdEx])
			copy(dAtA[i:], m.UnbondingConsumerChains[iNdEx])
			i = encodeVarintProvider(dAtA, i, uint64(len(m.UnbondingConsumerChains[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if m.Id != 0 {
		i = encodeVarintProvider(dAtA, i, uint64(m.Id))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *VscSendTimestamp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	n16, err16 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Timestamp, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp):])
	if err16 != nil {
		return 0, err16
	}
	i -= n16
	i = encodeVarintProvider(dAtA, i, uint64(n16))
	i--
	dAtA[i] = 0x12
	if m.VscId != 0 {
		i = encodeVarintProvider(dAtA, i, uint64(m.VscId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *KeyAssignmentReplacement) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Power != 0 {
		i = encodeVarintProvider(dAtA, i, uint64(m.Power))
		i--
		dAtA[i] = 0x18
	}
	if m.PrevCKey != nil {
		{
			size, err := m.PrevCKey.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintProvider(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.ProviderAddr) > 0 {
		i -= len(m.ProviderAddr)
		copy(dAtA[i:], m.ProviderAddr)
		i = encodeVarintProvider(dAtA, i, uint64(len(m.ProviderAddr)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *ValidatorByConsumerAddr) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ProviderAddr) > 0 {
		i -= len(m.ProviderAddr)
		copy(dAtA[i:], m.ProviderAddr)
		i = encodeVarintProvider(dAtA, i, uint64(len(m.ProviderAddr)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.ConsumerAddr) > 0 {
		i -= len(m.ConsumerAddr)
		copy(dAtA[i:], m.ConsumerAddr)
		i = encodeVarintProvider(dAtA, i, uint64(len(m.ConsumerAddr)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ChainId) > 0 {
		i -= len(m.ChainId)
		copy(dAtA[i:], m.ChainId)
		i = encodeVarintProvider(dAtA, i, uint64(len(m.ChainId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *ConsumerAddrsToPrune) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ConsumerAddrs != nil {
		{
			size, err := m.ConsumerAddrs.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintProvider(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.VscId != 0 {
		i = encodeVarintProvider(dAtA, i, uint64(m.VscId))
		i--
		dAtA[i] = 0x10
	}
	if len(m.ChainId) > 0 {
		i -= len(m.ChainId)
		copy(dAtA[i:], m.ChainId)
		i = encodeVarintProvider(dAtA, i, uint64(len(m.ChainId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintProvider(dAtA []byte, offset int, v uint64) int {
	offset -= sovProvider(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *ConsumerAdditionProposal) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Title)
	if l > 0 {
		n += 1 + l + sovProvider(uint64(l))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovProvider(uint64(l))
	}
	l = len(m.ChainId)
	if l > 0 {
		n += 1 + l + sovProvider(uint64(l))
	}
	l = m.InitialHeight.Size()
	n += 1 + l + sovProvider(uint64(l))
	l = len(m.GenesisHash)
	if l > 0 {
		n += 1 + l + sovProvider(uint64(l))
	}
	l = len(m.BinaryHash)
	if l > 0 {
		n += 1 + l + sovProvider(uint64(l))
	}
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.SpawnTime)
	n += 1 + l + sovProvider(uint64(l))
	l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.UnbondingPeriod)
	n += 1 + l + sovProvider(uint64(l))
	l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.CcvTimeoutPeriod)
	n += 1 + l + sovProvider(uint64(l))
	l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.TransferTimeoutPeriod)
	n += 1 + l + sovProvider(uint64(l))
	l = len(m.ConsumerRedistributionFraction)
	if l > 0 {
		n += 1 + l + sovProvider(uint64(l))
	}
	if m.BlocksPerDistributionTransmission != 0 {
		n += 1 + sovProvider(uint64(m.BlocksPerDistributionTransmission))
	}
	if m.HistoricalEntries != 0 {
		n += 1 + sovProvider(uint64(m.HistoricalEntries))
	}
	l = len(m.DistributionTransmissionChannel)
	if l > 0 {
		n += 1 + l + sovProvider(uint64(l))
	}
	return n
}

func (m *ConsumerRemovalProposal) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Title)
	if l > 0 {
		n += 1 + l + sovProvider(uint64(l))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovProvider(uint64(l))
	}
	l = len(m.ChainId)
	if l > 0 {
		n += 1 + l + sovProvider(uint64(l))
	}
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.StopTime)
	n += 1 + l + sovProvider(uint64(l))
	return n
}

func (m *ChangeRewardDenomsProposal) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Title)
	if l > 0 {
		n += 1 + l + sovProvider(uint64(l))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovProvider(uint64(l))
	}
	if len(m.DenomsToAdd) > 0 {
		for _, s := range m.DenomsToAdd {
			l = len(s)
			n += 1 + l + sovProvider(uint64(l))
		}
	}
	if len(m.DenomsToRemove) > 0 {
		for _, s := range m.DenomsToRemove {
			l = len(s)
			n += 1 + l + sovProvider(uint64(l))
		}
	}
	return n
}

func (m *GlobalSlashEntry) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.RecvTime)
	n += 1 + l + sovProvider(uint64(l))
	l = len(m.ConsumerChainID)
	if l > 0 {
		n += 1 + l + sovProvider(uint64(l))
	}
	if m.IbcSeqNum != 0 {
		n += 1 + sovProvider(uint64(m.IbcSeqNum))
	}
	l = len(m.ProviderValConsAddr)
	if l > 0 {
		n += 1 + l + sovProvider(uint64(l))
	}
	return n
}

func (m *Params) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TemplateClient != nil {
		l = m.TemplateClient.Size()
		n += 1 + l + sovProvider(uint64(l))
	}
	l = len(m.TrustingPeriodFraction)
	if l > 0 {
		n += 1 + l + sovProvider(uint64(l))
	}
	l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.CcvTimeoutPeriod)
	n += 1 + l + sovProvider(uint64(l))
	l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.InitTimeoutPeriod)
	n += 1 + l + sovProvider(uint64(l))
	l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.VscTimeoutPeriod)
	n += 1 + l + sovProvider(uint64(l))
	l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.SlashMeterReplenishPeriod)
	n += 1 + l + sovProvider(uint64(l))
	l = len(m.SlashMeterReplenishFraction)
	if l > 0 {
		n += 1 + l + sovProvider(uint64(l))
	}
	if m.MaxThrottledPackets != 0 {
		n += 1 + sovProvider(uint64(m.MaxThrottledPackets))
	}
	l = m.ConsumerRewardDenomRegistrationFee.Size()
	n += 1 + l + sovProvider(uint64(l))
	return n
}

func (m *HandshakeMetadata) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ProviderFeePoolAddr)
	if l > 0 {
		n += 1 + l + sovProvider(uint64(l))
	}
	l = len(m.Version)
	if l > 0 {
		n += 1 + l + sovProvider(uint64(l))
	}
	return n
}

func (m *SlashAcks) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Addresses) > 0 {
		for _, s := range m.Addresses {
			l = len(s)
			n += 1 + l + sovProvider(uint64(l))
		}
	}
	return n
}

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

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

func (m *AddressList) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Addresses) > 0 {
		for _, b := range m.Addresses {
			l = len(b)
			n += 1 + l + sovProvider(uint64(l))
		}
	}
	return n
}

func (m *ChannelToChain) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ChannelId)
	if l > 0 {
		n += 1 + l + sovProvider(uint64(l))
	}
	l = len(m.ChainId)
	if l > 0 {
		n += 1 + l + sovProvider(uint64(l))
	}
	return n
}

func (m *VscUnbondingOps) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.VscId != 0 {
		n += 1 + sovProvider(uint64(m.VscId))
	}
	if len(m.UnbondingOpIds) > 0 {
		l = 0
		for _, e := range m.UnbondingOpIds {
			l += sovProvider(uint64(e))
		}
		n += 1 + sovProvider(uint64(l)) + l
	}
	return n
}

func (m *UnbondingOp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Id != 0 {
		n += 1 + sovProvider(uint64(m.Id))
	}
	if len(m.UnbondingConsumerChains) > 0 {
		for _, s := range m.UnbondingConsumerChains {
			l = len(s)
			n += 1 + l + sovProvider(uint64(l))
		}
	}
	return n
}

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

func (m *VscSendTimestamp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.VscId != 0 {
		n += 1 + sovProvider(uint64(m.VscId))
	}
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp)
	n += 1 + l + sovProvider(uint64(l))
	return n
}

func (m *KeyAssignmentReplacement) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ProviderAddr)
	if l > 0 {
		n += 1 + l + sovProvider(uint64(l))
	}
	if m.PrevCKey != nil {
		l = m.PrevCKey.Size()
		n += 1 + l + sovProvider(uint64(l))
	}
	if m.Power != 0 {
		n += 1 + sovProvider(uint64(m.Power))
	}
	return n
}

func (m *ValidatorConsumerPubKey) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ChainId)
	if l > 0 {
		n += 1 + l + sovProvider(uint64(l))
	}
	l = len(m.ProviderAddr)
	if l > 0 {
		n += 1 + l + sovProvider(uint64(l))
	}
	if m.ConsumerKey != nil {
		l = m.ConsumerKey.Size()
		n += 1 + l + sovProvider(uint64(l))
	}
	return n
}

func (m *ValidatorByConsumerAddr) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ChainId)
	if l > 0 {
		n += 1 + l + sovProvider(uint64(l))
	}
	l = len(m.ConsumerAddr)
	if l > 0 {
		n += 1 + l + sovProvider(uint64(l))
	}
	l = len(m.ProviderAddr)
	if l > 0 {
		n += 1 + l + sovProvider(uint64(l))
	}
	return n
}

func (m *ConsumerAddrsToPrune) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ChainId)
	if l > 0 {
		n += 1 + l + sovProvider(uint64(l))
	}
	if m.VscId != 0 {
		n += 1 + sovProvider(uint64(m.VscId))
	}
	if m.ConsumerAddrs != nil {
		l = m.ConsumerAddrs.Size()
		n += 1 + l + sovProvider(uint64(l))
	}
	return n
}

func sovProvider(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozProvider(x uint64) (n int) {
	return sovProvider(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *ConsumerAdditionProposal) 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 ErrIntOverflowProvider
			}
			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: ConsumerAdditionProposal: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ConsumerAdditionProposal: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProvider
				}
				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 ErrInvalidLengthProvider
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthProvider
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Title = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProvider
				}
				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 ErrInvalidLengthProvider
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthProvider
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProvider
				}
				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 ErrInvalidLengthProvider
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthProvider
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ChainId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InitialHeight", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProvider
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProvider
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProvider
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.InitialHeight.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GenesisHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProvider
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthProvider
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthProvider
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.GenesisHash = append(m.GenesisHash[:0], dAtA[iNdEx:postIndex]...)
			if m.GenesisHash == nil {
				m.GenesisHash = []byte{}
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BinaryHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProvider
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthProvider
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthProvider
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BinaryHash = append(m.BinaryHash[:0], dAtA[iNdEx:postIndex]...)
			if m.BinaryHash == nil {
				m.BinaryHash = []byte{}
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SpawnTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProvider
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProvider
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProvider
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.SpawnTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			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 ErrIntOverflowProvider
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProvider
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProvider
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.UnbondingPeriod, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			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 ErrIntOverflowProvider
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProvider
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProvider
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.CcvTimeoutPeriod, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			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 ErrIntOverflowProvider
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProvider
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProvider
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.TransferTimeoutPeriod, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			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 ErrIntOverflowProvider
				}
				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 ErrInvalidLengthProvider
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthProvider
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ConsumerRedistributionFraction = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 12:
			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 ErrIntOverflowProvider
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BlocksPerDistributionTransmission |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 13:
			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 ErrIntOverflowProvider
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.HistoricalEntries |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 14:
			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 ErrIntOverflowProvider
				}
				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 ErrInvalidLengthProvider
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthProvider
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DistributionTransmissionChannel = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipProvider(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthProvider
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ConsumerRemovalProposal) 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 ErrIntOverflowProvider
			}
			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: ConsumerRemovalProposal: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ConsumerRemovalProposal: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProvider
				}
				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 ErrInvalidLengthProvider
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthProvider
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Title = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProvider
				}
				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 ErrInvalidLengthProvider
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthProvider
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProvider
				}
				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 ErrInvalidLengthProvider
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthProvider
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ChainId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StopTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProvider
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProvider
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProvider
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.StopTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipProvider(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthProvider
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GlobalSlashEntry) 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 ErrIntOverflowProvider
			}
			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: GlobalSlashEntry: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GlobalSlashEntry: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RecvTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProvider
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProvider
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProvider
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.RecvTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConsumerChainID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProvider
				}
				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 ErrInvalidLengthProvider
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthProvider
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ConsumerChainID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IbcSeqNum", wireType)
			}
			m.IbcSeqNum = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProvider
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.IbcSeqNum |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProviderValConsAddr", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProvider
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthProvider
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthProvider
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ProviderValConsAddr = append(m.ProviderValConsAddr[:0], dAtA[iNdEx:postIndex]...)
			if m.ProviderValConsAddr == nil {
				m.ProviderValConsAddr = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipProvider(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthProvider
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Params) 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 ErrIntOverflowProvider
			}
			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: Params: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Params: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TemplateClient", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProvider
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProvider
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProvider
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TemplateClient == nil {
				m.TemplateClient = &types1.ClientState{}
			}
			if err := m.TemplateClient.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TrustingPeriodFraction", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProvider
				}
				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 ErrInvalidLengthProvider
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthProvider
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TrustingPeriodFraction = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			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 ErrIntOverflowProvider
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProvider
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProvider
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.CcvTimeoutPeriod, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InitTimeoutPeriod", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProvider
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProvider
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProvider
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.InitTimeoutPeriod, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VscTimeoutPeriod", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProvider
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProvider
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProvider
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.VscTimeoutPeriod, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SlashMeterReplenishPeriod", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProvider
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProvider
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProvider
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.SlashMeterReplenishPeriod, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SlashMeterReplenishFraction", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProvider
				}
				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 ErrInvalidLengthProvider
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthProvider
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SlashMeterReplenishFraction = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxThrottledPackets", wireType)
			}
			m.MaxThrottledPackets = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProvider
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxThrottledPackets |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConsumerRewardDenomRegistrationFee", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProvider
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProvider
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProvider
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ConsumerRewardDenomRegistrationFee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipProvider(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthProvider
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *VscUnbondingOps) 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 ErrIntOverflowProvider
			}
			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: VscUnbondingOps: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: VscUnbondingOps: 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 ErrIntOverflowProvider
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.VscId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProvider
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.UnbondingOpIds = append(m.UnbondingOpIds, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProvider
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthProvider
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthProvider
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.UnbondingOpIds) == 0 {
					m.UnbondingOpIds = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowProvider
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.UnbondingOpIds = append(m.UnbondingOpIds, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field UnbondingOpIds", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipProvider(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthProvider
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *VscSendTimestamp) 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 ErrIntOverflowProvider
			}
			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: VscSendTimestamp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: VscSendTimestamp: 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 ErrIntOverflowProvider
				}
				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 Timestamp", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProvider
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProvider
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProvider
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.Timestamp, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipProvider(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthProvider
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ConsumerAddrsToPrune) 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 ErrIntOverflowProvider
			}
			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: ConsumerAddrsToPrune: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ConsumerAddrsToPrune: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProvider
				}
				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 ErrInvalidLengthProvider
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthProvider
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ChainId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field VscId", wireType)
			}
			m.VscId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProvider
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.VscId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConsumerAddrs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProvider
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProvider
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthProvider
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ConsumerAddrs == nil {
				m.ConsumerAddrs = &AddressList{}
			}
			if err := m.ConsumerAddrs.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipProvider(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthProvider
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

var (
	ErrInvalidLengthProvider        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowProvider          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupProvider = fmt.Errorf("proto: unexpected end of group")
)