query.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: palomachain/paloma/consensus/query.proto

package types

import (
	context "context"
	fmt "fmt"
	io "io"
	math "math"
	math_bits "math/bits"

	types "github.com/cosmos/cosmos-sdk/codec/types"
	github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
	_ "github.com/cosmos/gogoproto/gogoproto"
	grpc1 "github.com/cosmos/gogoproto/grpc"
	proto "github.com/cosmos/gogoproto/proto"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
)

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

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

// QueryParamsRequest is request type for the Query/Params RPC method.
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_186b66ae011355e3, []int{0}
}

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

// QueryParamsResponse is response type for the Query/Params RPC method.
type QueryParamsResponse struct {
	// params holds all the parameters of this module.
	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_186b66ae011355e3, []int{1}
}

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{}
}

type QueryQueuedMessagesForSigningRequest struct {
	ValAddress    github_com_cosmos_cosmos_sdk_types.ValAddress `protobuf:"bytes,1,opt,name=valAddress,proto3,casttype=github.com/cosmos/cosmos-sdk/types.ValAddress" json:"valAddress,omitempty"`
	QueueTypeName string                                        `protobuf:"bytes,2,opt,name=queueTypeName,proto3" json:"queueTypeName,omitempty"`
}

func (m *QueryQueuedMessagesForSigningRequest) Reset()         { *m = QueryQueuedMessagesForSigningRequest{} }
func (m *QueryQueuedMessagesForSigningRequest) String() string { return proto.CompactTextString(m) }
func (*QueryQueuedMessagesForSigningRequest) ProtoMessage()    {}
func (*QueryQueuedMessagesForSigningRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_186b66ae011355e3, []int{2}
}

func (m *QueryQueuedMessagesForSigningRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *QueryQueuedMessagesForSigningRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryQueuedMessagesForSigningRequest.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 *QueryQueuedMessagesForSigningRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryQueuedMessagesForSigningRequest.Merge(m, src)
}

func (m *QueryQueuedMessagesForSigningRequest) XXX_Size() int {
	return m.Size()
}

func (m *QueryQueuedMessagesForSigningRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryQueuedMessagesForSigningRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryQueuedMessagesForSigningRequest proto.InternalMessageInfo

func (m *QueryQueuedMessagesForSigningRequest) GetValAddress() github_com_cosmos_cosmos_sdk_types.ValAddress {
	if m != nil {
		return m.ValAddress
	}
	return nil
}

func (m *QueryQueuedMessagesForSigningRequest) GetQueueTypeName() string {
	if m != nil {
		return m.QueueTypeName
	}
	return ""
}

type QueryQueuedMessagesForSigningResponse struct {
	MessageToSign []*MessageToSign `protobuf:"bytes,1,rep,name=messageToSign,proto3" json:"messageToSign,omitempty"`
}

func (m *QueryQueuedMessagesForSigningResponse) Reset()         { *m = QueryQueuedMessagesForSigningResponse{} }
func (m *QueryQueuedMessagesForSigningResponse) String() string { return proto.CompactTextString(m) }
func (*QueryQueuedMessagesForSigningResponse) ProtoMessage()    {}
func (*QueryQueuedMessagesForSigningResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_186b66ae011355e3, []int{3}
}

func (m *QueryQueuedMessagesForSigningResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *QueryQueuedMessagesForSigningResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryQueuedMessagesForSigningResponse.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 *QueryQueuedMessagesForSigningResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryQueuedMessagesForSigningResponse.Merge(m, src)
}

func (m *QueryQueuedMessagesForSigningResponse) XXX_Size() int {
	return m.Size()
}

func (m *QueryQueuedMessagesForSigningResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryQueuedMessagesForSigningResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryQueuedMessagesForSigningResponse proto.InternalMessageInfo

func (m *QueryQueuedMessagesForSigningResponse) GetMessageToSign() []*MessageToSign {
	if m != nil {
		return m.MessageToSign
	}
	return nil
}

type MessageToSign struct {
	Nonce       []byte     `protobuf:"bytes,1,opt,name=nonce,proto3" json:"nonce,omitempty"`
	Id          uint64     `protobuf:"varint,2,opt,name=id,proto3" json:"id,omitempty"`
	BytesToSign []byte     `protobuf:"bytes,3,opt,name=bytesToSign,proto3" json:"bytesToSign,omitempty"`
	Msg         *types.Any `protobuf:"bytes,4,opt,name=msg,proto3" json:"msg,omitempty"`
}

func (m *MessageToSign) Reset()         { *m = MessageToSign{} }
func (m *MessageToSign) String() string { return proto.CompactTextString(m) }
func (*MessageToSign) ProtoMessage()    {}
func (*MessageToSign) Descriptor() ([]byte, []int) {
	return fileDescriptor_186b66ae011355e3, []int{4}
}

func (m *MessageToSign) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *MessageToSign) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MessageToSign.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 *MessageToSign) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessageToSign.Merge(m, src)
}

func (m *MessageToSign) XXX_Size() int {
	return m.Size()
}

func (m *MessageToSign) XXX_DiscardUnknown() {
	xxx_messageInfo_MessageToSign.DiscardUnknown(m)
}

var xxx_messageInfo_MessageToSign proto.InternalMessageInfo

func (m *MessageToSign) GetNonce() []byte {
	if m != nil {
		return m.Nonce
	}
	return nil
}

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

func (m *MessageToSign) GetBytesToSign() []byte {
	if m != nil {
		return m.BytesToSign
	}
	return nil
}

func (m *MessageToSign) GetMsg() *types.Any {
	if m != nil {
		return m.Msg
	}
	return nil
}

