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

package types

import (
	context "context"
	fmt "fmt"
	github_com_bandprotocol_chain_v3_pkg_tss "github.com/bandprotocol/chain/v3/pkg/tss"
	query "github.com/cosmos/cosmos-sdk/types/query"
	_ "github.com/cosmos/gogoproto/gogoproto"
	grpc1 "github.com/cosmos/gogoproto/grpc"
	proto "github.com/cosmos/gogoproto/proto"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	io "io"
	math "math"
	math_bits "math/bits"
)

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

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

// QueryCountsRequest is request type for the Query/Count RPC method.
type QueryCountsRequest struct {
}

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

var xxx_messageInfo_QueryCountsRequest proto.InternalMessageInfo

// QueryCountsResponse is response type for the Query/Count RPC method.
type QueryCountsResponse struct {
	// group_count is total number of group available on the chain
	GroupCount uint64 `protobuf:"varint,1,opt,name=group_count,json=groupCount,proto3" json:"group_count,omitempty"`
	// signing_count is total number of signing request submitted to the chain
	SigningCount uint64 `protobuf:"varint,2,opt,name=signing_count,json=signingCount,proto3" json:"signing_count,omitempty"`
}

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

var xxx_messageInfo_QueryCountsResponse proto.InternalMessageInfo

func (m *QueryCountsResponse) GetGroupCount() uint64 {
	if m != nil {
		return m.GroupCount
	}
	return 0
}

func (m *QueryCountsResponse) GetSigningCount() uint64 {
	if m != nil {
		return m.SigningCount
	}
	return 0
}

// QueryGroupRequest is the request type for the Query/Group RPC method
type QueryGroupRequest struct {
	// group_id defines the unique id of the group.
	GroupId uint64 `protobuf:"varint,1,opt,name=group_id,json=groupId,proto3" json:"group_id,omitempty"`
}

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

var xxx_messageInfo_QueryGroupRequest proto.InternalMessageInfo

func (m *QueryGroupRequest) GetGroupId() uint64 {
	if m != nil {
		return m.GroupId
	}
	return 0
}

// QueryGroupResponse is the response type for the Query/Group RPC method
type QueryGroupResponse struct {
	// group_result is the result of the group.
	GroupResult GroupResult `protobuf:"bytes,1,opt,name=group_result,json=groupResult,proto3" json:"group_result"`
}

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

var xxx_messageInfo_QueryGroupResponse proto.InternalMessageInfo

func (m *QueryGroupResponse) GetGroupResult() GroupResult {
	if m != nil {
		return m.GroupResult
	}
	return GroupResult{}
}

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

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

var xxx_messageInfo_QueryGroupsRequest proto.InternalMessageInfo

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

