query.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: evmos/incentives/v1/query.proto

package types

import (
	context "context"
	fmt "fmt"
	github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
	types "github.com/cosmos/cosmos-sdk/types"
	query "github.com/cosmos/cosmos-sdk/types/query"
	_ "github.com/gogo/protobuf/gogoproto"
	grpc1 "github.com/gogo/protobuf/grpc"
	proto "github.com/gogo/protobuf/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

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

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

var xxx_messageInfo_QueryIncentivesRequest proto.InternalMessageInfo

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

// QueryIncentivesResponse is the response type for the Query/Incentives RPC
// method.
type QueryIncentivesResponse struct {
	Incentives []Incentive `protobuf:"bytes,1,rep,name=incentives,proto3" json:"incentives"`
	// pagination defines the pagination in the response.
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryIncentivesResponse proto.InternalMessageInfo

func (m *QueryIncentivesResponse) GetIncentives() []Incentive {
	if m != nil {
		return m.Incentives
	}
	return nil
}

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

// QueryIncentiveRequest is the request type for the Query/Incentive RPC method.
type QueryIncentiveRequest struct {
	// contract identifier is the hex contract address of a contract
	Contract string `protobuf:"bytes,1,opt,name=contract,proto3" json:"contract,omitempty"`
}

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

var xxx_messageInfo_QueryIncentiveRequest proto.InternalMessageInfo

func (m *QueryIncentiveRequest) GetContract() string {
	if m != nil {
		return m.Contract
	}
	return ""
}

// QueryIncentiveResponse is the response type for the Query/Incentive RPC
// method.
type QueryIncentiveResponse struct {
	Incentive Incentive `protobuf:"bytes,1,opt,name=incentive,proto3" json:"incentive"`
}

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

var xxx_messageInfo_QueryIncentiveResponse proto.InternalMessageInfo

func (m *QueryIncentiveResponse) GetIncentive() Incentive {
	if m != nil {
		return m.Incentive
	}
	return Incentive{}
}

// QueryGasMetersRequest is the request type for the Query/Incentives RPC
// method.
type QueryGasMetersRequest struct {
	// contract is the hex contract address of a incentivized smart contract
	Contract string `protobuf:"bytes,1,opt,name=contract,proto3" json:"contract,omitempty"`
	// pagination defines an optional pagination for the request.
	Pagination *query.PageRequest `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryGasMetersRequest proto.InternalMessageInfo

func (m *QueryGasMetersRequest) GetContract() string {
	if m != nil {
		return m.Contract
	}
	return ""
}

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

// QueryGasMetersResponse is the response type for the Query/Incentives RPC
// method.
type QueryGasMetersResponse struct {
	GasMeters []GasMeter `protobuf:"bytes,1,rep,name=gas_meters,json=gasMeters,proto3" json:"gas_meters"`
	// pagination defines the pagination in the response.
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryGasMetersResponse proto.InternalMessageInfo

func (m *QueryGasMetersResponse) GetGasMeters() []GasMeter {
	if m != nil {
		return m.GasMeters
	}
	return nil
}

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

// QueryGasMeterRequest is the request type for the Query/Incentive RPC method.
type QueryGasMeterRequest struct {
	// contract identifier is the hex contract address of a contract
	Contract string `protobuf:"bytes,1,opt,name=contract,proto3" json:"contract,omitempty"`
	// participant identifier is the hex address of a user
	Participant string `protobuf:"bytes,2,opt,name=participant,proto3" json:"participant,omitempty"`
}

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

var xxx_messageInfo_QueryGasMeterRequest proto.InternalMessageInfo

func (m *QueryGasMeterRequest) GetContract() string {
	if m != nil {
		return m.Contract
	}
	return ""
}

func (m *QueryGasMeterRequest) GetParticipant() string {
	if m != nil {
		return m.Participant
	}
	return ""
}

// QueryGasMeterResponse is the response type for the Query/Incentive RPC
// method.
type QueryGasMeterResponse struct {
	GasMeter uint64 `protobuf:"varint,1,opt,name=gas_meter,json=gasMeter,proto3" json:"gas_meter,omitempty"`
}

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

var xxx_messageInfo_QueryGasMeterResponse proto.InternalMessageInfo

func (m *QueryGasMeterResponse) GetGasMeter() uint64 {
	if m != nil {
		return m.GasMeter
	}
	return 0
}

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

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

var xxx_messageInfo_QueryAllocationMetersRequest proto.InternalMessageInfo

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

// QueryAllocationMetersResponse is the response type for the
// Query/AllocationMeters RPC method.
type QueryAllocationMetersResponse struct {
	AllocationMeters github_com_cosmos_cosmos_sdk_types.DecCoins `protobuf:"bytes,1,rep,name=allocation_meters,json=allocationMeters,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.DecCoins" json:"allocation_meters"`
	// pagination defines the pagination in the response.
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryAllocationMetersResponse proto.InternalMessageInfo

func (m *QueryAllocationMetersResponse) GetAllocationMeters() github_com_cosmos_cosmos_sdk_types.DecCoins {
	if m != nil {
		return m.AllocationMeters
	}
	return nil
}

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

// QueryAllocationMeterRequest is the request type for the Query/AllocationMeter
// RPC method.
type QueryAllocationMeterRequest struct {
	// denom is the coin denom to query an allocation meter for.
	Denom string `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty"`
}

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

var xxx_messageInfo_QueryAllocationMeterRequest proto.InternalMessageInfo

func (m *QueryAllocationMeterRequest) GetDenom() string {
	if m != nil {
		return m.Denom
	}
	return ""
}

// QueryAllocationMeterResponse is the response type for the
// Query/AllocationMeter RPC method.
type QueryAllocationMeterResponse struct {
	AllocationMeter types.DecCoin `protobuf:"bytes,1,opt,name=allocation_meter,json=allocationMeter,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.DecCoins" json:"allocation_meter"`
}

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

var xxx_messageInfo_QueryAllocationMeterResponse proto.InternalMessageInfo

func (m *QueryAllocationMeterResponse) GetAllocationMeter() types.DecCoin {
	if m != nil {
		return m.AllocationMeter
	}
	return types.DecCoin{}
}

// 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_ee5d2766935e7631, []int{12}
}
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 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_ee5d2766935e7631, []int{13}
}
func (m *QueryParamsResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryParamsResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryParamsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryParamsResponse.Merge(m, src)
}
func (m *QueryParamsResponse) XXX_Size() int {
	return m.Size()
}
func (m *QueryParamsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryParamsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryParamsResponse proto.InternalMessageInfo

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

func init() {
	proto.RegisterType((*QueryIncentivesRequest)(nil), "evmos.incentives.v1.QueryIncentivesRequest")
	proto.RegisterType((*QueryIncentivesResponse)(nil), "evmos.incentives.v1.QueryIncentivesResponse")
	proto.RegisterType((*QueryIncentiveRequest)(nil), "evmos.incentives.v1.QueryIncentiveRequest")
	proto.RegisterType((*QueryIncentiveResponse)(nil), "evmos.incentives.v1.QueryIncentiveResponse")
	proto.RegisterType((*QueryGasMetersRequest)(nil), "evmos.incentives.v1.QueryGasMetersRequest")
	proto.RegisterType((*QueryGasMetersResponse)(nil), "evmos.incentives.v1.QueryGasMetersResponse")
	proto.RegisterType((*QueryGasMeterRequest)(nil), "evmos.incentives.v1.QueryGasMeterRequest")
	proto.RegisterType((*QueryGasMeterResponse)(nil), "evmos.incentives.v1.QueryGasMeterResponse")
	proto.RegisterType((*QueryAllocationMetersRequest)(nil), "evmos.incentives.v1.QueryAllocationMetersRequest")
	proto.RegisterType((*QueryAllocationMetersResponse)(nil), "evmos.incentives.v1.QueryAllocationMetersResponse")
	proto.RegisterType((*QueryAllocationMeterRequest)(nil), "evmos.incentives.v1.QueryAllocationMeterRequest")
	proto.RegisterType((*QueryAllocationMeterResponse)(nil), "evmos.incentives.v1.QueryAllocationMeterResponse")
	proto.RegisterType((*QueryParamsRequest)(nil), "evmos.incentives.v1.QueryParamsRequest")
	proto.RegisterType((*QueryParamsResponse)(nil), "evmos.incentives.v1.QueryParamsResponse")
}

func init() { proto.RegisterFile("evmos/incentives/v1/query.proto", fileDescriptor_ee5d2766935e7631) }

var fileDescriptor_ee5d2766935e7631 = []byte{
	// 836 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x96, 0x4f, 0x4f, 0x13, 0x4d,
	0x1c, 0xc7, 0x3b, 0x3c, 0x40, 0xda, 0xe1, 0x00, 0xcf, 0xd0, 0xe7, 0x91, 0xb4, 0xb0, 0x85, 0xd5,
	0x40, 0x2d, 0xb8, 0x4b, 0x8b, 0x31, 0xe8, 0x49, 0x2b, 0x81, 0x78, 0x30, 0xc1, 0xc6, 0x93, 0x31,
	0xd1, 0xe9, 0x32, 0xae, 0x1b, 0xe9, 0xce, 0xd2, 0x5d, 0x1a, 0x49, 0xc5, 0x18, 0x5f, 0x01, 0x89,
	0x17, 0x0f, 0xde, 0x8c, 0x89, 0x7a, 0xf0, 0x75, 0x70, 0x24, 0x31, 0x31, 0x9e, 0xd4, 0x80, 0x07,
	0x5f, 0x86, 0xe9, 0xfc, 0xd9, 0xee, 0x2e, 0x5b, 0xba, 0x18, 0xbc, 0x40, 0x3b, 0xfb, 0xfb, 0xf3,
	0xf9, 0xfe, 0x7e, 0xcc, 0x77, 0x81, 0x05, 0xd2, 0x6a, 0x50, 0x57, 0xb7, 0x6c, 0x83, 0xd8, 0x9e,
	0xd5, 0x22, 0xae, 0xde, 0x2a, 0xeb, 0x5b, 0xdb, 0xa4, 0xb9, 0xa3, 0x39, 0x4d, 0xea, 0x51, 0x34,
	0xce, 0x02, 0xb4, 0x6e, 0x80, 0xd6, 0x2a, 0xe7, 0x4a, 0x06, 0x75, 0x3b, 0x69, 0x75, 0xec, 0x12,
	0x1e, 0xad, 0xb7, 0xca, 0x75, 0xe2, 0xe1, 0xb2, 0xee, 0x60, 0xd3, 0xb2, 0xb1, 0x67, 0x51, 0x9b,
	0x17, 0xc8, 0x29, 0xc1, 0x58, 0x19, 0x65, 0x50, 0x4b, 0x3e, 0x9f, 0x89, 0x23, 0x30, 0x89, 0x4d,
	0x5c, 0xcb, 0x15, 0x21, 0x17, 0xe2, 0x42, 0x02, 0x44, 0x3c, 0x6a, 0xd2, 0xa4, 0xd4, 0xdc, 0x24,
	0x3a, 0x76, 0x2c, 0x1d, 0xdb, 0x36, 0xf5, 0x18, 0x85, 0x7c, 0x9a, 0x35, 0xa9, 0x49, 0xd9, 0x47,
	0xbd, 0xf3, 0x89, 0x9f, 0xaa, 0x0f, 0xe1, 0xff, 0x77, 0x3a, 0xf8, 0xb7, 0xfc, 0x62, 0x35, 0xb2,
	0xb5, 0x4d, 0x5c, 0x0f, 0xad, 0x42, 0xd8, 0x95, 0x32, 0x01, 0xa6, 0x41, 0x71, 0xa4, 0x32, 0xab,
	0x71, 0x2d, 0x5a, 0x47, 0x8b, 0xc6, 0xa7, 0x24, 0x14, 0x69, 0xeb, 0xd8, 0x24, 0x22, 0xb7, 0x16,
	0xc8, 0x54, 0xdf, 0x03, 0x78, 0xee, 0x58, 0x0b, 0xd7, 0xa1, 0xb6, 0x4b, 0xd0, 0x0a, 0x84, 0x5d,
	0x15, 0x13, 0x60, 0xfa, 0x9f, 0xe2, 0x48, 0x45, 0xd1, 0x62, 0x06, 0xae, 0xf9, 0xc9, 0xd5, 0xc1,
	0xfd, 0x6f, 0x85, 0x54, 0x2d, 0x90, 0x87, 0xd6, 0x42, 0xa4, 0x03, 0x8c, 0x74, 0xae, 0x2f, 0x29,
	0x47, 0x08, 0xa1, 0x2e, 0xc1, 0xff, 0xc2, 0xa4, 0x72, 0x16, 0x39, 0x98, 0x36, 0xa8, 0xed, 0x35,
	0xb1, 0xe1, 0xb1, 0x49, 0x64, 0x6a, 0xfe, 0x77, 0xf5, 0x7e, 0x74, 0x82, 0xbe, 0xba, 0x2a, 0xcc,
	0xf8, 0x94, 0x62, 0x80, 0xc9, 0xc4, 0x75, 0xd3, 0xd4, 0xb6, 0x40, 0x5a, 0xc3, 0xee, 0x6d, 0xe2,
	0x91, 0xa6, 0x9b, 0x00, 0x29, 0xb2, 0xba, 0x81, 0x3f, 0x5e, 0xdd, 0x3b, 0x20, 0xb4, 0x05, 0xba,
	0xfb, 0xda, 0xa0, 0x89, 0xdd, 0x07, 0x0d, 0x76, 0x2a, 0x36, 0x37, 0x15, 0x2b, 0x4e, 0xe6, 0x4a,
	0x6d, 0xa6, 0xac, 0x75, 0x76, 0x7b, 0xbb, 0x0b, 0xb3, 0x21, 0xcc, 0x24, 0x33, 0x9a, 0x86, 0x23,
	0x0e, 0x6e, 0x7a, 0x96, 0x61, 0x39, 0xd8, 0xf6, 0x58, 0xf7, 0x4c, 0x2d, 0x78, 0xa4, 0x5e, 0x8e,
	0x8c, 0xde, 0xd7, 0x9e, 0x87, 0x19, 0x5f, 0x3b, 0xab, 0x3b, 0x58, 0x4b, 0x4b, 0x55, 0xea, 0x23,
	0x38, 0xc9, 0xb2, 0x6e, 0x6c, 0x6e, 0x52, 0x83, 0xe1, 0x85, 0xf7, 0x76, 0x56, 0xd7, 0xea, 0x17,
	0x80, 0x53, 0x3d, 0x1a, 0x09, 0xcc, 0xe7, 0xf0, 0x5f, 0xec, 0x3f, 0x0b, 0x6f, 0x6a, 0x32, 0xd4,
	0x50, 0xb6, 0x5a, 0x21, 0xc6, 0x4d, 0x6a, 0xd9, 0xd5, 0xa5, 0xce, 0xa2, 0x3e, 0x7e, 0x2f, 0xcc,
	0x9b, 0x96, 0xf7, 0x78, 0xbb, 0xae, 0x19, 0xb4, 0xa1, 0x0b, 0x0f, 0xe3, 0xbf, 0x2e, 0xb9, 0x1b,
	0x4f, 0x74, 0x6f, 0xc7, 0x21, 0xae, 0xcc, 0x71, 0x6b, 0x63, 0x38, 0xc2, 0x71, 0x96, 0xd7, 0x32,
	0x1f, 0xa7, 0x54, 0x4e, 0x34, 0x0b, 0x87, 0x36, 0x88, 0x4d, 0x1b, 0x62, 0xc5, 0xfc, 0x8b, 0xfa,
	0x06, 0xc4, 0x2f, 0xc2, 0x1f, 0xcf, 0x33, 0x38, 0x16, 0x1d, 0x8f, 0x58, 0xc7, 0x5f, 0x98, 0xce,
	0x68, 0x64, 0x3a, 0x6a, 0x16, 0x22, 0x46, 0xb7, 0x8e, 0x9b, 0xb8, 0x21, 0xff, 0x38, 0xd4, 0x75,
	0x38, 0x1e, 0x3a, 0x15, 0xa8, 0x57, 0xe1, 0xb0, 0xc3, 0x4e, 0x04, 0x60, 0x3e, 0xf6, 0xa2, 0xf1,
	0x24, 0x71, 0xcd, 0x44, 0x42, 0xe5, 0x4b, 0x1a, 0x0e, 0xb1, 0x92, 0x68, 0x0f, 0x40, 0xd8, 0xb5,
	0x60, 0x34, 0x1f, 0x5b, 0x23, 0xfe, 0x5d, 0x90, 0x5b, 0x48, 0x16, 0xcc, 0x71, 0xd5, 0xb9, 0x97,
	0x9f, 0x7f, 0xbe, 0x1a, 0x98, 0x41, 0x05, 0xfd, 0xe4, 0xd7, 0x16, 0x7a, 0x0d, 0x60, 0xc6, 0xcf,
	0x47, 0xa5, 0x04, 0x4d, 0x24, 0xd0, 0x7c, 0xa2, 0x58, 0xc1, 0x53, 0x61, 0x3c, 0x0b, 0xa8, 0xd4,
	0x87, 0x47, 0x6f, 0x4b, 0x77, 0xd8, 0x65, 0x68, 0xbe, 0xeb, 0x9d, 0x84, 0x16, 0x35, 0xe6, 0x93,
	0xd0, 0x8e, 0xd9, 0x68, 0x1f, 0xb4, 0xae, 0xc3, 0x06, 0xd1, 0xde, 0x02, 0x98, 0x96, 0x95, 0xd0,
	0xc5, 0xfe, 0xdd, 0x24, 0x58, 0x29, 0x49, 0xa8, 0xe0, 0xba, 0xce, 0xb8, 0xae, 0xa1, 0xe5, 0xe4,
	0x5c, 0x7a, 0x3b, 0x60, 0x9e, 0xbb, 0xe8, 0x03, 0x80, 0x63, 0x51, 0x6b, 0x42, 0xe5, 0xde, 0x08,
	0x3d, 0xfc, 0x32, 0x57, 0x39, 0x4d, 0x8a, 0xa0, 0xd7, 0x18, 0x7d, 0x11, 0xcd, 0xc6, 0xd2, 0x1f,
	0x33, 0x45, 0xf4, 0x09, 0xc0, 0xd1, 0x48, 0x31, 0xb4, 0x98, 0xb8, 0xaf, 0x24, 0x2d, 0x9f, 0x22,
	0x43, 0x80, 0x5e, 0x61, 0xa0, 0x8b, 0x48, 0x4b, 0x06, 0xaa, 0xb7, 0x99, 0xb7, 0xed, 0xa2, 0x17,
	0x00, 0x0e, 0xf3, 0xeb, 0x8e, 0xe6, 0x7a, 0x77, 0x0d, 0x79, 0x4b, 0xae, 0xd8, 0x3f, 0x50, 0x50,
	0x9d, 0x67, 0x54, 0x53, 0x28, 0x1f, 0x4b, 0xc5, 0x8d, 0xa5, 0xba, 0xba, 0x7f, 0xa8, 0x80, 0x83,
	0x43, 0x05, 0xfc, 0x38, 0x54, 0xc0, 0xde, 0x91, 0x92, 0x3a, 0x38, 0x52, 0x52, 0x5f, 0x8f, 0x94,
	0xd4, 0xbd, 0x85, 0x80, 0x31, 0xf2, 0x02, 0xfc, 0x67, 0x6b, 0x59, 0x7f, 0x1a, 0xac, 0xc5, 0x2c,
	0xb2, 0x3e, 0xcc, 0xfe, 0x0f, 0x5d, 0xfa, 0x1d, 0x00, 0x00, 0xff, 0xff, 0xab, 0x9d, 0xfa, 0x49,
	0x88, 0x0b, 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 {
	// Incentives retrieves registered incentives
	Incentives(ctx context.Context, in *QueryIncentivesRequest, opts ...grpc.CallOption) (*QueryIncentivesResponse, error)
	// Incentive retrieves a registered incentive
	Incentive(ctx context.Context, in *QueryIncentiveRequest, opts ...grpc.CallOption) (*QueryIncentiveResponse, error)
	// GasMeters retrieves active gas meters for a given contract
	GasMeters(ctx context.Context, in *QueryGasMetersRequest, opts ...grpc.CallOption) (*QueryGasMetersResponse, error)
	// GasMeter Retrieves a active gas meter
	GasMeter(ctx context.Context, in *QueryGasMeterRequest, opts ...grpc.CallOption) (*QueryGasMeterResponse, error)
	// AllocationMeters retrieves active allocation meters for a given
	// denomination
	AllocationMeters(ctx context.Context, in *QueryAllocationMetersRequest, opts ...grpc.CallOption) (*QueryAllocationMetersResponse, error)
	// AllocationMeter Retrieves a active gas meter
	AllocationMeter(ctx context.Context, in *QueryAllocationMeterRequest, opts ...grpc.CallOption) (*QueryAllocationMeterResponse, error)
	// Params retrieves the incentives module params
	Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error)
}

type queryClient struct {
	cc grpc1.ClientConn
}

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

func (c *queryClient) Incentives(ctx context.Context, in *QueryIncentivesRequest, opts ...grpc.CallOption) (*QueryIncentivesResponse, error) {
	out := new(QueryIncentivesResponse)
	err := c.cc.Invoke(ctx, "/evmos.incentives.v1.Query/Incentives", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) Incentive(ctx context.Context, in *QueryIncentiveRequest, opts ...grpc.CallOption) (*QueryIncentiveResponse, error) {
	out := new(QueryIncentiveResponse)
	err := c.cc.Invoke(ctx, "/evmos.incentives.v1.Query/Incentive", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) GasMeters(ctx context.Context, in *QueryGasMetersRequest, opts ...grpc.CallOption) (*QueryGasMetersResponse, error) {
	out := new(QueryGasMetersResponse)
	err := c.cc.Invoke(ctx, "/evmos.incentives.v1.Query/GasMeters", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) GasMeter(ctx context.Context, in *QueryGasMeterRequest, opts ...grpc.CallOption) (*QueryGasMeterResponse, error) {
	out := new(QueryGasMeterResponse)
	err := c.cc.Invoke(ctx, "/evmos.incentives.v1.Query/GasMeter", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) AllocationMeters(ctx context.Context, in *QueryAllocationMetersRequest, opts ...grpc.CallOption) (*QueryAllocationMetersResponse, error) {
	out := new(QueryAllocationMetersResponse)
	err := c.cc.Invoke(ctx, "/evmos.incentives.v1.Query/AllocationMeters", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) AllocationMeter(ctx context.Context, in *QueryAllocationMeterRequest, opts ...grpc.CallOption) (*QueryAllocationMeterResponse, error) {
	out := new(QueryAllocationMeterResponse)
	err := c.cc.Invoke(ctx, "/evmos.incentives.v1.Query/AllocationMeter", 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, "/evmos.incentives.v1.Query/Params", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// QueryServer is the server API for Query service.
type QueryServer interface {
	// Incentives retrieves registered incentives
	Incentives(context.Context, *QueryIncentivesRequest) (*QueryIncentivesResponse, error)
	// Incentive retrieves a registered incentive
	Incentive(context.Context, *QueryIncentiveRequest) (*QueryIncentiveResponse, error)
	// GasMeters retrieves active gas meters for a given contract
	GasMeters(context.Context, *QueryGasMetersRequest) (*QueryGasMetersResponse, error)
	// GasMeter Retrieves a active gas meter
	GasMeter(context.Context, *QueryGasMeterRequest) (*QueryGasMeterResponse, error)
	// AllocationMeters retrieves active allocation meters for a given
	// denomination
	AllocationMeters(context.Context, *QueryAllocationMetersRequest) (*QueryAllocationMetersResponse, error)
	// AllocationMeter Retrieves a active gas meter
	AllocationMeter(context.Context, *QueryAllocationMeterRequest) (*QueryAllocationMeterResponse, error)
	// Params retrieves the incentives module params
	Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error)
}

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

func (*UnimplementedQueryServer) Incentives(ctx context.Context, req *QueryIncentivesRequest) (*QueryIncentivesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Incentives not implemented")
}
func (*UnimplementedQueryServer) Incentive(ctx context.Context, req *QueryIncentiveRequest) (*QueryIncentiveResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Incentive not implemented")
}
func (*UnimplementedQueryServer) GasMeters(ctx context.Context, req *QueryGasMetersRequest) (*QueryGasMetersResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GasMeters not implemented")
}
func (*UnimplementedQueryServer) GasMeter(ctx context.Context, req *QueryGasMeterRequest) (*QueryGasMeterResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GasMeter not implemented")
}
func (*UnimplementedQueryServer) AllocationMeters(ctx context.Context, req *QueryAllocationMetersRequest) (*QueryAllocationMetersResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AllocationMeters not implemented")
}
func (*UnimplementedQueryServer) AllocationMeter(ctx context.Context, req *QueryAllocationMeterRequest) (*QueryAllocationMeterResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AllocationMeter not implemented")
}
func (*UnimplementedQueryServer) Params(ctx context.Context, req *QueryParamsRequest) (*QueryParamsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Params not implemented")
}

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

func _Query_Incentives_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryIncentivesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).Incentives(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/evmos.incentives.v1.Query/Incentives",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Incentives(ctx, req.(*QueryIncentivesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_Incentive_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryIncentiveRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).Incentive(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/evmos.incentives.v1.Query/Incentive",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Incentive(ctx, req.(*QueryIncentiveRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_GasMeters_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryGasMetersRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).GasMeters(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/evmos.incentives.v1.Query/GasMeters",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).GasMeters(ctx, req.(*QueryGasMetersRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_GasMeter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryGasMeterRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).GasMeter(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/evmos.incentives.v1.Query/GasMeter",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).GasMeter(ctx, req.(*QueryGasMeterRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_AllocationMeters_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryAllocationMetersRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).AllocationMeters(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/evmos.incentives.v1.Query/AllocationMeters",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).AllocationMeters(ctx, req.(*QueryAllocationMetersRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_AllocationMeter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryAllocationMeterRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).AllocationMeter(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/evmos.incentives.v1.Query/AllocationMeter",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).AllocationMeter(ctx, req.(*QueryAllocationMeterRequest))
	}
	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: "/evmos.incentives.v1.Query/Params",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Params(ctx, req.(*QueryParamsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Query_serviceDesc = grpc.ServiceDesc{
	ServiceName: "evmos.incentives.v1.Query",
	HandlerType: (*QueryServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Incentives",
			Handler:    _Query_Incentives_Handler,
		},
		{
			MethodName: "Incentive",
			Handler:    _Query_Incentive_Handler,
		},
		{
			MethodName: "GasMeters",
			Handler:    _Query_GasMeters_Handler,
		},
		{
			MethodName: "GasMeter",
			Handler:    _Query_GasMeter_Handler,
		},
		{
			MethodName: "AllocationMeters",
			Handler:    _Query_AllocationMeters_Handler,
		},
		{
			MethodName: "AllocationMeter",
			Handler:    _Query_AllocationMeter_Handler,
		},
		{
			MethodName: "Params",
			Handler:    _Query_Params_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "evmos/incentives/v1/query.proto",
}

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

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

func (m *QueryIncentivesResponse) 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.Incentives) > 0 {
		for iNdEx := len(m.Incentives) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Incentives[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 *QueryIncentiveRequest) 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 *QueryIncentiveRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

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

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

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

func (m *QueryGasMetersResponse) 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.GasMeters) > 0 {
		for iNdEx := len(m.GasMeters) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.GasMeters[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 *QueryGasMeterRequest) 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 *QueryGasMeterRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

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

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

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

func (m *QueryAllocationMetersResponse) 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.AllocationMeters) > 0 {
		for iNdEx := len(m.AllocationMeters) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.AllocationMeters[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 *QueryAllocationMeterRequest) 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 *QueryAllocationMeterRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *QueryAllocationMeterResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.AllocationMeter.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 *QueryParamsRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

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

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

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

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

func encodeVarintQuery(dAtA []byte, offset int, v uint64) int {
	offset -= sovQuery(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *QueryIncentivesRequest) 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 *QueryIncentivesResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Incentives) > 0 {
		for _, e := range m.Incentives {
			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 *QueryIncentiveRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Contract)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

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

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

func (m *QueryGasMetersResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.GasMeters) > 0 {
		for _, e := range m.GasMeters {
			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 *QueryGasMeterRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Contract)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	l = len(m.Participant)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

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

func (m *QueryAllocationMetersRequest) 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 *QueryAllocationMetersResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.AllocationMeters) > 0 {
		for _, e := range m.AllocationMeters {
			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 *QueryAllocationMeterRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Denom)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

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

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

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

func sovQuery(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozQuery(x uint64) (n int) {
	return sovQuery(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *QueryIncentivesRequest) 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: QueryIncentivesRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryIncentivesRequest: 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 *QueryIncentivesResponse) 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: QueryIncentivesResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryIncentivesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Incentives", 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.Incentives = append(m.Incentives, Incentive{})
			if err := m.Incentives[len(m.Incentives)-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 *QueryIncentiveRequest) 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: QueryIncentiveRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryIncentiveRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Contract", 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.Contract = 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 *QueryIncentiveResponse) 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: QueryIncentiveResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryIncentiveResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Incentive", 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.Incentive.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 *QueryGasMetersRequest) 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: QueryGasMetersRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryGasMetersRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Contract", 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.Contract = 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 *QueryGasMetersResponse) 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: QueryGasMetersResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryGasMetersResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GasMeters", 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.GasMeters = append(m.GasMeters, GasMeter{})
			if err := m.GasMeters[len(m.GasMeters)-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 *QueryGasMeterRequest) 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: QueryGasMeterRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryGasMeterRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Contract", 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.Contract = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Participant", 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.Participant = 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 *QueryGasMeterResponse) 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: QueryGasMeterResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryGasMeterResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GasMeter", wireType)
			}
			m.GasMeter = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GasMeter |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryAllocationMetersRequest) 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: QueryAllocationMetersRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryAllocationMetersRequest: 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 *QueryAllocationMetersResponse) 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: QueryAllocationMetersResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryAllocationMetersResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AllocationMeters", 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.AllocationMeters = append(m.AllocationMeters, types.DecCoin{})
			if err := m.AllocationMeters[len(m.AllocationMeters)-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 *QueryAllocationMeterRequest) 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: QueryAllocationMeterRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryAllocationMeterRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Denom", 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.Denom = 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 *QueryAllocationMeterResponse) 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: QueryAllocationMeterResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryAllocationMeterResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AllocationMeter", 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.AllocationMeter.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipQuery(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthQuery
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupQuery
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthQuery
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

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