query.pb.go

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

package types

import (
	context "context"
	fmt "fmt"
	crypto "github.com/cometbft/cometbft/proto/tendermint/crypto"
	_ "github.com/cosmos/gogoproto/gogoproto"
	grpc1 "github.com/cosmos/gogoproto/grpc"
	proto "github.com/cosmos/gogoproto/proto"
	github_com_cosmos_gogoproto_types "github.com/cosmos/gogoproto/types"
	types "github.com/cosmos/interchain-security/v5/x/ccv/types"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	_ "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

type QueryConsumerGenesisRequest struct {
	ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
}

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

var xxx_messageInfo_QueryConsumerGenesisRequest proto.InternalMessageInfo

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

type QueryConsumerGenesisResponse struct {
	GenesisState types.ConsumerGenesisState `protobuf:"bytes,1,opt,name=genesis_state,json=genesisState,proto3" json:"genesis_state"`
}

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

var xxx_messageInfo_QueryConsumerGenesisResponse proto.InternalMessageInfo

func (m *QueryConsumerGenesisResponse) GetGenesisState() types.ConsumerGenesisState {
	if m != nil {
		return m.GenesisState
	}
	return types.ConsumerGenesisState{}
}

type QueryConsumerChainsRequest struct {
}

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

var xxx_messageInfo_QueryConsumerChainsRequest proto.InternalMessageInfo

type QueryConsumerChainsResponse struct {
	Chains []*Chain `protobuf:"bytes,1,rep,name=chains,proto3" json:"chains,omitempty"`
}

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

var xxx_messageInfo_QueryConsumerChainsResponse proto.InternalMessageInfo

func (m *QueryConsumerChainsResponse) GetChains() []*Chain {
	if m != nil {
		return m.Chains
	}
	return nil
}

type QueryConsumerChainStartProposalsRequest struct {
}

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

var xxx_messageInfo_QueryConsumerChainStartProposalsRequest proto.InternalMessageInfo

type QueryConsumerChainStartProposalsResponse struct {
	Proposals *ConsumerAdditionProposals `protobuf:"bytes,1,opt,name=proposals,proto3" json:"proposals,omitempty"`
}

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

var xxx_messageInfo_QueryConsumerChainStartProposalsResponse proto.InternalMessageInfo

func (m *QueryConsumerChainStartProposalsResponse) GetProposals() *ConsumerAdditionProposals {
	if m != nil {
		return m.Proposals
	}
	return nil
}

type QueryConsumerChainStopProposalsRequest struct {
}

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

var xxx_messageInfo_QueryConsumerChainStopProposalsRequest proto.InternalMessageInfo

type QueryConsumerChainStopProposalsResponse struct {
	Proposals *ConsumerRemovalProposals `protobuf:"bytes,1,opt,name=proposals,proto3" json:"proposals,omitempty"`
}

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

var xxx_messageInfo_QueryConsumerChainStopProposalsResponse proto.InternalMessageInfo

func (m *QueryConsumerChainStopProposalsResponse) GetProposals() *ConsumerRemovalProposals {
	if m != nil {
		return m.Proposals
	}
	return nil
}

type Chain struct {
	ChainId  string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
	ClientId string `protobuf:"bytes,2,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"`
}

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

var xxx_messageInfo_Chain proto.InternalMessageInfo

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

func (m *Chain) GetClientId() string {
	if m != nil {
		return m.ClientId
	}
	return ""
}

type QueryValidatorConsumerAddrRequest struct {
	// The id of the consumer chain
	ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
	// The consensus address of the validator on the provider chain
	ProviderAddress string `protobuf:"bytes,2,opt,name=provider_address,json=providerAddress,proto3" json:"provider_address,omitempty" yaml:"address"`
}

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

var xxx_messageInfo_QueryValidatorConsumerAddrRequest proto.InternalMessageInfo

type QueryValidatorConsumerAddrResponse struct {
	// The address of the validator on the consumer chain
	ConsumerAddress string `protobuf:"bytes,1,opt,name=consumer_address,json=consumerAddress,proto3" json:"consumer_address,omitempty"`
}

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

var xxx_messageInfo_QueryValidatorConsumerAddrResponse proto.InternalMessageInfo

func (m *QueryValidatorConsumerAddrResponse) GetConsumerAddress() string {
	if m != nil {
		return m.ConsumerAddress
	}
	return ""
}

type QueryValidatorProviderAddrRequest struct {
	// The id of the provider chain
	ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
	// The consensus address of the validator on the consumer chain
	ConsumerAddress string `protobuf:"bytes,2,opt,name=consumer_address,json=consumerAddress,proto3" json:"consumer_address,omitempty" yaml:"address"`
}

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

var xxx_messageInfo_QueryValidatorProviderAddrRequest proto.InternalMessageInfo

type QueryValidatorProviderAddrResponse struct {
	// The address of the validator on the provider chain
	ProviderAddress string `protobuf:"bytes,1,opt,name=provider_address,json=providerAddress,proto3" json:"provider_address,omitempty"`
}

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

var xxx_messageInfo_QueryValidatorProviderAddrResponse proto.InternalMessageInfo

func (m *QueryValidatorProviderAddrResponse) GetProviderAddress() string {
	if m != nil {
		return m.ProviderAddress
	}
	return ""
}

type QueryThrottleStateRequest struct {
}

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

var xxx_messageInfo_QueryThrottleStateRequest proto.InternalMessageInfo

type QueryThrottleStateResponse struct {
	// current slash_meter state
	SlashMeter int64 `protobuf:"varint,1,opt,name=slash_meter,json=slashMeter,proto3" json:"slash_meter,omitempty"`
	// allowance of voting power units (int) that the slash meter is given per
	// replenish period this also serves as the max value for the meter.
	SlashMeterAllowance int64 `protobuf:"varint,2,opt,name=slash_meter_allowance,json=slashMeterAllowance,proto3" json:"slash_meter_allowance,omitempty"`
	// next time the slash meter could potentially be replenished, iff it's not
	// full
	NextReplenishCandidate time.Time `protobuf:"bytes,3,opt,name=next_replenish_candidate,json=nextReplenishCandidate,proto3,stdtime" json:"next_replenish_candidate"`
}

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

var xxx_messageInfo_QueryThrottleStateResponse proto.InternalMessageInfo

func (m *QueryThrottleStateResponse) GetSlashMeter() int64 {
	if m != nil {
		return m.SlashMeter
	}
	return 0
}

func (m *QueryThrottleStateResponse) GetSlashMeterAllowance() int64 {
	if m != nil {
		return m.SlashMeterAllowance
	}
	return 0
}

func (m *QueryThrottleStateResponse) GetNextReplenishCandidate() time.Time {
	if m != nil {
		return m.NextReplenishCandidate
	}
	return time.Time{}
}

type QueryRegisteredConsumerRewardDenomsRequest struct {
}

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

var xxx_messageInfo_QueryRegisteredConsumerRewardDenomsRequest proto.InternalMessageInfo

type QueryRegisteredConsumerRewardDenomsResponse struct {
	Denoms []string `protobuf:"bytes,1,rep,name=denoms,proto3" json:"denoms,omitempty"`
}

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

var xxx_messageInfo_QueryRegisteredConsumerRewardDenomsResponse proto.InternalMessageInfo

func (m *QueryRegisteredConsumerRewardDenomsResponse) GetDenoms() []string {
	if m != nil {
		return m.Denoms
	}
	return nil
}

type QueryProposedChainIDsRequest struct {
}

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

var xxx_messageInfo_QueryProposedChainIDsRequest proto.InternalMessageInfo

type QueryProposedChainIDsResponse struct {
	ProposedChains []ProposedChain `protobuf:"bytes,1,rep,name=proposedChains,proto3" json:"proposedChains"`
}

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

var xxx_messageInfo_QueryProposedChainIDsResponse proto.InternalMessageInfo

func (m *QueryProposedChainIDsResponse) GetProposedChains() []ProposedChain {
	if m != nil {
		return m.ProposedChains
	}
	return nil
}

type ProposedChain struct {
	ChainID    string `protobuf:"bytes,1,opt,name=chainID,proto3" json:"chainID,omitempty"`
	ProposalID uint64 `protobuf:"varint,2,opt,name=proposalID,proto3" json:"proposalID,omitempty"`
}

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

var xxx_messageInfo_ProposedChain proto.InternalMessageInfo

func (m *ProposedChain) GetChainID() string {
	if m != nil {
		return m.ChainID
	}
	return ""
}

func (m *ProposedChain) GetProposalID() uint64 {
	if m != nil {
		return m.ProposalID
	}
	return 0
}

type QueryAllPairsValConAddrByConsumerChainIDRequest struct {
	// The id of the consumer chain
	ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
}

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

var xxx_messageInfo_QueryAllPairsValConAddrByConsumerChainIDRequest proto.InternalMessageInfo

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

type QueryAllPairsValConAddrByConsumerChainIDResponse struct {
	PairValConAddr []*PairValConAddrProviderAndConsumer `protobuf:"bytes,1,rep,name=pair_val_con_addr,json=pairValConAddr,proto3" json:"pair_val_con_addr,omitempty"`
}

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

var xxx_messageInfo_QueryAllPairsValConAddrByConsumerChainIDResponse proto.InternalMessageInfo

func (m *QueryAllPairsValConAddrByConsumerChainIDResponse) GetPairValConAddr() []*PairValConAddrProviderAndConsumer {
	if m != nil {
		return m.PairValConAddr
	}
	return nil
}

type PairValConAddrProviderAndConsumer struct {
	// The consensus address of the validator on the provider chain
	ProviderAddress string `protobuf:"bytes,1,opt,name=provider_address,json=providerAddress,proto3" json:"provider_address,omitempty" yaml:"address"`
	// The consensus address of the validator on the consumer chain
	ConsumerAddress string            `protobuf:"bytes,2,opt,name=consumer_address,json=consumerAddress,proto3" json:"consumer_address,omitempty" yaml:"address"`
	ConsumerKey     *crypto.PublicKey `protobuf:"bytes,3,opt,name=consumer_key,json=consumerKey,proto3" json:"consumer_key,omitempty"`
}

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

var xxx_messageInfo_PairValConAddrProviderAndConsumer proto.InternalMessageInfo

func (m *PairValConAddrProviderAndConsumer) GetProviderAddress() string {
	if m != nil {
		return m.ProviderAddress
	}
	return ""
}

func (m *PairValConAddrProviderAndConsumer) GetConsumerAddress() string {
	if m != nil {
		return m.ConsumerAddress
	}
	return ""
}

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

type QueryParamsRequest struct {
}

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

var xxx_messageInfo_QueryParamsRequest proto.InternalMessageInfo

type QueryParamsResponse struct {
	Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"`
}

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

var xxx_messageInfo_QueryParamsResponse proto.InternalMessageInfo

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

func init() {
	proto.RegisterType((*QueryConsumerGenesisRequest)(nil), "interchain_security.ccv.provider.v1.QueryConsumerGenesisRequest")
	proto.RegisterType((*QueryConsumerGenesisResponse)(nil), "interchain_security.ccv.provider.v1.QueryConsumerGenesisResponse")
	proto.RegisterType((*QueryConsumerChainsRequest)(nil), "interchain_security.ccv.provider.v1.QueryConsumerChainsRequest")
	proto.RegisterType((*QueryConsumerChainsResponse)(nil), "interchain_security.ccv.provider.v1.QueryConsumerChainsResponse")
	proto.RegisterType((*QueryConsumerChainStartProposalsRequest)(nil), "interchain_security.ccv.provider.v1.QueryConsumerChainStartProposalsRequest")
	proto.RegisterType((*QueryConsumerChainStartProposalsResponse)(nil), "interchain_security.ccv.provider.v1.QueryConsumerChainStartProposalsResponse")
	proto.RegisterType((*QueryConsumerChainStopProposalsRequest)(nil), "interchain_security.ccv.provider.v1.QueryConsumerChainStopProposalsRequest")
	proto.RegisterType((*QueryConsumerChainStopProposalsResponse)(nil), "interchain_security.ccv.provider.v1.QueryConsumerChainStopProposalsResponse")
	proto.RegisterType((*Chain)(nil), "interchain_security.ccv.provider.v1.Chain")
	proto.RegisterType((*QueryValidatorConsumerAddrRequest)(nil), "interchain_security.ccv.provider.v1.QueryValidatorConsumerAddrRequest")
	proto.RegisterType((*QueryValidatorConsumerAddrResponse)(nil), "interchain_security.ccv.provider.v1.QueryValidatorConsumerAddrResponse")
	proto.RegisterType((*QueryValidatorProviderAddrRequest)(nil), "interchain_security.ccv.provider.v1.QueryValidatorProviderAddrRequest")
	proto.RegisterType((*QueryValidatorProviderAddrResponse)(nil), "interchain_security.ccv.provider.v1.QueryValidatorProviderAddrResponse")
	proto.RegisterType((*QueryThrottleStateRequest)(nil), "interchain_security.ccv.provider.v1.QueryThrottleStateRequest")
	proto.RegisterType((*QueryThrottleStateResponse)(nil), "interchain_security.ccv.provider.v1.QueryThrottleStateResponse")
	proto.RegisterType((*QueryRegisteredConsumerRewardDenomsRequest)(nil), "interchain_security.ccv.provider.v1.QueryRegisteredConsumerRewardDenomsRequest")
	proto.RegisterType((*QueryRegisteredConsumerRewardDenomsResponse)(nil), "interchain_security.ccv.provider.v1.QueryRegisteredConsumerRewardDenomsResponse")
	proto.RegisterType((*QueryProposedChainIDsRequest)(nil), "interchain_security.ccv.provider.v1.QueryProposedChainIDsRequest")
	proto.RegisterType((*QueryProposedChainIDsResponse)(nil), "interchain_security.ccv.provider.v1.QueryProposedChainIDsResponse")
	proto.RegisterType((*ProposedChain)(nil), "interchain_security.ccv.provider.v1.ProposedChain")
	proto.RegisterType((*QueryAllPairsValConAddrByConsumerChainIDRequest)(nil), "interchain_security.ccv.provider.v1.QueryAllPairsValConAddrByConsumerChainIDRequest")
	proto.RegisterType((*QueryAllPairsValConAddrByConsumerChainIDResponse)(nil), "interchain_security.ccv.provider.v1.QueryAllPairsValConAddrByConsumerChainIDResponse")
	proto.RegisterType((*PairValConAddrProviderAndConsumer)(nil), "interchain_security.ccv.provider.v1.PairValConAddrProviderAndConsumer")
	proto.RegisterType((*QueryParamsRequest)(nil), "interchain_security.ccv.provider.v1.QueryParamsRequest")
	proto.RegisterType((*QueryParamsResponse)(nil), "interchain_security.ccv.provider.v1.QueryParamsResponse")
}

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

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

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

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

// QueryClient is the client API for Query service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type QueryClient interface {
	// ConsumerGenesis queries the genesis state needed to start a consumer chain
	// whose proposal has been accepted
	QueryConsumerGenesis(ctx context.Context, in *QueryConsumerGenesisRequest, opts ...grpc.CallOption) (*QueryConsumerGenesisResponse, error)
	// ConsumerChains queries active consumer chains supported by the provider
	// chain
	QueryConsumerChains(ctx context.Context, in *QueryConsumerChainsRequest, opts ...grpc.CallOption) (*QueryConsumerChainsResponse, error)
	// QueryConsumerChainStarts queries consumer chain start proposals.
	QueryConsumerChainStarts(ctx context.Context, in *QueryConsumerChainStartProposalsRequest, opts ...grpc.CallOption) (*QueryConsumerChainStartProposalsResponse, error)
	// QueryConsumerChainStops queries consumer chain stop proposals.
	QueryConsumerChainStops(ctx context.Context, in *QueryConsumerChainStopProposalsRequest, opts ...grpc.CallOption) (*QueryConsumerChainStopProposalsResponse, error)
	// QueryValidatorConsumerAddr queries the address
	// assigned by a validator for a consumer chain.
	QueryValidatorConsumerAddr(ctx context.Context, in *QueryValidatorConsumerAddrRequest, opts ...grpc.CallOption) (*QueryValidatorConsumerAddrResponse, error)
	// QueryProviderAddr returns the provider chain validator
	// given a consumer chain validator address
	QueryValidatorProviderAddr(ctx context.Context, in *QueryValidatorProviderAddrRequest, opts ...grpc.CallOption) (*QueryValidatorProviderAddrResponse, error)
	// QueryThrottleState returns the main on-chain state relevant to currently
	// throttled slash packets
	QueryThrottleState(ctx context.Context, in *QueryThrottleStateRequest, opts ...grpc.CallOption) (*QueryThrottleStateResponse, error)
	// QueryRegisteredConsumerRewardDenoms returns a list of consumer reward
	// denoms that are registered
	QueryRegisteredConsumerRewardDenoms(ctx context.Context, in *QueryRegisteredConsumerRewardDenomsRequest, opts ...grpc.CallOption) (*QueryRegisteredConsumerRewardDenomsResponse, error)
	// QueryProposedConsumerChainIDs returns the chain IDs of the proposed consumer chain addition proposals
	// that are still in the voting period
	QueryProposedConsumerChainIDs(ctx context.Context, in *QueryProposedChainIDsRequest, opts ...grpc.CallOption) (*QueryProposedChainIDsResponse, error)
	// QueryAllPairsValConAddrByConsumerChainID returns a list of pair valconsensus address
	// between provider and consumer chain
	QueryAllPairsValConAddrByConsumerChainID(ctx context.Context, in *QueryAllPairsValConAddrByConsumerChainIDRequest, opts ...grpc.CallOption) (*QueryAllPairsValConAddrByConsumerChainIDResponse, error)
	// QueryParams returns all current values of provider parameters
	QueryParams(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error)
}