// QueryGroupsResponse is the response type for the Query/Group RPC method
type QueryGroupsResponse struct {
	// groups is the list of groups.
	Groups []*GroupResult `protobuf:"bytes,1,rep,name=groups,proto3" json:"groups,omitempty"`
	// pagination defines an pagination for the response.
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryGroupsResponse proto.InternalMessageInfo

func (m *QueryGroupsResponse) GetGroups() []*GroupResult {
	if m != nil {
		return m.Groups
	}
	return nil
}

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

// QueryMembersRequest is the request type for the Query/Members RPC method
type QueryMembersRequest struct {
	// group_id defines the unique id of the group.
	GroupId uint64 `protobuf:"varint,1,opt,name=group_id,json=groupId,proto3" json:"group_id,omitempty"`
}

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

var xxx_messageInfo_QueryMembersRequest proto.InternalMessageInfo

func (m *QueryMembersRequest) GetGroupId() uint64 {
	if m != nil {
		return m.GroupId
	}
	return 0
}

// QueryMembersResponse is the response type for the Query/Members RPC method
type QueryMembersResponse struct {
	// members are member list of the group
	Members []Member `protobuf:"bytes,1,rep,name=members,proto3" json:"members"`
}

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

var xxx_messageInfo_QueryMembersResponse proto.InternalMessageInfo

func (m *QueryMembersResponse) GetMembers() []Member {
	if m != nil {
		return m.Members
	}
	return nil
}

// QueryIsGranteeRequest is request type for the Query/IsGrantee RPC method.
type QueryIsGranteeRequest struct {
	// granter is a granter address
	Granter string `protobuf:"bytes,1,opt,name=granter,proto3" json:"granter,omitempty"`
	// grantee is a grantee address
	Grantee string `protobuf:"bytes,2,opt,name=grantee,proto3" json:"grantee,omitempty"`
}

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

var xxx_messageInfo_QueryIsGranteeRequest proto.InternalMessageInfo

func (m *QueryIsGranteeRequest) GetGranter() string {
	if m != nil {
		return m.Granter
	}
	return ""
}

func (m *QueryIsGranteeRequest) GetGrantee() string {
	if m != nil {
		return m.Grantee
	}
	return ""
}

// QueryIsGranteeResponse is response type for the Query/IsGrantee RPC method.
type QueryIsGranteeResponse struct {
	// is_grantee is true if this account has been granted by granter
	IsGrantee bool `protobuf:"varint,1,opt,name=is_grantee,json=isGrantee,proto3" json:"is_grantee,omitempty"`
}

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

var xxx_messageInfo_QueryIsGranteeResponse proto.InternalMessageInfo

func (m *QueryIsGranteeResponse) GetIsGrantee() bool {
	if m != nil {
		return m.IsGrantee
	}
	return false
}

// QueryDERequest is the request type for the Query/DE RPC method.
type QueryDERequest struct {
	// address is the address for the request.
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	// pagination defines pagination settings for the request.
	Pagination *query.PageRequest `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryDERequest proto.InternalMessageInfo

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

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

// QueryDEResponse is the response type for the Query/DE RPC method.
type QueryDEResponse struct {
	// des is a list of DEs.
	DEs []DE `protobuf:"bytes,1,rep,name=des,proto3" json:"des"`
	// pagination defines an pagination for the response.
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QueryDEResponse proto.InternalMessageInfo

func (m *QueryDEResponse) GetDEs() []DE {
	if m != nil {
		return m.DEs
	}
	return nil
}

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

// QueryPendingGroupsRequest is the request type for the Query/PendingGroups RPC method.
type QueryPendingGroupsRequest struct {
	// address is the address of the member.
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
}

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

var xxx_messageInfo_QueryPendingGroupsRequest proto.InternalMessageInfo

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

// QueryPendingGroupsResponse is the response type for the Query/PendingGroups RPC method.
type QueryPendingGroupsResponse struct {
	// pending_groups is a list of pending groups.
	PendingGroups []uint64 `protobuf:"varint,1,rep,packed,name=pending_groups,json=pendingGroups,proto3" json:"pending_groups,omitempty"`
}

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

var xxx_messageInfo_QueryPendingGroupsResponse proto.InternalMessageInfo

func (m *QueryPendingGroupsResponse) GetPendingGroups() []uint64 {
	if m != nil {
		return m.PendingGroups
	}
	return nil
}

// QueryPendingSigningsRequest is the request type for the Query/PendingSignings RPC method.
type QueryPendingSigningsRequest struct {
	// address is the address of the member.
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
}

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

var xxx_messageInfo_QueryPendingSigningsRequest proto.InternalMessageInfo

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

// QueryPendingSigningsResponse is the response type for the Query/PendingSignings RPC method.
type QueryPendingSigningsResponse struct {
	// pending_signings is a list of pending signings.
	PendingSignings []github_com_bandprotocol_chain_v3_pkg_tss.SigningID `protobuf:"varint,1,rep,packed,name=pending_signings,json=pendingSignings,proto3,casttype=github.com/bandprotocol/chain/v3/pkg/tss.SigningID" json:"pending_signings,omitempty"`
}

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

var xxx_messageInfo_QueryPendingSigningsResponse proto.InternalMessageInfo

func (m *QueryPendingSigningsResponse) GetPendingSignings() []github_com_bandprotocol_chain_v3_pkg_tss.SigningID {
	if m != nil {
		return m.PendingSignings
	}
	return nil
}

// QuerySigningRequest is the request type for the Query/Signing RPC method.
type QuerySigningRequest struct {
	// signing_id is the ID of the signing request.
	SigningId uint64 `protobuf:"varint,1,opt,name=signing_id,json=signingId,proto3" json:"signing_id,omitempty"`
}

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

var xxx_messageInfo_QuerySigningRequest proto.InternalMessageInfo

func (m *QuerySigningRequest) GetSigningId() uint64 {
	if m != nil {
		return m.SigningId
	}
	return 0
}

// QuerySigningResponse is the response type for the Query/Signing RPC method.
type QuerySigningResponse struct {
	// signing_result is the result of the signing.
	SigningResult SigningResult `protobuf:"bytes,1,opt,name=signing_result,json=signingResult,proto3" json:"signing_result"`
}

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

var xxx_messageInfo_QuerySigningResponse proto.InternalMessageInfo

func (m *QuerySigningResponse) GetSigningResult() SigningResult {
	if m != nil {
		return m.SigningResult
	}
	return SigningResult{}
}

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

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

var xxx_messageInfo_QuerySigningsRequest proto.InternalMessageInfo

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

// QuerySigningsResponse is the response type for the Query/Signings RPC method.
type QuerySigningsResponse struct {
	// signing_results is a list of signing results.
	SigningResults []*SigningResult `protobuf:"bytes,1,rep,name=signing_results,json=signingResults,proto3" json:"signing_results,omitempty"`
	// pagination defines an pagination for the response.
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

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

var xxx_messageInfo_QuerySigningsResponse proto.InternalMessageInfo

func (m *QuerySigningsResponse) GetSigningResults() []*SigningResult {
	if m != nil {
		return m.SigningResults
	}
	return nil
}

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

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

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

var xxx_messageInfo_QueryParamsRequest proto.InternalMessageInfo

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

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

var xxx_messageInfo_QueryParamsResponse proto.InternalMessageInfo

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

func init() {
	proto.RegisterType((*QueryCountsRequest)(nil), "band.tss.v1beta1.QueryCountsRequest")
	proto.RegisterType((*QueryCountsResponse)(nil), "band.tss.v1beta1.QueryCountsResponse")
	proto.RegisterType((*QueryGroupRequest)(nil), "band.tss.v1beta1.QueryGroupRequest")
	proto.RegisterType((*QueryGroupResponse)(nil), "band.tss.v1beta1.QueryGroupResponse")
	proto.RegisterType((*QueryGroupsRequest)(nil), "band.tss.v1beta1.QueryGroupsRequest")
	proto.RegisterType((*QueryGroupsResponse)(nil), "band.tss.v1beta1.QueryGroupsResponse")
	proto.RegisterType((*QueryMembersRequest)(nil), "band.tss.v1beta1.QueryMembersRequest")
	proto.RegisterType((*QueryMembersResponse)(nil), "band.tss.v1beta1.QueryMembersResponse")
	proto.RegisterType((*QueryIsGranteeRequest)(nil), "band.tss.v1beta1.QueryIsGranteeRequest")
	proto.RegisterType((*QueryIsGranteeResponse)(nil), "band.tss.v1beta1.QueryIsGranteeResponse")
	proto.RegisterType((*QueryDERequest)(nil), "band.tss.v1beta1.QueryDERequest")
	proto.RegisterType((*QueryDEResponse)(nil), "band.tss.v1beta1.QueryDEResponse")
	proto.RegisterType((*QueryPendingGroupsRequest)(nil), "band.tss.v1beta1.QueryPendingGroupsRequest")
	proto.RegisterType((*QueryPendingGroupsResponse)(nil), "band.tss.v1beta1.QueryPendingGroupsResponse")
	proto.RegisterType((*QueryPendingSigningsRequest)(nil), "band.tss.v1beta1.QueryPendingSigningsRequest")
	proto.RegisterType((*QueryPendingSigningsResponse)(nil), "band.tss.v1beta1.QueryPendingSigningsResponse")
	proto.RegisterType((*QuerySigningRequest)(nil), "band.tss.v1beta1.QuerySigningRequest")
	proto.RegisterType((*QuerySigningResponse)(nil), "band.tss.v1beta1.QuerySigningResponse")
	proto.RegisterType((*QuerySigningsRequest)(nil), "band.tss.v1beta1.QuerySigningsRequest")
	proto.RegisterType((*QuerySigningsResponse)(nil), "band.tss.v1beta1.QuerySigningsResponse")
	proto.RegisterType((*QueryParamsRequest)(nil), "band.tss.v1beta1.QueryParamsRequest")
	proto.RegisterType((*QueryParamsResponse)(nil), "band.tss.v1beta1.QueryParamsResponse")
}

func init() { proto.RegisterFile("band/tss/v1beta1/query.proto", fileDescriptor_297ba1d2a9889c1d) }

var fileDescriptor_297ba1d2a9889c1d = []byte{
	// 1093 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x96, 0x4f, 0x6f, 0x1b, 0xc5,
	0x1b, 0xc7, 0xb3, 0x4e, 0x6a, 0x27, 0x4f, 0x9a, 0xa4, 0xbf, 0x69, 0xf2, 0x23, 0xdd, 0x26, 0x76,
	0xd8, 0x26, 0x71, 0x68, 0x9b, 0x5d, 0x9a, 0xd0, 0x96, 0x73, 0xea, 0x24, 0x44, 0x50, 0x29, 0x2c,
	0x37, 0x40, 0x44, 0x6b, 0xef, 0x68, 0xbb, 0xc2, 0xde, 0xdd, 0xec, 0xac, 0x2b, 0xda, 0xca, 0x07,
	0x10, 0x07, 0x6e, 0x20, 0x55, 0x1c, 0x38, 0x72, 0xe5, 0x05, 0xf0, 0x1a, 0x7a, 0xac, 0xc4, 0x85,
	0x53, 0x84, 0x12, 0x5e, 0x05, 0x27, 0xb4, 0x33, 0xcf, 0xac, 0x3d, 0xb6, 0xd7, 0x8e, 0x50, 0x6e,
	0xde, 0x79, 0xfe, 0x7d, 0xe6, 0x99, 0x99, 0xe7, 0x6b, 0x58, 0xa9, 0x3b, 0x81, 0x6b, 0x25, 0x8c,
	0x59, 0xcf, 0x1f, 0xd4, 0x69, 0xe2, 0x3c, 0xb0, 0x4e, 0xdb, 0x34, 0x7e, 0x61, 0x46, 0x71, 0x98,
	0x84, 0xe4, 0x46, 0x6a, 0x35, 0x13, 0xc6, 0x4c, 0xb4, 0xea, 0x8b, 0x5e, 0xe8, 0x85, 0xdc, 0x68,
	0xa5, 0xbf, 0x84, 0x9f, 0x7e, 0xb7, 0x11, 0xb2, 0x56, 0xc8, 0xac, 0xba, 0xc3, 0xa8, 0x48, 0x90,
	0xa5, 0x8b, 0x1c, 0xcf, 0x0f, 0x9c, 0xc4, 0x0f, 0x03, 0xf4, 0x5d, 0xf1, 0xc2, 0xd0, 0x6b, 0x52,
	0xcb, 0x89, 0x7c, 0xcb, 0x09, 0x82, 0x30, 0xe1, 0x46, 0x86, 0x56, 0x7d, 0x80, 0x27, 0xad, 0x2e,
	0x6c, 0xe5, 0x01, 0x9b, 0x47, 0x03, 0xca, 0x7c, 0xb4, 0x1b, 0x8b, 0x40, 0x3e, 0x4d, 0x6b, 0x3f,
	0x09, 0xdb, 0x41, 0xc2, 0x6c, 0x7a, 0xda, 0xa6, 0x2c, 0x31, 0xbe, 0x80, 0x9b, 0xca, 0x2a, 0x8b,
	0xc2, 0x80, 0x51, 0x52, 0x81, 0x59, 0x2f, 0x0e, 0xdb, 0xd1, 0x49, 0x23, 0x5d, 0x5f, 0xd6, 0xd6,
	0xb4, 0xad, 0x29, 0x1b, 0xf8, 0x12, 0xf7, 0x24, 0x77, 0x60, 0x8e, 0xf9, 0x5e, 0xe0, 0x07, 0x1e,
	0xba, 0x14, 0xb8, 0xcb, 0x75, 0x5c, 0xe4, 0x4e, 0x86, 0x09, 0xff, 0xe3, 0xc9, 0x0f, 0xd3, 0x38,
	0xac, 0x48, 0x6e, 0xc1, 0xb4, 0x48, 0xed, 0xbb, 0x98, 0xb7, 0xc4, 0xbf, 0x8f, 0x5c, 0xe3, 0x4b,
	0x44, 0x44, 0x7f, 0x64, 0x39, 0x80, 0xeb, 0x22, 0x20, 0xa6, 0xac, 0xdd, 0x14, 0x30, 0xb3, 0x3b,
	0xab, 0x66, 0x7f, 0xf7, 0x4d, 0x19, 0xd6, 0x6e, 0x26, 0x7b, 0x53, 0x6f, 0xce, 0x2a, 0x13, 0xb6,
	0xd8, 0x84, 0x58, 0x52, 0xb3, 0xcb, 0x06, 0x90, 0x03, 0x80, 0xee, 0x21, 0x60, 0xee, 0x4d, 0x53,
	0x9c, 0x98, 0x99, 0x9e, 0x98, 0x29, 0x8e, 0x5c, 0x16, 0x39, 0x76, 0x3c, 0x8a, 0xb1, 0x76, 0x4f,
	0xa4, 0xf1, 0xb3, 0x86, 0x9d, 0x94, 0xe9, 0x91, 0xfe, 0x21, 0x14, 0x39, 0x04, 0x5b, 0xd6, 0xd6,
	0x26, 0xc7, 0x72, 0xdb, 0xe8, 0x4c, 0x0e, 0x15, 0xac, 0x02, 0xc7, 0xaa, 0x8e, 0xc5, 0x12, 0x35,
	0x15, 0xae, 0xf7, 0x11, 0xeb, 0x29, 0x6d, 0xd5, 0x69, 0xcc, 0x2e, 0x71, 0x0a, 0xc7, 0xb0, 0xa8,
	0x46, 0xe0, 0x4e, 0x3e, 0x84, 0x52, 0x4b, 0x2c, 0xe1, 0x56, 0x96, 0x07, 0xb7, 0x22, 0x62, 0xb0,
	0xfb, 0xd2, 0xdd, 0xf8, 0x18, 0x96, 0x78, 0xc6, 0x23, 0x76, 0x18, 0x3b, 0x41, 0x42, 0x65, 0x03,
	0xc9, 0x32, 0x94, 0x3c, 0xbe, 0x12, 0x73, 0x88, 0x19, 0x5b, 0x7e, 0x76, 0x2d, 0x94, 0x6f, 0x3e,
	0xb3, 0x50, 0xe3, 0x31, 0xfc, 0xbf, 0x3f, 0x19, 0x02, 0xae, 0x02, 0xf8, 0xec, 0x44, 0x86, 0xa5,
	0x09, 0xa7, 0xed, 0x19, 0x5f, 0xba, 0x19, 0x31, 0xcc, 0xf3, 0xc0, 0xda, 0x7e, 0x4f, 0x79, 0xc7,
	0x75, 0x63, 0xca, 0x98, 0x2c, 0x8f, 0x9f, 0x7d, 0xb7, 0xa2, 0xf0, 0x9f, 0x6f, 0xc5, 0x8f, 0x1a,
	0x2c, 0x64, 0x45, 0x11, 0x73, 0x17, 0x26, 0x5d, 0x2a, 0x7b, 0xb8, 0x38, 0xd8, 0xc3, 0xda, 0xfe,
	0xde, 0x6c, 0xda, 0xbf, 0xf3, 0xb3, 0xca, 0x64, 0x6d, 0x9f, 0xd9, 0xa9, 0xf7, 0xd5, 0xdd, 0x87,
	0x87, 0x70, 0x8b, 0x03, 0x1d, 0xd3, 0xc0, 0xf5, 0x03, 0x4f, 0x7d, 0x0c, 0xb9, 0x0d, 0x31, 0x9e,
	0x80, 0x3e, 0x2c, 0x0c, 0xb7, 0xb4, 0x01, 0xf3, 0x91, 0x30, 0x9c, 0xf4, 0x5c, 0xf6, 0x29, 0x7b,
	0x2e, 0xea, 0x75, 0x37, 0x1e, 0xc3, 0xed, 0xde, 0x24, 0x9f, 0x89, 0x59, 0x71, 0x89, 0xea, 0xdf,
	0x6a, 0xb0, 0x32, 0x3c, 0x12, 0x01, 0x1c, 0xb8, 0x21, 0x01, 0x70, 0x02, 0x21, 0xc2, 0xde, 0xa3,
	0x7f, 0xce, 0x2a, 0x3b, 0x9e, 0x9f, 0x3c, 0x6b, 0xd7, 0xcd, 0x46, 0xd8, 0xb2, 0xd2, 0x76, 0xf3,
	0x81, 0xd8, 0x08, 0x9b, 0x56, 0xe3, 0x99, 0xe3, 0x07, 0xd6, 0xf3, 0x5d, 0x2b, 0xfa, 0xda, 0xe3,
	0xa3, 0x14, 0x13, 0x1f, 0xd5, 0xec, 0x85, 0x48, 0x2d, 0x65, 0x7c, 0x80, 0x0f, 0x09, 0x17, 0x24,
	0xf4, 0x2a, 0x80, 0x1c, 0x84, 0xd9, 0x53, 0x9a, 0xc1, 0x95, 0x23, 0xd7, 0x70, 0xf1, 0x31, 0x65,
	0x51, 0x08, 0xfc, 0x09, 0xcc, 0xcb, 0x30, 0x65, 0xac, 0x55, 0x06, 0xef, 0x43, 0x37, 0xb4, 0x3b,
	0xd8, 0xe4, 0xf0, 0xc5, 0xd1, 0xf6, 0x95, 0x5a, 0xe5, 0xca, 0x87, 0xdb, 0x6f, 0x1a, 0xbe, 0xe0,
	0x81, 0xc6, 0x7f, 0x04, 0x0b, 0xea, 0x3e, 0xe4, 0xc5, 0x1e, 0xb7, 0x11, 0x7b, 0x5e, 0xd9, 0xc2,
	0x15, 0xde, 0x70, 0x29, 0x74, 0xc7, 0x4e, 0xec, 0xb4, 0x32, 0xa1, 0x7b, 0x8a, 0xc7, 0x27, 0x57,
	0x91, 0xff, 0x11, 0x14, 0x23, 0xbe, 0x82, 0xdd, 0x19, 0x32, 0xd3, 0x44, 0x04, 0x36, 0x1e, 0xbd,
	0x77, 0x7e, 0x9f, 0x85, 0x6b, 0x3c, 0x1f, 0x89, 0xa1, 0x28, 0xc4, 0x93, 0xac, 0x0f, 0xc6, 0x0e,
	0x2a, 0xae, 0xbe, 0x31, 0xc6, 0x4b, 0x80, 0x19, 0xb7, 0xbf, 0xfb, 0xe3, 0xef, 0xd7, 0x85, 0x25,
	0x72, 0x53, 0x91, 0xf4, 0x86, 0xa8, 0x14, 0x43, 0x51, 0x3c, 0xa9, 0xdc, 0x9a, 0xca, 0xbb, 0xce,
	0xad, 0xa9, 0x3e, 0xe3, 0x9c, 0x9a, 0xa8, 0x48, 0x2f, 0xe1, 0x1a, 0x77, 0x27, 0x77, 0x46, 0x25,
	0x93, 0x15, 0xd7, 0x47, 0x3b, 0x61, 0xc1, 0x4d, 0x5e, 0x70, 0x8d, 0x94, 0x87, 0x14, 0xb4, 0x5e,
	0x49, 0x81, 0xea, 0x90, 0x1f, 0x34, 0x28, 0xa1, 0x1c, 0x91, 0xbc, 0xbd, 0xa8, 0x02, 0xa7, 0x6f,
	0x8e, 0x73, 0x43, 0x04, 0x93, 0x23, 0x6c, 0x91, 0xcd, 0xd1, 0x08, 0x16, 0x6a, 0x19, 0x79, 0xad,
	0xc1, 0x4c, 0x26, 0x3d, 0xa4, 0x9a, 0x53, 0xa5, 0x5f, 0xe9, 0xf4, 0xad, 0xf1, 0x8e, 0x08, 0xb4,
	0xcb, 0x81, 0xb6, 0xc9, 0x3d, 0x05, 0xa8, 0x2b, 0x6c, 0x29, 0x14, 0xd7, 0xc8, 0x8e, 0xfc, 0x45,
	0x3b, 0xe4, 0x14, 0x0a, 0xb5, 0x7d, 0xb2, 0x96, 0x53, 0x24, 0x53, 0x3c, 0xfd, 0xdd, 0x11, 0x1e,
	0x23, 0xcf, 0xc4, 0xa5, 0x27, 0x4d, 0x9f, 0x25, 0xd6, 0x2b, 0x1c, 0xc9, 0x1d, 0xf2, 0x8b, 0x06,
	0x73, 0x8a, 0x1a, 0x90, 0x7b, 0x39, 0xc9, 0x87, 0x49, 0x8d, 0x7e, 0xff, 0x72, 0xce, 0x08, 0xb5,
	0xcd, 0xa1, 0xaa, 0x64, 0x43, 0x81, 0x52, 0x35, 0xa7, 0x87, 0xed, 0x57, 0x0d, 0x16, 0xfa, 0xa4,
	0x82, 0x6c, 0x8f, 0x2e, 0xd8, 0x37, 0x3a, 0x75, 0xf3, 0xb2, 0xee, 0x48, 0x68, 0x71, 0xc2, 0xf7,
	0x48, 0x75, 0x28, 0xa1, 0x14, 0xa5, 0x1e, 0xc6, 0xef, 0x35, 0x28, 0x61, 0x96, 0xdc, 0x3b, 0xad,
	0x6a, 0x4d, 0xee, 0x9d, 0xee, 0x13, 0x17, 0xe3, 0x2e, 0x67, 0x59, 0x27, 0x86, 0xc2, 0xd2, 0x65,
	0xe8, 0x0a, 0x56, 0x87, 0xbc, 0x84, 0xe9, 0xac, 0x45, 0x63, 0xf2, 0x67, 0xbd, 0xa9, 0x8e, 0xf5,
	0x43, 0x90, 0x55, 0x0e, 0xf2, 0x0e, 0x59, 0x1a, 0x0a, 0x92, 0x8e, 0x31, 0x31, 0x5c, 0x73, 0xc7,
	0x98, 0x32, 0xc3, 0x73, 0xc7, 0x98, 0x3a, 0xd3, 0x73, 0xc6, 0x98, 0x18, 0xdc, 0x7b, 0x07, 0x6f,
	0xce, 0xcb, 0xda, 0xdb, 0xf3, 0xb2, 0xf6, 0xd7, 0x79, 0x59, 0xfb, 0xe9, 0xa2, 0x3c, 0xf1, 0xf6,
	0xa2, 0x3c, 0xf1, 0xe7, 0x45, 0x79, 0xe2, 0xf3, 0xfb, 0x63, 0xff, 0x25, 0x7c, 0xc3, 0x13, 0x26,
	0x2f, 0x22, 0xca, 0xea, 0x45, 0x6e, 0xde, 0xfd, 0x37, 0x00, 0x00, 0xff, 0xff, 0xb8, 0xf4, 0x47,
	0x33, 0x23, 0x0e, 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 {
	// Counts queries the number of existing groups and signing.
	Counts(ctx context.Context, in *QueryCountsRequest, opts ...grpc.CallOption) (*QueryCountsResponse, error)
	// Groups queries groups details.
	Groups(ctx context.Context, in *QueryGroupsRequest, opts ...grpc.CallOption) (*QueryGroupsResponse, error)
	// Group queries group details from the given id.
	Group(ctx context.Context, in *QueryGroupRequest, opts ...grpc.CallOption) (*QueryGroupResponse, error)
	// Members queries all members in this group.
	Members(ctx context.Context, in *QueryMembersRequest, opts ...grpc.CallOption) (*QueryMembersResponse, error)
	// IsGrantee queries whether granter grants the grantee.
	IsGrantee(ctx context.Context, in *QueryIsGranteeRequest, opts ...grpc.CallOption) (*QueryIsGranteeResponse, error)
	// DE queries all de for this address.
	DE(ctx context.Context, in *QueryDERequest, opts ...grpc.CallOption) (*QueryDEResponse, error)
	// PendingGroups queries all pending groups that waits the given address to submit a message.
	PendingGroups(ctx context.Context, in *QueryPendingGroupsRequest, opts ...grpc.CallOption) (*QueryPendingGroupsResponse, error)
	// PendingSignings queries all pending requests that waits the given address to sign a message.
	PendingSignings(ctx context.Context, in *QueryPendingSigningsRequest, opts ...grpc.CallOption) (*QueryPendingSigningsResponse, error)
	// Signing queries signing details from the given id.
	Signing(ctx context.Context, in *QuerySigningRequest, opts ...grpc.CallOption) (*QuerySigningResponse, error)
	// Signings queries signings details.
	Signings(ctx context.Context, in *QuerySigningsRequest, opts ...grpc.CallOption) (*QuerySigningsResponse, error)
	// Params returns all parameters of the module.
	Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error)
}

type queryClient struct {
	cc grpc1.ClientConn
}

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

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

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

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

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

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

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

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

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

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

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

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

// QueryServer is the server API for Query service.
type QueryServer interface {
	// Counts queries the number of existing groups and signing.
	Counts(context.Context, *QueryCountsRequest) (*QueryCountsResponse, error)
	// Groups queries groups details.
	Groups(context.Context, *QueryGroupsRequest) (*QueryGroupsResponse, error)
	// Group queries group details from the given id.
	Group(context.Context, *QueryGroupRequest) (*QueryGroupResponse, error)
	// Members queries all members in this group.
	Members(context.Context, *QueryMembersRequest) (*QueryMembersResponse, error)
	// IsGrantee queries whether granter grants the grantee.
	IsGrantee(context.Context, *QueryIsGranteeRequest) (*QueryIsGranteeResponse, error)
	// DE queries all de for this address.
	DE(context.Context, *QueryDERequest) (*QueryDEResponse, error)
	// PendingGroups queries all pending groups that waits the given address to submit a message.
	PendingGroups(context.Context, *QueryPendingGroupsRequest) (*QueryPendingGroupsResponse, error)
	// PendingSignings queries all pending requests that waits the given address to sign a message.
	PendingSignings(context.Context, *QueryPendingSigningsRequest) (*QueryPendingSigningsResponse, error)
	// Signing queries signing details from the given id.
	Signing(context.Context, *QuerySigningRequest) (*QuerySigningResponse, error)
	// Signings queries signings details.
	Signings(context.Context, *QuerySigningsRequest) (*QuerySigningsResponse, error)
	// Params returns all parameters of the module.
	Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error)
}

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

func (*UnimplementedQueryServer) Counts(ctx context.Context, req *QueryCountsRequest) (*QueryCountsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Counts not implemented")
}
func (*UnimplementedQueryServer) Groups(ctx context.Context, req *QueryGroupsRequest) (*QueryGroupsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Groups not implemented")
}
func (*UnimplementedQueryServer) Group(ctx context.Context, req *QueryGroupRequest) (*QueryGroupResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Group not implemented")
}
func (*UnimplementedQueryServer) Members(ctx context.Context, req *QueryMembersRequest) (*QueryMembersResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Members not implemented")
}
func (*UnimplementedQueryServer) IsGrantee(ctx context.Context, req *QueryIsGranteeRequest) (*QueryIsGranteeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method IsGrantee not implemented")
}
func (*UnimplementedQueryServer) DE(ctx context.Context, req *QueryDERequest) (*QueryDEResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DE not implemented")
}
func (*UnimplementedQueryServer) PendingGroups(ctx context.Context, req *QueryPendingGroupsRequest) (*QueryPendingGroupsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PendingGroups not implemented")
}
func (*UnimplementedQueryServer) PendingSignings(ctx context.Context, req *QueryPendingSigningsRequest) (*QueryPendingSigningsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PendingSignings not implemented")
}
func (*UnimplementedQueryServer) Signing(ctx context.Context, req *QuerySigningRequest) (*QuerySigningResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Signing not implemented")
}
func (*UnimplementedQueryServer) Signings(ctx context.Context, req *QuerySigningsRequest) (*QuerySigningsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Signings not implemented")
}
func (*UnimplementedQueryServer) Params(ctx context.Context, req *QueryParamsRequest) (*QueryParamsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Params not implemented")
}

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

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

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

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

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

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

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

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

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

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

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

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

var _Query_serviceDesc = grpc.ServiceDesc{
	ServiceName: "band.tss.v1beta1.Query",
	HandlerType: (*QueryServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Counts",
			Handler:    _Query_Counts_Handler,
		},
		{
			MethodName: "Groups",
			Handler:    _Query_Groups_Handler,
		},
		{
			MethodName: "Group",
			Handler:    _Query_Group_Handler,
		},
		{
			MethodName: "Members",
			Handler:    _Query_Members_Handler,
		},
		{
			MethodName: "IsGrantee",
			Handler:    _Query_IsGrantee_Handler,
		},
		{
			MethodName: "DE",
			Handler:    _Query_DE_Handler,
		},
		{
			MethodName: "PendingGroups",
			Handler:    _Query_PendingGroups_Handler,
		},
		{
			MethodName: "PendingSignings",
			Handler:    _Query_PendingSignings_Handler,
		},
		{
			MethodName: "Signing",
			Handler:    _Query_Signing_Handler,
		},
		{
			MethodName: "Signings",
			Handler:    _Query_Signings_Handler,
		},
		{
			MethodName: "Params",
			Handler:    _Query_Params_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "band/tss/v1beta1/query.proto",
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *QueryPendingGroupsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.PendingGroups) > 0 {
		dAtA7 := make([]byte, len(m.PendingGroups)*10)
		var j6 int
		for _, num := range m.PendingGroups {
			for num >= 1<<7 {
				dAtA7[j6] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j6++
			}
			dAtA7[j6] = uint8(num)
			j6++
		}
		i -= j6
		copy(dAtA[i:], dAtA7[:j6])
		i = encodeVarintQuery(dAtA, i, uint64(j6))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *QueryPendingSigningsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.PendingSignings) > 0 {
		dAtA9 := make([]byte, len(m.PendingSignings)*10)
		var j8 int
		for _, num := range m.PendingSignings {
			for num >= 1<<7 {
				dAtA9[j8] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j8++
			}
			dAtA9[j8] = uint8(num)
			j8++
		}
		i -= j8
		copy(dAtA[i:], dAtA9[:j8])
		i = encodeVarintQuery(dAtA, i, uint64(j8))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *QuerySigningsResponse) 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.SigningResults) > 0 {
		for iNdEx := len(m.SigningResults) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.SigningResults[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 *QueryParamsRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

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

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

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

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

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

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

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

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

func (m *QueryGroupsRequest) 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 *QueryGroupsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Groups) > 0 {
		for _, e := range m.Groups {
			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 *QueryMembersRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.GroupId != 0 {
		n += 1 + sovQuery(uint64(m.GroupId))
	}
	return n
}

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

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

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

func (m *QueryDERequest) 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))
	}
	if m.Pagination != nil {
		l = m.Pagination.Size()
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

func (m *QueryDEResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.DEs) > 0 {
		for _, e := range m.DEs {
			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 *QueryPendingGroupsRequest) 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))
	}
	return n
}

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

func (m *QueryPendingSigningsRequest) 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))
	}
	return n
}

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

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

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

func (m *QuerySigningsRequest) 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 *QuerySigningsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.SigningResults) > 0 {
		for _, e := range m.SigningResults {
			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 *QueryParamsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

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

func sovQuery(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozQuery(x uint64) (n int) {
	return sovQuery(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *QueryCountsRequest) 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: QueryCountsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryCountsRequest: 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 *QueryCountsResponse) 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: QueryCountsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryCountsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GroupCount", wireType)
			}
			m.GroupCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GroupCount |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SigningCount", wireType)
			}
			m.SigningCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SigningCount |= 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 *QueryGroupRequest) 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: QueryGroupRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryGroupRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GroupId", wireType)
			}
			m.GroupId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GroupId |= 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 *QueryGroupResponse) 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: QueryGroupResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryGroupResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GroupResult", 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.GroupResult.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 *QueryGroupsRequest) 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: QueryGroupsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryGroupsRequest: 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 *QueryGroupsResponse) 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: QueryGroupsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryGroupsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Groups", 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.Groups = append(m.Groups, &GroupResult{})
			if err := m.Groups[len(m.Groups)-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 *QueryMembersRequest) 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: QueryMembersRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryMembersRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GroupId", wireType)
			}
			m.GroupId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GroupId |= 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 *QueryMembersResponse) 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: QueryMembersResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryMembersResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Members", 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.Members = append(m.Members, Member{})
			if err := m.Members[len(m.Members)-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 *QueryIsGranteeRequest) 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: QueryIsGranteeRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryIsGranteeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Granter", 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.Granter = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Grantee", 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.Grantee = 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 *QueryIsGranteeResponse) 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: QueryIsGranteeResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryIsGranteeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsGrantee", 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.IsGrantee = 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 *QueryDERequest) 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: QueryDERequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryDERequest: 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 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 *QueryDEResponse) 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: QueryDEResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryDEResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DEs", 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.DEs = append(m.DEs, DE{})
			if err := m.DEs[len(m.DEs)-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 *QueryPendingGroupsRequest) 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: QueryPendingGroupsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryPendingGroupsRequest: 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
		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 *QueryPendingGroupsResponse) 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: QueryPendingGroupsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryPendingGroupsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowQuery
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.PendingGroups = append(m.PendingGroups, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowQuery
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthQuery
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthQuery
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.PendingGroups) == 0 {
					m.PendingGroups = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowQuery
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.PendingGroups = append(m.PendingGroups, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field PendingGroups", wireType)
			}
		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 *QueryPendingSigningsRequest) 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: QueryPendingSigningsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryPendingSigningsRequest: 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
		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 *QueryPendingSigningsResponse) 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: QueryPendingSigningsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryPendingSigningsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType == 0 {
				var v github_com_bandprotocol_chain_v3_pkg_tss.SigningID
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowQuery
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= github_com_bandprotocol_chain_v3_pkg_tss.SigningID(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.PendingSignings = append(m.PendingSignings, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowQuery
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthQuery
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthQuery
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.PendingSignings) == 0 {
					m.PendingSignings = make([]github_com_bandprotocol_chain_v3_pkg_tss.SigningID, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v github_com_bandprotocol_chain_v3_pkg_tss.SigningID
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowQuery
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= github_com_bandprotocol_chain_v3_pkg_tss.SigningID(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.PendingSignings = append(m.PendingSignings, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field PendingSignings", wireType)
			}
		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 *QuerySigningRequest) 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: QuerySigningRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QuerySigningRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SigningId", wireType)
			}
			m.SigningId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQuery
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SigningId |= 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 *QuerySigningResponse) 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: QuerySigningResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QuerySigningResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SigningResult", 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.SigningResult.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 *QuerySigningsRequest) 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: QuerySigningsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QuerySigningsRequest: 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 *QuerySigningsResponse) 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: QuerySigningsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QuerySigningsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SigningResults", 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.SigningResults = append(m.SigningResults, &SigningResult{})
			if err := m.SigningResults[len(m.SigningResults)-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 *QueryParamsRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowQuery
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: QueryParamsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryParamsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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