// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: band/feeds/v1beta1/query.proto

package types

import (
	context "context"
	fmt "fmt"
	_ "github.com/cosmos/cosmos-proto"
	query "github.com/cosmos/cosmos-sdk/types/query"
	_ "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"
	io "io"
	math "math"
	math_bits "math/bits"
)

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

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

// QueryCurrentFeedsRequest is the request type for the Query/CurrentFeeds RPC method.
type QueryCurrentFeedsRequest struct {
}

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

var xxx_messageInfo_QueryCurrentFeedsRequest proto.InternalMessageInfo

// QueryCurrentFeedsResponse is the response type for the Query/CurrentFeeds RPC method.
type QueryCurrentFeedsResponse struct {
	// current_feeds is a list of currently supported feed-with-deviations, and its last update time and block.
	CurrentFeeds CurrentFeedWithDeviations `protobuf:"bytes,1,opt,name=current_feeds,json=currentFeeds,proto3" json:"current_feeds"`
}

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

var xxx_messageInfo_QueryCurrentFeedsResponse proto.InternalMessageInfo

func (m *QueryCurrentFeedsResponse) GetCurrentFeeds() CurrentFeedWithDeviations {
	if m != nil {
		return m.CurrentFeeds
	}
	return CurrentFeedWithDeviations{}
}

// QueryIsFeederRequest is the request type for the Query/IsFeeder RPC method.
type QueryIsFeederRequest struct {
	// validator is a validator address.
	Validator string `protobuf:"bytes,1,opt,name=validator,proto3" json:"validator,omitempty"`
	// feeder is a candidate account.
	Feeder string `protobuf:"bytes,2,opt,name=feeder,proto3" json:"feeder,omitempty"`
}

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

var xxx_messageInfo_QueryIsFeederRequest proto.InternalMessageInfo

func (m *QueryIsFeederRequest) GetValidator() string {
	if m != nil {
		return m.Validator
	}
	return ""
}

func (m *QueryIsFeederRequest) GetFeeder() string {
	if m != nil {
		return m.Feeder
	}
	return ""
}

// QueryIsFeederResponse is the response type for the Query/IsFeeder RPC method.
type QueryIsFeederResponse struct {
	// is_feeder is true if this account has been granted by validator.
	IsFeeder bool `protobuf:"varint,1,opt,name=is_feeder,json=isFeeder,proto3" json:"is_feeder,omitempty"`
}

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

var xxx_messageInfo_QueryIsFeederResponse proto.InternalMessageInfo

func (m *QueryIsFeederResponse) GetIsFeeder() bool {
	if m != nil {
		return m.IsFeeder
	}
	return false
}

// QueryParamsRequest is the 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_39690037efa6f66f, []int{4}
}
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 the response type for the Query/Params RPC method.
type QueryParamsResponse struct {
	// params is the parameters of the 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_39690037efa6f66f, []int{5}
}
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{}
}

// QueryPriceRequest is the request type for the Query/Price RPC method.
type QueryPriceRequest struct {
	// signal_id is the signal id to query the price for.
	SignalId string `protobuf:"bytes,1,opt,name=signal_id,json=signalId,proto3" json:"signal_id,omitempty"`
}

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

var xxx_messageInfo_QueryPriceRequest proto.InternalMessageInfo

func (m *QueryPriceRequest) GetSignalId() string {
	if m != nil {
		return m.SignalId
	}
	return ""
}

// QueryPriceResponse is the response type for the Query/Price RPC method.
type QueryPriceResponse struct {
	// price is the aggregated price of the signal id.
	Price Price `protobuf:"bytes,1,opt,name=price,proto3" json:"price"`
}

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

var xxx_messageInfo_QueryPriceResponse proto.InternalMessageInfo

func (m *QueryPriceResponse) GetPrice() Price {
	if m != nil {
		return m.Price
	}
	return Price{}
}

// QueryPricesRequest is the request type for the Query/Prices RPC method.
type QueryPricesRequest struct {
	// signal_ids is a list of signal ids to query prices for.
	SignalIds []string `protobuf:"bytes,1,rep,name=signal_ids,json=signalIds,proto3" json:"signal_ids,omitempty"`
}

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

