query.pb.go

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

package types

import (
	context "context"
	fmt "fmt"
	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"
	types "github.com/lavanet/lava/x/epochstorage/types"
	types2 "github.com/lavanet/lava/x/projects/types"
	types1 "github.com/lavanet/lava/x/subscription/types"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	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

// QueryParamsRequest is request type for the Query/Params RPC method.
type QueryParamsRequest struct {
}

func (m *QueryParamsRequest) Reset()         { *m = QueryParamsRequest{} }
func (m *QueryParamsRequest) String() string { return proto.CompactTextString(m) }
func (*QueryParamsRequest) ProtoMessage()    {}
func (*QueryParamsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_6bd8a3cd41a2a1ee, []int{0}
}
func (m *QueryParamsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryParamsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryParamsRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryParamsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryParamsRequest.Merge(m, src)
}
func (m *QueryParamsRequest) XXX_Size() int {
	return m.Size()
}
func (m *QueryParamsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryParamsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_QueryParamsRequest proto.InternalMessageInfo

// QueryParamsResponse is response type for the Query/Params RPC method.
type QueryParamsResponse struct {
	// params holds all the parameters of this module.
	Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"`
}

func (m *QueryParamsResponse) Reset()         { *m = QueryParamsResponse{} }
func (m *QueryParamsResponse) String() string { return proto.CompactTextString(m) }
func (*QueryParamsResponse) ProtoMessage()    {}
func (*QueryParamsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_6bd8a3cd41a2a1ee, []int{1}
}
func (m *QueryParamsResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueryParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueryParamsResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *QueryParamsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryParamsResponse.Merge(m, src)
}
func (m *QueryParamsResponse) XXX_Size() int {
	return m.Size()
}
func (m *QueryParamsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryParamsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_QueryParamsResponse proto.InternalMessageInfo

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

type QueryProvidersRequest struct {
	ChainID    string `protobuf:"bytes,1,opt,name=chainID,proto3" json:"chainID,omitempty"`
	ShowFrozen bool   `protobuf:"varint,2,opt,name=showFrozen,proto3" json:"showFrozen,omitempty"`
}

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

var xxx_messageInfo_QueryProvidersRequest proto.InternalMessageInfo

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

func (m *QueryProvidersRequest) GetShowFrozen() bool {
	if m != nil {
		return m.ShowFrozen
	}
	return false
}

type QueryProvidersResponse struct {
	StakeEntry []types.StakeEntry `protobuf:"bytes,1,rep,name=stakeEntry,proto3" json:"stakeEntry"`
	Output     string             `protobuf:"bytes,2,opt,name=output,proto3" json:"output,omitempty"`
}

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

var xxx_messageInfo_QueryProvidersResponse proto.InternalMessageInfo

func (m *QueryProvidersResponse) GetStakeEntry() []types.StakeEntry {
	if m != nil {
		return m.StakeEntry
	}
	return nil
}

func (m *QueryProvidersResponse) GetOutput() string {
	if m != nil {
		return m.Output
	}
	return ""
}

type QueryClientsRequest struct {
	ChainID string `protobuf:"bytes,1,opt,name=chainID,proto3" json:"chainID,omitempty"`
}

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

var xxx_messageInfo_QueryClientsRequest proto.InternalMessageInfo

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

type QueryClientsResponse struct {
	StakeEntry []types.StakeEntry `protobuf:"bytes,1,rep,name=stakeEntry,proto3" json:"stakeEntry"`
	Output     string             `protobuf:"bytes,2,opt,name=output,proto3" json:"output,omitempty"`
}

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

var xxx_messageInfo_QueryClientsResponse proto.InternalMessageInfo

func (m *QueryClientsResponse) GetStakeEntry() []types.StakeEntry {
	if m != nil {
		return m.StakeEntry
	}
	return nil
}

func (m *QueryClientsResponse) GetOutput() string {
	if m != nil {
		return m.Output
	}
	return ""
}

type QueryGetPairingRequest struct {
	ChainID string `protobuf:"bytes,1,opt,name=chainID,proto3" json:"chainID,omitempty"`
	Client  string `protobuf:"bytes,2,opt,name=client,proto3" json:"client,omitempty"`
}

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

var xxx_messageInfo_QueryGetPairingRequest proto.InternalMessageInfo

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

func (m *QueryGetPairingRequest) GetClient() string {
	if m != nil {
		return m.Client
	}
	return ""
}

type QueryGetPairingResponse struct {
	Providers             []types.StakeEntry `protobuf:"bytes,1,rep,name=providers,proto3" json:"providers"`
	CurrentEpoch          uint64             `protobuf:"varint,2,opt,name=current_epoch,json=currentEpoch,proto3" json:"current_epoch,omitempty"`
	TimeLeftToNextPairing uint64             `protobuf:"varint,3,opt,name=time_left_to_next_pairing,json=timeLeftToNextPairing,proto3" json:"time_left_to_next_pairing,omitempty"`
	SpecLastUpdatedBlock  uint64             `protobuf:"varint,4,opt,name=spec_last_updated_block,json=specLastUpdatedBlock,proto3" json:"spec_last_updated_block,omitempty"`
	BlockOfNextPairing    uint64             `protobuf:"varint,5,opt,name=block_of_next_pairing,json=blockOfNextPairing,proto3" json:"block_of_next_pairing,omitempty"`
}

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

var xxx_messageInfo_QueryGetPairingResponse proto.InternalMessageInfo

func (m *QueryGetPairingResponse) GetProviders() []types.StakeEntry {
	if m != nil {
		return m.Providers
	}
	return nil
}

func (m *QueryGetPairingResponse) GetCurrentEpoch() uint64 {
	if m != nil {
		return m.CurrentEpoch
	}
	return 0
}

func (m *QueryGetPairingResponse) GetTimeLeftToNextPairing() uint64 {
	if m != nil {
		return m.TimeLeftToNextPairing
	}
	return 0
}

func (m *QueryGetPairingResponse) GetSpecLastUpdatedBlock() uint64 {
	if m != nil {
		return m.SpecLastUpdatedBlock
	}
	return 0
}

func (m *QueryGetPairingResponse) GetBlockOfNextPairing() uint64 {
	if m != nil {
		return m.BlockOfNextPairing
	}
	return 0
}

type QueryVerifyPairingRequest struct {
	ChainID  string `protobuf:"bytes,1,opt,name=chainID,proto3" json:"chainID,omitempty"`
	Client   string `protobuf:"bytes,2,opt,name=client,proto3" json:"client,omitempty"`
	Provider string `protobuf:"bytes,3,opt,name=provider,proto3" json:"provider,omitempty"`
	Block    uint64 `protobuf:"varint,4,opt,name=block,proto3" json:"block,omitempty"`
}

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

var xxx_messageInfo_QueryVerifyPairingRequest proto.InternalMessageInfo

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

func (m *QueryVerifyPairingRequest) GetClient() string {
	if m != nil {
		return m.Client
	}
	return ""
}

func (m *QueryVerifyPairingRequest) GetProvider() string {
	if m != nil {
		return m.Provider
	}
	return ""
}

func (m *QueryVerifyPairingRequest) GetBlock() uint64 {
	if m != nil {
		return m.Block
	}
	return 0
}

type QueryVerifyPairingResponse struct {
	Valid           bool   `protobuf:"varint,1,opt,name=valid,proto3" json:"valid,omitempty"`
	PairedProviders uint64 `protobuf:"varint,3,opt,name=paired_providers,json=pairedProviders,proto3" json:"paired_providers,omitempty"`
	CuPerEpoch      uint64 `protobuf:"varint,4,opt,name=cu_per_epoch,json=cuPerEpoch,proto3" json:"cu_per_epoch,omitempty"`
}

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

var xxx_messageInfo_QueryVerifyPairingResponse proto.InternalMessageInfo

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

func (m *QueryVerifyPairingResponse) GetPairedProviders() uint64 {
	if m != nil {
		return m.PairedProviders
	}
	return 0
}

func (m *QueryVerifyPairingResponse) GetCuPerEpoch() uint64 {
	if m != nil {
		return m.CuPerEpoch
	}
	return 0
}

type QueryGetUniquePaymentStorageClientProviderRequest struct {
	Index string `protobuf:"bytes,1,opt,name=index,proto3" json:"index,omitempty"`
}

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

var xxx_messageInfo_QueryGetUniquePaymentStorageClientProviderRequest proto.InternalMessageInfo

func (m *QueryGetUniquePaymentStorageClientProviderRequest) GetIndex() string {
	if m != nil {
		return m.Index
	}
	return ""
}

type QueryGetUniquePaymentStorageClientProviderResponse struct {
	UniquePaymentStorageClientProvider UniquePaymentStorageClientProvider `protobuf:"bytes,1,opt,name=uniquePaymentStorageClientProvider,proto3" json:"uniquePaymentStorageClientProvider"`
}

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

var xxx_messageInfo_QueryGetUniquePaymentStorageClientProviderResponse proto.InternalMessageInfo

func (m *QueryGetUniquePaymentStorageClientProviderResponse) GetUniquePaymentStorageClientProvider() UniquePaymentStorageClientProvider {
	if m != nil {
		return m.UniquePaymentStorageClientProvider
	}
	return UniquePaymentStorageClientProvider{}
}

type QueryAllUniquePaymentStorageClientProviderRequest struct {
	Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryAllUniquePaymentStorageClientProviderRequest proto.InternalMessageInfo

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

type QueryAllUniquePaymentStorageClientProviderResponse struct {
	UniquePaymentStorageClientProvider []UniquePaymentStorageClientProvider `protobuf:"bytes,1,rep,name=uniquePaymentStorageClientProvider,proto3" json:"uniquePaymentStorageClientProvider"`
	Pagination                         *query.PageResponse                  `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryAllUniquePaymentStorageClientProviderResponse proto.InternalMessageInfo

func (m *QueryAllUniquePaymentStorageClientProviderResponse) GetUniquePaymentStorageClientProvider() []UniquePaymentStorageClientProvider {
	if m != nil {
		return m.UniquePaymentStorageClientProvider
	}
	return nil
}

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

type QueryGetProviderPaymentStorageRequest struct {
	Index string `protobuf:"bytes,1,opt,name=index,proto3" json:"index,omitempty"`
}

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

var xxx_messageInfo_QueryGetProviderPaymentStorageRequest proto.InternalMessageInfo

func (m *QueryGetProviderPaymentStorageRequest) GetIndex() string {
	if m != nil {
		return m.Index
	}
	return ""
}

type QueryGetProviderPaymentStorageResponse struct {
	ProviderPaymentStorage ProviderPaymentStorage `protobuf:"bytes,1,opt,name=providerPaymentStorage,proto3" json:"providerPaymentStorage"`
}

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

var xxx_messageInfo_QueryGetProviderPaymentStorageResponse proto.InternalMessageInfo

func (m *QueryGetProviderPaymentStorageResponse) GetProviderPaymentStorage() ProviderPaymentStorage {
	if m != nil {
		return m.ProviderPaymentStorage
	}
	return ProviderPaymentStorage{}
}

type QueryAllProviderPaymentStorageRequest struct {
	Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryAllProviderPaymentStorageRequest proto.InternalMessageInfo

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

type QueryAllProviderPaymentStorageResponse struct {
	ProviderPaymentStorage []ProviderPaymentStorage `protobuf:"bytes,1,rep,name=providerPaymentStorage,proto3" json:"providerPaymentStorage"`
	Pagination             *query.PageResponse      `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryAllProviderPaymentStorageResponse proto.InternalMessageInfo

func (m *QueryAllProviderPaymentStorageResponse) GetProviderPaymentStorage() []ProviderPaymentStorage {
	if m != nil {
		return m.ProviderPaymentStorage
	}
	return nil
}

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

type QueryGetEpochPaymentsRequest struct {
	Index string `protobuf:"bytes,1,opt,name=index,proto3" json:"index,omitempty"`
}

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

var xxx_messageInfo_QueryGetEpochPaymentsRequest proto.InternalMessageInfo

func (m *QueryGetEpochPaymentsRequest) GetIndex() string {
	if m != nil {
		return m.Index
	}
	return ""
}

type QueryGetEpochPaymentsResponse struct {
	EpochPayments EpochPayments `protobuf:"bytes,1,opt,name=epochPayments,proto3" json:"epochPayments"`
}

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

var xxx_messageInfo_QueryGetEpochPaymentsResponse proto.InternalMessageInfo

func (m *QueryGetEpochPaymentsResponse) GetEpochPayments() EpochPayments {
	if m != nil {
		return m.EpochPayments
	}
	return EpochPayments{}
}

type QueryAllEpochPaymentsRequest struct {
	Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryAllEpochPaymentsRequest proto.InternalMessageInfo

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

type QueryAllEpochPaymentsResponse struct {
	EpochPayments []EpochPayments     `protobuf:"bytes,1,rep,name=epochPayments,proto3" json:"epochPayments"`
	Pagination    *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryAllEpochPaymentsResponse proto.InternalMessageInfo

func (m *QueryAllEpochPaymentsResponse) GetEpochPayments() []EpochPayments {
	if m != nil {
		return m.EpochPayments
	}
	return nil
}

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

type QueryUserEntryRequest struct {
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	ChainID string `protobuf:"bytes,2,opt,name=chainID,proto3" json:"chainID,omitempty"`
	Block   uint64 `protobuf:"varint,3,opt,name=block,proto3" json:"block,omitempty"`
}

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

var xxx_messageInfo_QueryUserEntryRequest proto.InternalMessageInfo

func (m *QueryUserEntryRequest) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

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

func (m *QueryUserEntryRequest) GetBlock() uint64 {
	if m != nil {
		return m.Block
	}
	return 0
}

type QueryUserEntryResponse struct {
	Consumer types.StakeEntry `protobuf:"bytes,1,opt,name=consumer,proto3" json:"consumer"`
	MaxCU    uint64           `protobuf:"varint,2,opt,name=maxCU,proto3" json:"maxCU,omitempty"`
}

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

var xxx_messageInfo_QueryUserEntryResponse proto.InternalMessageInfo

func (m *QueryUserEntryResponse) GetConsumer() types.StakeEntry {
	if m != nil {
		return m.Consumer
	}
	return types.StakeEntry{}
}

func (m *QueryUserEntryResponse) GetMaxCU() uint64 {
	if m != nil {
		return m.MaxCU
	}
	return 0
}

type QueryStaticProvidersListRequest struct {
	ChainID string `protobuf:"bytes,1,opt,name=chainID,proto3" json:"chainID,omitempty"`
}

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

var xxx_messageInfo_QueryStaticProvidersListRequest proto.InternalMessageInfo

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

type QueryStaticProvidersListResponse struct {
	Providers []types.StakeEntry `protobuf:"bytes,1,rep,name=providers,proto3" json:"providers"`
}

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

var xxx_messageInfo_QueryStaticProvidersListResponse proto.InternalMessageInfo

func (m *QueryStaticProvidersListResponse) GetProviders() []types.StakeEntry {
	if m != nil {
		return m.Providers
	}
	return nil
}

type QueryAccountInfoResponse struct {
	Provider     []types.StakeEntry   `protobuf:"bytes,1,rep,name=provider,proto3" json:"provider"`
	Frozen       []types.StakeEntry   `protobuf:"bytes,2,rep,name=frozen,proto3" json:"frozen"`
	Consumer     []types.StakeEntry   `protobuf:"bytes,3,rep,name=consumer,proto3" json:"consumer"`
	Unstaked     []types.StakeEntry   `protobuf:"bytes,4,rep,name=unstaked,proto3" json:"unstaked"`
	Subscription *types1.Subscription `protobuf:"bytes,5,opt,name=subscription,proto3" json:"subscription,omitempty"`
	Project      *types2.Project      `protobuf:"bytes,6,opt,name=project,proto3" json:"project,omitempty"`
}

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

var xxx_messageInfo_QueryAccountInfoResponse proto.InternalMessageInfo

func (m *QueryAccountInfoResponse) GetProvider() []types.StakeEntry {
	if m != nil {
		return m.Provider
	}
	return nil
}

func (m *QueryAccountInfoResponse) GetFrozen() []types.StakeEntry {
	if m != nil {
		return m.Frozen
	}
	return nil
}

func (m *QueryAccountInfoResponse) GetConsumer() []types.StakeEntry {
	if m != nil {
		return m.Consumer
	}
	return nil
}

func (m *QueryAccountInfoResponse) GetUnstaked() []types.StakeEntry {
	if m != nil {
		return m.Unstaked
	}
	return nil
}

func (m *QueryAccountInfoResponse) GetSubscription() *types1.Subscription {
	if m != nil {
		return m.Subscription
	}
	return nil
}

func (m *QueryAccountInfoResponse) GetProject() *types2.Project {
	if m != nil {
		return m.Project
	}
	return nil
}

func init() {
	proto.RegisterType((*QueryParamsRequest)(nil), "lavanet.lava.pairing.QueryParamsRequest")
	proto.RegisterType((*QueryParamsResponse)(nil), "lavanet.lava.pairing.QueryParamsResponse")
	proto.RegisterType((*QueryProvidersRequest)(nil), "lavanet.lava.pairing.QueryProvidersRequest")
	proto.RegisterType((*QueryProvidersResponse)(nil), "lavanet.lava.pairing.QueryProvidersResponse")
	proto.RegisterType((*QueryClientsRequest)(nil), "lavanet.lava.pairing.QueryClientsRequest")
	proto.RegisterType((*QueryClientsResponse)(nil), "lavanet.lava.pairing.QueryClientsResponse")
	proto.RegisterType((*QueryGetPairingRequest)(nil), "lavanet.lava.pairing.QueryGetPairingRequest")
	proto.RegisterType((*QueryGetPairingResponse)(nil), "lavanet.lava.pairing.QueryGetPairingResponse")
	proto.RegisterType((*QueryVerifyPairingRequest)(nil), "lavanet.lava.pairing.QueryVerifyPairingRequest")
	proto.RegisterType((*QueryVerifyPairingResponse)(nil), "lavanet.lava.pairing.QueryVerifyPairingResponse")
	proto.RegisterType((*QueryGetUniquePaymentStorageClientProviderRequest)(nil), "lavanet.lava.pairing.QueryGetUniquePaymentStorageClientProviderRequest")
	proto.RegisterType((*QueryGetUniquePaymentStorageClientProviderResponse)(nil), "lavanet.lava.pairing.QueryGetUniquePaymentStorageClientProviderResponse")
	proto.RegisterType((*QueryAllUniquePaymentStorageClientProviderRequest)(nil), "lavanet.lava.pairing.QueryAllUniquePaymentStorageClientProviderRequest")
	proto.RegisterType((*QueryAllUniquePaymentStorageClientProviderResponse)(nil), "lavanet.lava.pairing.QueryAllUniquePaymentStorageClientProviderResponse")
	proto.RegisterType((*QueryGetProviderPaymentStorageRequest)(nil), "lavanet.lava.pairing.QueryGetProviderPaymentStorageRequest")
	proto.RegisterType((*QueryGetProviderPaymentStorageResponse)(nil), "lavanet.lava.pairing.QueryGetProviderPaymentStorageResponse")
	proto.RegisterType((*QueryAllProviderPaymentStorageRequest)(nil), "lavanet.lava.pairing.QueryAllProviderPaymentStorageRequest")
	proto.RegisterType((*QueryAllProviderPaymentStorageResponse)(nil), "lavanet.lava.pairing.QueryAllProviderPaymentStorageResponse")
	proto.RegisterType((*QueryGetEpochPaymentsRequest)(nil), "lavanet.lava.pairing.QueryGetEpochPaymentsRequest")
	proto.RegisterType((*QueryGetEpochPaymentsResponse)(nil), "lavanet.lava.pairing.QueryGetEpochPaymentsResponse")
	proto.RegisterType((*QueryAllEpochPaymentsRequest)(nil), "lavanet.lava.pairing.QueryAllEpochPaymentsRequest")
	proto.RegisterType((*QueryAllEpochPaymentsResponse)(nil), "lavanet.lava.pairing.QueryAllEpochPaymentsResponse")
	proto.RegisterType((*QueryUserEntryRequest)(nil), "lavanet.lava.pairing.QueryUserEntryRequest")
	proto.RegisterType((*QueryUserEntryResponse)(nil), "lavanet.lava.pairing.QueryUserEntryResponse")
	proto.RegisterType((*QueryStaticProvidersListRequest)(nil), "lavanet.lava.pairing.QueryStaticProvidersListRequest")
	proto.RegisterType((*QueryStaticProvidersListResponse)(nil), "lavanet.lava.pairing.QueryStaticProvidersListResponse")
	proto.RegisterType((*QueryAccountInfoResponse)(nil), "lavanet.lava.pairing.QueryAccountInfoResponse")
}

func init() { proto.RegisterFile("pairing/query.proto", fileDescriptor_6bd8a3cd41a2a1ee) }

var fileDescriptor_6bd8a3cd41a2a1ee = []byte{
	// 1640 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x59, 0xcb, 0x4f, 0xdc, 0x56,
	0x17, 0xc7, 0x33, 0x40, 0xe0, 0x24, 0xe8, 0x8b, 0x2e, 0x13, 0x32, 0x99, 0x8f, 0x6f, 0x82, 0x9c,
	0x84, 0x40, 0xc2, 0x37, 0x0e, 0x84, 0xd0, 0xa8, 0x79, 0x48, 0xe4, 0x45, 0x49, 0x51, 0x03, 0x43,
	0xe9, 0xa2, 0x1b, 0xcb, 0x78, 0xee, 0x0c, 0x4e, 0x3c, 0xb6, 0xe3, 0x07, 0x81, 0x8e, 0x50, 0xab,
	0x56, 0xd9, 0x46, 0xad, 0xda, 0x4d, 0xf7, 0x95, 0xaa, 0x4a, 0x6d, 0xf7, 0x5d, 0x57, 0xad, 0xb2,
	0x69, 0x15, 0x29, 0x9b, 0x6e, 0x5a, 0x55, 0x49, 0xff, 0x90, 0xca, 0xf7, 0x1e, 0x7b, 0x6c, 0xf0,
	0x78, 0x66, 0x00, 0x65, 0xc5, 0x5c, 0xdf, 0xf3, 0xf8, 0x9d, 0xdf, 0xb9, 0xbe, 0xe7, 0x1c, 0x03,
	0xc3, 0x96, 0xa2, 0xd9, 0x9a, 0x51, 0x93, 0x1e, 0x7b, 0xd4, 0xde, 0x2e, 0x59, 0xb6, 0xe9, 0x9a,
	0x24, 0xa7, 0x2b, 0x9b, 0x8a, 0x41, 0xdd, 0x92, 0xff, 0xb7, 0x84, 0x12, 0x85, 0x5c, 0xcd, 0xac,
	0x99, 0x4c, 0x40, 0xf2, 0x7f, 0x71, 0xd9, 0xc2, 0x68, 0xcd, 0x34, 0x6b, 0x3a, 0x95, 0x14, 0x4b,
	0x93, 0x14, 0xc3, 0x30, 0x5d, 0xc5, 0xd5, 0x4c, 0xc3, 0xc1, 0xdd, 0x0b, 0xaa, 0xe9, 0xd4, 0x4d,
	0x47, 0x5a, 0x57, 0x1c, 0xca, 0x5d, 0x48, 0x9b, 0xd3, 0xeb, 0xd4, 0x55, 0xa6, 0x25, 0x4b, 0xa9,
	0x69, 0x06, 0x13, 0x46, 0xd9, 0x5c, 0x00, 0xc5, 0x52, 0x6c, 0xa5, 0x1e, 0x58, 0x18, 0x0d, 0x9e,
	0x52, 0xcb, 0x54, 0x37, 0x64, 0x4b, 0xd9, 0xae, 0x53, 0xc3, 0x0d, 0x76, 0xff, 0x1b, 0xec, 0xae,
	0x2b, 0x95, 0x1a, 0x95, 0x3d, 0x87, 0x56, 0x64, 0xd5, 0xc3, 0xcd, 0xf1, 0xd0, 0xa0, 0x6d, 0x6e,
	0x6a, 0x15, 0x6a, 0x07, 0xda, 0xb2, 0xe3, 0x9a, 0xb6, 0x52, 0xa3, 0x28, 0x37, 0x1b, 0xc8, 0x79,
	0x86, 0xf6, 0xd8, 0xa3, 0xbb, 0xa5, 0x64, 0x55, 0xd7, 0xfc, 0x65, 0x60, 0x05, 0xb5, 0x8a, 0x0c,
	0x10, 0xca, 0x48, 0x8e, 0xab, 0x3c, 0xa2, 0x32, 0x35, 0xdc, 0x80, 0xc4, 0xc2, 0x69, 0xc7, 0x5b,
	0x77, 0x54, 0x5b, 0xb3, 0xfc, 0x10, 0xa5, 0xe8, 0x02, 0x05, 0x46, 0x2c, 0xdb, 0x7c, 0x48, 0x55,
	0xd7, 0x91, 0xf0, 0x07, 0x7f, 0x2e, 0xe6, 0x80, 0xac, 0xf8, 0x4c, 0x2d, 0x33, 0x1a, 0xca, 0xf4,
	0xb1, 0x47, 0x1d, 0x57, 0x5c, 0x81, 0xe1, 0xd8, 0x53, 0xc7, 0x32, 0x0d, 0x87, 0x92, 0xb7, 0xa1,
	0x9f, 0xd3, 0x95, 0x17, 0xc6, 0x84, 0x89, 0xa3, 0x33, 0xa3, 0xa5, 0xa4, 0xdc, 0x95, 0xb8, 0xd6,
	0xad, 0xde, 0xe7, 0x7f, 0x9d, 0xee, 0x29, 0xa3, 0x86, 0xb8, 0x02, 0x27, 0xb8, 0x49, 0x0c, 0x2c,
	0xf0, 0x45, 0xf2, 0x70, 0x44, 0xdd, 0x50, 0x34, 0x63, 0xf1, 0x0e, 0xb3, 0x3a, 0x58, 0x0e, 0x96,
	0xa4, 0x08, 0xe0, 0x6c, 0x98, 0x4f, 0xee, 0xd9, 0xe6, 0x47, 0xd4, 0xc8, 0x67, 0xc6, 0x84, 0x89,
	0x81, 0x72, 0xe4, 0x89, 0xb8, 0x03, 0x23, 0xbb, 0x4d, 0x22, 0xd0, 0x77, 0x01, 0x18, 0x47, 0x77,
	0x7d, 0x8a, 0xf2, 0xc2, 0x58, 0x76, 0xe2, 0xe8, 0xcc, 0xb9, 0x38, 0xd8, 0x28, 0xa1, 0xa5, 0xd5,
	0x50, 0x18, 0x51, 0x47, 0xd4, 0xc9, 0x08, 0xf4, 0x9b, 0x9e, 0x6b, 0x79, 0x2e, 0x83, 0x30, 0x58,
	0xc6, 0x95, 0x28, 0x21, 0x49, 0xb7, 0x59, 0xc6, 0xda, 0xc7, 0x23, 0x36, 0x20, 0x17, 0x57, 0x78,
	0x93, 0x68, 0xef, 0x23, 0x59, 0x0b, 0xd4, 0x5d, 0xe6, 0x79, 0x6a, 0x9f, 0x80, 0x11, 0xe8, 0xe7,
	0xc7, 0x31, 0xb0, 0xc5, 0x57, 0xe2, 0x0f, 0x19, 0x38, 0xb9, 0xc7, 0x18, 0x06, 0xb3, 0x08, 0x83,
	0xc1, 0xd9, 0x75, 0xf6, 0x13, 0x4b, 0x53, 0x9b, 0x9c, 0x81, 0x21, 0xd5, 0xb3, 0x6d, 0xff, 0x75,
	0x60, 0x3a, 0x0c, 0x45, 0x6f, 0xf9, 0x18, 0x3e, 0xbc, 0xeb, 0x3f, 0x23, 0x57, 0xe1, 0x94, 0xab,
	0xd5, 0xa9, 0xac, 0xd3, 0xaa, 0x2b, 0xbb, 0xa6, 0x6c, 0xd0, 0x2d, 0x57, 0xc6, 0x93, 0x98, 0xcf,
	0x32, 0x85, 0x13, 0xbe, 0xc0, 0x12, 0xad, 0xba, 0xef, 0x9b, 0xef, 0xd1, 0xad, 0x00, 0x31, 0xb9,
	0x02, 0x27, 0x1d, 0x8b, 0xaa, 0xb2, 0xae, 0x38, 0xae, 0xec, 0x59, 0x15, 0xc5, 0xa5, 0x15, 0x79,
	0x5d, 0x37, 0xd5, 0x47, 0xf9, 0x5e, 0xa6, 0x97, 0xf3, 0xb7, 0x97, 0x14, 0xc7, 0x5d, 0xe3, 0x9b,
	0xb7, 0xfc, 0x3d, 0x32, 0x0d, 0x27, 0x98, 0x90, 0x6c, 0x56, 0xe3, 0xce, 0xfa, 0x98, 0x12, 0x61,
	0x9b, 0x0f, 0xaa, 0x11, 0x4f, 0xe2, 0xc7, 0x70, 0x8a, 0xd1, 0xf5, 0x01, 0xb5, 0xb5, 0xea, 0xf6,
	0x41, 0xe9, 0x27, 0x05, 0x18, 0x08, 0x48, 0x62, 0x11, 0x0e, 0x96, 0xc3, 0x35, 0xc9, 0x41, 0x5f,
	0x34, 0x04, 0xbe, 0x10, 0x9f, 0x0a, 0x50, 0x48, 0x42, 0x80, 0x39, 0xcb, 0x41, 0xdf, 0xa6, 0xa2,
	0x6b, 0x15, 0x06, 0x60, 0xa0, 0xcc, 0x17, 0x64, 0x12, 0x8e, 0xfb, 0xa1, 0xd1, 0x8a, 0xdc, 0x4c,
	0x28, 0x27, 0xf4, 0x3f, 0xfc, 0x79, 0xf8, 0xde, 0x91, 0x31, 0x38, 0xa6, 0x7a, 0xb2, 0x45, 0x6d,
	0x4c, 0x14, 0x77, 0x0e, 0xaa, 0xb7, 0x4c, 0x6d, 0x96, 0xa6, 0xfb, 0xbd, 0x03, 0x99, 0xe3, 0x59,
	0x71, 0x11, 0xa6, 0x83, 0x73, 0xb3, 0xc6, 0xae, 0xbf, 0x65, 0x7e, 0xfb, 0xad, 0xf2, 0xd3, 0xc0,
	0x5f, 0x8c, 0xc0, 0x6c, 0x40, 0x50, 0x0e, 0xfa, 0x34, 0xa3, 0x42, 0xb7, 0x90, 0x1e, 0xbe, 0x10,
	0x7f, 0x11, 0x60, 0xa6, 0x1b, 0x5b, 0x18, 0xea, 0x33, 0x01, 0x44, 0xaf, 0xad, 0x38, 0xde, 0x6f,
	0x57, 0x93, 0xef, 0xb7, 0xf6, 0xee, 0xf0, 0x2c, 0x77, 0xe0, 0x49, 0x6c, 0x20, 0x25, 0xf3, 0xba,
	0xde, 0x39, 0x25, 0xf7, 0x00, 0x9a, 0x15, 0x0d, 0xc1, 0x8e, 0x97, 0x78, 0xf9, 0x2b, 0xf9, 0xe5,
	0xaf, 0xc4, 0x2b, 0x2c, 0x96, 0xbf, 0xd2, 0xb2, 0x52, 0xa3, 0xa8, 0x5b, 0x8e, 0x68, 0x8a, 0xcf,
	0x32, 0x48, 0x62, 0x87, 0xde, 0xbb, 0x25, 0x31, 0xfb, 0x66, 0x48, 0x24, 0x0b, 0x31, 0x3e, 0x32,
	0x8c, 0x8f, 0xf3, 0x6d, 0xf9, 0xe0, 0xd1, 0xc4, 0x08, 0xb9, 0x01, 0xe7, 0xc2, 0x8b, 0x0d, 0x8d,
	0xc7, 0x1d, 0xa7, 0x1f, 0xca, 0xaf, 0x04, 0x18, 0x6f, 0xa7, 0x8f, 0x1c, 0x3e, 0x84, 0x11, 0x2b,
	0x51, 0x02, 0xd3, 0x39, 0xd5, 0xa2, 0xb6, 0x26, 0xea, 0x20, 0x55, 0x2d, 0x2c, 0x8a, 0x26, 0x46,
	0x35, 0xaf, 0xeb, 0xe9, 0x51, 0x1d, 0xd6, 0xb9, 0xfa, 0x33, 0xe0, 0x21, 0xc5, 0x63, 0x07, 0x3c,
	0x64, 0x0f, 0x97, 0x87, 0xc3, 0x3b, 0x26, 0xb3, 0x30, 0x1a, 0xa4, 0x99, 0x5d, 0x6f, 0xe8, 0xc7,
	0x49, 0x3f, 0x1d, 0x16, 0xfc, 0xaf, 0x85, 0x16, 0x72, 0xf1, 0x00, 0x86, 0x68, 0x74, 0x03, 0x33,
	0x70, 0x26, 0x99, 0x82, 0x98, 0x0d, 0x8c, 0x3c, 0xae, 0x2f, 0x56, 0x11, 0xe7, 0xbc, 0xae, 0x27,
	0xe2, 0x3c, 0xac, 0x7c, 0xff, 0x24, 0x60, 0x68, 0x7b, 0x1d, 0xb5, 0x0e, 0x2d, 0x7b, 0x90, 0xd0,
	0x0e, 0x2f, 0x97, 0x0a, 0x36, 0xa6, 0x6b, 0x0e, 0xb5, 0x59, 0x23, 0x12, 0x29, 0xcc, 0x4a, 0xa5,
	0x62, 0x53, 0xc7, 0x09, 0x0a, 0x33, 0x2e, 0xa3, 0x25, 0x3b, 0x13, 0x2f, 0xd9, 0x61, 0xf9, 0xcd,
	0x46, 0xcb, 0xef, 0x13, 0xec, 0xbd, 0x22, 0x2e, 0x90, 0x96, 0x05, 0x18, 0x50, 0x4d, 0xc3, 0xf1,
	0xea, 0x61, 0xcd, 0xe9, 0xaa, 0x59, 0x0a, 0x95, 0x7d, 0xc7, 0x75, 0x65, 0xeb, 0xf6, 0x1a, 0xf6,
	0x48, 0x7c, 0x21, 0x5e, 0x83, 0xd3, 0xcc, 0xf1, 0xaa, 0x3f, 0x28, 0xa9, 0x61, 0xbd, 0x5e, 0xd2,
	0x1c, 0xb7, 0x7d, 0xbb, 0x5a, 0x87, 0xb1, 0xd6, 0xca, 0x87, 0xde, 0xed, 0x89, 0xbf, 0x65, 0x21,
	0xcf, 0xcf, 0x90, 0xaa, 0x9a, 0x9e, 0xe1, 0x2e, 0x1a, 0x55, 0x33, 0xca, 0x93, 0x15, 0x2f, 0x2b,
	0xdd, 0xf1, 0x14, 0xf6, 0x47, 0xb7, 0xa1, 0xbf, 0x1a, 0xcc, 0x13, 0x5d, 0x9b, 0x41, 0xd5, 0x58,
	0xd6, 0xb2, 0xfb, 0x40, 0x13, 0x66, 0x6d, 0x01, 0x06, 0x3c, 0x83, 0x35, 0xef, 0x95, 0x7c, 0xef,
	0x3e, 0x0c, 0x05, 0xca, 0x64, 0x05, 0x8e, 0x45, 0x87, 0x3e, 0xd6, 0x8b, 0xfa, 0xef, 0x43, 0xcc,
	0x58, 0x6c, 0x2c, 0x5c, 0x8d, 0x2c, 0x98, 0x39, 0xa1, 0x1c, 0x33, 0x41, 0x6e, 0xc2, 0x11, 0x1c,
	0x15, 0xf3, 0xfd, 0xcc, 0x5a, 0x71, 0xd7, 0xbb, 0x8a, 0x03, 0xa5, 0x7f, 0x15, 0xfb, 0x3f, 0xd0,
	0x48, 0xa0, 0x34, 0xf3, 0xfd, 0x30, 0xf4, 0xb1, 0x7c, 0x92, 0xcf, 0x04, 0xe8, 0xe7, 0x33, 0x21,
	0x99, 0x48, 0x7e, 0xdf, 0xf7, 0x8e, 0xa0, 0x85, 0xc9, 0x0e, 0x24, 0xf9, 0xe1, 0x10, 0xcf, 0x7e,
	0xfa, 0xf2, 0x9f, 0x2f, 0x33, 0x45, 0x32, 0x2a, 0xa1, 0x0a, 0xfb, 0x2b, 0xc5, 0x27, 0x7c, 0xf2,
	0xb5, 0x00, 0x83, 0xcd, 0x8e, 0xf5, 0x62, 0x9a, 0xf9, 0x5d, 0x23, 0x6a, 0x61, 0xaa, 0x33, 0x61,
	0x84, 0x33, 0xcd, 0xe0, 0x5c, 0x24, 0x93, 0x2d, 0xe0, 0x04, 0x0a, 0x52, 0x03, 0xdf, 0xb4, 0x1d,
	0xf2, 0x85, 0x00, 0x47, 0x70, 0x2a, 0x24, 0x69, 0x81, 0xc7, 0x47, 0xcd, 0xc2, 0x85, 0x4e, 0x44,
	0x11, 0x95, 0xc4, 0x50, 0x4d, 0x92, 0xf3, 0xc9, 0xa8, 0xf8, 0x68, 0x11, 0xc5, 0xf4, 0xad, 0x00,
	0xd0, 0x9c, 0xef, 0x48, 0x1a, 0x07, 0x7b, 0x66, 0xca, 0xc2, 0xff, 0x3b, 0x94, 0x46, 0x70, 0xd7,
	0x19, 0xb8, 0x39, 0x32, 0x9b, 0x0c, 0xae, 0x46, 0xc3, 0x29, 0xab, 0x09, 0x50, 0x6a, 0x70, 0xcc,
	0x3b, 0xe4, 0x57, 0x01, 0x86, 0x62, 0x83, 0x0d, 0x91, 0x52, 0xdc, 0x27, 0x0d, 0x61, 0x85, 0x4b,
	0x9d, 0x2b, 0x20, 0xe4, 0x32, 0x83, 0xbc, 0x44, 0xee, 0x27, 0x43, 0xde, 0x64, 0x4a, 0x29, 0xa8,
	0xa5, 0x46, 0x70, 0x10, 0x76, 0xa4, 0x06, 0x2b, 0x13, 0x3b, 0xe4, 0x69, 0x06, 0xc4, 0xb5, 0x0e,
	0xba, 0xdd, 0x74, 0x72, 0x3b, 0x1e, 0x23, 0x0a, 0xef, 0x1c, 0xdc, 0x10, 0xb2, 0xb1, 0xc4, 0xd8,
	0xb8, 0x47, 0xee, 0x24, 0xb3, 0xd1, 0xd9, 0xb7, 0x2e, 0xa9, 0xc1, 0xfa, 0xa4, 0x1d, 0xf2, 0x49,
	0x06, 0xce, 0xb5, 0x77, 0x3e, 0xaf, 0xeb, 0xa9, 0x54, 0x74, 0x33, 0x51, 0xa5, 0x52, 0xd1, 0xd5,
	0x70, 0x24, 0xde, 0x61, 0x54, 0xdc, 0x24, 0xd7, 0x0f, 0x42, 0x05, 0x79, 0x29, 0xc0, 0x48, 0x72,
	0x8f, 0x4b, 0xae, 0xb5, 0x79, 0xb7, 0xd2, 0x3a, 0xfc, 0xc2, 0xf5, 0xfd, 0x29, 0x63, 0x6c, 0x37,
	0x59, 0x6c, 0x57, 0xc9, 0x5c, 0xfa, 0xd5, 0xb6, 0x3b, 0xba, 0x30, 0xb1, 0xbf, 0x0b, 0x70, 0x2a,
	0xd9, 0x85, 0x9f, 0xcc, 0x6b, 0xe9, 0x39, 0xd8, 0x7f, 0x60, 0x6d, 0xa7, 0x10, 0x71, 0x8e, 0x05,
	0x76, 0x89, 0x94, 0xba, 0x0b, 0x8c, 0xfc, 0x28, 0xc0, 0x50, 0xac, 0x59, 0x25, 0x33, 0xe9, 0x04,
	0x27, 0xb5, 0xe1, 0x85, 0xcb, 0x5d, 0xe9, 0x20, 0xe4, 0x59, 0x06, 0xb9, 0x44, 0xa6, 0x92, 0x21,
	0xc7, 0xbf, 0x60, 0x87, 0x19, 0xf8, 0x4e, 0x80, 0xe3, 0x31, 0x7b, 0x3e, 0xf1, 0x33, 0xe9, 0xdc,
	0x75, 0x8d, 0xb9, 0xd5, 0x14, 0x20, 0x4e, 0x31, 0xcc, 0xe3, 0xe4, 0x6c, 0x27, 0x98, 0xc9, 0x37,
	0x02, 0x0c, 0x86, 0x2d, 0x73, 0x6a, 0xc5, 0xde, 0xdd, 0xbb, 0xa7, 0x56, 0xec, 0x3d, 0x5d, 0x78,
	0xbb, 0xf2, 0xe3, 0x39, 0xd4, 0xe6, 0x5f, 0xdb, 0xa5, 0x06, 0x8e, 0x00, 0x3b, 0x91, 0x42, 0xf9,
	0xb3, 0x00, 0xc3, 0x09, 0x3d, 0x32, 0xb9, 0x92, 0x82, 0xa1, 0x75, 0x43, 0x5e, 0x98, 0xeb, 0x56,
	0x0d, 0x83, 0xb8, 0xc1, 0x82, 0x78, 0x8b, 0x5c, 0x49, 0x0e, 0xc2, 0x61, 0xaa, 0xcd, 0x4f, 0x79,
	0xb2, 0xae, 0x39, 0x6e, 0x33, 0x8a, 0x5b, 0xf3, 0xcf, 0x5f, 0x15, 0x85, 0x17, 0xaf, 0x8a, 0xc2,
	0xdf, 0xaf, 0x8a, 0xc2, 0xe7, 0xaf, 0x8b, 0x3d, 0x2f, 0x5e, 0x17, 0x7b, 0xfe, 0x78, 0x5d, 0xec,
	0xf9, 0xf0, 0x7c, 0x4d, 0x73, 0x37, 0xbc, 0xf5, 0x92, 0x6a, 0xd6, 0xe3, 0xa6, 0xb7, 0x42, 0xe3,
	0xee, 0xb6, 0x45, 0x9d, 0xf5, 0x7e, 0xf6, 0x2f, 0x85, 0xcb, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff,
	0x88, 0x6f, 0x04, 0xb1, 0xe7, 0x19, 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 {
	// Parameters queries the parameters of the module.
	Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error)
	// Queries a list of Providers items.
	Providers(ctx context.Context, in *QueryProvidersRequest, opts ...grpc.CallOption) (*QueryProvidersResponse, error)
	// Queries a list of Clients items.
	Clients(ctx context.Context, in *QueryClientsRequest, opts ...grpc.CallOption) (*QueryClientsResponse, error)
	// Queries a list of GetPairing items.
	GetPairing(ctx context.Context, in *QueryGetPairingRequest, opts ...grpc.CallOption) (*QueryGetPairingResponse, error)
	// Queries a list of VerifyPairing items.
	VerifyPairing(ctx context.Context, in *QueryVerifyPairingRequest, opts ...grpc.CallOption) (*QueryVerifyPairingResponse, error)
	// Queries a UniquePaymentStorageClientProvider by index.
	UniquePaymentStorageClientProvider(ctx context.Context, in *QueryGetUniquePaymentStorageClientProviderRequest, opts ...grpc.CallOption) (*QueryGetUniquePaymentStorageClientProviderResponse, error)
	// Queries a list of UniquePaymentStorageClientProvider items.
	UniquePaymentStorageClientProviderAll(ctx context.Context, in *QueryAllUniquePaymentStorageClientProviderRequest, opts ...grpc.CallOption) (*QueryAllUniquePaymentStorageClientProviderResponse, error)
	// Queries a ProviderPaymentStorage by index.
	ProviderPaymentStorage(ctx context.Context, in *QueryGetProviderPaymentStorageRequest, opts ...grpc.CallOption) (*QueryGetProviderPaymentStorageResponse, error)
	// Queries a list of ProviderPaymentStorage items.
	ProviderPaymentStorageAll(ctx context.Context, in *QueryAllProviderPaymentStorageRequest, opts ...grpc.CallOption) (*QueryAllProviderPaymentStorageResponse, error)
	// Queries a EpochPayments by index.
	EpochPayments(ctx context.Context, in *QueryGetEpochPaymentsRequest, opts ...grpc.CallOption) (*QueryGetEpochPaymentsResponse, error)
	// Queries a list of EpochPayments items.
	EpochPaymentsAll(ctx context.Context, in *QueryAllEpochPaymentsRequest, opts ...grpc.CallOption) (*QueryAllEpochPaymentsResponse, error)
	// Queries a UserEntry items.
	UserEntry(ctx context.Context, in *QueryUserEntryRequest, opts ...grpc.CallOption) (*QueryUserEntryResponse, error)
	// Queries a list of StaticProvidersList items.
	StaticProvidersList(ctx context.Context, in *QueryStaticProvidersListRequest, opts ...grpc.CallOption) (*QueryStaticProvidersListResponse, error)
}

type queryClient struct {
	cc grpc1.ClientConn
}

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

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

func (c *queryClient) Providers(ctx context.Context, in *QueryProvidersRequest, opts ...grpc.CallOption) (*QueryProvidersResponse, error) {
	out := new(QueryProvidersResponse)
	err := c.cc.Invoke(ctx, "/lavanet.lava.pairing.Query/Providers", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) Clients(ctx context.Context, in *QueryClientsRequest, opts ...grpc.CallOption) (*QueryClientsResponse, error) {
	out := new(QueryClientsResponse)
	err := c.cc.Invoke(ctx, "/lavanet.lava.pairing.Query/Clients", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) GetPairing(ctx context.Context, in *QueryGetPairingRequest, opts ...grpc.CallOption) (*QueryGetPairingResponse, error) {
	out := new(QueryGetPairingResponse)
	err := c.cc.Invoke(ctx, "/lavanet.lava.pairing.Query/GetPairing", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) VerifyPairing(ctx context.Context, in *QueryVerifyPairingRequest, opts ...grpc.CallOption) (*QueryVerifyPairingResponse, error) {
	out := new(QueryVerifyPairingResponse)
	err := c.cc.Invoke(ctx, "/lavanet.lava.pairing.Query/VerifyPairing", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) UniquePaymentStorageClientProvider(ctx context.Context, in *QueryGetUniquePaymentStorageClientProviderRequest, opts ...grpc.CallOption) (*QueryGetUniquePaymentStorageClientProviderResponse, error) {
	out := new(QueryGetUniquePaymentStorageClientProviderResponse)
	err := c.cc.Invoke(ctx, "/lavanet.lava.pairing.Query/UniquePaymentStorageClientProvider", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) UniquePaymentStorageClientProviderAll(ctx context.Context, in *QueryAllUniquePaymentStorageClientProviderRequest, opts ...grpc.CallOption) (*QueryAllUniquePaymentStorageClientProviderResponse, error) {
	out := new(QueryAllUniquePaymentStorageClientProviderResponse)
	err := c.cc.Invoke(ctx, "/lavanet.lava.pairing.Query/UniquePaymentStorageClientProviderAll", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) ProviderPaymentStorage(ctx context.Context, in *QueryGetProviderPaymentStorageRequest, opts ...grpc.CallOption) (*QueryGetProviderPaymentStorageResponse, error) {
	out := new(QueryGetProviderPaymentStorageResponse)
	err := c.cc.Invoke(ctx, "/lavanet.lava.pairing.Query/ProviderPaymentStorage", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) ProviderPaymentStorageAll(ctx context.Context, in *QueryAllProviderPaymentStorageRequest, opts ...grpc.CallOption) (*QueryAllProviderPaymentStorageResponse, error) {
	out := new(QueryAllProviderPaymentStorageResponse)
	err := c.cc.Invoke(ctx, "/lavanet.lava.pairing.Query/ProviderPaymentStorageAll", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) EpochPayments(ctx context.Context, in *QueryGetEpochPaymentsRequest, opts ...grpc.CallOption) (*QueryGetEpochPaymentsResponse, error) {
	out := new(QueryGetEpochPaymentsResponse)
	err := c.cc.Invoke(ctx, "/lavanet.lava.pairing.Query/EpochPayments", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) EpochPaymentsAll(ctx context.Context, in *QueryAllEpochPaymentsRequest, opts ...grpc.CallOption) (*QueryAllEpochPaymentsResponse, error) {
	out := new(QueryAllEpochPaymentsResponse)
	err := c.cc.Invoke(ctx, "/lavanet.lava.pairing.Query/EpochPaymentsAll", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) UserEntry(ctx context.Context, in *QueryUserEntryRequest, opts ...grpc.CallOption) (*QueryUserEntryResponse, error) {
	out := new(QueryUserEntryResponse)
	err := c.cc.Invoke(ctx, "/lavanet.lava.pairing.Query/UserEntry", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) StaticProvidersList(ctx context.Context, in *QueryStaticProvidersListRequest, opts ...grpc.CallOption) (*QueryStaticProvidersListResponse, error) {
	out := new(QueryStaticProvidersListResponse)
	err := c.cc.Invoke(ctx, "/lavanet.lava.pairing.Query/StaticProvidersList", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// QueryServer is the server API for Query service.
type QueryServer interface {
	// Parameters queries the parameters of the module.
	Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error)
	// Queries a list of Providers items.
	Providers(context.Context, *QueryProvidersRequest) (*QueryProvidersResponse, error)
	// Queries a list of Clients items.
	Clients(context.Context, *QueryClientsRequest) (*QueryClientsResponse, error)
	// Queries a list of GetPairing items.
	GetPairing(context.Context, *QueryGetPairingRequest) (*QueryGetPairingResponse, error)
	// Queries a list of VerifyPairing items.
	VerifyPairing(context.Context, *QueryVerifyPairingRequest) (*QueryVerifyPairingResponse, error)
	// Queries a UniquePaymentStorageClientProvider by index.
	UniquePaymentStorageClientProvider(context.Context, *QueryGetUniquePaymentStorageClientProviderRequest) (*QueryGetUniquePaymentStorageClientProviderResponse, error)
	// Queries a list of UniquePaymentStorageClientProvider items.
	UniquePaymentStorageClientProviderAll(context.Context, *QueryAllUniquePaymentStorageClientProviderRequest) (*QueryAllUniquePaymentStorageClientProviderResponse, error)
	// Queries a ProviderPaymentStorage by index.
	ProviderPaymentStorage(context.Context, *QueryGetProviderPaymentStorageRequest) (*QueryGetProviderPaymentStorageResponse, error)
	// Queries a list of ProviderPaymentStorage items.
	ProviderPaymentStorageAll(context.Context, *QueryAllProviderPaymentStorageRequest) (*QueryAllProviderPaymentStorageResponse, error)
	// Queries a EpochPayments by index.
	EpochPayments(context.Context, *QueryGetEpochPaymentsRequest) (*QueryGetEpochPaymentsResponse, error)
	// Queries a list of EpochPayments items.
	EpochPaymentsAll(context.Context, *QueryAllEpochPaymentsRequest) (*QueryAllEpochPaymentsResponse, error)
	// Queries a UserEntry items.
	UserEntry(context.Context, *QueryUserEntryRequest) (*QueryUserEntryResponse, error)
	// Queries a list of StaticProvidersList items.
	StaticProvidersList(context.Context, *QueryStaticProvidersListRequest) (*QueryStaticProvidersListResponse, error)
}

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

func (*UnimplementedQueryServer) Params(ctx context.Context, req *QueryParamsRequest) (*QueryParamsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Params not implemented")
}
func (*UnimplementedQueryServer) Providers(ctx context.Context, req *QueryProvidersRequest) (*QueryProvidersResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Providers not implemented")
}
func (*UnimplementedQueryServer) Clients(ctx context.Context, req *QueryClientsRequest) (*QueryClientsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Clients not implemented")
}
func (*UnimplementedQueryServer) GetPairing(ctx context.Context, req *QueryGetPairingRequest) (*QueryGetPairingResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetPairing not implemented")
}
func (*UnimplementedQueryServer) VerifyPairing(ctx context.Context, req *QueryVerifyPairingRequest) (*QueryVerifyPairingResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method VerifyPairing not implemented")
}
func (*UnimplementedQueryServer) UniquePaymentStorageClientProvider(ctx context.Context, req *QueryGetUniquePaymentStorageClientProviderRequest) (*QueryGetUniquePaymentStorageClientProviderResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UniquePaymentStorageClientProvider not implemented")
}
func (*UnimplementedQueryServer) UniquePaymentStorageClientProviderAll(ctx context.Context, req *QueryAllUniquePaymentStorageClientProviderRequest) (*QueryAllUniquePaymentStorageClientProviderResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UniquePaymentStorageClientProviderAll not implemented")
}
func (*UnimplementedQueryServer) ProviderPaymentStorage(ctx context.Context, req *QueryGetProviderPaymentStorageRequest) (*QueryGetProviderPaymentStorageResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ProviderPaymentStorage not implemented")
}
func (*UnimplementedQueryServer) ProviderPaymentStorageAll(ctx context.Context, req *QueryAllProviderPaymentStorageRequest) (*QueryAllProviderPaymentStorageResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ProviderPaymentStorageAll not implemented")
}
func (*UnimplementedQueryServer) EpochPayments(ctx context.Context, req *QueryGetEpochPaymentsRequest) (*QueryGetEpochPaymentsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method EpochPayments not implemented")
}
func (*UnimplementedQueryServer) EpochPaymentsAll(ctx context.Context, req *QueryAllEpochPaymentsRequest) (*QueryAllEpochPaymentsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method EpochPaymentsAll not implemented")
}
func (*UnimplementedQueryServer) UserEntry(ctx context.Context, req *QueryUserEntryRequest) (*QueryUserEntryResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UserEntry not implemented")
}
func (*UnimplementedQueryServer) StaticProvidersList(ctx context.Context, req *QueryStaticProvidersListRequest) (*QueryStaticProvidersListResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StaticProvidersList not implemented")
}

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

func _Query_Params_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryParamsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).Params(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/lavanet.lava.pairing.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_Providers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryProvidersRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).Providers(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/lavanet.lava.pairing.Query/Providers",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Providers(ctx, req.(*QueryProvidersRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_Clients_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryClientsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).Clients(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/lavanet.lava.pairing.Query/Clients",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Clients(ctx, req.(*QueryClientsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_GetPairing_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryGetPairingRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).GetPairing(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/lavanet.lava.pairing.Query/GetPairing",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).GetPairing(ctx, req.(*QueryGetPairingRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_VerifyPairing_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryVerifyPairingRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).VerifyPairing(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/lavanet.lava.pairing.Query/VerifyPairing",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).VerifyPairing(ctx, req.(*QueryVerifyPairingRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_UniquePaymentStorageClientProvider_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryGetUniquePaymentStorageClientProviderRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).UniquePaymentStorageClientProvider(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/lavanet.lava.pairing.Query/UniquePaymentStorageClientProvider",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).UniquePaymentStorageClientProvider(ctx, req.(*QueryGetUniquePaymentStorageClientProviderRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_UniquePaymentStorageClientProviderAll_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryAllUniquePaymentStorageClientProviderRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).UniquePaymentStorageClientProviderAll(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/lavanet.lava.pairing.Query/UniquePaymentStorageClientProviderAll",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).UniquePaymentStorageClientProviderAll(ctx, req.(*QueryAllUniquePaymentStorageClientProviderRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_ProviderPaymentStorage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryGetProviderPaymentStorageRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).ProviderPaymentStorage(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/lavanet.lava.pairing.Query/ProviderPaymentStorage",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).ProviderPaymentStorage(ctx, req.(*QueryGetProviderPaymentStorageRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_ProviderPaymentStorageAll_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryAllProviderPaymentStorageRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).ProviderPaymentStorageAll(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/lavanet.lava.pairing.Query/ProviderPaymentStorageAll",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).ProviderPaymentStorageAll(ctx, req.(*QueryAllProviderPaymentStorageRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_EpochPayments_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryGetEpochPaymentsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).EpochPayments(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/lavanet.lava.pairing.Query/EpochPayments",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).EpochPayments(ctx, req.(*QueryGetEpochPaymentsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_EpochPaymentsAll_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryAllEpochPaymentsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).EpochPaymentsAll(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/lavanet.lava.pairing.Query/EpochPaymentsAll",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).EpochPaymentsAll(ctx, req.(*QueryAllEpochPaymentsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_UserEntry_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryUserEntryRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).UserEntry(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/lavanet.lava.pairing.Query/UserEntry",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).UserEntry(ctx, req.(*QueryUserEntryRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_StaticProvidersList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryStaticProvidersListRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).StaticProvidersList(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/lavanet.lava.pairing.Query/StaticProvidersList",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).StaticProvidersList(ctx, req.(*QueryStaticProvidersListRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Query_serviceDesc = grpc.ServiceDesc{
	ServiceName: "lavanet.lava.pairing.Query",
	HandlerType: (*QueryServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Params",
			Handler:    _Query_Params_Handler,
		},
		{
			MethodName: "Providers",
			Handler:    _Query_Providers_Handler,
		},
		{
			MethodName: "Clients",
			Handler:    _Query_Clients_Handler,
		},
		{
			MethodName: "GetPairing",
			Handler:    _Query_GetPairing_Handler,
		},
		{
			MethodName: "VerifyPairing",
			Handler:    _Query_VerifyPairing_Handler,
		},
		{
			MethodName: "UniquePaymentStorageClientProvider",
			Handler:    _Query_UniquePaymentStorageClientProvider_Handler,
		},
		{
			MethodName: "UniquePaymentStorageClientProviderAll",
			Handler:    _Query_UniquePaymentStorageClientProviderAll_Handler,
		},
		{
			MethodName: "ProviderPaymentStorage",
			Handler:    _Query_ProviderPaymentStorage_Handler,
		},
		{
			MethodName: "ProviderPaymentStorageAll",
			Handler:    _Query_ProviderPaymentStorageAll_Handler,
		},
		{
			MethodName: "EpochPayments",
			Handler:    _Query_EpochPayments_Handler,
		},
		{
			MethodName: "EpochPaymentsAll",
			Handler:    _Query_EpochPaymentsAll_Handler,
		},
		{
			MethodName: "UserEntry",
			Handler:    _Query_UserEntry_Handler,
		},
		{
			MethodName: "StaticProvidersList",
			Handler:    _Query_StaticProvidersList_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "pairing/query.proto",
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *QueryGetPairingResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.BlockOfNextPairing != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.BlockOfNextPairing))
		i--
		dAtA[i] = 0x28
	}
	if m.SpecLastUpdatedBlock != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.SpecLastUpdatedBlock))
		i--
		dAtA[i] = 0x20
	}
	if m.TimeLeftToNextPairing != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.TimeLeftToNextPairing))
		i--
		dAtA[i] = 0x18
	}
	if m.CurrentEpoch != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.CurrentEpoch))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Providers) > 0 {
		for iNdEx := len(m.Providers) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Providers[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 *QueryVerifyPairingRequest) 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 *QueryVerifyPairingRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueryVerifyPairingRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Block != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.Block))
		i--
		dAtA[i] = 0x20
	}
	if len(m.Provider) > 0 {
		i -= len(m.Provider)
		copy(dAtA[i:], m.Provider)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.Provider)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Client) > 0 {
		i -= len(m.Client)
		copy(dAtA[i:], m.Client)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.Client)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ChainID) > 0 {
		i -= len(m.ChainID)
		copy(dAtA[i:], m.ChainID)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.ChainID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *QueryVerifyPairingResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.CuPerEpoch != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.CuPerEpoch))
		i--
		dAtA[i] = 0x20
	}
	if m.PairedProviders != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.PairedProviders))
		i--
		dAtA[i] = 0x18
	}
	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 *QueryGetUniquePaymentStorageClientProviderRequest) 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 *QueryGetUniquePaymentStorageClientProviderRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *QueryUserEntryResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.MaxCU != 0 {
		i = encodeVarintQuery(dAtA, i, uint64(m.MaxCU))
		i--
		dAtA[i] = 0x10
	}
	{
		size, err := m.Consumer.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 *QueryStaticProvidersListRequest) 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 *QueryStaticProvidersListRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

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

func (m *QueryAccountInfoResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Project != nil {
		{
			size, err := m.Project.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQuery(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.Subscription != nil {
		{
			size, err := m.Subscription.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQuery(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Unstaked) > 0 {
		for iNdEx := len(m.Unstaked) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Unstaked[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQuery(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.Consumer) > 0 {
		for iNdEx := len(m.Consumer) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Consumer[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQuery(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Frozen) > 0 {
		for iNdEx := len(m.Frozen) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Frozen[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQuery(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Provider) > 0 {
		for iNdEx := len(m.Provider) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Provider[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 *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 *QueryProvidersRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ChainID)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	if m.ShowFrozen {
		n += 2
	}
	return n
}

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

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

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

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

func (m *QueryGetPairingResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Providers) > 0 {
		for _, e := range m.Providers {
			l = e.Size()
			n += 1 + l + sovQuery(uint64(l))
		}
	}
	if m.CurrentEpoch != 0 {
		n += 1 + sovQuery(uint64(m.CurrentEpoch))
	}
	if m.TimeLeftToNextPairing != 0 {
		n += 1 + sovQuery(uint64(m.TimeLeftToNextPairing))
	}
	if m.SpecLastUpdatedBlock != 0 {
		n += 1 + sovQuery(uint64(m.SpecLastUpdatedBlock))
	}
	if m.BlockOfNextPairing != 0 {
		n += 1 + sovQuery(uint64(m.BlockOfNextPairing))
	}
	return n
}

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

func (m *QueryVerifyPairingResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Valid {
		n += 2
	}
	if m.PairedProviders != 0 {
		n += 1 + sovQuery(uint64(m.PairedProviders))
	}
	if m.CuPerEpoch != 0 {
		n += 1 + sovQuery(uint64(m.CuPerEpoch))
	}
	return n
}

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

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

func (m *QueryAllUniquePaymentStorageClientProviderRequest) 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 *QueryAllUniquePaymentStorageClientProviderResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.UniquePaymentStorageClientProvider) > 0 {
		for _, e := range m.UniquePaymentStorageClientProvider {
			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 *QueryGetProviderPaymentStorageRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Index)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

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

func (m *QueryAllProviderPaymentStorageRequest) 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 *QueryAllProviderPaymentStorageResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.ProviderPaymentStorage) > 0 {
		for _, e := range m.ProviderPaymentStorage {
			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 *QueryGetEpochPaymentsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Index)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

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

func (m *QueryAllEpochPaymentsRequest) 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 *QueryAllEpochPaymentsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.EpochPayments) > 0 {
		for _, e := range m.EpochPayments {
			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 *QueryUserEntryRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	l = len(m.ChainID)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	if m.Block != 0 {
		n += 1 + sovQuery(uint64(m.Block))
	}
	return n
}

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

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

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

func (m *QueryAccountInfoResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Provider) > 0 {
		for _, e := range m.Provider {
			l = e.Size()
			n += 1 + l + sovQuery(uint64(l))
		}
	}
	if len(m.Frozen) > 0 {
		for _, e := range m.Frozen {
			l = e.Size()
			n += 1 + l + sovQuery(uint64(l))
		}
	}
	if len(m.Consumer) > 0 {
		for _, e := range m.Consumer {
			l = e.Size()
			n += 1 + l + sovQuery(uint64(l))
		}
	}
	if len(m.Unstaked) > 0 {
		for _, e := range m.Unstaked {
			l = e.Size()
			n += 1 + l + sovQuery(uint64(l))
		}
	}
	if m.Subscription != nil {
		l = m.Subscription.Size()
		n += 1 + l + sovQuery(uint64(l))
	}
	if m.Project != nil {
		l = m.Project.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 *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 *QueryProvidersRequest) 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: QueryProvidersRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryProvidersRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChainID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ChainID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ShowFrozen", 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.ShowFrozen = 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 *QueryProvidersResponse) 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: QueryProvidersResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryProvidersResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StakeEntry", 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.StakeEntry = append(m.StakeEntry, types.StakeEntry{})
			if err := m.StakeEntry[len(m.StakeEntry)-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 Output", 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.Output = 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 *QueryClientsRequest) 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: QueryClientsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryClientsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChainID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ChainID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryClientsResponse) 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: QueryClientsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryClientsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StakeEntry", 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.StakeEntry = append(m.StakeEntry, types.StakeEntry{})
			if err := m.StakeEntry[len(m.StakeEntry)-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 Output", 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.Output = 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 *QueryGetPairingRequest) 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: QueryGetPairingRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryGetPairingRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChainID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ChainID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Client", 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.Client = 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 *QueryGetPairingResponse) 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: QueryGetPairingResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryGetPairingResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Providers", 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.Providers = append(m.Providers, types.StakeEntry{})
			if err := m.Providers[len(m.Providers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CurrentEpoch", wireType)
			}
			m.CurrentEpoch = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CurrentEpoch |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TimeLeftToNextPairing", wireType)
			}
			m.TimeLeftToNextPairing = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TimeLeftToNextPairing |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SpecLastUpdatedBlock", wireType)
			}
			m.SpecLastUpdatedBlock = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SpecLastUpdatedBlock |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BlockOfNextPairing", wireType)
			}
			m.BlockOfNextPairing = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BlockOfNextPairing |= 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 *QueryVerifyPairingRequest) 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: QueryVerifyPairingRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryVerifyPairingRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChainID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ChainID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Client", 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.Client = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Provider", 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.Provider = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Block", wireType)
			}
			m.Block = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Block |= 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 *QueryVerifyPairingResponse) 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: QueryVerifyPairingResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryVerifyPairingResponse: 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)
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PairedProviders", wireType)
			}
			m.PairedProviders = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PairedProviders |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CuPerEpoch", wireType)
			}
			m.CuPerEpoch = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CuPerEpoch |= 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 *QueryGetUniquePaymentStorageClientProviderRequest) 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: QueryGetUniquePaymentStorageClientProviderRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryGetUniquePaymentStorageClientProviderRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", 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.Index = 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 *QueryGetUniquePaymentStorageClientProviderResponse) 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: QueryGetUniquePaymentStorageClientProviderResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryGetUniquePaymentStorageClientProviderResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UniquePaymentStorageClientProvider", 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.UniquePaymentStorageClientProvider.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 *QueryAllUniquePaymentStorageClientProviderRequest) 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: QueryAllUniquePaymentStorageClientProviderRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryAllUniquePaymentStorageClientProviderRequest: 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 *QueryAllUniquePaymentStorageClientProviderResponse) 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: QueryAllUniquePaymentStorageClientProviderResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryAllUniquePaymentStorageClientProviderResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UniquePaymentStorageClientProvider", 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.UniquePaymentStorageClientProvider = append(m.UniquePaymentStorageClientProvider, UniquePaymentStorageClientProvider{})
			if err := m.UniquePaymentStorageClientProvider[len(m.UniquePaymentStorageClientProvider)-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 *QueryGetProviderPaymentStorageRequest) 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: QueryGetProviderPaymentStorageRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryGetProviderPaymentStorageRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", 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.Index = 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 *QueryGetProviderPaymentStorageResponse) 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: QueryGetProviderPaymentStorageResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryGetProviderPaymentStorageResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProviderPaymentStorage", 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.ProviderPaymentStorage.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 *QueryAllProviderPaymentStorageRequest) 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: QueryAllProviderPaymentStorageRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryAllProviderPaymentStorageRequest: 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 *QueryAllProviderPaymentStorageResponse) 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: QueryAllProviderPaymentStorageResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryAllProviderPaymentStorageResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProviderPaymentStorage", 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.ProviderPaymentStorage = append(m.ProviderPaymentStorage, ProviderPaymentStorage{})
			if err := m.ProviderPaymentStorage[len(m.ProviderPaymentStorage)-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 *QueryGetEpochPaymentsRequest) 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: QueryGetEpochPaymentsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryGetEpochPaymentsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", 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.Index = 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 *QueryGetEpochPaymentsResponse) 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: QueryGetEpochPaymentsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryGetEpochPaymentsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EpochPayments", 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.EpochPayments.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 *QueryAllEpochPaymentsRequest) 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: QueryAllEpochPaymentsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryAllEpochPaymentsRequest: 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 *QueryAllEpochPaymentsResponse) 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: QueryAllEpochPaymentsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryAllEpochPaymentsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EpochPayments", 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.EpochPayments = append(m.EpochPayments, EpochPayments{})
			if err := m.EpochPayments[len(m.EpochPayments)-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 *QueryUserEntryRequest) 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: QueryUserEntryRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryUserEntryRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", 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.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChainID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ChainID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Block", wireType)
			}
			m.Block = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Block |= 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 *QueryUserEntryResponse) 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: QueryUserEntryResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryUserEntryResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Consumer", 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.Consumer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxCU", wireType)
			}
			m.MaxCU = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxCU |= 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 *QueryStaticProvidersListRequest) 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: QueryStaticProvidersListRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryStaticProvidersListRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChainID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthQuery
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQuery
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ChainID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueryStaticProvidersListResponse) 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: QueryStaticProvidersListResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryStaticProvidersListResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Providers", 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.Providers = append(m.Providers, types.StakeEntry{})
			if err := m.Providers[len(m.Providers)-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 *QueryAccountInfoResponse) 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: QueryAccountInfoResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryAccountInfoResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Provider", 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.Provider = append(m.Provider, types.StakeEntry{})
			if err := m.Provider[len(m.Provider)-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 Frozen", 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.Frozen = append(m.Frozen, types.StakeEntry{})
			if err := m.Frozen[len(m.Frozen)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Consumer", 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.Consumer = append(m.Consumer, types.StakeEntry{})
			if err := m.Consumer[len(m.Consumer)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Unstaked", 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.Unstaked = append(m.Unstaked, types.StakeEntry{})
			if err := m.Unstaked[len(m.Unstaked)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Subscription", 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.Subscription == nil {
				m.Subscription = &types1.Subscription{}
			}
			if err := m.Subscription.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Project", 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.Project == nil {
				m.Project = &types2.Project{}
			}
			if err := m.Project.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")
)