type ValidatorSignature struct {
	ValAddress             github_com_cosmos_cosmos_sdk_types.ValAddress `protobuf:"bytes,1,opt,name=valAddress,proto3,casttype=github.com/cosmos/cosmos-sdk/types.ValAddress" json:"valAddress,omitempty"`
	Signature              []byte                                        `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
	ExtraData              []byte                                        `protobuf:"bytes,3,opt,name=extraData,proto3" json:"extraData,omitempty"`
	ExternalAccountAddress string                                        `protobuf:"bytes,4,opt,name=externalAccountAddress,proto3" json:"externalAccountAddress,omitempty"`
	PublicKey              []byte                                        `protobuf:"bytes,5,opt,name=publicKey,proto3" json:"publicKey,omitempty"`
}

func (m *ValidatorSignature) Reset()         { *m = ValidatorSignature{} }
func (m *ValidatorSignature) String() string { return proto.CompactTextString(m) }
func (*ValidatorSignature) ProtoMessage()    {}
func (*ValidatorSignature) Descriptor() ([]byte, []int) {
	return fileDescriptor_186b66ae011355e3, []int{5}
}

func (m *ValidatorSignature) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *ValidatorSignature) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ValidatorSignature.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 *ValidatorSignature) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ValidatorSignature.Merge(m, src)
}

func (m *ValidatorSignature) XXX_Size() int {
	return m.Size()
}

func (m *ValidatorSignature) XXX_DiscardUnknown() {
	xxx_messageInfo_ValidatorSignature.DiscardUnknown(m)
}

var xxx_messageInfo_ValidatorSignature proto.InternalMessageInfo

func (m *ValidatorSignature) GetValAddress() github_com_cosmos_cosmos_sdk_types.ValAddress {
	if m != nil {
		return m.ValAddress
	}
	return nil
}

func (m *ValidatorSignature) GetSignature() []byte {
	if m != nil {
		return m.Signature
	}
	return nil
}

func (m *ValidatorSignature) GetExtraData() []byte {
	if m != nil {
		return m.ExtraData
	}
	return nil
}

func (m *ValidatorSignature) GetExternalAccountAddress() string {
	if m != nil {
		return m.ExternalAccountAddress
	}
	return ""
}

func (m *ValidatorSignature) GetPublicKey() []byte {
	if m != nil {
		return m.PublicKey
	}
	return nil
}

type MessageWithSignatures struct {
	Nonce            []byte                `protobuf:"bytes,1,opt,name=nonce,proto3" json:"nonce,omitempty"`
	Id               uint64                `protobuf:"varint,2,opt,name=id,proto3" json:"id,omitempty"`
	Msg              *types.Any            `protobuf:"bytes,3,opt,name=msg,proto3" json:"msg,omitempty"`
	SignData         []*ValidatorSignature `protobuf:"bytes,4,rep,name=signData,proto3" json:"signData,omitempty"`
	BytesToSign      []byte                `protobuf:"bytes,5,opt,name=bytesToSign,proto3" json:"bytesToSign,omitempty"`
	PublicAccessData []byte                `protobuf:"bytes,6,opt,name=publicAccessData,proto3" json:"publicAccessData,omitempty"`
	ErrorData        []byte                `protobuf:"bytes,7,opt,name=errorData,proto3" json:"errorData,omitempty"`
	Evidence         []*Evidence           `protobuf:"bytes,8,rep,name=evidence,proto3" json:"evidence,omitempty"`
}

func (m *MessageWithSignatures) Reset()         { *m = MessageWithSignatures{} }
func (m *MessageWithSignatures) String() string { return proto.CompactTextString(m) }
func (*MessageWithSignatures) ProtoMessage()    {}
func (*MessageWithSignatures) Descriptor() ([]byte, []int) {
	return fileDescriptor_186b66ae011355e3, []int{6}
}

func (m *MessageWithSignatures) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *MessageWithSignatures) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MessageWithSignatures.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 *MessageWithSignatures) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MessageWithSignatures.Merge(m, src)
}

func (m *MessageWithSignatures) XXX_Size() int {
	return m.Size()
}

func (m *MessageWithSignatures) XXX_DiscardUnknown() {
	xxx_messageInfo_MessageWithSignatures.DiscardUnknown(m)
}

var xxx_messageInfo_MessageWithSignatures proto.InternalMessageInfo

func (m *MessageWithSignatures) GetNonce() []byte {
	if m != nil {
		return m.Nonce
	}
	return nil
}

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

func (m *MessageWithSignatures) GetMsg() *types.Any {
	if m != nil {
		return m.Msg
	}
	return nil
}

func (m *MessageWithSignatures) GetSignData() []*ValidatorSignature {
	if m != nil {
		return m.SignData
	}
	return nil
}

func (m *MessageWithSignatures) GetBytesToSign() []byte {
	if m != nil {
		return m.BytesToSign
	}
	return nil
}

func (m *MessageWithSignatures) GetPublicAccessData() []byte {
	if m != nil {
		return m.PublicAccessData
	}
	return nil
}

func (m *MessageWithSignatures) GetErrorData() []byte {
	if m != nil {
		return m.ErrorData
	}
	return nil
}

func (m *MessageWithSignatures) GetEvidence() []*Evidence {
	if m != nil {
		return m.Evidence
	}
	return nil
}

type QueryMessageByIDRequest struct {
	QueueTypeName string `protobuf:"bytes,1,opt,name=queueTypeName,proto3" json:"queueTypeName,omitempty"`
	Id            uint64 `protobuf:"varint,2,opt,name=id,proto3" json:"id,omitempty"`
}

func (m *QueryMessageByIDRequest) Reset()         { *m = QueryMessageByIDRequest{} }
func (m *QueryMessageByIDRequest) String() string { return proto.CompactTextString(m) }
func (*QueryMessageByIDRequest) ProtoMessage()    {}
func (*QueryMessageByIDRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_186b66ae011355e3, []int{7}
}

func (m *QueryMessageByIDRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *QueryMessageByIDRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryMessageByIDRequest.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 *QueryMessageByIDRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryMessageByIDRequest.Merge(m, src)
}

func (m *QueryMessageByIDRequest) XXX_Size() int {
	return m.Size()
}

func (m *QueryMessageByIDRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryMessageByIDRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryMessageByIDRequest proto.InternalMessageInfo

func (m *QueryMessageByIDRequest) GetQueueTypeName() string {
	if m != nil {
		return m.QueueTypeName
	}
	return ""
}

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

type QueryMessagesInQueueRequest struct {
	QueueTypeName                    string                                        `protobuf:"bytes,1,opt,name=queueTypeName,proto3" json:"queueTypeName,omitempty"`
	SkipEvidenceProvidedByValAddress github_com_cosmos_cosmos_sdk_types.ValAddress `protobuf:"bytes,2,opt,name=skipEvidenceProvidedByValAddress,proto3,casttype=github.com/cosmos/cosmos-sdk/types.ValAddress" json:"skipEvidenceProvidedByValAddress,omitempty"`
}

func (m *QueryMessagesInQueueRequest) Reset()         { *m = QueryMessagesInQueueRequest{} }
func (m *QueryMessagesInQueueRequest) String() string { return proto.CompactTextString(m) }
func (*QueryMessagesInQueueRequest) ProtoMessage()    {}
func (*QueryMessagesInQueueRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_186b66ae011355e3, []int{8}
}

func (m *QueryMessagesInQueueRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *QueryMessagesInQueueRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryMessagesInQueueRequest.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 *QueryMessagesInQueueRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryMessagesInQueueRequest.Merge(m, src)
}

func (m *QueryMessagesInQueueRequest) XXX_Size() int {
	return m.Size()
}

func (m *QueryMessagesInQueueRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryMessagesInQueueRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryMessagesInQueueRequest proto.InternalMessageInfo

func (m *QueryMessagesInQueueRequest) GetQueueTypeName() string {
	if m != nil {
		return m.QueueTypeName
	}
	return ""
}

func (m *QueryMessagesInQueueRequest) GetSkipEvidenceProvidedByValAddress() github_com_cosmos_cosmos_sdk_types.ValAddress {
	if m != nil {
		return m.SkipEvidenceProvidedByValAddress
	}
	return nil
}

type QueryMessagesInQueueResponse struct {
	Messages []MessageWithSignatures `protobuf:"bytes,1,rep,name=messages,proto3" json:"messages"`
}

func (m *QueryMessagesInQueueResponse) Reset()         { *m = QueryMessagesInQueueResponse{} }
func (m *QueryMessagesInQueueResponse) String() string { return proto.CompactTextString(m) }
func (*QueryMessagesInQueueResponse) ProtoMessage()    {}
func (*QueryMessagesInQueueResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_186b66ae011355e3, []int{9}
}

func (m *QueryMessagesInQueueResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *QueryMessagesInQueueResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryMessagesInQueueResponse.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 *QueryMessagesInQueueResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryMessagesInQueueResponse.Merge(m, src)
}

func (m *QueryMessagesInQueueResponse) XXX_Size() int {
	return m.Size()
}

func (m *QueryMessagesInQueueResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryMessagesInQueueResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryMessagesInQueueResponse proto.InternalMessageInfo

func (m *QueryMessagesInQueueResponse) GetMessages() []MessageWithSignatures {
	if m != nil {
		return m.Messages
	}
	return nil
}

type QueryQueuedMessagesForRelayingRequest struct {
	QueueTypeName string                                        `protobuf:"bytes,1,opt,name=queueTypeName,proto3" json:"queueTypeName,omitempty"`
	ValAddress    github_com_cosmos_cosmos_sdk_types.ValAddress `protobuf:"bytes,2,opt,name=valAddress,proto3,casttype=github.com/cosmos/cosmos-sdk/types.ValAddress" json:"valAddress,omitempty"`
}

func (m *QueryQueuedMessagesForRelayingRequest) Reset()         { *m = QueryQueuedMessagesForRelayingRequest{} }
func (m *QueryQueuedMessagesForRelayingRequest) String() string { return proto.CompactTextString(m) }
func (*QueryQueuedMessagesForRelayingRequest) ProtoMessage()    {}
func (*QueryQueuedMessagesForRelayingRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_186b66ae011355e3, []int{10}
}

func (m *QueryQueuedMessagesForRelayingRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *QueryQueuedMessagesForRelayingRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryQueuedMessagesForRelayingRequest.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 *QueryQueuedMessagesForRelayingRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryQueuedMessagesForRelayingRequest.Merge(m, src)
}

func (m *QueryQueuedMessagesForRelayingRequest) XXX_Size() int {
	return m.Size()
}

func (m *QueryQueuedMessagesForRelayingRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryQueuedMessagesForRelayingRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryQueuedMessagesForRelayingRequest proto.InternalMessageInfo

func (m *QueryQueuedMessagesForRelayingRequest) GetQueueTypeName() string {
	if m != nil {
		return m.QueueTypeName
	}
	return ""
}

func (m *QueryQueuedMessagesForRelayingRequest) GetValAddress() github_com_cosmos_cosmos_sdk_types.ValAddress {
	if m != nil {
		return m.ValAddress
	}
	return nil
}

type QueryQueuedMessagesForRelayingResponse struct {
	Messages []MessageWithSignatures `protobuf:"bytes,1,rep,name=messages,proto3" json:"messages"`
}

func (m *QueryQueuedMessagesForRelayingResponse) Reset() {
	*m = QueryQueuedMessagesForRelayingResponse{}
}
func (m *QueryQueuedMessagesForRelayingResponse) String() string { return proto.CompactTextString(m) }
func (*QueryQueuedMessagesForRelayingResponse) ProtoMessage()    {}
func (*QueryQueuedMessagesForRelayingResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_186b66ae011355e3, []int{11}
}

func (m *QueryQueuedMessagesForRelayingResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *QueryQueuedMessagesForRelayingResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryQueuedMessagesForRelayingResponse.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 *QueryQueuedMessagesForRelayingResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryQueuedMessagesForRelayingResponse.Merge(m, src)
}

func (m *QueryQueuedMessagesForRelayingResponse) XXX_Size() int {
	return m.Size()
}

func (m *QueryQueuedMessagesForRelayingResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryQueuedMessagesForRelayingResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryQueuedMessagesForRelayingResponse proto.InternalMessageInfo

func (m *QueryQueuedMessagesForRelayingResponse) GetMessages() []MessageWithSignatures {
	if m != nil {
		return m.Messages
	}
	return nil
}

type QueryQueuedMessagesForAttestingRequest struct {
	QueueTypeName string                                        `protobuf:"bytes,1,opt,name=queueTypeName,proto3" json:"queueTypeName,omitempty"`
	ValAddress    github_com_cosmos_cosmos_sdk_types.ValAddress `protobuf:"bytes,2,opt,name=valAddress,proto3,casttype=github.com/cosmos/cosmos-sdk/types.ValAddress" json:"valAddress,omitempty"`
}

func (m *QueryQueuedMessagesForAttestingRequest) Reset() {
	*m = QueryQueuedMessagesForAttestingRequest{}
}
func (m *QueryQueuedMessagesForAttestingRequest) String() string { return proto.CompactTextString(m) }
func (*QueryQueuedMessagesForAttestingRequest) ProtoMessage()    {}
func (*QueryQueuedMessagesForAttestingRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_186b66ae011355e3, []int{12}
}

func (m *QueryQueuedMessagesForAttestingRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *QueryQueuedMessagesForAttestingRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryQueuedMessagesForAttestingRequest.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 *QueryQueuedMessagesForAttestingRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryQueuedMessagesForAttestingRequest.Merge(m, src)
}

func (m *QueryQueuedMessagesForAttestingRequest) XXX_Size() int {
	return m.Size()
}

func (m *QueryQueuedMessagesForAttestingRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryQueuedMessagesForAttestingRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryQueuedMessagesForAttestingRequest proto.InternalMessageInfo

func (m *QueryQueuedMessagesForAttestingRequest) GetQueueTypeName() string {
	if m != nil {
		return m.QueueTypeName
	}
	return ""
}

func (m *QueryQueuedMessagesForAttestingRequest) GetValAddress() github_com_cosmos_cosmos_sdk_types.ValAddress {
	if m != nil {
		return m.ValAddress
	}
	return nil
}

type QueryQueuedMessagesForAttestingResponse struct {
	Messages []MessageWithSignatures `protobuf:"bytes,1,rep,name=messages,proto3" json:"messages"`
}

func (m *QueryQueuedMessagesForAttestingResponse) Reset() {
	*m = QueryQueuedMessagesForAttestingResponse{}
}
func (m *QueryQueuedMessagesForAttestingResponse) String() string { return proto.CompactTextString(m) }
func (*QueryQueuedMessagesForAttestingResponse) ProtoMessage()    {}
func (*QueryQueuedMessagesForAttestingResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_186b66ae011355e3, []int{13}
}

func (m *QueryQueuedMessagesForAttestingResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *QueryQueuedMessagesForAttestingResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryQueuedMessagesForAttestingResponse.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 *QueryQueuedMessagesForAttestingResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryQueuedMessagesForAttestingResponse.Merge(m, src)
}

func (m *QueryQueuedMessagesForAttestingResponse) XXX_Size() int {
	return m.Size()
}

func (m *QueryQueuedMessagesForAttestingResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryQueuedMessagesForAttestingResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryQueuedMessagesForAttestingResponse proto.InternalMessageInfo

func (m *QueryQueuedMessagesForAttestingResponse) GetMessages() []MessageWithSignatures {
	if m != nil {
		return m.Messages
	}
	return nil
}

type QueryGetAllQueueNamesRequest struct{}

func (m *QueryGetAllQueueNamesRequest) Reset()         { *m = QueryGetAllQueueNamesRequest{} }
func (m *QueryGetAllQueueNamesRequest) String() string { return proto.CompactTextString(m) }
func (*QueryGetAllQueueNamesRequest) ProtoMessage()    {}
func (*QueryGetAllQueueNamesRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_186b66ae011355e3, []int{14}
}

func (m *QueryGetAllQueueNamesRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *QueryGetAllQueueNamesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryGetAllQueueNamesRequest.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 *QueryGetAllQueueNamesRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryGetAllQueueNamesRequest.Merge(m, src)
}

func (m *QueryGetAllQueueNamesRequest) XXX_Size() int {
	return m.Size()
}

func (m *QueryGetAllQueueNamesRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryGetAllQueueNamesRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryGetAllQueueNamesRequest proto.InternalMessageInfo

type QueryGetAllQueueNamesResponse struct {
	Queues []string `protobuf:"bytes,1,rep,name=queues,proto3" json:"queues,omitempty"`
}

func (m *QueryGetAllQueueNamesResponse) Reset()         { *m = QueryGetAllQueueNamesResponse{} }
func (m *QueryGetAllQueueNamesResponse) String() string { return proto.CompactTextString(m) }
func (*QueryGetAllQueueNamesResponse) ProtoMessage()    {}
func (*QueryGetAllQueueNamesResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_186b66ae011355e3, []int{15}
}

func (m *QueryGetAllQueueNamesResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *QueryGetAllQueueNamesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryGetAllQueueNamesResponse.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 *QueryGetAllQueueNamesResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryGetAllQueueNamesResponse.Merge(m, src)
}

func (m *QueryGetAllQueueNamesResponse) XXX_Size() int {
	return m.Size()
}

func (m *QueryGetAllQueueNamesResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryGetAllQueueNamesResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryGetAllQueueNamesResponse proto.InternalMessageInfo

func (m *QueryGetAllQueueNamesResponse) GetQueues() []string {
	if m != nil {
		return m.Queues
	}
	return nil
}

func init() {
	proto.RegisterType((*QueryParamsRequest)(nil), "palomachain.paloma.consensus.QueryParamsRequest")
	proto.RegisterType((*QueryParamsResponse)(nil), "palomachain.paloma.consensus.QueryParamsResponse")
	proto.RegisterType((*QueryQueuedMessagesForSigningRequest)(nil), "palomachain.paloma.consensus.QueryQueuedMessagesForSigningRequest")
	proto.RegisterType((*QueryQueuedMessagesForSigningResponse)(nil), "palomachain.paloma.consensus.QueryQueuedMessagesForSigningResponse")
	proto.RegisterType((*MessageToSign)(nil), "palomachain.paloma.consensus.MessageToSign")
	proto.RegisterType((*ValidatorSignature)(nil), "palomachain.paloma.consensus.ValidatorSignature")
	proto.RegisterType((*MessageWithSignatures)(nil), "palomachain.paloma.consensus.MessageWithSignatures")
	proto.RegisterType((*QueryMessageByIDRequest)(nil), "palomachain.paloma.consensus.QueryMessageByIDRequest")
	proto.RegisterType((*QueryMessagesInQueueRequest)(nil), "palomachain.paloma.consensus.QueryMessagesInQueueRequest")
	proto.RegisterType((*QueryMessagesInQueueResponse)(nil), "palomachain.paloma.consensus.QueryMessagesInQueueResponse")
	proto.RegisterType((*QueryQueuedMessagesForRelayingRequest)(nil), "palomachain.paloma.consensus.QueryQueuedMessagesForRelayingRequest")
	proto.RegisterType((*QueryQueuedMessagesForRelayingResponse)(nil), "palomachain.paloma.consensus.QueryQueuedMessagesForRelayingResponse")
	proto.RegisterType((*QueryQueuedMessagesForAttestingRequest)(nil), "palomachain.paloma.consensus.QueryQueuedMessagesForAttestingRequest")
	proto.RegisterType((*QueryQueuedMessagesForAttestingResponse)(nil), "palomachain.paloma.consensus.QueryQueuedMessagesForAttestingResponse")
	proto.RegisterType((*QueryGetAllQueueNamesRequest)(nil), "palomachain.paloma.consensus.QueryGetAllQueueNamesRequest")
	proto.RegisterType((*QueryGetAllQueueNamesResponse)(nil), "palomachain.paloma.consensus.QueryGetAllQueueNamesResponse")
}

func init() {
	proto.RegisterFile("palomachain/paloma/consensus/query.proto", fileDescriptor_186b66ae011355e3)
}

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

// Reference imports to suppress errors if they are not otherwise used.
var (
	_ context.Context
	_ 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 {
	// Parameters queries the parameters of the module.
	Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error)
	// Queries a list of QueuedMessagesForSigning items.
	QueuedMessagesForSigning(ctx context.Context, in *QueryQueuedMessagesForSigningRequest, opts ...grpc.CallOption) (*QueryQueuedMessagesForSigningResponse, error)
	// Queries a list of QueuedMessagesForRelaying items.
	QueuedMessagesForRelaying(ctx context.Context, in *QueryQueuedMessagesForRelayingRequest, opts ...grpc.CallOption) (*QueryQueuedMessagesForRelayingResponse, error)
	// Queries a list of QueuedMessagesForAttesting items.
	QueuedMessagesForAttesting(ctx context.Context, in *QueryQueuedMessagesForAttestingRequest, opts ...grpc.CallOption) (*QueryQueuedMessagesForAttestingResponse, error)
	// Queries a list of MessagesInQueue items.
	MessagesInQueue(ctx context.Context, in *QueryMessagesInQueueRequest, opts ...grpc.CallOption) (*QueryMessagesInQueueResponse, error)
	// Queries one message by ID.
	MessageByID(ctx context.Context, in *QueryMessageByIDRequest, opts ...grpc.CallOption) (*MessageWithSignatures, error)
	// Queries a list of GetAllQueueNames items.
	GetAllQueueNames(ctx context.Context, in *QueryGetAllQueueNamesRequest, opts ...grpc.CallOption) (*QueryGetAllQueueNamesResponse, error)
}

type queryClient struct {
	cc grpc1.ClientConn
}

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

func (c *queryClient) Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error) {
	out := new(QueryParamsResponse)
	err := c.cc.Invoke(ctx, "/palomachain.paloma.consensus.Query/Params", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) QueuedMessagesForSigning(ctx context.Context, in *QueryQueuedMessagesForSigningRequest, opts ...grpc.CallOption) (*QueryQueuedMessagesForSigningResponse, error) {
	out := new(QueryQueuedMessagesForSigningResponse)
	err := c.cc.Invoke(ctx, "/palomachain.paloma.consensus.Query/QueuedMessagesForSigning", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) QueuedMessagesForRelaying(ctx context.Context, in *QueryQueuedMessagesForRelayingRequest, opts ...grpc.CallOption) (*QueryQueuedMessagesForRelayingResponse, error) {
	out := new(QueryQueuedMessagesForRelayingResponse)
	err := c.cc.Invoke(ctx, "/palomachain.paloma.consensus.Query/QueuedMessagesForRelaying", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) QueuedMessagesForAttesting(ctx context.Context, in *QueryQueuedMessagesForAttestingRequest, opts ...grpc.CallOption) (*QueryQueuedMessagesForAttestingResponse, error) {
	out := new(QueryQueuedMessagesForAttestingResponse)
	err := c.cc.Invoke(ctx, "/palomachain.paloma.consensus.Query/QueuedMessagesForAttesting", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) MessagesInQueue(ctx context.Context, in *QueryMessagesInQueueRequest, opts ...grpc.CallOption) (*QueryMessagesInQueueResponse, error) {
	out := new(QueryMessagesInQueueResponse)
	err := c.cc.Invoke(ctx, "/palomachain.paloma.consensus.Query/MessagesInQueue", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) MessageByID(ctx context.Context, in *QueryMessageByIDRequest, opts ...grpc.CallOption) (*MessageWithSignatures, error) {
	out := new(MessageWithSignatures)
	err := c.cc.Invoke(ctx, "/palomachain.paloma.consensus.Query/MessageByID", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) GetAllQueueNames(ctx context.Context, in *QueryGetAllQueueNamesRequest, opts ...grpc.CallOption) (*QueryGetAllQueueNamesResponse, error) {
	out := new(QueryGetAllQueueNamesResponse)
	err := c.cc.Invoke(ctx, "/palomachain.paloma.consensus.Query/GetAllQueueNames", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// QueryServer is the server API for Query service.
type QueryServer interface {
	// Parameters queries the parameters of the module.
	Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error)
	// Queries a list of QueuedMessagesForSigning items.
	QueuedMessagesForSigning(context.Context, *QueryQueuedMessagesForSigningRequest) (*QueryQueuedMessagesForSigningResponse, error)
	// Queries a list of QueuedMessagesForRelaying items.
	QueuedMessagesForRelaying(context.Context, *QueryQueuedMessagesForRelayingRequest) (*QueryQueuedMessagesForRelayingResponse, error)
	// Queries a list of QueuedMessagesForAttesting items.
	QueuedMessagesForAttesting(context.Context, *QueryQueuedMessagesForAttestingRequest) (*QueryQueuedMessagesForAttestingResponse, error)
	// Queries a list of MessagesInQueue items.
	MessagesInQueue(context.Context, *QueryMessagesInQueueRequest) (*QueryMessagesInQueueResponse, error)
	// Queries one message by ID.
	MessageByID(context.Context, *QueryMessageByIDRequest) (*MessageWithSignatures, error)
	// Queries a list of GetAllQueueNames items.
	GetAllQueueNames(context.Context, *QueryGetAllQueueNamesRequest) (*QueryGetAllQueueNamesResponse, error)
}

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

func (*UnimplementedQueryServer) Params(ctx context.Context, req *QueryParamsRequest) (*QueryParamsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Params not implemented")
}

func (*UnimplementedQueryServer) QueuedMessagesForSigning(ctx context.Context, req *QueryQueuedMessagesForSigningRequest) (*QueryQueuedMessagesForSigningResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method QueuedMessagesForSigning not implemented")
}

func (*UnimplementedQueryServer) QueuedMessagesForRelaying(ctx context.Context, req *QueryQueuedMessagesForRelayingRequest) (*QueryQueuedMessagesForRelayingResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method QueuedMessagesForRelaying not implemented")
}

func (*UnimplementedQueryServer) QueuedMessagesForAttesting(ctx context.Context, req *QueryQueuedMessagesForAttestingRequest) (*QueryQueuedMessagesForAttestingResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method QueuedMessagesForAttesting not implemented")
}

func (*UnimplementedQueryServer) MessagesInQueue(ctx context.Context, req *QueryMessagesInQueueRequest) (*QueryMessagesInQueueResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MessagesInQueue not implemented")
}

func (*UnimplementedQueryServer) MessageByID(ctx context.Context, req *QueryMessageByIDRequest) (*MessageWithSignatures, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MessageByID not implemented")
}

func (*UnimplementedQueryServer) GetAllQueueNames(ctx context.Context, req *QueryGetAllQueueNamesRequest) (*QueryGetAllQueueNamesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetAllQueueNames not implemented")
}

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

func _Query_Params_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).Params(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/palomachain.paloma.consensus.Query/Params",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Params(ctx, req.(*QueryParamsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_QueuedMessagesForSigning_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryQueuedMessagesForSigningRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).QueuedMessagesForSigning(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/palomachain.paloma.consensus.Query/QueuedMessagesForSigning",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).QueuedMessagesForSigning(ctx, req.(*QueryQueuedMessagesForSigningRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_QueuedMessagesForRelaying_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryQueuedMessagesForRelayingRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).QueuedMessagesForRelaying(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/palomachain.paloma.consensus.Query/QueuedMessagesForRelaying",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).QueuedMessagesForRelaying(ctx, req.(*QueryQueuedMessagesForRelayingRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_QueuedMessagesForAttesting_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryQueuedMessagesForAttestingRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).QueuedMessagesForAttesting(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/palomachain.paloma.consensus.Query/QueuedMessagesForAttesting",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).QueuedMessagesForAttesting(ctx, req.(*QueryQueuedMessagesForAttestingRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_MessagesInQueue_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryMessagesInQueueRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).MessagesInQueue(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/palomachain.paloma.consensus.Query/MessagesInQueue",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).MessagesInQueue(ctx, req.(*QueryMessagesInQueueRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_MessageByID_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryMessageByIDRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).MessageByID(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/palomachain.paloma.consensus.Query/MessageByID",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).MessageByID(ctx, req.(*QueryMessageByIDRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_GetAllQueueNames_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryGetAllQueueNamesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).GetAllQueueNames(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/palomachain.paloma.consensus.Query/GetAllQueueNames",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).GetAllQueueNames(ctx, req.(*QueryGetAllQueueNamesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Query_serviceDesc = grpc.ServiceDesc{
	ServiceName: "palomachain.paloma.consensus.Query",
	HandlerType: (*QueryServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Params",
			Handler:    _Query_Params_Handler,
		},
		{
			MethodName: "QueuedMessagesForSigning",
			Handler:    _Query_QueuedMessagesForSigning_Handler,
		},
		{
			MethodName: "QueuedMessagesForRelaying",
			Handler:    _Query_QueuedMessagesForRelaying_Handler,
		},
		{
			MethodName: "QueuedMessagesForAttesting",
			Handler:    _Query_QueuedMessagesForAttesting_Handler,
		},
		{
			MethodName: "MessagesInQueue",
			Handler:    _Query_MessagesInQueue_Handler,
		},
		{
			MethodName: "MessageByID",
			Handler:    _Query_MessageByID_Handler,
		},
		{
			MethodName: "GetAllQueueNames",
			Handler:    _Query_GetAllQueueNames_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "palomachain/paloma/consensus/query.proto",
}

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

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

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

func (m *QueryQueuedMessagesForSigningResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.MessageToSign) > 0 {
		for iNdEx := len(m.MessageToSign) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.MessageToSign[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 *MessageToSign) 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 *MessageToSign) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MessageToSign) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Msg != nil {
		{
			size, err := m.Msg.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQuery(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.BytesToSign) > 0 {
		i -= len(m.BytesToSign)
		copy(dAtA[i:], m.BytesToSign)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.BytesToSign)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Id != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.Id))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Nonce) > 0 {
		i -= len(m.Nonce)
		copy(dAtA[i:], m.Nonce)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.Nonce)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *ValidatorSignature) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.PublicKey) > 0 {
		i -= len(m.PublicKey)
		copy(dAtA[i:], m.PublicKey)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.PublicKey)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.ExternalAccountAddress) > 0 {
		i -= len(m.ExternalAccountAddress)
		copy(dAtA[i:], m.ExternalAccountAddress)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.ExternalAccountAddress)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.ExtraData) > 0 {
		i -= len(m.ExtraData)
		copy(dAtA[i:], m.ExtraData)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.ExtraData)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Signature) > 0 {
		i -= len(m.Signature)
		copy(dAtA[i:], m.Signature)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.Signature)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ValAddress) > 0 {
		i -= len(m.ValAddress)
		copy(dAtA[i:], m.ValAddress)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.ValAddress)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *MessageWithSignatures) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Evidence) > 0 {
		for iNdEx := len(m.Evidence) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Evidence[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQuery(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x42
		}
	}
	if len(m.ErrorData) > 0 {
		i -= len(m.ErrorData)
		copy(dAtA[i:], m.ErrorData)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.ErrorData)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.PublicAccessData) > 0 {
		i -= len(m.PublicAccessData)
		copy(dAtA[i:], m.PublicAccessData)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.PublicAccessData)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.BytesToSign) > 0 {
		i -= len(m.BytesToSign)
		copy(dAtA[i:], m.BytesToSign)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.BytesToSign)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.SignData) > 0 {
		for iNdEx := len(m.SignData) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.SignData[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQuery(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if m.Msg != nil {
		{
			size, err := m.Msg.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQuery(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Id != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.Id))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Nonce) > 0 {
		i -= len(m.Nonce)
		copy(dAtA[i:], m.Nonce)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.Nonce)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *QueryMessagesInQueueResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Messages) > 0 {
		for iNdEx := len(m.Messages) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Messages[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 *QueryQueuedMessagesForRelayingRequest) 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 *QueryQueuedMessagesForRelayingRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *QueryQueuedMessagesForRelayingResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Messages) > 0 {
		for iNdEx := len(m.Messages) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Messages[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 *QueryQueuedMessagesForAttestingRequest) 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 *QueryQueuedMessagesForAttestingRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *QueryQueuedMessagesForAttestingResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Messages) > 0 {
		for iNdEx := len(m.Messages) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Messages[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 *QueryGetAllQueueNamesRequest) 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 *QueryGetAllQueueNamesRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *QueryGetAllQueueNamesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Queues) > 0 {
		for iNdEx := len(m.Queues) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Queues[iNdEx])
			copy(dAtA[i:], m.Queues[iNdEx])
			i = encodeVarintQuery(dAtA, i, uint64(len(m.Queues[iNdEx])))
			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 *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 (m *QueryQueuedMessagesForSigningRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ValAddress)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	l = len(m.QueueTypeName)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

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

func (m *MessageToSign) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Nonce)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	if m.Id != 0 {
		n += 1 + sovQuery(uint64(m.Id))
	}
	l = len(m.BytesToSign)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	if m.Msg != nil {
		l = m.Msg.Size()
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

func (m *ValidatorSignature) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ValAddress)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	l = len(m.Signature)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	l = len(m.ExtraData)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	l = len(m.ExternalAccountAddress)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	l = len(m.PublicKey)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

func (m *MessageWithSignatures) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Nonce)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	if m.Id != 0 {
		n += 1 + sovQuery(uint64(m.Id))
	}
	if m.Msg != nil {
		l = m.Msg.Size()
		n += 1 + l + sovQuery(uint64(l))
	}
	if len(m.SignData) > 0 {
		for _, e := range m.SignData {
			l = e.Size()
			n += 1 + l + sovQuery(uint64(l))
		}
	}
	l = len(m.BytesToSign)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	l = len(m.PublicAccessData)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	l = len(m.ErrorData)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	if len(m.Evidence) > 0 {
		for _, e := range m.Evidence {
			l = e.Size()
			n += 1 + l + sovQuery(uint64(l))
		}
	}
	return n
}

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

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

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

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

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

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

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

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

func (m *QueryGetAllQueueNamesResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Queues) > 0 {
		for _, s := range m.Queues {
			l = len(s)
			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 *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 (m *QueryQueuedMessagesForSigningRequest) 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: QueryQueuedMessagesForSigningRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryQueuedMessagesForSigningRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValAddress", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ValAddress = append(m.ValAddress[:0], dAtA[iNdEx:postIndex]...)
			if m.ValAddress == nil {
				m.ValAddress = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field QueueTypeName", 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.QueueTypeName = 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 *QueryQueuedMessagesForSigningResponse) 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: QueryQueuedMessagesForSigningResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryQueuedMessagesForSigningResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MessageToSign", 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.MessageToSign = append(m.MessageToSign, &MessageToSign{})
			if err := m.MessageToSign[len(m.MessageToSign)-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 *MessageToSign) 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: MessageToSign: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MessageToSign: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Nonce", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Nonce = append(m.Nonce[:0], dAtA[iNdEx:postIndex]...)
			if m.Nonce == nil {
				m.Nonce = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			m.Id = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Id |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BytesToSign", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BytesToSign = append(m.BytesToSign[:0], dAtA[iNdEx:postIndex]...)
			if m.BytesToSign == nil {
				m.BytesToSign = []byte{}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Msg", 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.Msg == nil {
				m.Msg = &types.Any{}
			}
			if err := m.Msg.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 *ValidatorSignature) 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: ValidatorSignature: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ValidatorSignature: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValAddress", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ValAddress = append(m.ValAddress[:0], dAtA[iNdEx:postIndex]...)
			if m.ValAddress == nil {
				m.ValAddress = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...)
			if m.Signature == nil {
				m.Signature = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExtraData", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ExtraData = append(m.ExtraData[:0], dAtA[iNdEx:postIndex]...)
			if m.ExtraData == nil {
				m.ExtraData = []byte{}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExternalAccountAddress", 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.ExternalAccountAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PublicKey", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PublicKey = append(m.PublicKey[:0], dAtA[iNdEx:postIndex]...)
			if m.PublicKey == nil {
				m.PublicKey = []byte{}
			}
			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 *MessageWithSignatures) 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: MessageWithSignatures: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MessageWithSignatures: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Nonce", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Nonce = append(m.Nonce[:0], dAtA[iNdEx:postIndex]...)
			if m.Nonce == nil {
				m.Nonce = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			m.Id = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Id |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Msg", 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.Msg == nil {
				m.Msg = &types.Any{}
			}
			if err := m.Msg.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SignData", 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.SignData = append(m.SignData, &ValidatorSignature{})
			if err := m.SignData[len(m.SignData)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BytesToSign", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BytesToSign = append(m.BytesToSign[:0], dAtA[iNdEx:postIndex]...)
			if m.BytesToSign == nil {
				m.BytesToSign = []byte{}
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PublicAccessData", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PublicAccessData = append(m.PublicAccessData[:0], dAtA[iNdEx:postIndex]...)
			if m.PublicAccessData == nil {
				m.PublicAccessData = []byte{}
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ErrorData", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ErrorData = append(m.ErrorData[:0], dAtA[iNdEx:postIndex]...)
			if m.ErrorData == nil {
				m.ErrorData = []byte{}
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Evidence", 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.Evidence = append(m.Evidence, &Evidence{})
			if err := m.Evidence[len(m.Evidence)-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 *QueryMessageByIDRequest) 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: QueryMessageByIDRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryMessageByIDRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field QueueTypeName", 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.QueueTypeName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			m.Id = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Id |= 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 *QueryMessagesInQueueRequest) 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: QueryMessagesInQueueRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryMessagesInQueueRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field QueueTypeName", 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.QueueTypeName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SkipEvidenceProvidedByValAddress", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SkipEvidenceProvidedByValAddress = append(m.SkipEvidenceProvidedByValAddress[:0], dAtA[iNdEx:postIndex]...)
			if m.SkipEvidenceProvidedByValAddress == nil {
				m.SkipEvidenceProvidedByValAddress = []byte{}
			}
			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 *QueryMessagesInQueueResponse) 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: QueryMessagesInQueueResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryMessagesInQueueResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Messages", 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.Messages = append(m.Messages, MessageWithSignatures{})
			if err := m.Messages[len(m.Messages)-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 *QueryQueuedMessagesForRelayingRequest) 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: QueryQueuedMessagesForRelayingRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryQueuedMessagesForRelayingRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field QueueTypeName", 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.QueueTypeName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValAddress", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ValAddress = append(m.ValAddress[:0], dAtA[iNdEx:postIndex]...)
			if m.ValAddress == nil {
				m.ValAddress = []byte{}
			}
			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 *QueryQueuedMessagesForRelayingResponse) 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: QueryQueuedMessagesForRelayingResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryQueuedMessagesForRelayingResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Messages", 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.Messages = append(m.Messages, MessageWithSignatures{})
			if err := m.Messages[len(m.Messages)-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 *QueryQueuedMessagesForAttestingRequest) 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: QueryQueuedMessagesForAttestingRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryQueuedMessagesForAttestingRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field QueueTypeName", 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.QueueTypeName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValAddress", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ValAddress = append(m.ValAddress[:0], dAtA[iNdEx:postIndex]...)
			if m.ValAddress == nil {
				m.ValAddress = []byte{}
			}
			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 *QueryQueuedMessagesForAttestingResponse) 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: QueryQueuedMessagesForAttestingResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryQueuedMessagesForAttestingResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Messages", 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.Messages = append(m.Messages, MessageWithSignatures{})
			if err := m.Messages[len(m.Messages)-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 *QueryGetAllQueueNamesRequest) 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: QueryGetAllQueueNamesRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryGetAllQueueNamesRequest: 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 *QueryGetAllQueueNamesResponse) 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: QueryGetAllQueueNamesResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryGetAllQueueNamesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Queues", 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.Queues = append(m.Queues, 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 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")
)