var xxx_messageInfo_QueryPricesRequest proto.InternalMessageInfo

func (m *QueryPricesRequest) GetSignalIds() []string {
	if m != nil {
		return m.SignalIds
	}
	return nil
}

// QueryPricesResponse is the response type for the Query/Prices RPC method.
type QueryPricesResponse struct {
	// prices is a list of prices.
	Prices []Price `protobuf:"bytes,1,rep,name=prices,proto3" json:"prices"`
}

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

var xxx_messageInfo_QueryPricesResponse proto.InternalMessageInfo

func (m *QueryPricesResponse) GetPrices() []Price {
	if m != nil {
		return m.Prices
	}
	return nil
}

// QueryAllPricesRequest is the request type for the Query/AllPrices RPC method.
type QueryAllPricesRequest struct {
	// pagination is the pagination for the request.
	Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryAllPricesRequest proto.InternalMessageInfo

func (m *QueryAllPricesRequest) GetPagination() *query.PageRequest {
	if m != nil {
		return m.Pagination
	}
	return nil
}

// QueryAllPricesResponse is the response type for the Query/AllPrices RPC method.
type QueryAllPricesResponse struct {
	// prices is a list of prices.
	Prices []Price `protobuf:"bytes,1,rep,name=prices,proto3" json:"prices"`
	// pagination is the pagination information in the response.
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryAllPricesResponse proto.InternalMessageInfo

func (m *QueryAllPricesResponse) GetPrices() []Price {
	if m != nil {
		return m.Prices
	}
	return nil
}

func (m *QueryAllPricesResponse) GetPagination() *query.PageResponse {
	if m != nil {
		return m.Pagination
	}
	return nil
}

// QueryReferenceSourceConfigRequest is the request type for the Query/ReferenceSourceConfig RPC method.
type QueryReferenceSourceConfigRequest struct {
}

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

var xxx_messageInfo_QueryReferenceSourceConfigRequest proto.InternalMessageInfo

// QueryReferenceSourceConfigResponse is the response type for the Query/ReferenceSourceConfig RPC method.
type QueryReferenceSourceConfigResponse struct {
	// reference_source_config is the information about the reference price source.
	ReferenceSourceConfig ReferenceSourceConfig `protobuf:"bytes,1,opt,name=reference_source_config,json=referenceSourceConfig,proto3" json:"reference_source_config"`
}

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

var xxx_messageInfo_QueryReferenceSourceConfigResponse proto.InternalMessageInfo

func (m *QueryReferenceSourceConfigResponse) GetReferenceSourceConfig() ReferenceSourceConfig {
	if m != nil {
		return m.ReferenceSourceConfig
	}
	return ReferenceSourceConfig{}
}

// QuerySignalTotalPowersRequest is the request type for the Query/SignalTotalPowers RPC method.
type QuerySignalTotalPowersRequest struct {
	// signal_ids is a list of signal ids to query.
	SignalIds []string `protobuf:"bytes,1,rep,name=signal_ids,json=signalIds,proto3" json:"signal_ids,omitempty"`
	// pagination is the pagination for the request.
	Pagination *query.PageRequest `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QuerySignalTotalPowersRequest proto.InternalMessageInfo

func (m *QuerySignalTotalPowersRequest) GetSignalIds() []string {
	if m != nil {
		return m.SignalIds
	}
	return nil
}

func (m *QuerySignalTotalPowersRequest) GetPagination() *query.PageRequest {
	if m != nil {
		return m.Pagination
	}
	return nil
}

// QuerySignalTotalPowersResponse is the response type for the Query/SignalTotalPowers RPC method.
type QuerySignalTotalPowersResponse struct {
	// signal_total_powers is a list of signal-total-powers.
	SignalTotalPowers []*Signal `protobuf:"bytes,1,rep,name=signal_total_powers,json=signalTotalPowers,proto3" json:"signal_total_powers,omitempty"`
	// pagination is the pagination information in the response.
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QuerySignalTotalPowersResponse proto.InternalMessageInfo

func (m *QuerySignalTotalPowersResponse) GetSignalTotalPowers() []*Signal {
	if m != nil {
		return m.SignalTotalPowers
	}
	return nil
}

func (m *QuerySignalTotalPowersResponse) GetPagination() *query.PageResponse {
	if m != nil {
		return m.Pagination
	}
	return nil
}

// QueryValidValidatorRequest is the request type for the Query/ValidValidator RPC method.
type QueryValidValidatorRequest struct {
	// validator is the validator address to query the flag.
	Validator string `protobuf:"bytes,1,opt,name=validator,proto3" json:"validator,omitempty"`
}

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

var xxx_messageInfo_QueryValidValidatorRequest proto.InternalMessageInfo

func (m *QueryValidValidatorRequest) GetValidator() string {
	if m != nil {
		return m.Validator
	}
	return ""
}

// QueryValidValidatorResponse is the response type for the Query/ValidValidator RPC method.
type QueryValidValidatorResponse struct {
	// valid is a valid flag.
	Valid bool `protobuf:"varint,1,opt,name=valid,proto3" json:"valid,omitempty"`
}

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

var xxx_messageInfo_QueryValidValidatorResponse proto.InternalMessageInfo

func (m *QueryValidValidatorResponse) GetValid() bool {
	if m != nil {
		return m.Valid
	}
	return false
}

// QueryValidatorPricesRequest is the request type for the Query/ValidatorPrices RPC method.
type QueryValidatorPricesRequest struct {
	// validator is the validator address to query prices for.
	Validator string `protobuf:"bytes,1,opt,name=validator,proto3" json:"validator,omitempty"`
	// signal_ids is the list of signal ids to query the price for.
	SignalIds []string `protobuf:"bytes,2,rep,name=signal_ids,json=signalIds,proto3" json:"signal_ids,omitempty"`
}

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

var xxx_messageInfo_QueryValidatorPricesRequest proto.InternalMessageInfo

func (m *QueryValidatorPricesRequest) GetValidator() string {
	if m != nil {
		return m.Validator
	}
	return ""
}

func (m *QueryValidatorPricesRequest) GetSignalIds() []string {
	if m != nil {
		return m.SignalIds
	}
	return nil
}

// QueryValidatorPricesResponse is the response type for the Query/ValidatorPrices RPC method.
type QueryValidatorPricesResponse struct {
	// validator_prices is a list of prices submitted by the validator.
	ValidatorPrices []ValidatorPrice `protobuf:"bytes,1,rep,name=validator_prices,json=validatorPrices,proto3" json:"validator_prices"`
}

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

var xxx_messageInfo_QueryValidatorPricesResponse proto.InternalMessageInfo

func (m *QueryValidatorPricesResponse) GetValidatorPrices() []ValidatorPrice {
	if m != nil {
		return m.ValidatorPrices
	}
	return nil
}

// QueryVoteRequest is the request type for the Query/Vote RPC method.
type QueryVoteRequest struct {
	// voter is the voter address to query signal for.
	Voter string `protobuf:"bytes,1,opt,name=voter,proto3" json:"voter,omitempty"`
}

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

var xxx_messageInfo_QueryVoteRequest proto.InternalMessageInfo

func (m *QueryVoteRequest) GetVoter() string {
	if m != nil {
		return m.Voter
	}
	return ""
}

// QueryVoteResponse is the response type for the Query/Vote RPC method.
type QueryVoteResponse struct {
	// signals is a list of signals submitted by the voter.
	Signals []Signal `protobuf:"bytes,1,rep,name=signals,proto3" json:"signals"`
}

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

var xxx_messageInfo_QueryVoteResponse proto.InternalMessageInfo

func (m *QueryVoteResponse) GetSignals() []Signal {
	if m != nil {
		return m.Signals
	}
	return nil
}

func init() {
	proto.RegisterType((*QueryCurrentFeedsRequest)(nil), "band.feeds.v1beta1.QueryCurrentFeedsRequest")
	proto.RegisterType((*QueryCurrentFeedsResponse)(nil), "band.feeds.v1beta1.QueryCurrentFeedsResponse")
	proto.RegisterType((*QueryIsFeederRequest)(nil), "band.feeds.v1beta1.QueryIsFeederRequest")
	proto.RegisterType((*QueryIsFeederResponse)(nil), "band.feeds.v1beta1.QueryIsFeederResponse")
	proto.RegisterType((*QueryParamsRequest)(nil), "band.feeds.v1beta1.QueryParamsRequest")
	proto.RegisterType((*QueryParamsResponse)(nil), "band.feeds.v1beta1.QueryParamsResponse")
	proto.RegisterType((*QueryPriceRequest)(nil), "band.feeds.v1beta1.QueryPriceRequest")
	proto.RegisterType((*QueryPriceResponse)(nil), "band.feeds.v1beta1.QueryPriceResponse")
	proto.RegisterType((*QueryPricesRequest)(nil), "band.feeds.v1beta1.QueryPricesRequest")
	proto.RegisterType((*QueryPricesResponse)(nil), "band.feeds.v1beta1.QueryPricesResponse")
	proto.RegisterType((*QueryAllPricesRequest)(nil), "band.feeds.v1beta1.QueryAllPricesRequest")
	proto.RegisterType((*QueryAllPricesResponse)(nil), "band.feeds.v1beta1.QueryAllPricesResponse")
	proto.RegisterType((*QueryReferenceSourceConfigRequest)(nil), "band.feeds.v1beta1.QueryReferenceSourceConfigRequest")
	proto.RegisterType((*QueryReferenceSourceConfigResponse)(nil), "band.feeds.v1beta1.QueryReferenceSourceConfigResponse")
	proto.RegisterType((*QuerySignalTotalPowersRequest)(nil), "band.feeds.v1beta1.QuerySignalTotalPowersRequest")
	proto.RegisterType((*QuerySignalTotalPowersResponse)(nil), "band.feeds.v1beta1.QuerySignalTotalPowersResponse")
	proto.RegisterType((*QueryValidValidatorRequest)(nil), "band.feeds.v1beta1.QueryValidValidatorRequest")
	proto.RegisterType((*QueryValidValidatorResponse)(nil), "band.feeds.v1beta1.QueryValidValidatorResponse")
	proto.RegisterType((*QueryValidatorPricesRequest)(nil), "band.feeds.v1beta1.QueryValidatorPricesRequest")
	proto.RegisterType((*QueryValidatorPricesResponse)(nil), "band.feeds.v1beta1.QueryValidatorPricesResponse")
	proto.RegisterType((*QueryVoteRequest)(nil), "band.feeds.v1beta1.QueryVoteRequest")
	proto.RegisterType((*QueryVoteResponse)(nil), "band.feeds.v1beta1.QueryVoteResponse")
}

func init() { proto.RegisterFile("band/feeds/v1beta1/query.proto", fileDescriptor_39690037efa6f66f) }

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

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

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

// QueryClient is the client API for Query service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type QueryClient interface {
	// CurrentFeeds is an RPC method that returns a list of current supported feeds.
	CurrentFeeds(ctx context.Context, in *QueryCurrentFeedsRequest, opts ...grpc.CallOption) (*QueryCurrentFeedsResponse, error)
	// IsFeeder is an RPC method that returns whether an account is a feeder for a specified validator.
	IsFeeder(ctx context.Context, in *QueryIsFeederRequest, opts ...grpc.CallOption) (*QueryIsFeederResponse, error)
	// Params is an RPC method that returns all parameters of the module.
	Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error)
	// Price is an RPC method that returns price by signal id.
	Price(ctx context.Context, in *QueryPriceRequest, opts ...grpc.CallOption) (*QueryPriceResponse, error)
	// Prices is an RPC method that prices by signal ids.
	Prices(ctx context.Context, in *QueryPricesRequest, opts ...grpc.CallOption) (*QueryPricesResponse, error)
	// AllPrices is an RPC method that returns all prices.
	AllPrices(ctx context.Context, in *QueryAllPricesRequest, opts ...grpc.CallOption) (*QueryAllPricesResponse, error)
	// ReferenceSourceConfig is an RPC method that returns information on the reference price source.
	ReferenceSourceConfig(ctx context.Context, in *QueryReferenceSourceConfigRequest, opts ...grpc.CallOption) (*QueryReferenceSourceConfigResponse, error)
	// SignalTotalPowers is an RPC method that returns all signal-total-powers or specified signal-total-power by signal
	// id.
	SignalTotalPowers(ctx context.Context, in *QuerySignalTotalPowersRequest, opts ...grpc.CallOption) (*QuerySignalTotalPowersResponse, error)
	// ValidValidator is an RPC method that returns a flag to show if the validator is required to send prices.
	ValidValidator(ctx context.Context, in *QueryValidValidatorRequest, opts ...grpc.CallOption) (*QueryValidValidatorResponse, error)
	// ValidatorPrices is an RPC method that returns prices of a validator.
	ValidatorPrices(ctx context.Context, in *QueryValidatorPricesRequest, opts ...grpc.CallOption) (*QueryValidatorPricesResponse, error)
	// Vote is an RPC method that returns signals of a voter.
	Vote(ctx context.Context, in *QueryVoteRequest, opts ...grpc.CallOption) (*QueryVoteResponse, error)
}

type queryClient struct {
	cc grpc1.ClientConn
}

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

func (c *queryClient) CurrentFeeds(ctx context.Context, in *QueryCurrentFeedsRequest, opts ...grpc.CallOption) (*QueryCurrentFeedsResponse, error) {
	out := new(QueryCurrentFeedsResponse)
	err := c.cc.Invoke(ctx, "/band.feeds.v1beta1.Query/CurrentFeeds", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) IsFeeder(ctx context.Context, in *QueryIsFeederRequest, opts ...grpc.CallOption) (*QueryIsFeederResponse, error) {
	out := new(QueryIsFeederResponse)
	err := c.cc.Invoke(ctx, "/band.feeds.v1beta1.Query/IsFeeder", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

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

func (c *queryClient) Price(ctx context.Context, in *QueryPriceRequest, opts ...grpc.CallOption) (*QueryPriceResponse, error) {
	out := new(QueryPriceResponse)
	err := c.cc.Invoke(ctx, "/band.feeds.v1beta1.Query/Price", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) Prices(ctx context.Context, in *QueryPricesRequest, opts ...grpc.CallOption) (*QueryPricesResponse, error) {
	out := new(QueryPricesResponse)
	err := c.cc.Invoke(ctx, "/band.feeds.v1beta1.Query/Prices", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) AllPrices(ctx context.Context, in *QueryAllPricesRequest, opts ...grpc.CallOption) (*QueryAllPricesResponse, error) {
	out := new(QueryAllPricesResponse)
	err := c.cc.Invoke(ctx, "/band.feeds.v1beta1.Query/AllPrices", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) ReferenceSourceConfig(ctx context.Context, in *QueryReferenceSourceConfigRequest, opts ...grpc.CallOption) (*QueryReferenceSourceConfigResponse, error) {
	out := new(QueryReferenceSourceConfigResponse)
	err := c.cc.Invoke(ctx, "/band.feeds.v1beta1.Query/ReferenceSourceConfig", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) SignalTotalPowers(ctx context.Context, in *QuerySignalTotalPowersRequest, opts ...grpc.CallOption) (*QuerySignalTotalPowersResponse, error) {
	out := new(QuerySignalTotalPowersResponse)
	err := c.cc.Invoke(ctx, "/band.feeds.v1beta1.Query/SignalTotalPowers", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) ValidValidator(ctx context.Context, in *QueryValidValidatorRequest, opts ...grpc.CallOption) (*QueryValidValidatorResponse, error) {
	out := new(QueryValidValidatorResponse)
	err := c.cc.Invoke(ctx, "/band.feeds.v1beta1.Query/ValidValidator", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) ValidatorPrices(ctx context.Context, in *QueryValidatorPricesRequest, opts ...grpc.CallOption) (*QueryValidatorPricesResponse, error) {
	out := new(QueryValidatorPricesResponse)
	err := c.cc.Invoke(ctx, "/band.feeds.v1beta1.Query/ValidatorPrices", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) Vote(ctx context.Context, in *QueryVoteRequest, opts ...grpc.CallOption) (*QueryVoteResponse, error) {
	out := new(QueryVoteResponse)
	err := c.cc.Invoke(ctx, "/band.feeds.v1beta1.Query/Vote", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// QueryServer is the server API for Query service.
type QueryServer interface {
	// CurrentFeeds is an RPC method that returns a list of current supported feeds.
	CurrentFeeds(context.Context, *QueryCurrentFeedsRequest) (*QueryCurrentFeedsResponse, error)
	// IsFeeder is an RPC method that returns whether an account is a feeder for a specified validator.
	IsFeeder(context.Context, *QueryIsFeederRequest) (*QueryIsFeederResponse, error)
	// Params is an RPC method that returns all parameters of the module.
	Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error)
	// Price is an RPC method that returns price by signal id.
	Price(context.Context, *QueryPriceRequest) (*QueryPriceResponse, error)
	// Prices is an RPC method that prices by signal ids.
	Prices(context.Context, *QueryPricesRequest) (*QueryPricesResponse, error)
	// AllPrices is an RPC method that returns all prices.
	AllPrices(context.Context, *QueryAllPricesRequest) (*QueryAllPricesResponse, error)
	// ReferenceSourceConfig is an RPC method that returns information on the reference price source.
	ReferenceSourceConfig(context.Context, *QueryReferenceSourceConfigRequest) (*QueryReferenceSourceConfigResponse, error)
	// SignalTotalPowers is an RPC method that returns all signal-total-powers or specified signal-total-power by signal
	// id.
	SignalTotalPowers(context.Context, *QuerySignalTotalPowersRequest) (*QuerySignalTotalPowersResponse, error)
	// ValidValidator is an RPC method that returns a flag to show if the validator is required to send prices.
	ValidValidator(context.Context, *QueryValidValidatorRequest) (*QueryValidValidatorResponse, error)
	// ValidatorPrices is an RPC method that returns prices of a validator.
	ValidatorPrices(context.Context, *QueryValidatorPricesRequest) (*QueryValidatorPricesResponse, error)
	// Vote is an RPC method that returns signals of a voter.
	Vote(context.Context, *QueryVoteRequest) (*QueryVoteResponse, error)
}

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

func (*UnimplementedQueryServer) CurrentFeeds(ctx context.Context, req *QueryCurrentFeedsRequest) (*QueryCurrentFeedsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CurrentFeeds not implemented")
}
func (*UnimplementedQueryServer) IsFeeder(ctx context.Context, req *QueryIsFeederRequest) (*QueryIsFeederResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method IsFeeder not implemented")
}
func (*UnimplementedQueryServer) Params(ctx context.Context, req *QueryParamsRequest) (*QueryParamsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Params not implemented")
}
func (*UnimplementedQueryServer) Price(ctx context.Context, req *QueryPriceRequest) (*QueryPriceResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Price not implemented")
}
func (*UnimplementedQueryServer) Prices(ctx context.Context, req *QueryPricesRequest) (*QueryPricesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Prices not implemented")
}
func (*UnimplementedQueryServer) AllPrices(ctx context.Context, req *QueryAllPricesRequest) (*QueryAllPricesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AllPrices not implemented")
}
func (*UnimplementedQueryServer) ReferenceSourceConfig(ctx context.Context, req *QueryReferenceSourceConfigRequest) (*QueryReferenceSourceConfigResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ReferenceSourceConfig not implemented")
}
func (*UnimplementedQueryServer) SignalTotalPowers(ctx context.Context, req *QuerySignalTotalPowersRequest) (*QuerySignalTotalPowersResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SignalTotalPowers not implemented")
}
func (*UnimplementedQueryServer) ValidValidator(ctx context.Context, req *QueryValidValidatorRequest) (*QueryValidValidatorResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ValidValidator not implemented")
}
func (*UnimplementedQueryServer) ValidatorPrices(ctx context.Context, req *QueryValidatorPricesRequest) (*QueryValidatorPricesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ValidatorPrices not implemented")
}
func (*UnimplementedQueryServer) Vote(ctx context.Context, req *QueryVoteRequest) (*QueryVoteResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Vote not implemented")
}

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

func _Query_CurrentFeeds_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryCurrentFeedsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).CurrentFeeds(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/band.feeds.v1beta1.Query/CurrentFeeds",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).CurrentFeeds(ctx, req.(*QueryCurrentFeedsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_IsFeeder_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryIsFeederRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).IsFeeder(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/band.feeds.v1beta1.Query/IsFeeder",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).IsFeeder(ctx, req.(*QueryIsFeederRequest))
	}
	return interceptor(ctx, in, info, handler)
}

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: "/band.feeds.v1beta1.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_Price_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryPriceRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).Price(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/band.feeds.v1beta1.Query/Price",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Price(ctx, req.(*QueryPriceRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_Prices_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryPricesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).Prices(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/band.feeds.v1beta1.Query/Prices",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Prices(ctx, req.(*QueryPricesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_AllPrices_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryAllPricesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).AllPrices(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/band.feeds.v1beta1.Query/AllPrices",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).AllPrices(ctx, req.(*QueryAllPricesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_ReferenceSourceConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryReferenceSourceConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).ReferenceSourceConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/band.feeds.v1beta1.Query/ReferenceSourceConfig",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).ReferenceSourceConfig(ctx, req.(*QueryReferenceSourceConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_SignalTotalPowers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QuerySignalTotalPowersRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).SignalTotalPowers(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/band.feeds.v1beta1.Query/SignalTotalPowers",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).SignalTotalPowers(ctx, req.(*QuerySignalTotalPowersRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_ValidValidator_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryValidValidatorRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).ValidValidator(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/band.feeds.v1beta1.Query/ValidValidator",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).ValidValidator(ctx, req.(*QueryValidValidatorRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_ValidatorPrices_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryValidatorPricesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).ValidatorPrices(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/band.feeds.v1beta1.Query/ValidatorPrices",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).ValidatorPrices(ctx, req.(*QueryValidatorPricesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_Vote_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryVoteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).Vote(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/band.feeds.v1beta1.Query/Vote",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Vote(ctx, req.(*QueryVoteRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Query_serviceDesc = grpc.ServiceDesc{
	ServiceName: "band.feeds.v1beta1.Query",
	HandlerType: (*QueryServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CurrentFeeds",
			Handler:    _Query_CurrentFeeds_Handler,
		},
		{
			MethodName: "IsFeeder",
			Handler:    _Query_IsFeeder_Handler,
		},
		{
			MethodName: "Params",
			Handler:    _Query_Params_Handler,
		},
		{
			MethodName: "Price",
			Handler:    _Query_Price_Handler,
		},
		{
			MethodName: "Prices",
			Handler:    _Query_Prices_Handler,
		},
		{
			MethodName: "AllPrices",
			Handler:    _Query_AllPrices_Handler,
		},
		{
			MethodName: "ReferenceSourceConfig",
			Handler:    _Query_ReferenceSourceConfig_Handler,
		},
		{
			MethodName: "SignalTotalPowers",
			Handler:    _Query_SignalTotalPowers_Handler,
		},
		{
			MethodName: "ValidValidator",
			Handler:    _Query_ValidValidator_Handler,
		},
		{
			MethodName: "ValidatorPrices",
			Handler:    _Query_ValidatorPrices_Handler,
		},
		{
			MethodName: "Vote",
			Handler:    _Query_Vote_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "band/feeds/v1beta1/query.proto",
}

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

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

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

func (m *QueryCurrentFeedsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.CurrentFeeds.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 *QueryIsFeederRequest) 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 *QueryIsFeederRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *QueryIsFeederResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.IsFeeder {
		i--
		if m.IsFeeder {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *QueryParamsRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryParamsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *QueryParamsResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueryParamsResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

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

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

func (m *QueryPriceResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Price.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 *QueryPricesRequest) 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 *QueryPricesRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

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

func (m *QueryAllPricesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Pagination != nil {
		{
			size, err := m.Pagination.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 *QueryAllPricesResponse) 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 *QueryAllPricesResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryAllPricesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Pagination != nil {
		{
			size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQuery(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Prices) > 0 {
		for iNdEx := len(m.Prices) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Prices[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 *QueryReferenceSourceConfigRequest) 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 *QueryReferenceSourceConfigRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *QueryReferenceSourceConfigResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.ReferenceSourceConfig.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 *QuerySignalTotalPowersRequest) 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 *QuerySignalTotalPowersRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *QuerySignalTotalPowersResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Pagination != nil {
		{
			size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQuery(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.SignalTotalPowers) > 0 {
		for iNdEx := len(m.SignalTotalPowers) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.SignalTotalPowers[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 *QueryValidValidatorRequest) 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 *QueryValidValidatorRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *QueryValidValidatorResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Valid {
		i--
		if m.Valid {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

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

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

func (m *QueryIsFeederResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.IsFeeder {
		n += 2
	}
	return n
}

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *QueryValidValidatorResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Valid {
		n += 2
	}
	return n
}

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

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

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

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

func sovQuery(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozQuery(x uint64) (n int) {
	return sovQuery(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *QueryCurrentFeedsRequest) 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: QueryCurrentFeedsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryCurrentFeedsRequest: 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 *QueryCurrentFeedsResponse) 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: QueryCurrentFeedsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryCurrentFeedsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CurrentFeeds", 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.CurrentFeeds.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 *QueryIsFeederRequest) 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: QueryIsFeederRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryIsFeederRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Validator", 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.Validator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Feeder", 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.Feeder = 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 *QueryIsFeederResponse) 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: QueryIsFeederResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryIsFeederResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsFeeder", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsFeeder = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryParamsRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryParamsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryParamsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryPriceRequest) 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: QueryPriceRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryPriceRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SignalId", 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.SignalId = 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 *QueryPriceResponse) 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: QueryPriceResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryPriceResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Price", 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.Price.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 *QueryPricesRequest) 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: QueryPricesRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryPricesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SignalIds", 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.SignalIds = append(m.SignalIds, 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 *QueryPricesResponse) 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: QueryPricesResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryPricesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Prices", 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.Prices = append(m.Prices, Price{})
			if err := m.Prices[len(m.Prices)-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 *QueryAllPricesRequest) 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: QueryAllPricesRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryAllPricesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", 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.Pagination == nil {
				m.Pagination = &query.PageRequest{}
			}
			if err := m.Pagination.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 *QueryAllPricesResponse) 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: QueryAllPricesResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryAllPricesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Prices", 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.Prices = append(m.Prices, Price{})
			if err := m.Prices[len(m.Prices)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", 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.Pagination == nil {
				m.Pagination = &query.PageResponse{}
			}
			if err := m.Pagination.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 *QueryReferenceSourceConfigRequest) 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: QueryReferenceSourceConfigRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryReferenceSourceConfigRequest: 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 *QueryReferenceSourceConfigResponse) 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: QueryReferenceSourceConfigResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryReferenceSourceConfigResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReferenceSourceConfig", 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.ReferenceSourceConfig.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 *QuerySignalTotalPowersRequest) 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: QuerySignalTotalPowersRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QuerySignalTotalPowersRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SignalIds", 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.SignalIds = append(m.SignalIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", 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.Pagination == nil {
				m.Pagination = &query.PageRequest{}
			}
			if err := m.Pagination.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 *QuerySignalTotalPowersResponse) 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: QuerySignalTotalPowersResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QuerySignalTotalPowersResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SignalTotalPowers", 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.SignalTotalPowers = append(m.SignalTotalPowers, &Signal{})
			if err := m.SignalTotalPowers[len(m.SignalTotalPowers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pagination", 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.Pagination == nil {
				m.Pagination = &query.PageResponse{}
			}
			if err := m.Pagination.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 *QueryValidValidatorRequest) 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: QueryValidValidatorRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryValidValidatorRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Validator", 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.Validator = 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 *QueryValidValidatorResponse) 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: QueryValidValidatorResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryValidValidatorResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Valid", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Valid = bool(v != 0)
		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 *QueryValidatorPricesRequest) 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: QueryValidatorPricesRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryValidatorPricesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Validator", 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.Validator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SignalIds", 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.SignalIds = append(m.SignalIds, 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 *QueryValidatorPricesResponse) 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: QueryValidatorPricesResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryValidatorPricesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorPrices", 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.ValidatorPrices = append(m.ValidatorPrices, ValidatorPrice{})
			if err := m.ValidatorPrices[len(m.ValidatorPrices)-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 *QueryVoteRequest) 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: QueryVoteRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryVoteRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Voter", 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.Voter = 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 *QueryVoteResponse) 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: QueryVoteResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryVoteResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Signals", 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.Signals = append(m.Signals, Signal{})
			if err := m.Signals[len(m.Signals)-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 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")
)