type queryClient struct {
	cc grpc1.ClientConn
}

func NewQueryClient(cc grpc1.ClientConn) QueryClient {
	return &queryClient{cc}
}

func (c *queryClient) QueryConsumerGenesis(ctx context.Context, in *QueryConsumerGenesisRequest, opts ...grpc.CallOption) (*QueryConsumerGenesisResponse, error) {
	out := new(QueryConsumerGenesisResponse)
	err := c.cc.Invoke(ctx, "/interchain_security.ccv.provider.v1.Query/QueryConsumerGenesis", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) QueryConsumerChains(ctx context.Context, in *QueryConsumerChainsRequest, opts ...grpc.CallOption) (*QueryConsumerChainsResponse, error) {
	out := new(QueryConsumerChainsResponse)
	err := c.cc.Invoke(ctx, "/interchain_security.ccv.provider.v1.Query/QueryConsumerChains", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) QueryConsumerChainStarts(ctx context.Context, in *QueryConsumerChainStartProposalsRequest, opts ...grpc.CallOption) (*QueryConsumerChainStartProposalsResponse, error) {
	out := new(QueryConsumerChainStartProposalsResponse)
	err := c.cc.Invoke(ctx, "/interchain_security.ccv.provider.v1.Query/QueryConsumerChainStarts", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) QueryConsumerChainStops(ctx context.Context, in *QueryConsumerChainStopProposalsRequest, opts ...grpc.CallOption) (*QueryConsumerChainStopProposalsResponse, error) {
	out := new(QueryConsumerChainStopProposalsResponse)
	err := c.cc.Invoke(ctx, "/interchain_security.ccv.provider.v1.Query/QueryConsumerChainStops", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) QueryValidatorConsumerAddr(ctx context.Context, in *QueryValidatorConsumerAddrRequest, opts ...grpc.CallOption) (*QueryValidatorConsumerAddrResponse, error) {
	out := new(QueryValidatorConsumerAddrResponse)
	err := c.cc.Invoke(ctx, "/interchain_security.ccv.provider.v1.Query/QueryValidatorConsumerAddr", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) QueryValidatorProviderAddr(ctx context.Context, in *QueryValidatorProviderAddrRequest, opts ...grpc.CallOption) (*QueryValidatorProviderAddrResponse, error) {
	out := new(QueryValidatorProviderAddrResponse)
	err := c.cc.Invoke(ctx, "/interchain_security.ccv.provider.v1.Query/QueryValidatorProviderAddr", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) QueryThrottleState(ctx context.Context, in *QueryThrottleStateRequest, opts ...grpc.CallOption) (*QueryThrottleStateResponse, error) {
	out := new(QueryThrottleStateResponse)
	err := c.cc.Invoke(ctx, "/interchain_security.ccv.provider.v1.Query/QueryThrottleState", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) QueryRegisteredConsumerRewardDenoms(ctx context.Context, in *QueryRegisteredConsumerRewardDenomsRequest, opts ...grpc.CallOption) (*QueryRegisteredConsumerRewardDenomsResponse, error) {
	out := new(QueryRegisteredConsumerRewardDenomsResponse)
	err := c.cc.Invoke(ctx, "/interchain_security.ccv.provider.v1.Query/QueryRegisteredConsumerRewardDenoms", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) QueryProposedConsumerChainIDs(ctx context.Context, in *QueryProposedChainIDsRequest, opts ...grpc.CallOption) (*QueryProposedChainIDsResponse, error) {
	out := new(QueryProposedChainIDsResponse)
	err := c.cc.Invoke(ctx, "/interchain_security.ccv.provider.v1.Query/QueryProposedConsumerChainIDs", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) QueryAllPairsValConAddrByConsumerChainID(ctx context.Context, in *QueryAllPairsValConAddrByConsumerChainIDRequest, opts ...grpc.CallOption) (*QueryAllPairsValConAddrByConsumerChainIDResponse, error) {
	out := new(QueryAllPairsValConAddrByConsumerChainIDResponse)
	err := c.cc.Invoke(ctx, "/interchain_security.ccv.provider.v1.Query/QueryAllPairsValConAddrByConsumerChainID", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) QueryParams(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error) {
	out := new(QueryParamsResponse)
	err := c.cc.Invoke(ctx, "/interchain_security.ccv.provider.v1.Query/QueryParams", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// QueryServer is the server API for Query service.
type QueryServer interface {
	// ConsumerGenesis queries the genesis state needed to start a consumer chain
	// whose proposal has been accepted
	QueryConsumerGenesis(context.Context, *QueryConsumerGenesisRequest) (*QueryConsumerGenesisResponse, error)
	// ConsumerChains queries active consumer chains supported by the provider
	// chain
	QueryConsumerChains(context.Context, *QueryConsumerChainsRequest) (*QueryConsumerChainsResponse, error)
	// QueryConsumerChainStarts queries consumer chain start proposals.
	QueryConsumerChainStarts(context.Context, *QueryConsumerChainStartProposalsRequest) (*QueryConsumerChainStartProposalsResponse, error)
	// QueryConsumerChainStops queries consumer chain stop proposals.
	QueryConsumerChainStops(context.Context, *QueryConsumerChainStopProposalsRequest) (*QueryConsumerChainStopProposalsResponse, error)
	// QueryValidatorConsumerAddr queries the address
	// assigned by a validator for a consumer chain.
	QueryValidatorConsumerAddr(context.Context, *QueryValidatorConsumerAddrRequest) (*QueryValidatorConsumerAddrResponse, error)
	// QueryProviderAddr returns the provider chain validator
	// given a consumer chain validator address
	QueryValidatorProviderAddr(context.Context, *QueryValidatorProviderAddrRequest) (*QueryValidatorProviderAddrResponse, error)
	// QueryThrottleState returns the main on-chain state relevant to currently
	// throttled slash packets
	QueryThrottleState(context.Context, *QueryThrottleStateRequest) (*QueryThrottleStateResponse, error)
	// QueryRegisteredConsumerRewardDenoms returns a list of consumer reward
	// denoms that are registered
	QueryRegisteredConsumerRewardDenoms(context.Context, *QueryRegisteredConsumerRewardDenomsRequest) (*QueryRegisteredConsumerRewardDenomsResponse, error)
	// QueryProposedConsumerChainIDs returns the chain IDs of the proposed consumer chain addition proposals
	// that are still in the voting period
	QueryProposedConsumerChainIDs(context.Context, *QueryProposedChainIDsRequest) (*QueryProposedChainIDsResponse, error)
	// QueryAllPairsValConAddrByConsumerChainID returns a list of pair valconsensus address
	// between provider and consumer chain
	QueryAllPairsValConAddrByConsumerChainID(context.Context, *QueryAllPairsValConAddrByConsumerChainIDRequest) (*QueryAllPairsValConAddrByConsumerChainIDResponse, error)
	// QueryParams returns all current values of provider parameters
	QueryParams(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error)
}

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

func (*UnimplementedQueryServer) QueryConsumerGenesis(ctx context.Context, req *QueryConsumerGenesisRequest) (*QueryConsumerGenesisResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method QueryConsumerGenesis not implemented")
}
func (*UnimplementedQueryServer) QueryConsumerChains(ctx context.Context, req *QueryConsumerChainsRequest) (*QueryConsumerChainsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method QueryConsumerChains not implemented")
}
func (*UnimplementedQueryServer) QueryConsumerChainStarts(ctx context.Context, req *QueryConsumerChainStartProposalsRequest) (*QueryConsumerChainStartProposalsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method QueryConsumerChainStarts not implemented")
}
func (*UnimplementedQueryServer) QueryConsumerChainStops(ctx context.Context, req *QueryConsumerChainStopProposalsRequest) (*QueryConsumerChainStopProposalsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method QueryConsumerChainStops not implemented")
}
func (*UnimplementedQueryServer) QueryValidatorConsumerAddr(ctx context.Context, req *QueryValidatorConsumerAddrRequest) (*QueryValidatorConsumerAddrResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method QueryValidatorConsumerAddr not implemented")
}
func (*UnimplementedQueryServer) QueryValidatorProviderAddr(ctx context.Context, req *QueryValidatorProviderAddrRequest) (*QueryValidatorProviderAddrResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method QueryValidatorProviderAddr not implemented")
}
func (*UnimplementedQueryServer) QueryThrottleState(ctx context.Context, req *QueryThrottleStateRequest) (*QueryThrottleStateResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method QueryThrottleState not implemented")
}
func (*UnimplementedQueryServer) QueryRegisteredConsumerRewardDenoms(ctx context.Context, req *QueryRegisteredConsumerRewardDenomsRequest) (*QueryRegisteredConsumerRewardDenomsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method QueryRegisteredConsumerRewardDenoms not implemented")
}
func (*UnimplementedQueryServer) QueryProposedConsumerChainIDs(ctx context.Context, req *QueryProposedChainIDsRequest) (*QueryProposedChainIDsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method QueryProposedConsumerChainIDs not implemented")
}
func (*UnimplementedQueryServer) QueryAllPairsValConAddrByConsumerChainID(ctx context.Context, req *QueryAllPairsValConAddrByConsumerChainIDRequest) (*QueryAllPairsValConAddrByConsumerChainIDResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method QueryAllPairsValConAddrByConsumerChainID not implemented")
}
func (*UnimplementedQueryServer) QueryParams(ctx context.Context, req *QueryParamsRequest) (*QueryParamsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method QueryParams not implemented")
}

func RegisterQueryServer(s grpc1.Server, srv QueryServer) {
	s.RegisterService(&_Query_serviceDesc, srv)
}

func _Query_QueryConsumerGenesis_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryConsumerGenesisRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).QueryConsumerGenesis(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/interchain_security.ccv.provider.v1.Query/QueryConsumerGenesis",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).QueryConsumerGenesis(ctx, req.(*QueryConsumerGenesisRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_QueryConsumerChains_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryConsumerChainsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).QueryConsumerChains(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/interchain_security.ccv.provider.v1.Query/QueryConsumerChains",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).QueryConsumerChains(ctx, req.(*QueryConsumerChainsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_QueryConsumerChainStarts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryConsumerChainStartProposalsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).QueryConsumerChainStarts(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/interchain_security.ccv.provider.v1.Query/QueryConsumerChainStarts",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).QueryConsumerChainStarts(ctx, req.(*QueryConsumerChainStartProposalsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_QueryConsumerChainStops_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryConsumerChainStopProposalsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).QueryConsumerChainStops(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/interchain_security.ccv.provider.v1.Query/QueryConsumerChainStops",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).QueryConsumerChainStops(ctx, req.(*QueryConsumerChainStopProposalsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_QueryValidatorConsumerAddr_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryValidatorConsumerAddrRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).QueryValidatorConsumerAddr(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/interchain_security.ccv.provider.v1.Query/QueryValidatorConsumerAddr",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).QueryValidatorConsumerAddr(ctx, req.(*QueryValidatorConsumerAddrRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_QueryValidatorProviderAddr_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryValidatorProviderAddrRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).QueryValidatorProviderAddr(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/interchain_security.ccv.provider.v1.Query/QueryValidatorProviderAddr",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).QueryValidatorProviderAddr(ctx, req.(*QueryValidatorProviderAddrRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_QueryThrottleState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryThrottleStateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).QueryThrottleState(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/interchain_security.ccv.provider.v1.Query/QueryThrottleState",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).QueryThrottleState(ctx, req.(*QueryThrottleStateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_QueryRegisteredConsumerRewardDenoms_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryRegisteredConsumerRewardDenomsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).QueryRegisteredConsumerRewardDenoms(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/interchain_security.ccv.provider.v1.Query/QueryRegisteredConsumerRewardDenoms",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).QueryRegisteredConsumerRewardDenoms(ctx, req.(*QueryRegisteredConsumerRewardDenomsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_QueryProposedConsumerChainIDs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryProposedChainIDsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).QueryProposedConsumerChainIDs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/interchain_security.ccv.provider.v1.Query/QueryProposedConsumerChainIDs",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).QueryProposedConsumerChainIDs(ctx, req.(*QueryProposedChainIDsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_QueryAllPairsValConAddrByConsumerChainID_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryAllPairsValConAddrByConsumerChainIDRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).QueryAllPairsValConAddrByConsumerChainID(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/interchain_security.ccv.provider.v1.Query/QueryAllPairsValConAddrByConsumerChainID",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).QueryAllPairsValConAddrByConsumerChainID(ctx, req.(*QueryAllPairsValConAddrByConsumerChainIDRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_QueryParams_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryParamsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).QueryParams(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/interchain_security.ccv.provider.v1.Query/QueryParams",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).QueryParams(ctx, req.(*QueryParamsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Query_serviceDesc = grpc.ServiceDesc{
	ServiceName: "interchain_security.ccv.provider.v1.Query",
	HandlerType: (*QueryServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "QueryConsumerGenesis",
			Handler:    _Query_QueryConsumerGenesis_Handler,
		},
		{
			MethodName: "QueryConsumerChains",
			Handler:    _Query_QueryConsumerChains_Handler,
		},
		{
			MethodName: "QueryConsumerChainStarts",
			Handler:    _Query_QueryConsumerChainStarts_Handler,
		},
		{
			MethodName: "QueryConsumerChainStops",
			Handler:    _Query_QueryConsumerChainStops_Handler,
		},
		{
			MethodName: "QueryValidatorConsumerAddr",
			Handler:    _Query_QueryValidatorConsumerAddr_Handler,
		},
		{
			MethodName: "QueryValidatorProviderAddr",
			Handler:    _Query_QueryValidatorProviderAddr_Handler,
		},
		{
			MethodName: "QueryThrottleState",
			Handler:    _Query_QueryThrottleState_Handler,
		},
		{
			MethodName: "QueryRegisteredConsumerRewardDenoms",
			Handler:    _Query_QueryRegisteredConsumerRewardDenoms_Handler,
		},
		{
			MethodName: "QueryProposedConsumerChainIDs",
			Handler:    _Query_QueryProposedConsumerChainIDs_Handler,
		},
		{
			MethodName: "QueryAllPairsValConAddrByConsumerChainID",
			Handler:    _Query_QueryAllPairsValConAddrByConsumerChainID_Handler,
		},
		{
			MethodName: "QueryParams",
			Handler:    _Query_QueryParams_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "interchain_security/ccv/provider/v1/query.proto",
}

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

func (m *QueryConsumerGenesisRequest) 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 = encodeVarintQuery(dAtA, i, uint64(len(m.ChainId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *QueryConsumerChainsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

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

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

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

func (m *QueryConsumerChainStartProposalsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

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

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

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

func (m *QueryConsumerChainStopProposalsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *QueryThrottleStateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

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

func (m *QueryThrottleStateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	n4, err4 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.NextReplenishCandidate, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.NextReplenishCandidate):])
	if err4 != nil {
		return 0, err4
	}
	i -= n4
	i = encodeVarintQuery(dAtA, i, uint64(n4))
	i--
	dAtA[i] = 0x1a
	if m.SlashMeterAllowance != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.SlashMeterAllowance))
		i--
		dAtA[i] = 0x10
	}
	if m.SlashMeter != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.SlashMeter))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *QueryRegisteredConsumerRewardDenomsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

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

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

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

func (m *QueryProposedChainIDsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *QueryAllPairsValConAddrByConsumerChainIDRequest) 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 = encodeVarintQuery(dAtA, i, uint64(len(m.ChainId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *PairValConAddrProviderAndConsumer) 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 = encodeVarintQuery(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.ConsumerAddress) > 0 {
		i -= len(m.ConsumerAddress)
		copy(dAtA[i:], m.ConsumerAddress)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.ConsumerAddress)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ProviderAddress) > 0 {
		i -= len(m.ProviderAddress)
		copy(dAtA[i:], m.ProviderAddress)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.ProviderAddress)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *QueryParamsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

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

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

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

func (m *QueryConsumerGenesisResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.GenesisState.Size()
	n += 1 + l + sovQuery(uint64(l))
	return n
}

func (m *QueryConsumerChainsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

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

func (m *QueryConsumerChainStartProposalsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *QueryConsumerChainStartProposalsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Proposals != nil {
		l = m.Proposals.Size()
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

func (m *QueryConsumerChainStopProposalsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *QueryConsumerChainStopProposalsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Proposals != nil {
		l = m.Proposals.Size()
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

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

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

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

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

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

func (m *QueryThrottleStateRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *QueryThrottleStateResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SlashMeter != 0 {
		n += 1 + sovQuery(uint64(m.SlashMeter))
	}
	if m.SlashMeterAllowance != 0 {
		n += 1 + sovQuery(uint64(m.SlashMeterAllowance))
	}
	l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.NextReplenishCandidate)
	n += 1 + l + sovQuery(uint64(l))
	return n
}

func (m *QueryRegisteredConsumerRewardDenomsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

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

func (m *QueryProposedChainIDsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

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

func (m *ProposedChain) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ChainID)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	if m.ProposalID != 0 {
		n += 1 + sovQuery(uint64(m.ProposalID))
	}
	return n
}

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

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

func (m *PairValConAddrProviderAndConsumer) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ProviderAddress)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	l = len(m.ConsumerAddress)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	if m.ConsumerKey != nil {
		l = m.ConsumerKey.Size()
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

func (m *QueryParamsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *QueryParamsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Params.Size()
	n += 1 + l + sovQuery(uint64(l))
	return n
}

func sovQuery(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozQuery(x uint64) (n int) {
	return sovQuery(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *QueryConsumerGenesisRequest) 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 ErrIntOverflowQuery
			}
			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: QueryConsumerGenesisRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryConsumerGenesisRequest: 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 ErrIntOverflowQuery
				}
				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 ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ChainId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryConsumerChainsRequest) 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 ErrIntOverflowQuery
			}
			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: QueryConsumerChainsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryConsumerChainsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryConsumerChainStartProposalsRequest) 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 ErrIntOverflowQuery
			}
			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: QueryConsumerChainStartProposalsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryConsumerChainStartProposalsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryConsumerChainStopProposalsRequest) 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 ErrIntOverflowQuery
			}
			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: QueryConsumerChainStopProposalsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryConsumerChainStopProposalsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Chain) 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 ErrIntOverflowQuery
			}
			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: Chain: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Chain: 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 ErrIntOverflowQuery
				}
				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 ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			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 ClientId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				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 ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ClientId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryValidatorConsumerAddrRequest) 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 ErrIntOverflowQuery
			}
			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: QueryValidatorConsumerAddrRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryValidatorConsumerAddrRequest: 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 ErrIntOverflowQuery
				}
				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 ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			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 ProviderAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				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 ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ProviderAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryValidatorProviderAddrRequest) 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 ErrIntOverflowQuery
			}
			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: QueryValidatorProviderAddrRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryValidatorProviderAddrRequest: 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 ErrIntOverflowQuery
				}
				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 ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			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 ConsumerAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				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 ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ConsumerAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryThrottleStateRequest) 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 ErrIntOverflowQuery
			}
			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: QueryThrottleStateRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryThrottleStateRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryRegisteredConsumerRewardDenomsRequest) 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 ErrIntOverflowQuery
			}
			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: QueryRegisteredConsumerRewardDenomsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryRegisteredConsumerRewardDenomsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryProposedChainIDsRequest) 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 ErrIntOverflowQuery
			}
			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: QueryProposedChainIDsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryProposedChainIDsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ProposedChain) 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 ErrIntOverflowQuery
			}
			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: ProposedChain: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ProposedChain: 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 ErrIntOverflowQuery
				}
				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 ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			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 ProposalID", wireType)
			}
			m.ProposalID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ProposalID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryAllPairsValConAddrByConsumerChainIDRequest) 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 ErrIntOverflowQuery
			}
			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: QueryAllPairsValConAddrByConsumerChainIDRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryAllPairsValConAddrByConsumerChainIDRequest: 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 ErrIntOverflowQuery
				}
				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 ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ChainId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryParamsRequest) 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 ErrIntOverflowQuery
			}
			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: QueryParamsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryParamsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

var (
	ErrInvalidLengthQuery        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowQuery          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupQuery = fmt.Errorf("proto: unexpected end of group")
)