From d322b23dd24d48240a7a6e8d1bac6bd721359cee Mon Sep 17 00:00:00 2001 From: Hieu Vu <72878483+hieuvubk@users.noreply.github.com> Date: Fri, 17 Nov 2023 19:42:57 +0700 Subject: [PATCH] feat(x/nft): add new queries for nft modules that support query string (#18355) Co-authored-by: Julien Robert --- api/cosmos/nft/v1beta1/query.pulsar.go | 5484 ++++++++++++++++++++++- api/cosmos/nft/v1beta1/query_grpc.pb.go | 209 +- client/docs/swagger-ui/swagger.yaml | 2057 +++++++++ proto/cosmos/nft/v1beta1/query.proto | 124 + x/nft/CHANGELOG.md | 3 + x/nft/keeper/grpc_query.go | 63 + x/nft/keeper/grpc_query_test.go | 392 ++ x/nft/query.pb.go | 2184 ++++++++- x/nft/query.pb.gw.go | 415 ++ 9 files changed, 10635 insertions(+), 296 deletions(-) diff --git a/api/cosmos/nft/v1beta1/query.pulsar.go b/api/cosmos/nft/v1beta1/query.pulsar.go index cfcb7d51b5..5f0101a708 100644 --- a/api/cosmos/nft/v1beta1/query.pulsar.go +++ b/api/cosmos/nft/v1beta1/query.pulsar.go @@ -498,6 +498,490 @@ func (x *fastReflection_QueryBalanceRequest) ProtoMethods() *protoiface.Methods } } +var ( + md_QueryBalanceByQueryStringRequest protoreflect.MessageDescriptor + fd_QueryBalanceByQueryStringRequest_class_id protoreflect.FieldDescriptor + fd_QueryBalanceByQueryStringRequest_owner protoreflect.FieldDescriptor +) + +func init() { + file_cosmos_nft_v1beta1_query_proto_init() + md_QueryBalanceByQueryStringRequest = File_cosmos_nft_v1beta1_query_proto.Messages().ByName("QueryBalanceByQueryStringRequest") + fd_QueryBalanceByQueryStringRequest_class_id = md_QueryBalanceByQueryStringRequest.Fields().ByName("class_id") + fd_QueryBalanceByQueryStringRequest_owner = md_QueryBalanceByQueryStringRequest.Fields().ByName("owner") +} + +var _ protoreflect.Message = (*fastReflection_QueryBalanceByQueryStringRequest)(nil) + +type fastReflection_QueryBalanceByQueryStringRequest QueryBalanceByQueryStringRequest + +func (x *QueryBalanceByQueryStringRequest) ProtoReflect() protoreflect.Message { + return (*fastReflection_QueryBalanceByQueryStringRequest)(x) +} + +func (x *QueryBalanceByQueryStringRequest) slowProtoReflect() protoreflect.Message { + mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_QueryBalanceByQueryStringRequest_messageType fastReflection_QueryBalanceByQueryStringRequest_messageType +var _ protoreflect.MessageType = fastReflection_QueryBalanceByQueryStringRequest_messageType{} + +type fastReflection_QueryBalanceByQueryStringRequest_messageType struct{} + +func (x fastReflection_QueryBalanceByQueryStringRequest_messageType) Zero() protoreflect.Message { + return (*fastReflection_QueryBalanceByQueryStringRequest)(nil) +} +func (x fastReflection_QueryBalanceByQueryStringRequest_messageType) New() protoreflect.Message { + return new(fastReflection_QueryBalanceByQueryStringRequest) +} +func (x fastReflection_QueryBalanceByQueryStringRequest_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QueryBalanceByQueryStringRequest +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QueryBalanceByQueryStringRequest) Descriptor() protoreflect.MessageDescriptor { + return md_QueryBalanceByQueryStringRequest +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_QueryBalanceByQueryStringRequest) Type() protoreflect.MessageType { + return _fastReflection_QueryBalanceByQueryStringRequest_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QueryBalanceByQueryStringRequest) New() protoreflect.Message { + return new(fastReflection_QueryBalanceByQueryStringRequest) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QueryBalanceByQueryStringRequest) Interface() protoreflect.ProtoMessage { + return (*QueryBalanceByQueryStringRequest)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_QueryBalanceByQueryStringRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.ClassId != "" { + value := protoreflect.ValueOfString(x.ClassId) + if !f(fd_QueryBalanceByQueryStringRequest_class_id, value) { + return + } + } + if x.Owner != "" { + value := protoreflect.ValueOfString(x.Owner) + if !f(fd_QueryBalanceByQueryStringRequest_owner, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_QueryBalanceByQueryStringRequest) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QueryBalanceByQueryStringRequest.class_id": + return x.ClassId != "" + case "cosmos.nft.v1beta1.QueryBalanceByQueryStringRequest.owner": + return x.Owner != "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QueryBalanceByQueryStringRequest")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QueryBalanceByQueryStringRequest does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_QueryBalanceByQueryStringRequest) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QueryBalanceByQueryStringRequest.class_id": + x.ClassId = "" + case "cosmos.nft.v1beta1.QueryBalanceByQueryStringRequest.owner": + x.Owner = "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QueryBalanceByQueryStringRequest")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QueryBalanceByQueryStringRequest does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_QueryBalanceByQueryStringRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "cosmos.nft.v1beta1.QueryBalanceByQueryStringRequest.class_id": + value := x.ClassId + return protoreflect.ValueOfString(value) + case "cosmos.nft.v1beta1.QueryBalanceByQueryStringRequest.owner": + value := x.Owner + return protoreflect.ValueOfString(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QueryBalanceByQueryStringRequest")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QueryBalanceByQueryStringRequest does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_QueryBalanceByQueryStringRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QueryBalanceByQueryStringRequest.class_id": + x.ClassId = value.Interface().(string) + case "cosmos.nft.v1beta1.QueryBalanceByQueryStringRequest.owner": + x.Owner = value.Interface().(string) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QueryBalanceByQueryStringRequest")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QueryBalanceByQueryStringRequest does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_QueryBalanceByQueryStringRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QueryBalanceByQueryStringRequest.class_id": + panic(fmt.Errorf("field class_id of message cosmos.nft.v1beta1.QueryBalanceByQueryStringRequest is not mutable")) + case "cosmos.nft.v1beta1.QueryBalanceByQueryStringRequest.owner": + panic(fmt.Errorf("field owner of message cosmos.nft.v1beta1.QueryBalanceByQueryStringRequest is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QueryBalanceByQueryStringRequest")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QueryBalanceByQueryStringRequest does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_QueryBalanceByQueryStringRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QueryBalanceByQueryStringRequest.class_id": + return protoreflect.ValueOfString("") + case "cosmos.nft.v1beta1.QueryBalanceByQueryStringRequest.owner": + return protoreflect.ValueOfString("") + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QueryBalanceByQueryStringRequest")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QueryBalanceByQueryStringRequest does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_QueryBalanceByQueryStringRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in cosmos.nft.v1beta1.QueryBalanceByQueryStringRequest", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_QueryBalanceByQueryStringRequest) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_QueryBalanceByQueryStringRequest) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_QueryBalanceByQueryStringRequest) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_QueryBalanceByQueryStringRequest) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QueryBalanceByQueryStringRequest) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + l = len(x.ClassId) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Owner) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*QueryBalanceByQueryStringRequest) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if len(x.Owner) > 0 { + i -= len(x.Owner) + copy(dAtA[i:], x.Owner) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Owner))) + i-- + dAtA[i] = 0x12 + } + if len(x.ClassId) > 0 { + i -= len(x.ClassId) + copy(dAtA[i:], x.ClassId) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ClassId))) + i-- + dAtA[i] = 0xa + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*QueryBalanceByQueryStringRequest) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryBalanceByQueryStringRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryBalanceByQueryStringRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ClassId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.ClassId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Owner", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Owner = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + var ( md_QueryBalanceResponse protoreflect.MessageDescriptor fd_QueryBalanceResponse_amount protoreflect.FieldDescriptor @@ -518,7 +1002,7 @@ func (x *QueryBalanceResponse) ProtoReflect() protoreflect.Message { } func (x *QueryBalanceResponse) slowProtoReflect() protoreflect.Message { - mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[1] + mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[2] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -902,6 +1386,410 @@ func (x *fastReflection_QueryBalanceResponse) ProtoMethods() *protoiface.Methods } } +var ( + md_QueryBalanceByQueryStringResponse protoreflect.MessageDescriptor + fd_QueryBalanceByQueryStringResponse_amount protoreflect.FieldDescriptor +) + +func init() { + file_cosmos_nft_v1beta1_query_proto_init() + md_QueryBalanceByQueryStringResponse = File_cosmos_nft_v1beta1_query_proto.Messages().ByName("QueryBalanceByQueryStringResponse") + fd_QueryBalanceByQueryStringResponse_amount = md_QueryBalanceByQueryStringResponse.Fields().ByName("amount") +} + +var _ protoreflect.Message = (*fastReflection_QueryBalanceByQueryStringResponse)(nil) + +type fastReflection_QueryBalanceByQueryStringResponse QueryBalanceByQueryStringResponse + +func (x *QueryBalanceByQueryStringResponse) ProtoReflect() protoreflect.Message { + return (*fastReflection_QueryBalanceByQueryStringResponse)(x) +} + +func (x *QueryBalanceByQueryStringResponse) slowProtoReflect() protoreflect.Message { + mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_QueryBalanceByQueryStringResponse_messageType fastReflection_QueryBalanceByQueryStringResponse_messageType +var _ protoreflect.MessageType = fastReflection_QueryBalanceByQueryStringResponse_messageType{} + +type fastReflection_QueryBalanceByQueryStringResponse_messageType struct{} + +func (x fastReflection_QueryBalanceByQueryStringResponse_messageType) Zero() protoreflect.Message { + return (*fastReflection_QueryBalanceByQueryStringResponse)(nil) +} +func (x fastReflection_QueryBalanceByQueryStringResponse_messageType) New() protoreflect.Message { + return new(fastReflection_QueryBalanceByQueryStringResponse) +} +func (x fastReflection_QueryBalanceByQueryStringResponse_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QueryBalanceByQueryStringResponse +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QueryBalanceByQueryStringResponse) Descriptor() protoreflect.MessageDescriptor { + return md_QueryBalanceByQueryStringResponse +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_QueryBalanceByQueryStringResponse) Type() protoreflect.MessageType { + return _fastReflection_QueryBalanceByQueryStringResponse_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QueryBalanceByQueryStringResponse) New() protoreflect.Message { + return new(fastReflection_QueryBalanceByQueryStringResponse) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QueryBalanceByQueryStringResponse) Interface() protoreflect.ProtoMessage { + return (*QueryBalanceByQueryStringResponse)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_QueryBalanceByQueryStringResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Amount != uint64(0) { + value := protoreflect.ValueOfUint64(x.Amount) + if !f(fd_QueryBalanceByQueryStringResponse_amount, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_QueryBalanceByQueryStringResponse) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QueryBalanceByQueryStringResponse.amount": + return x.Amount != uint64(0) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QueryBalanceByQueryStringResponse")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QueryBalanceByQueryStringResponse does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_QueryBalanceByQueryStringResponse) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QueryBalanceByQueryStringResponse.amount": + x.Amount = uint64(0) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QueryBalanceByQueryStringResponse")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QueryBalanceByQueryStringResponse does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_QueryBalanceByQueryStringResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "cosmos.nft.v1beta1.QueryBalanceByQueryStringResponse.amount": + value := x.Amount + return protoreflect.ValueOfUint64(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QueryBalanceByQueryStringResponse")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QueryBalanceByQueryStringResponse does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_QueryBalanceByQueryStringResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QueryBalanceByQueryStringResponse.amount": + x.Amount = value.Uint() + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QueryBalanceByQueryStringResponse")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QueryBalanceByQueryStringResponse does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_QueryBalanceByQueryStringResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QueryBalanceByQueryStringResponse.amount": + panic(fmt.Errorf("field amount of message cosmos.nft.v1beta1.QueryBalanceByQueryStringResponse is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QueryBalanceByQueryStringResponse")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QueryBalanceByQueryStringResponse does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_QueryBalanceByQueryStringResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QueryBalanceByQueryStringResponse.amount": + return protoreflect.ValueOfUint64(uint64(0)) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QueryBalanceByQueryStringResponse")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QueryBalanceByQueryStringResponse does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_QueryBalanceByQueryStringResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in cosmos.nft.v1beta1.QueryBalanceByQueryStringResponse", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_QueryBalanceByQueryStringResponse) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_QueryBalanceByQueryStringResponse) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_QueryBalanceByQueryStringResponse) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_QueryBalanceByQueryStringResponse) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QueryBalanceByQueryStringResponse) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + if x.Amount != 0 { + n += 1 + runtime.Sov(uint64(x.Amount)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*QueryBalanceByQueryStringResponse) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if x.Amount != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.Amount)) + i-- + dAtA[i] = 0x8 + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*QueryBalanceByQueryStringResponse) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryBalanceByQueryStringResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryBalanceByQueryStringResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) + } + x.Amount = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.Amount |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + var ( md_QueryOwnerRequest protoreflect.MessageDescriptor fd_QueryOwnerRequest_class_id protoreflect.FieldDescriptor @@ -924,7 +1812,7 @@ func (x *QueryOwnerRequest) ProtoReflect() protoreflect.Message { } func (x *QueryOwnerRequest) slowProtoReflect() protoreflect.Message { - mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[2] + mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[4] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1386,6 +2274,490 @@ func (x *fastReflection_QueryOwnerRequest) ProtoMethods() *protoiface.Methods { } } +var ( + md_QueryOwnerByQueryStringRequest protoreflect.MessageDescriptor + fd_QueryOwnerByQueryStringRequest_class_id protoreflect.FieldDescriptor + fd_QueryOwnerByQueryStringRequest_id protoreflect.FieldDescriptor +) + +func init() { + file_cosmos_nft_v1beta1_query_proto_init() + md_QueryOwnerByQueryStringRequest = File_cosmos_nft_v1beta1_query_proto.Messages().ByName("QueryOwnerByQueryStringRequest") + fd_QueryOwnerByQueryStringRequest_class_id = md_QueryOwnerByQueryStringRequest.Fields().ByName("class_id") + fd_QueryOwnerByQueryStringRequest_id = md_QueryOwnerByQueryStringRequest.Fields().ByName("id") +} + +var _ protoreflect.Message = (*fastReflection_QueryOwnerByQueryStringRequest)(nil) + +type fastReflection_QueryOwnerByQueryStringRequest QueryOwnerByQueryStringRequest + +func (x *QueryOwnerByQueryStringRequest) ProtoReflect() protoreflect.Message { + return (*fastReflection_QueryOwnerByQueryStringRequest)(x) +} + +func (x *QueryOwnerByQueryStringRequest) slowProtoReflect() protoreflect.Message { + mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_QueryOwnerByQueryStringRequest_messageType fastReflection_QueryOwnerByQueryStringRequest_messageType +var _ protoreflect.MessageType = fastReflection_QueryOwnerByQueryStringRequest_messageType{} + +type fastReflection_QueryOwnerByQueryStringRequest_messageType struct{} + +func (x fastReflection_QueryOwnerByQueryStringRequest_messageType) Zero() protoreflect.Message { + return (*fastReflection_QueryOwnerByQueryStringRequest)(nil) +} +func (x fastReflection_QueryOwnerByQueryStringRequest_messageType) New() protoreflect.Message { + return new(fastReflection_QueryOwnerByQueryStringRequest) +} +func (x fastReflection_QueryOwnerByQueryStringRequest_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QueryOwnerByQueryStringRequest +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QueryOwnerByQueryStringRequest) Descriptor() protoreflect.MessageDescriptor { + return md_QueryOwnerByQueryStringRequest +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_QueryOwnerByQueryStringRequest) Type() protoreflect.MessageType { + return _fastReflection_QueryOwnerByQueryStringRequest_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QueryOwnerByQueryStringRequest) New() protoreflect.Message { + return new(fastReflection_QueryOwnerByQueryStringRequest) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QueryOwnerByQueryStringRequest) Interface() protoreflect.ProtoMessage { + return (*QueryOwnerByQueryStringRequest)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_QueryOwnerByQueryStringRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.ClassId != "" { + value := protoreflect.ValueOfString(x.ClassId) + if !f(fd_QueryOwnerByQueryStringRequest_class_id, value) { + return + } + } + if x.Id != "" { + value := protoreflect.ValueOfString(x.Id) + if !f(fd_QueryOwnerByQueryStringRequest_id, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_QueryOwnerByQueryStringRequest) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QueryOwnerByQueryStringRequest.class_id": + return x.ClassId != "" + case "cosmos.nft.v1beta1.QueryOwnerByQueryStringRequest.id": + return x.Id != "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QueryOwnerByQueryStringRequest")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QueryOwnerByQueryStringRequest does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_QueryOwnerByQueryStringRequest) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QueryOwnerByQueryStringRequest.class_id": + x.ClassId = "" + case "cosmos.nft.v1beta1.QueryOwnerByQueryStringRequest.id": + x.Id = "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QueryOwnerByQueryStringRequest")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QueryOwnerByQueryStringRequest does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_QueryOwnerByQueryStringRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "cosmos.nft.v1beta1.QueryOwnerByQueryStringRequest.class_id": + value := x.ClassId + return protoreflect.ValueOfString(value) + case "cosmos.nft.v1beta1.QueryOwnerByQueryStringRequest.id": + value := x.Id + return protoreflect.ValueOfString(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QueryOwnerByQueryStringRequest")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QueryOwnerByQueryStringRequest does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_QueryOwnerByQueryStringRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QueryOwnerByQueryStringRequest.class_id": + x.ClassId = value.Interface().(string) + case "cosmos.nft.v1beta1.QueryOwnerByQueryStringRequest.id": + x.Id = value.Interface().(string) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QueryOwnerByQueryStringRequest")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QueryOwnerByQueryStringRequest does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_QueryOwnerByQueryStringRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QueryOwnerByQueryStringRequest.class_id": + panic(fmt.Errorf("field class_id of message cosmos.nft.v1beta1.QueryOwnerByQueryStringRequest is not mutable")) + case "cosmos.nft.v1beta1.QueryOwnerByQueryStringRequest.id": + panic(fmt.Errorf("field id of message cosmos.nft.v1beta1.QueryOwnerByQueryStringRequest is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QueryOwnerByQueryStringRequest")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QueryOwnerByQueryStringRequest does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_QueryOwnerByQueryStringRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QueryOwnerByQueryStringRequest.class_id": + return protoreflect.ValueOfString("") + case "cosmos.nft.v1beta1.QueryOwnerByQueryStringRequest.id": + return protoreflect.ValueOfString("") + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QueryOwnerByQueryStringRequest")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QueryOwnerByQueryStringRequest does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_QueryOwnerByQueryStringRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in cosmos.nft.v1beta1.QueryOwnerByQueryStringRequest", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_QueryOwnerByQueryStringRequest) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_QueryOwnerByQueryStringRequest) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_QueryOwnerByQueryStringRequest) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_QueryOwnerByQueryStringRequest) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QueryOwnerByQueryStringRequest) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + l = len(x.ClassId) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Id) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*QueryOwnerByQueryStringRequest) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if len(x.Id) > 0 { + i -= len(x.Id) + copy(dAtA[i:], x.Id) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Id))) + i-- + dAtA[i] = 0x12 + } + if len(x.ClassId) > 0 { + i -= len(x.ClassId) + copy(dAtA[i:], x.ClassId) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ClassId))) + i-- + dAtA[i] = 0xa + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*QueryOwnerByQueryStringRequest) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryOwnerByQueryStringRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryOwnerByQueryStringRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ClassId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.ClassId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Id = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + var ( md_QueryOwnerResponse protoreflect.MessageDescriptor fd_QueryOwnerResponse_owner protoreflect.FieldDescriptor @@ -1406,7 +2778,7 @@ func (x *QueryOwnerResponse) ProtoReflect() protoreflect.Message { } func (x *QueryOwnerResponse) slowProtoReflect() protoreflect.Message { - mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[3] + mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[6] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1806,6 +3178,426 @@ func (x *fastReflection_QueryOwnerResponse) ProtoMethods() *protoiface.Methods { } } +var ( + md_QueryOwnerByQueryStringResponse protoreflect.MessageDescriptor + fd_QueryOwnerByQueryStringResponse_owner protoreflect.FieldDescriptor +) + +func init() { + file_cosmos_nft_v1beta1_query_proto_init() + md_QueryOwnerByQueryStringResponse = File_cosmos_nft_v1beta1_query_proto.Messages().ByName("QueryOwnerByQueryStringResponse") + fd_QueryOwnerByQueryStringResponse_owner = md_QueryOwnerByQueryStringResponse.Fields().ByName("owner") +} + +var _ protoreflect.Message = (*fastReflection_QueryOwnerByQueryStringResponse)(nil) + +type fastReflection_QueryOwnerByQueryStringResponse QueryOwnerByQueryStringResponse + +func (x *QueryOwnerByQueryStringResponse) ProtoReflect() protoreflect.Message { + return (*fastReflection_QueryOwnerByQueryStringResponse)(x) +} + +func (x *QueryOwnerByQueryStringResponse) slowProtoReflect() protoreflect.Message { + mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[7] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_QueryOwnerByQueryStringResponse_messageType fastReflection_QueryOwnerByQueryStringResponse_messageType +var _ protoreflect.MessageType = fastReflection_QueryOwnerByQueryStringResponse_messageType{} + +type fastReflection_QueryOwnerByQueryStringResponse_messageType struct{} + +func (x fastReflection_QueryOwnerByQueryStringResponse_messageType) Zero() protoreflect.Message { + return (*fastReflection_QueryOwnerByQueryStringResponse)(nil) +} +func (x fastReflection_QueryOwnerByQueryStringResponse_messageType) New() protoreflect.Message { + return new(fastReflection_QueryOwnerByQueryStringResponse) +} +func (x fastReflection_QueryOwnerByQueryStringResponse_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QueryOwnerByQueryStringResponse +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QueryOwnerByQueryStringResponse) Descriptor() protoreflect.MessageDescriptor { + return md_QueryOwnerByQueryStringResponse +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_QueryOwnerByQueryStringResponse) Type() protoreflect.MessageType { + return _fastReflection_QueryOwnerByQueryStringResponse_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QueryOwnerByQueryStringResponse) New() protoreflect.Message { + return new(fastReflection_QueryOwnerByQueryStringResponse) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QueryOwnerByQueryStringResponse) Interface() protoreflect.ProtoMessage { + return (*QueryOwnerByQueryStringResponse)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_QueryOwnerByQueryStringResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Owner != "" { + value := protoreflect.ValueOfString(x.Owner) + if !f(fd_QueryOwnerByQueryStringResponse_owner, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_QueryOwnerByQueryStringResponse) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QueryOwnerByQueryStringResponse.owner": + return x.Owner != "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QueryOwnerByQueryStringResponse")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QueryOwnerByQueryStringResponse does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_QueryOwnerByQueryStringResponse) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QueryOwnerByQueryStringResponse.owner": + x.Owner = "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QueryOwnerByQueryStringResponse")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QueryOwnerByQueryStringResponse does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_QueryOwnerByQueryStringResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "cosmos.nft.v1beta1.QueryOwnerByQueryStringResponse.owner": + value := x.Owner + return protoreflect.ValueOfString(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QueryOwnerByQueryStringResponse")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QueryOwnerByQueryStringResponse does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_QueryOwnerByQueryStringResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QueryOwnerByQueryStringResponse.owner": + x.Owner = value.Interface().(string) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QueryOwnerByQueryStringResponse")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QueryOwnerByQueryStringResponse does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_QueryOwnerByQueryStringResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QueryOwnerByQueryStringResponse.owner": + panic(fmt.Errorf("field owner of message cosmos.nft.v1beta1.QueryOwnerByQueryStringResponse is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QueryOwnerByQueryStringResponse")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QueryOwnerByQueryStringResponse does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_QueryOwnerByQueryStringResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QueryOwnerByQueryStringResponse.owner": + return protoreflect.ValueOfString("") + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QueryOwnerByQueryStringResponse")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QueryOwnerByQueryStringResponse does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_QueryOwnerByQueryStringResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in cosmos.nft.v1beta1.QueryOwnerByQueryStringResponse", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_QueryOwnerByQueryStringResponse) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_QueryOwnerByQueryStringResponse) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_QueryOwnerByQueryStringResponse) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_QueryOwnerByQueryStringResponse) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QueryOwnerByQueryStringResponse) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + l = len(x.Owner) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*QueryOwnerByQueryStringResponse) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if len(x.Owner) > 0 { + i -= len(x.Owner) + copy(dAtA[i:], x.Owner) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Owner))) + i-- + dAtA[i] = 0xa + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*QueryOwnerByQueryStringResponse) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryOwnerByQueryStringResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryOwnerByQueryStringResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Owner", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Owner = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + var ( md_QuerySupplyRequest protoreflect.MessageDescriptor fd_QuerySupplyRequest_class_id protoreflect.FieldDescriptor @@ -1826,7 +3618,7 @@ func (x *QuerySupplyRequest) ProtoReflect() protoreflect.Message { } func (x *QuerySupplyRequest) slowProtoReflect() protoreflect.Message { - mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[4] + mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[8] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2226,6 +4018,426 @@ func (x *fastReflection_QuerySupplyRequest) ProtoMethods() *protoiface.Methods { } } +var ( + md_QuerySupplyByQueryStringRequest protoreflect.MessageDescriptor + fd_QuerySupplyByQueryStringRequest_class_id protoreflect.FieldDescriptor +) + +func init() { + file_cosmos_nft_v1beta1_query_proto_init() + md_QuerySupplyByQueryStringRequest = File_cosmos_nft_v1beta1_query_proto.Messages().ByName("QuerySupplyByQueryStringRequest") + fd_QuerySupplyByQueryStringRequest_class_id = md_QuerySupplyByQueryStringRequest.Fields().ByName("class_id") +} + +var _ protoreflect.Message = (*fastReflection_QuerySupplyByQueryStringRequest)(nil) + +type fastReflection_QuerySupplyByQueryStringRequest QuerySupplyByQueryStringRequest + +func (x *QuerySupplyByQueryStringRequest) ProtoReflect() protoreflect.Message { + return (*fastReflection_QuerySupplyByQueryStringRequest)(x) +} + +func (x *QuerySupplyByQueryStringRequest) slowProtoReflect() protoreflect.Message { + mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[9] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_QuerySupplyByQueryStringRequest_messageType fastReflection_QuerySupplyByQueryStringRequest_messageType +var _ protoreflect.MessageType = fastReflection_QuerySupplyByQueryStringRequest_messageType{} + +type fastReflection_QuerySupplyByQueryStringRequest_messageType struct{} + +func (x fastReflection_QuerySupplyByQueryStringRequest_messageType) Zero() protoreflect.Message { + return (*fastReflection_QuerySupplyByQueryStringRequest)(nil) +} +func (x fastReflection_QuerySupplyByQueryStringRequest_messageType) New() protoreflect.Message { + return new(fastReflection_QuerySupplyByQueryStringRequest) +} +func (x fastReflection_QuerySupplyByQueryStringRequest_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QuerySupplyByQueryStringRequest +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QuerySupplyByQueryStringRequest) Descriptor() protoreflect.MessageDescriptor { + return md_QuerySupplyByQueryStringRequest +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_QuerySupplyByQueryStringRequest) Type() protoreflect.MessageType { + return _fastReflection_QuerySupplyByQueryStringRequest_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QuerySupplyByQueryStringRequest) New() protoreflect.Message { + return new(fastReflection_QuerySupplyByQueryStringRequest) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QuerySupplyByQueryStringRequest) Interface() protoreflect.ProtoMessage { + return (*QuerySupplyByQueryStringRequest)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_QuerySupplyByQueryStringRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.ClassId != "" { + value := protoreflect.ValueOfString(x.ClassId) + if !f(fd_QuerySupplyByQueryStringRequest_class_id, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_QuerySupplyByQueryStringRequest) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QuerySupplyByQueryStringRequest.class_id": + return x.ClassId != "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QuerySupplyByQueryStringRequest")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QuerySupplyByQueryStringRequest does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_QuerySupplyByQueryStringRequest) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QuerySupplyByQueryStringRequest.class_id": + x.ClassId = "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QuerySupplyByQueryStringRequest")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QuerySupplyByQueryStringRequest does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_QuerySupplyByQueryStringRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "cosmos.nft.v1beta1.QuerySupplyByQueryStringRequest.class_id": + value := x.ClassId + return protoreflect.ValueOfString(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QuerySupplyByQueryStringRequest")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QuerySupplyByQueryStringRequest does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_QuerySupplyByQueryStringRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QuerySupplyByQueryStringRequest.class_id": + x.ClassId = value.Interface().(string) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QuerySupplyByQueryStringRequest")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QuerySupplyByQueryStringRequest does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_QuerySupplyByQueryStringRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QuerySupplyByQueryStringRequest.class_id": + panic(fmt.Errorf("field class_id of message cosmos.nft.v1beta1.QuerySupplyByQueryStringRequest is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QuerySupplyByQueryStringRequest")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QuerySupplyByQueryStringRequest does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_QuerySupplyByQueryStringRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QuerySupplyByQueryStringRequest.class_id": + return protoreflect.ValueOfString("") + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QuerySupplyByQueryStringRequest")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QuerySupplyByQueryStringRequest does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_QuerySupplyByQueryStringRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in cosmos.nft.v1beta1.QuerySupplyByQueryStringRequest", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_QuerySupplyByQueryStringRequest) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_QuerySupplyByQueryStringRequest) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_QuerySupplyByQueryStringRequest) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_QuerySupplyByQueryStringRequest) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QuerySupplyByQueryStringRequest) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + l = len(x.ClassId) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*QuerySupplyByQueryStringRequest) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if len(x.ClassId) > 0 { + i -= len(x.ClassId) + copy(dAtA[i:], x.ClassId) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ClassId))) + i-- + dAtA[i] = 0xa + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*QuerySupplyByQueryStringRequest) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QuerySupplyByQueryStringRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QuerySupplyByQueryStringRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ClassId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.ClassId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + var ( md_QuerySupplyResponse protoreflect.MessageDescriptor fd_QuerySupplyResponse_amount protoreflect.FieldDescriptor @@ -2246,7 +4458,7 @@ func (x *QuerySupplyResponse) ProtoReflect() protoreflect.Message { } func (x *QuerySupplyResponse) slowProtoReflect() protoreflect.Message { - mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[5] + mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[10] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2630,6 +4842,410 @@ func (x *fastReflection_QuerySupplyResponse) ProtoMethods() *protoiface.Methods } } +var ( + md_QuerySupplyByQueryStringResponse protoreflect.MessageDescriptor + fd_QuerySupplyByQueryStringResponse_amount protoreflect.FieldDescriptor +) + +func init() { + file_cosmos_nft_v1beta1_query_proto_init() + md_QuerySupplyByQueryStringResponse = File_cosmos_nft_v1beta1_query_proto.Messages().ByName("QuerySupplyByQueryStringResponse") + fd_QuerySupplyByQueryStringResponse_amount = md_QuerySupplyByQueryStringResponse.Fields().ByName("amount") +} + +var _ protoreflect.Message = (*fastReflection_QuerySupplyByQueryStringResponse)(nil) + +type fastReflection_QuerySupplyByQueryStringResponse QuerySupplyByQueryStringResponse + +func (x *QuerySupplyByQueryStringResponse) ProtoReflect() protoreflect.Message { + return (*fastReflection_QuerySupplyByQueryStringResponse)(x) +} + +func (x *QuerySupplyByQueryStringResponse) slowProtoReflect() protoreflect.Message { + mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[11] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_QuerySupplyByQueryStringResponse_messageType fastReflection_QuerySupplyByQueryStringResponse_messageType +var _ protoreflect.MessageType = fastReflection_QuerySupplyByQueryStringResponse_messageType{} + +type fastReflection_QuerySupplyByQueryStringResponse_messageType struct{} + +func (x fastReflection_QuerySupplyByQueryStringResponse_messageType) Zero() protoreflect.Message { + return (*fastReflection_QuerySupplyByQueryStringResponse)(nil) +} +func (x fastReflection_QuerySupplyByQueryStringResponse_messageType) New() protoreflect.Message { + return new(fastReflection_QuerySupplyByQueryStringResponse) +} +func (x fastReflection_QuerySupplyByQueryStringResponse_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QuerySupplyByQueryStringResponse +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QuerySupplyByQueryStringResponse) Descriptor() protoreflect.MessageDescriptor { + return md_QuerySupplyByQueryStringResponse +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_QuerySupplyByQueryStringResponse) Type() protoreflect.MessageType { + return _fastReflection_QuerySupplyByQueryStringResponse_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QuerySupplyByQueryStringResponse) New() protoreflect.Message { + return new(fastReflection_QuerySupplyByQueryStringResponse) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QuerySupplyByQueryStringResponse) Interface() protoreflect.ProtoMessage { + return (*QuerySupplyByQueryStringResponse)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_QuerySupplyByQueryStringResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Amount != uint64(0) { + value := protoreflect.ValueOfUint64(x.Amount) + if !f(fd_QuerySupplyByQueryStringResponse_amount, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_QuerySupplyByQueryStringResponse) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QuerySupplyByQueryStringResponse.amount": + return x.Amount != uint64(0) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QuerySupplyByQueryStringResponse")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QuerySupplyByQueryStringResponse does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_QuerySupplyByQueryStringResponse) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QuerySupplyByQueryStringResponse.amount": + x.Amount = uint64(0) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QuerySupplyByQueryStringResponse")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QuerySupplyByQueryStringResponse does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_QuerySupplyByQueryStringResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "cosmos.nft.v1beta1.QuerySupplyByQueryStringResponse.amount": + value := x.Amount + return protoreflect.ValueOfUint64(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QuerySupplyByQueryStringResponse")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QuerySupplyByQueryStringResponse does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_QuerySupplyByQueryStringResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QuerySupplyByQueryStringResponse.amount": + x.Amount = value.Uint() + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QuerySupplyByQueryStringResponse")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QuerySupplyByQueryStringResponse does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_QuerySupplyByQueryStringResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QuerySupplyByQueryStringResponse.amount": + panic(fmt.Errorf("field amount of message cosmos.nft.v1beta1.QuerySupplyByQueryStringResponse is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QuerySupplyByQueryStringResponse")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QuerySupplyByQueryStringResponse does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_QuerySupplyByQueryStringResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QuerySupplyByQueryStringResponse.amount": + return protoreflect.ValueOfUint64(uint64(0)) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QuerySupplyByQueryStringResponse")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QuerySupplyByQueryStringResponse does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_QuerySupplyByQueryStringResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in cosmos.nft.v1beta1.QuerySupplyByQueryStringResponse", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_QuerySupplyByQueryStringResponse) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_QuerySupplyByQueryStringResponse) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_QuerySupplyByQueryStringResponse) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_QuerySupplyByQueryStringResponse) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QuerySupplyByQueryStringResponse) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + if x.Amount != 0 { + n += 1 + runtime.Sov(uint64(x.Amount)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*QuerySupplyByQueryStringResponse) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if x.Amount != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.Amount)) + i-- + dAtA[i] = 0x8 + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*QuerySupplyByQueryStringResponse) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QuerySupplyByQueryStringResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QuerySupplyByQueryStringResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) + } + x.Amount = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + x.Amount |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + var ( md_QueryNFTsRequest protoreflect.MessageDescriptor fd_QueryNFTsRequest_class_id protoreflect.FieldDescriptor @@ -2654,7 +5270,7 @@ func (x *QueryNFTsRequest) ProtoReflect() protoreflect.Message { } func (x *QueryNFTsRequest) slowProtoReflect() protoreflect.Message { - mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[6] + mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[12] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3266,7 +5882,7 @@ func (x *QueryNFTsResponse) ProtoReflect() protoreflect.Message { } func (x *QueryNFTsResponse) slowProtoReflect() protoreflect.Message { - mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[7] + mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[13] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3788,7 +6404,7 @@ func (x *QueryNFTRequest) ProtoReflect() protoreflect.Message { } func (x *QueryNFTRequest) slowProtoReflect() protoreflect.Message { - mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[8] + mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[14] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4250,6 +6866,490 @@ func (x *fastReflection_QueryNFTRequest) ProtoMethods() *protoiface.Methods { } } +var ( + md_QueryNFTByQueryStringRequest protoreflect.MessageDescriptor + fd_QueryNFTByQueryStringRequest_class_id protoreflect.FieldDescriptor + fd_QueryNFTByQueryStringRequest_id protoreflect.FieldDescriptor +) + +func init() { + file_cosmos_nft_v1beta1_query_proto_init() + md_QueryNFTByQueryStringRequest = File_cosmos_nft_v1beta1_query_proto.Messages().ByName("QueryNFTByQueryStringRequest") + fd_QueryNFTByQueryStringRequest_class_id = md_QueryNFTByQueryStringRequest.Fields().ByName("class_id") + fd_QueryNFTByQueryStringRequest_id = md_QueryNFTByQueryStringRequest.Fields().ByName("id") +} + +var _ protoreflect.Message = (*fastReflection_QueryNFTByQueryStringRequest)(nil) + +type fastReflection_QueryNFTByQueryStringRequest QueryNFTByQueryStringRequest + +func (x *QueryNFTByQueryStringRequest) ProtoReflect() protoreflect.Message { + return (*fastReflection_QueryNFTByQueryStringRequest)(x) +} + +func (x *QueryNFTByQueryStringRequest) slowProtoReflect() protoreflect.Message { + mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[15] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_QueryNFTByQueryStringRequest_messageType fastReflection_QueryNFTByQueryStringRequest_messageType +var _ protoreflect.MessageType = fastReflection_QueryNFTByQueryStringRequest_messageType{} + +type fastReflection_QueryNFTByQueryStringRequest_messageType struct{} + +func (x fastReflection_QueryNFTByQueryStringRequest_messageType) Zero() protoreflect.Message { + return (*fastReflection_QueryNFTByQueryStringRequest)(nil) +} +func (x fastReflection_QueryNFTByQueryStringRequest_messageType) New() protoreflect.Message { + return new(fastReflection_QueryNFTByQueryStringRequest) +} +func (x fastReflection_QueryNFTByQueryStringRequest_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QueryNFTByQueryStringRequest +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QueryNFTByQueryStringRequest) Descriptor() protoreflect.MessageDescriptor { + return md_QueryNFTByQueryStringRequest +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_QueryNFTByQueryStringRequest) Type() protoreflect.MessageType { + return _fastReflection_QueryNFTByQueryStringRequest_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QueryNFTByQueryStringRequest) New() protoreflect.Message { + return new(fastReflection_QueryNFTByQueryStringRequest) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QueryNFTByQueryStringRequest) Interface() protoreflect.ProtoMessage { + return (*QueryNFTByQueryStringRequest)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_QueryNFTByQueryStringRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.ClassId != "" { + value := protoreflect.ValueOfString(x.ClassId) + if !f(fd_QueryNFTByQueryStringRequest_class_id, value) { + return + } + } + if x.Id != "" { + value := protoreflect.ValueOfString(x.Id) + if !f(fd_QueryNFTByQueryStringRequest_id, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_QueryNFTByQueryStringRequest) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QueryNFTByQueryStringRequest.class_id": + return x.ClassId != "" + case "cosmos.nft.v1beta1.QueryNFTByQueryStringRequest.id": + return x.Id != "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QueryNFTByQueryStringRequest")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QueryNFTByQueryStringRequest does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_QueryNFTByQueryStringRequest) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QueryNFTByQueryStringRequest.class_id": + x.ClassId = "" + case "cosmos.nft.v1beta1.QueryNFTByQueryStringRequest.id": + x.Id = "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QueryNFTByQueryStringRequest")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QueryNFTByQueryStringRequest does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_QueryNFTByQueryStringRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "cosmos.nft.v1beta1.QueryNFTByQueryStringRequest.class_id": + value := x.ClassId + return protoreflect.ValueOfString(value) + case "cosmos.nft.v1beta1.QueryNFTByQueryStringRequest.id": + value := x.Id + return protoreflect.ValueOfString(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QueryNFTByQueryStringRequest")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QueryNFTByQueryStringRequest does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_QueryNFTByQueryStringRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QueryNFTByQueryStringRequest.class_id": + x.ClassId = value.Interface().(string) + case "cosmos.nft.v1beta1.QueryNFTByQueryStringRequest.id": + x.Id = value.Interface().(string) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QueryNFTByQueryStringRequest")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QueryNFTByQueryStringRequest does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_QueryNFTByQueryStringRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QueryNFTByQueryStringRequest.class_id": + panic(fmt.Errorf("field class_id of message cosmos.nft.v1beta1.QueryNFTByQueryStringRequest is not mutable")) + case "cosmos.nft.v1beta1.QueryNFTByQueryStringRequest.id": + panic(fmt.Errorf("field id of message cosmos.nft.v1beta1.QueryNFTByQueryStringRequest is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QueryNFTByQueryStringRequest")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QueryNFTByQueryStringRequest does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_QueryNFTByQueryStringRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QueryNFTByQueryStringRequest.class_id": + return protoreflect.ValueOfString("") + case "cosmos.nft.v1beta1.QueryNFTByQueryStringRequest.id": + return protoreflect.ValueOfString("") + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QueryNFTByQueryStringRequest")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QueryNFTByQueryStringRequest does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_QueryNFTByQueryStringRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in cosmos.nft.v1beta1.QueryNFTByQueryStringRequest", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_QueryNFTByQueryStringRequest) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_QueryNFTByQueryStringRequest) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_QueryNFTByQueryStringRequest) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_QueryNFTByQueryStringRequest) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QueryNFTByQueryStringRequest) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + l = len(x.ClassId) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + l = len(x.Id) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*QueryNFTByQueryStringRequest) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if len(x.Id) > 0 { + i -= len(x.Id) + copy(dAtA[i:], x.Id) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Id))) + i-- + dAtA[i] = 0x12 + } + if len(x.ClassId) > 0 { + i -= len(x.ClassId) + copy(dAtA[i:], x.ClassId) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ClassId))) + i-- + dAtA[i] = 0xa + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*QueryNFTByQueryStringRequest) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryNFTByQueryStringRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryNFTByQueryStringRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ClassId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.ClassId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Id = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + var ( md_QueryNFTResponse protoreflect.MessageDescriptor fd_QueryNFTResponse_nft protoreflect.FieldDescriptor @@ -4270,7 +7370,7 @@ func (x *QueryNFTResponse) ProtoReflect() protoreflect.Message { } func (x *QueryNFTResponse) slowProtoReflect() protoreflect.Message { - mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[9] + mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[16] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4685,6 +7785,441 @@ func (x *fastReflection_QueryNFTResponse) ProtoMethods() *protoiface.Methods { } } +var ( + md_QueryNFTByQueryStringResponse protoreflect.MessageDescriptor + fd_QueryNFTByQueryStringResponse_nft protoreflect.FieldDescriptor +) + +func init() { + file_cosmos_nft_v1beta1_query_proto_init() + md_QueryNFTByQueryStringResponse = File_cosmos_nft_v1beta1_query_proto.Messages().ByName("QueryNFTByQueryStringResponse") + fd_QueryNFTByQueryStringResponse_nft = md_QueryNFTByQueryStringResponse.Fields().ByName("nft") +} + +var _ protoreflect.Message = (*fastReflection_QueryNFTByQueryStringResponse)(nil) + +type fastReflection_QueryNFTByQueryStringResponse QueryNFTByQueryStringResponse + +func (x *QueryNFTByQueryStringResponse) ProtoReflect() protoreflect.Message { + return (*fastReflection_QueryNFTByQueryStringResponse)(x) +} + +func (x *QueryNFTByQueryStringResponse) slowProtoReflect() protoreflect.Message { + mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[17] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_QueryNFTByQueryStringResponse_messageType fastReflection_QueryNFTByQueryStringResponse_messageType +var _ protoreflect.MessageType = fastReflection_QueryNFTByQueryStringResponse_messageType{} + +type fastReflection_QueryNFTByQueryStringResponse_messageType struct{} + +func (x fastReflection_QueryNFTByQueryStringResponse_messageType) Zero() protoreflect.Message { + return (*fastReflection_QueryNFTByQueryStringResponse)(nil) +} +func (x fastReflection_QueryNFTByQueryStringResponse_messageType) New() protoreflect.Message { + return new(fastReflection_QueryNFTByQueryStringResponse) +} +func (x fastReflection_QueryNFTByQueryStringResponse_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QueryNFTByQueryStringResponse +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QueryNFTByQueryStringResponse) Descriptor() protoreflect.MessageDescriptor { + return md_QueryNFTByQueryStringResponse +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_QueryNFTByQueryStringResponse) Type() protoreflect.MessageType { + return _fastReflection_QueryNFTByQueryStringResponse_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QueryNFTByQueryStringResponse) New() protoreflect.Message { + return new(fastReflection_QueryNFTByQueryStringResponse) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QueryNFTByQueryStringResponse) Interface() protoreflect.ProtoMessage { + return (*QueryNFTByQueryStringResponse)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_QueryNFTByQueryStringResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Nft != nil { + value := protoreflect.ValueOfMessage(x.Nft.ProtoReflect()) + if !f(fd_QueryNFTByQueryStringResponse_nft, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_QueryNFTByQueryStringResponse) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QueryNFTByQueryStringResponse.nft": + return x.Nft != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QueryNFTByQueryStringResponse")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QueryNFTByQueryStringResponse does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_QueryNFTByQueryStringResponse) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QueryNFTByQueryStringResponse.nft": + x.Nft = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QueryNFTByQueryStringResponse")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QueryNFTByQueryStringResponse does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_QueryNFTByQueryStringResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "cosmos.nft.v1beta1.QueryNFTByQueryStringResponse.nft": + value := x.Nft + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QueryNFTByQueryStringResponse")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QueryNFTByQueryStringResponse does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_QueryNFTByQueryStringResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QueryNFTByQueryStringResponse.nft": + x.Nft = value.Message().Interface().(*NFT) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QueryNFTByQueryStringResponse")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QueryNFTByQueryStringResponse does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_QueryNFTByQueryStringResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QueryNFTByQueryStringResponse.nft": + if x.Nft == nil { + x.Nft = new(NFT) + } + return protoreflect.ValueOfMessage(x.Nft.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QueryNFTByQueryStringResponse")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QueryNFTByQueryStringResponse does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_QueryNFTByQueryStringResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QueryNFTByQueryStringResponse.nft": + m := new(NFT) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QueryNFTByQueryStringResponse")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QueryNFTByQueryStringResponse does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_QueryNFTByQueryStringResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in cosmos.nft.v1beta1.QueryNFTByQueryStringResponse", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_QueryNFTByQueryStringResponse) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_QueryNFTByQueryStringResponse) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_QueryNFTByQueryStringResponse) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_QueryNFTByQueryStringResponse) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QueryNFTByQueryStringResponse) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + if x.Nft != nil { + l = options.Size(x.Nft) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*QueryNFTByQueryStringResponse) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if x.Nft != nil { + encoded, err := options.Marshal(x.Nft) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0xa + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*QueryNFTByQueryStringResponse) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryNFTByQueryStringResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryNFTByQueryStringResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Nft", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.Nft == nil { + x.Nft = &NFT{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Nft); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + var ( md_QueryClassRequest protoreflect.MessageDescriptor fd_QueryClassRequest_class_id protoreflect.FieldDescriptor @@ -4705,7 +8240,7 @@ func (x *QueryClassRequest) ProtoReflect() protoreflect.Message { } func (x *QueryClassRequest) slowProtoReflect() protoreflect.Message { - mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[10] + mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[18] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5105,6 +8640,426 @@ func (x *fastReflection_QueryClassRequest) ProtoMethods() *protoiface.Methods { } } +var ( + md_QueryClassByQueryStringRequest protoreflect.MessageDescriptor + fd_QueryClassByQueryStringRequest_class_id protoreflect.FieldDescriptor +) + +func init() { + file_cosmos_nft_v1beta1_query_proto_init() + md_QueryClassByQueryStringRequest = File_cosmos_nft_v1beta1_query_proto.Messages().ByName("QueryClassByQueryStringRequest") + fd_QueryClassByQueryStringRequest_class_id = md_QueryClassByQueryStringRequest.Fields().ByName("class_id") +} + +var _ protoreflect.Message = (*fastReflection_QueryClassByQueryStringRequest)(nil) + +type fastReflection_QueryClassByQueryStringRequest QueryClassByQueryStringRequest + +func (x *QueryClassByQueryStringRequest) ProtoReflect() protoreflect.Message { + return (*fastReflection_QueryClassByQueryStringRequest)(x) +} + +func (x *QueryClassByQueryStringRequest) slowProtoReflect() protoreflect.Message { + mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[19] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_QueryClassByQueryStringRequest_messageType fastReflection_QueryClassByQueryStringRequest_messageType +var _ protoreflect.MessageType = fastReflection_QueryClassByQueryStringRequest_messageType{} + +type fastReflection_QueryClassByQueryStringRequest_messageType struct{} + +func (x fastReflection_QueryClassByQueryStringRequest_messageType) Zero() protoreflect.Message { + return (*fastReflection_QueryClassByQueryStringRequest)(nil) +} +func (x fastReflection_QueryClassByQueryStringRequest_messageType) New() protoreflect.Message { + return new(fastReflection_QueryClassByQueryStringRequest) +} +func (x fastReflection_QueryClassByQueryStringRequest_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QueryClassByQueryStringRequest +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QueryClassByQueryStringRequest) Descriptor() protoreflect.MessageDescriptor { + return md_QueryClassByQueryStringRequest +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_QueryClassByQueryStringRequest) Type() protoreflect.MessageType { + return _fastReflection_QueryClassByQueryStringRequest_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QueryClassByQueryStringRequest) New() protoreflect.Message { + return new(fastReflection_QueryClassByQueryStringRequest) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QueryClassByQueryStringRequest) Interface() protoreflect.ProtoMessage { + return (*QueryClassByQueryStringRequest)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_QueryClassByQueryStringRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.ClassId != "" { + value := protoreflect.ValueOfString(x.ClassId) + if !f(fd_QueryClassByQueryStringRequest_class_id, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_QueryClassByQueryStringRequest) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QueryClassByQueryStringRequest.class_id": + return x.ClassId != "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QueryClassByQueryStringRequest")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QueryClassByQueryStringRequest does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_QueryClassByQueryStringRequest) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QueryClassByQueryStringRequest.class_id": + x.ClassId = "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QueryClassByQueryStringRequest")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QueryClassByQueryStringRequest does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_QueryClassByQueryStringRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "cosmos.nft.v1beta1.QueryClassByQueryStringRequest.class_id": + value := x.ClassId + return protoreflect.ValueOfString(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QueryClassByQueryStringRequest")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QueryClassByQueryStringRequest does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_QueryClassByQueryStringRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QueryClassByQueryStringRequest.class_id": + x.ClassId = value.Interface().(string) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QueryClassByQueryStringRequest")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QueryClassByQueryStringRequest does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_QueryClassByQueryStringRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QueryClassByQueryStringRequest.class_id": + panic(fmt.Errorf("field class_id of message cosmos.nft.v1beta1.QueryClassByQueryStringRequest is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QueryClassByQueryStringRequest")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QueryClassByQueryStringRequest does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_QueryClassByQueryStringRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QueryClassByQueryStringRequest.class_id": + return protoreflect.ValueOfString("") + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QueryClassByQueryStringRequest")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QueryClassByQueryStringRequest does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_QueryClassByQueryStringRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in cosmos.nft.v1beta1.QueryClassByQueryStringRequest", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_QueryClassByQueryStringRequest) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_QueryClassByQueryStringRequest) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_QueryClassByQueryStringRequest) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_QueryClassByQueryStringRequest) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QueryClassByQueryStringRequest) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + l = len(x.ClassId) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*QueryClassByQueryStringRequest) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if len(x.ClassId) > 0 { + i -= len(x.ClassId) + copy(dAtA[i:], x.ClassId) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ClassId))) + i-- + dAtA[i] = 0xa + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*QueryClassByQueryStringRequest) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryClassByQueryStringRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryClassByQueryStringRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ClassId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.ClassId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + var ( md_QueryClassResponse protoreflect.MessageDescriptor fd_QueryClassResponse_class protoreflect.FieldDescriptor @@ -5125,7 +9080,7 @@ func (x *QueryClassResponse) ProtoReflect() protoreflect.Message { } func (x *QueryClassResponse) slowProtoReflect() protoreflect.Message { - mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[11] + mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[20] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5540,6 +9495,441 @@ func (x *fastReflection_QueryClassResponse) ProtoMethods() *protoiface.Methods { } } +var ( + md_QueryClassByQueryStringResponse protoreflect.MessageDescriptor + fd_QueryClassByQueryStringResponse_class protoreflect.FieldDescriptor +) + +func init() { + file_cosmos_nft_v1beta1_query_proto_init() + md_QueryClassByQueryStringResponse = File_cosmos_nft_v1beta1_query_proto.Messages().ByName("QueryClassByQueryStringResponse") + fd_QueryClassByQueryStringResponse_class = md_QueryClassByQueryStringResponse.Fields().ByName("class") +} + +var _ protoreflect.Message = (*fastReflection_QueryClassByQueryStringResponse)(nil) + +type fastReflection_QueryClassByQueryStringResponse QueryClassByQueryStringResponse + +func (x *QueryClassByQueryStringResponse) ProtoReflect() protoreflect.Message { + return (*fastReflection_QueryClassByQueryStringResponse)(x) +} + +func (x *QueryClassByQueryStringResponse) slowProtoReflect() protoreflect.Message { + mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[21] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_QueryClassByQueryStringResponse_messageType fastReflection_QueryClassByQueryStringResponse_messageType +var _ protoreflect.MessageType = fastReflection_QueryClassByQueryStringResponse_messageType{} + +type fastReflection_QueryClassByQueryStringResponse_messageType struct{} + +func (x fastReflection_QueryClassByQueryStringResponse_messageType) Zero() protoreflect.Message { + return (*fastReflection_QueryClassByQueryStringResponse)(nil) +} +func (x fastReflection_QueryClassByQueryStringResponse_messageType) New() protoreflect.Message { + return new(fastReflection_QueryClassByQueryStringResponse) +} +func (x fastReflection_QueryClassByQueryStringResponse_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QueryClassByQueryStringResponse +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QueryClassByQueryStringResponse) Descriptor() protoreflect.MessageDescriptor { + return md_QueryClassByQueryStringResponse +} + +// Type returns the message type, which encapsulates both Go and protobuf +// type information. If the Go type information is not needed, +// it is recommended that the message descriptor be used instead. +func (x *fastReflection_QueryClassByQueryStringResponse) Type() protoreflect.MessageType { + return _fastReflection_QueryClassByQueryStringResponse_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QueryClassByQueryStringResponse) New() protoreflect.Message { + return new(fastReflection_QueryClassByQueryStringResponse) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QueryClassByQueryStringResponse) Interface() protoreflect.ProtoMessage { + return (*QueryClassByQueryStringResponse)(x) +} + +// Range iterates over every populated field in an undefined order, +// calling f for each field descriptor and value encountered. +// Range returns immediately if f returns false. +// While iterating, mutating operations may only be performed +// on the current field descriptor. +func (x *fastReflection_QueryClassByQueryStringResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Class != nil { + value := protoreflect.ValueOfMessage(x.Class.ProtoReflect()) + if !f(fd_QueryClassByQueryStringResponse_class, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_QueryClassByQueryStringResponse) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QueryClassByQueryStringResponse.class": + return x.Class != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QueryClassByQueryStringResponse")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QueryClassByQueryStringResponse does not contain field %s", fd.FullName())) + } +} + +// Clear clears the field such that a subsequent Has call reports false. +// +// Clearing an extension field clears both the extension type and value +// associated with the given field number. +// +// Clear is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_QueryClassByQueryStringResponse) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QueryClassByQueryStringResponse.class": + x.Class = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QueryClassByQueryStringResponse")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QueryClassByQueryStringResponse does not contain field %s", fd.FullName())) + } +} + +// Get retrieves the value for a field. +// +// For unpopulated scalars, it returns the default value, where +// the default value of a bytes scalar is guaranteed to be a copy. +// For unpopulated composite types, it returns an empty, read-only view +// of the value; to obtain a mutable reference, use Mutable. +func (x *fastReflection_QueryClassByQueryStringResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "cosmos.nft.v1beta1.QueryClassByQueryStringResponse.class": + value := x.Class + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QueryClassByQueryStringResponse")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QueryClassByQueryStringResponse does not contain field %s", descriptor.FullName())) + } +} + +// Set stores the value for a field. +// +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType. +// When setting a composite type, it is unspecified whether the stored value +// aliases the source's memory in any way. If the composite value is an +// empty, read-only value, then it panics. +// +// Set is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_QueryClassByQueryStringResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QueryClassByQueryStringResponse.class": + x.Class = value.Message().Interface().(*Class) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QueryClassByQueryStringResponse")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QueryClassByQueryStringResponse does not contain field %s", fd.FullName())) + } +} + +// Mutable returns a mutable reference to a composite type. +// +// If the field is unpopulated, it may allocate a composite value. +// For a field belonging to a oneof, it implicitly clears any other field +// that may be currently set within the same oneof. +// For extension fields, it implicitly stores the provided ExtensionType +// if not already stored. +// It panics if the field does not contain a composite type. +// +// Mutable is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_QueryClassByQueryStringResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QueryClassByQueryStringResponse.class": + if x.Class == nil { + x.Class = new(Class) + } + return protoreflect.ValueOfMessage(x.Class.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QueryClassByQueryStringResponse")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QueryClassByQueryStringResponse does not contain field %s", fd.FullName())) + } +} + +// NewField returns a new value that is assignable to the field +// for the given descriptor. For scalars, this returns the default value. +// For lists, maps, and messages, this returns a new, empty, mutable value. +func (x *fastReflection_QueryClassByQueryStringResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.nft.v1beta1.QueryClassByQueryStringResponse.class": + m := new(Class) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.nft.v1beta1.QueryClassByQueryStringResponse")) + } + panic(fmt.Errorf("message cosmos.nft.v1beta1.QueryClassByQueryStringResponse does not contain field %s", fd.FullName())) + } +} + +// WhichOneof reports which field within the oneof is populated, +// returning nil if none are populated. +// It panics if the oneof descriptor does not belong to this message. +func (x *fastReflection_QueryClassByQueryStringResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in cosmos.nft.v1beta1.QueryClassByQueryStringResponse", d.FullName())) + } + panic("unreachable") +} + +// GetUnknown retrieves the entire list of unknown fields. +// The caller may only mutate the contents of the RawFields +// if the mutated bytes are stored back into the message with SetUnknown. +func (x *fastReflection_QueryClassByQueryStringResponse) GetUnknown() protoreflect.RawFields { + return x.unknownFields +} + +// SetUnknown stores an entire list of unknown fields. +// The raw fields must be syntactically valid according to the wire format. +// An implementation may panic if this is not the case. +// Once stored, the caller must not mutate the content of the RawFields. +// An empty RawFields may be passed to clear the fields. +// +// SetUnknown is a mutating operation and unsafe for concurrent use. +func (x *fastReflection_QueryClassByQueryStringResponse) SetUnknown(fields protoreflect.RawFields) { + x.unknownFields = fields +} + +// IsValid reports whether the message is valid. +// +// An invalid message is an empty, read-only value. +// +// An invalid message often corresponds to a nil pointer of the concrete +// message type, but the details are implementation dependent. +// Validity is not part of the protobuf data model, and may not +// be preserved in marshaling or other operations. +func (x *fastReflection_QueryClassByQueryStringResponse) IsValid() bool { + return x != nil +} + +// ProtoMethods returns optional fastReflectionFeature-path implementations of various operations. +// This method may return nil. +// +// The returned methods type is identical to +// "google.golang.org/protobuf/runtime/protoiface".Methods. +// Consult the protoiface package documentation for details. +func (x *fastReflection_QueryClassByQueryStringResponse) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QueryClassByQueryStringResponse) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + if x.Class != nil { + l = options.Size(x.Class) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*QueryClassByQueryStringResponse) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if x.Class != nil { + encoded, err := options.Marshal(x.Class) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0xa + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*QueryClassByQueryStringResponse) + if x == nil { + return protoiface.UnmarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Flags: input.Flags, + }, nil + } + options := runtime.UnmarshalInputToOptions(input) + _ = options + dAtA := input.Buf + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, 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 protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryClassByQueryStringResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryClassByQueryStringResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Class", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.Class == nil { + x.Class = &Class{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Class); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + var ( md_QueryClassesRequest protoreflect.MessageDescriptor fd_QueryClassesRequest_pagination protoreflect.FieldDescriptor @@ -5560,7 +9950,7 @@ func (x *QueryClassesRequest) ProtoReflect() protoreflect.Message { } func (x *QueryClassesRequest) slowProtoReflect() protoreflect.Message { - mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[12] + mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[22] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6048,7 +10438,7 @@ func (x *QueryClassesResponse) ProtoReflect() protoreflect.Message { } func (x *QueryClassesResponse) slowProtoReflect() protoreflect.Message { - mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[13] + mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[23] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6607,6 +10997,52 @@ func (x *QueryBalanceRequest) GetOwner() string { return "" } +// QueryBalanceByQueryStringRequest is the request type for the Query/Balance RPC method +type QueryBalanceByQueryStringRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // class_id associated with the nft + ClassId string `protobuf:"bytes,1,opt,name=class_id,json=classId,proto3" json:"class_id,omitempty"` + // owner is the owner address of the nft + Owner string `protobuf:"bytes,2,opt,name=owner,proto3" json:"owner,omitempty"` +} + +func (x *QueryBalanceByQueryStringRequest) Reset() { + *x = QueryBalanceByQueryStringRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QueryBalanceByQueryStringRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryBalanceByQueryStringRequest) ProtoMessage() {} + +// Deprecated: Use QueryBalanceByQueryStringRequest.ProtoReflect.Descriptor instead. +func (*QueryBalanceByQueryStringRequest) Descriptor() ([]byte, []int) { + return file_cosmos_nft_v1beta1_query_proto_rawDescGZIP(), []int{1} +} + +func (x *QueryBalanceByQueryStringRequest) GetClassId() string { + if x != nil { + return x.ClassId + } + return "" +} + +func (x *QueryBalanceByQueryStringRequest) GetOwner() string { + if x != nil { + return x.Owner + } + return "" +} + // QueryBalanceResponse is the response type for the Query/Balance RPC method type QueryBalanceResponse struct { state protoimpl.MessageState @@ -6620,7 +11056,7 @@ type QueryBalanceResponse struct { func (x *QueryBalanceResponse) Reset() { *x = QueryBalanceResponse{} if protoimpl.UnsafeEnabled { - mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[1] + mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[2] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6634,7 +11070,7 @@ func (*QueryBalanceResponse) ProtoMessage() {} // Deprecated: Use QueryBalanceResponse.ProtoReflect.Descriptor instead. func (*QueryBalanceResponse) Descriptor() ([]byte, []int) { - return file_cosmos_nft_v1beta1_query_proto_rawDescGZIP(), []int{1} + return file_cosmos_nft_v1beta1_query_proto_rawDescGZIP(), []int{2} } func (x *QueryBalanceResponse) GetAmount() uint64 { @@ -6644,6 +11080,43 @@ func (x *QueryBalanceResponse) GetAmount() uint64 { return 0 } +// QueryBalanceByQueryStringResponse is the response type for the Query/Balance RPC method +type QueryBalanceByQueryStringResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // amount is the number of all NFTs of a given class owned by the owner + Amount uint64 `protobuf:"varint,1,opt,name=amount,proto3" json:"amount,omitempty"` +} + +func (x *QueryBalanceByQueryStringResponse) Reset() { + *x = QueryBalanceByQueryStringResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QueryBalanceByQueryStringResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryBalanceByQueryStringResponse) ProtoMessage() {} + +// Deprecated: Use QueryBalanceByQueryStringResponse.ProtoReflect.Descriptor instead. +func (*QueryBalanceByQueryStringResponse) Descriptor() ([]byte, []int) { + return file_cosmos_nft_v1beta1_query_proto_rawDescGZIP(), []int{3} +} + +func (x *QueryBalanceByQueryStringResponse) GetAmount() uint64 { + if x != nil { + return x.Amount + } + return 0 +} + // QueryOwnerRequest is the request type for the Query/Owner RPC method type QueryOwnerRequest struct { state protoimpl.MessageState @@ -6659,7 +11132,7 @@ type QueryOwnerRequest struct { func (x *QueryOwnerRequest) Reset() { *x = QueryOwnerRequest{} if protoimpl.UnsafeEnabled { - mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[2] + mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[4] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6673,7 +11146,7 @@ func (*QueryOwnerRequest) ProtoMessage() {} // Deprecated: Use QueryOwnerRequest.ProtoReflect.Descriptor instead. func (*QueryOwnerRequest) Descriptor() ([]byte, []int) { - return file_cosmos_nft_v1beta1_query_proto_rawDescGZIP(), []int{2} + return file_cosmos_nft_v1beta1_query_proto_rawDescGZIP(), []int{4} } func (x *QueryOwnerRequest) GetClassId() string { @@ -6690,6 +11163,52 @@ func (x *QueryOwnerRequest) GetId() string { return "" } +// QueryOwnerByQueryStringRequest is the request type for the Query/Owner RPC method +type QueryOwnerByQueryStringRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // class_id associated with the nft + ClassId string `protobuf:"bytes,1,opt,name=class_id,json=classId,proto3" json:"class_id,omitempty"` + // id is a unique identifier of the NFT + Id string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"` +} + +func (x *QueryOwnerByQueryStringRequest) Reset() { + *x = QueryOwnerByQueryStringRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QueryOwnerByQueryStringRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryOwnerByQueryStringRequest) ProtoMessage() {} + +// Deprecated: Use QueryOwnerByQueryStringRequest.ProtoReflect.Descriptor instead. +func (*QueryOwnerByQueryStringRequest) Descriptor() ([]byte, []int) { + return file_cosmos_nft_v1beta1_query_proto_rawDescGZIP(), []int{5} +} + +func (x *QueryOwnerByQueryStringRequest) GetClassId() string { + if x != nil { + return x.ClassId + } + return "" +} + +func (x *QueryOwnerByQueryStringRequest) GetId() string { + if x != nil { + return x.Id + } + return "" +} + // QueryOwnerResponse is the response type for the Query/Owner RPC method type QueryOwnerResponse struct { state protoimpl.MessageState @@ -6703,7 +11222,7 @@ type QueryOwnerResponse struct { func (x *QueryOwnerResponse) Reset() { *x = QueryOwnerResponse{} if protoimpl.UnsafeEnabled { - mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[3] + mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[6] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6717,7 +11236,7 @@ func (*QueryOwnerResponse) ProtoMessage() {} // Deprecated: Use QueryOwnerResponse.ProtoReflect.Descriptor instead. func (*QueryOwnerResponse) Descriptor() ([]byte, []int) { - return file_cosmos_nft_v1beta1_query_proto_rawDescGZIP(), []int{3} + return file_cosmos_nft_v1beta1_query_proto_rawDescGZIP(), []int{6} } func (x *QueryOwnerResponse) GetOwner() string { @@ -6727,6 +11246,43 @@ func (x *QueryOwnerResponse) GetOwner() string { return "" } +// QueryOwnerByQueryStringResponse is the response type for the Query/Owner RPC method +type QueryOwnerByQueryStringResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // owner is the owner address of the nft + Owner string `protobuf:"bytes,1,opt,name=owner,proto3" json:"owner,omitempty"` +} + +func (x *QueryOwnerByQueryStringResponse) Reset() { + *x = QueryOwnerByQueryStringResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QueryOwnerByQueryStringResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryOwnerByQueryStringResponse) ProtoMessage() {} + +// Deprecated: Use QueryOwnerByQueryStringResponse.ProtoReflect.Descriptor instead. +func (*QueryOwnerByQueryStringResponse) Descriptor() ([]byte, []int) { + return file_cosmos_nft_v1beta1_query_proto_rawDescGZIP(), []int{7} +} + +func (x *QueryOwnerByQueryStringResponse) GetOwner() string { + if x != nil { + return x.Owner + } + return "" +} + // QuerySupplyRequest is the request type for the Query/Supply RPC method type QuerySupplyRequest struct { state protoimpl.MessageState @@ -6740,7 +11296,7 @@ type QuerySupplyRequest struct { func (x *QuerySupplyRequest) Reset() { *x = QuerySupplyRequest{} if protoimpl.UnsafeEnabled { - mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[4] + mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[8] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6754,7 +11310,7 @@ func (*QuerySupplyRequest) ProtoMessage() {} // Deprecated: Use QuerySupplyRequest.ProtoReflect.Descriptor instead. func (*QuerySupplyRequest) Descriptor() ([]byte, []int) { - return file_cosmos_nft_v1beta1_query_proto_rawDescGZIP(), []int{4} + return file_cosmos_nft_v1beta1_query_proto_rawDescGZIP(), []int{8} } func (x *QuerySupplyRequest) GetClassId() string { @@ -6764,6 +11320,43 @@ func (x *QuerySupplyRequest) GetClassId() string { return "" } +// QuerySupplyByQueryStringRequest is the request type for the Query/Supply RPC method +type QuerySupplyByQueryStringRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // class_id associated with the nft + ClassId string `protobuf:"bytes,1,opt,name=class_id,json=classId,proto3" json:"class_id,omitempty"` +} + +func (x *QuerySupplyByQueryStringRequest) Reset() { + *x = QuerySupplyByQueryStringRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QuerySupplyByQueryStringRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QuerySupplyByQueryStringRequest) ProtoMessage() {} + +// Deprecated: Use QuerySupplyByQueryStringRequest.ProtoReflect.Descriptor instead. +func (*QuerySupplyByQueryStringRequest) Descriptor() ([]byte, []int) { + return file_cosmos_nft_v1beta1_query_proto_rawDescGZIP(), []int{9} +} + +func (x *QuerySupplyByQueryStringRequest) GetClassId() string { + if x != nil { + return x.ClassId + } + return "" +} + // QuerySupplyResponse is the response type for the Query/Supply RPC method type QuerySupplyResponse struct { state protoimpl.MessageState @@ -6777,7 +11370,7 @@ type QuerySupplyResponse struct { func (x *QuerySupplyResponse) Reset() { *x = QuerySupplyResponse{} if protoimpl.UnsafeEnabled { - mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[5] + mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[10] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6791,7 +11384,7 @@ func (*QuerySupplyResponse) ProtoMessage() {} // Deprecated: Use QuerySupplyResponse.ProtoReflect.Descriptor instead. func (*QuerySupplyResponse) Descriptor() ([]byte, []int) { - return file_cosmos_nft_v1beta1_query_proto_rawDescGZIP(), []int{5} + return file_cosmos_nft_v1beta1_query_proto_rawDescGZIP(), []int{10} } func (x *QuerySupplyResponse) GetAmount() uint64 { @@ -6801,6 +11394,43 @@ func (x *QuerySupplyResponse) GetAmount() uint64 { return 0 } +// QuerySupplyByQueryStringResponse is the response type for the Query/Supply RPC method +type QuerySupplyByQueryStringResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // amount is the number of all NFTs from the given class + Amount uint64 `protobuf:"varint,1,opt,name=amount,proto3" json:"amount,omitempty"` +} + +func (x *QuerySupplyByQueryStringResponse) Reset() { + *x = QuerySupplyByQueryStringResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QuerySupplyByQueryStringResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QuerySupplyByQueryStringResponse) ProtoMessage() {} + +// Deprecated: Use QuerySupplyByQueryStringResponse.ProtoReflect.Descriptor instead. +func (*QuerySupplyByQueryStringResponse) Descriptor() ([]byte, []int) { + return file_cosmos_nft_v1beta1_query_proto_rawDescGZIP(), []int{11} +} + +func (x *QuerySupplyByQueryStringResponse) GetAmount() uint64 { + if x != nil { + return x.Amount + } + return 0 +} + // QueryNFTstRequest is the request type for the Query/NFTs RPC method type QueryNFTsRequest struct { state protoimpl.MessageState @@ -6818,7 +11448,7 @@ type QueryNFTsRequest struct { func (x *QueryNFTsRequest) Reset() { *x = QueryNFTsRequest{} if protoimpl.UnsafeEnabled { - mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[6] + mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[12] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6832,7 +11462,7 @@ func (*QueryNFTsRequest) ProtoMessage() {} // Deprecated: Use QueryNFTsRequest.ProtoReflect.Descriptor instead. func (*QueryNFTsRequest) Descriptor() ([]byte, []int) { - return file_cosmos_nft_v1beta1_query_proto_rawDescGZIP(), []int{6} + return file_cosmos_nft_v1beta1_query_proto_rawDescGZIP(), []int{12} } func (x *QueryNFTsRequest) GetClassId() string { @@ -6871,7 +11501,7 @@ type QueryNFTsResponse struct { func (x *QueryNFTsResponse) Reset() { *x = QueryNFTsResponse{} if protoimpl.UnsafeEnabled { - mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[7] + mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[13] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6885,7 +11515,7 @@ func (*QueryNFTsResponse) ProtoMessage() {} // Deprecated: Use QueryNFTsResponse.ProtoReflect.Descriptor instead. func (*QueryNFTsResponse) Descriptor() ([]byte, []int) { - return file_cosmos_nft_v1beta1_query_proto_rawDescGZIP(), []int{7} + return file_cosmos_nft_v1beta1_query_proto_rawDescGZIP(), []int{13} } func (x *QueryNFTsResponse) GetNfts() []*NFT { @@ -6917,7 +11547,7 @@ type QueryNFTRequest struct { func (x *QueryNFTRequest) Reset() { *x = QueryNFTRequest{} if protoimpl.UnsafeEnabled { - mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[8] + mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[14] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6931,7 +11561,7 @@ func (*QueryNFTRequest) ProtoMessage() {} // Deprecated: Use QueryNFTRequest.ProtoReflect.Descriptor instead. func (*QueryNFTRequest) Descriptor() ([]byte, []int) { - return file_cosmos_nft_v1beta1_query_proto_rawDescGZIP(), []int{8} + return file_cosmos_nft_v1beta1_query_proto_rawDescGZIP(), []int{14} } func (x *QueryNFTRequest) GetClassId() string { @@ -6948,6 +11578,52 @@ func (x *QueryNFTRequest) GetId() string { return "" } +// QueryNFTByQueryStringRequest is the request type for the Query/NFT RPC method +type QueryNFTByQueryStringRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // class_id associated with the nft + ClassId string `protobuf:"bytes,1,opt,name=class_id,json=classId,proto3" json:"class_id,omitempty"` + // id is a unique identifier of the NFT + Id string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"` +} + +func (x *QueryNFTByQueryStringRequest) Reset() { + *x = QueryNFTByQueryStringRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[15] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QueryNFTByQueryStringRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryNFTByQueryStringRequest) ProtoMessage() {} + +// Deprecated: Use QueryNFTByQueryStringRequest.ProtoReflect.Descriptor instead. +func (*QueryNFTByQueryStringRequest) Descriptor() ([]byte, []int) { + return file_cosmos_nft_v1beta1_query_proto_rawDescGZIP(), []int{15} +} + +func (x *QueryNFTByQueryStringRequest) GetClassId() string { + if x != nil { + return x.ClassId + } + return "" +} + +func (x *QueryNFTByQueryStringRequest) GetId() string { + if x != nil { + return x.Id + } + return "" +} + // QueryNFTResponse is the response type for the Query/NFT RPC method type QueryNFTResponse struct { state protoimpl.MessageState @@ -6961,7 +11637,7 @@ type QueryNFTResponse struct { func (x *QueryNFTResponse) Reset() { *x = QueryNFTResponse{} if protoimpl.UnsafeEnabled { - mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[9] + mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[16] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6975,7 +11651,7 @@ func (*QueryNFTResponse) ProtoMessage() {} // Deprecated: Use QueryNFTResponse.ProtoReflect.Descriptor instead. func (*QueryNFTResponse) Descriptor() ([]byte, []int) { - return file_cosmos_nft_v1beta1_query_proto_rawDescGZIP(), []int{9} + return file_cosmos_nft_v1beta1_query_proto_rawDescGZIP(), []int{16} } func (x *QueryNFTResponse) GetNft() *NFT { @@ -6985,6 +11661,43 @@ func (x *QueryNFTResponse) GetNft() *NFT { return nil } +// QueryNFTByQueryStringResponse is the response type for the Query/NFT RPC method +type QueryNFTByQueryStringResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // owner is the owner address of the nft + Nft *NFT `protobuf:"bytes,1,opt,name=nft,proto3" json:"nft,omitempty"` +} + +func (x *QueryNFTByQueryStringResponse) Reset() { + *x = QueryNFTByQueryStringResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[17] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QueryNFTByQueryStringResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryNFTByQueryStringResponse) ProtoMessage() {} + +// Deprecated: Use QueryNFTByQueryStringResponse.ProtoReflect.Descriptor instead. +func (*QueryNFTByQueryStringResponse) Descriptor() ([]byte, []int) { + return file_cosmos_nft_v1beta1_query_proto_rawDescGZIP(), []int{17} +} + +func (x *QueryNFTByQueryStringResponse) GetNft() *NFT { + if x != nil { + return x.Nft + } + return nil +} + // QueryClassRequest is the request type for the Query/Class RPC method type QueryClassRequest struct { state protoimpl.MessageState @@ -6998,7 +11711,7 @@ type QueryClassRequest struct { func (x *QueryClassRequest) Reset() { *x = QueryClassRequest{} if protoimpl.UnsafeEnabled { - mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[10] + mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[18] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7012,7 +11725,7 @@ func (*QueryClassRequest) ProtoMessage() {} // Deprecated: Use QueryClassRequest.ProtoReflect.Descriptor instead. func (*QueryClassRequest) Descriptor() ([]byte, []int) { - return file_cosmos_nft_v1beta1_query_proto_rawDescGZIP(), []int{10} + return file_cosmos_nft_v1beta1_query_proto_rawDescGZIP(), []int{18} } func (x *QueryClassRequest) GetClassId() string { @@ -7022,6 +11735,43 @@ func (x *QueryClassRequest) GetClassId() string { return "" } +// QueryClassByQueryStringRequest is the request type for the Query/Class RPC method +type QueryClassByQueryStringRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // class_id associated with the nft + ClassId string `protobuf:"bytes,1,opt,name=class_id,json=classId,proto3" json:"class_id,omitempty"` +} + +func (x *QueryClassByQueryStringRequest) Reset() { + *x = QueryClassByQueryStringRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[19] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QueryClassByQueryStringRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryClassByQueryStringRequest) ProtoMessage() {} + +// Deprecated: Use QueryClassByQueryStringRequest.ProtoReflect.Descriptor instead. +func (*QueryClassByQueryStringRequest) Descriptor() ([]byte, []int) { + return file_cosmos_nft_v1beta1_query_proto_rawDescGZIP(), []int{19} +} + +func (x *QueryClassByQueryStringRequest) GetClassId() string { + if x != nil { + return x.ClassId + } + return "" +} + // QueryClassResponse is the response type for the Query/Class RPC method type QueryClassResponse struct { state protoimpl.MessageState @@ -7035,7 +11785,7 @@ type QueryClassResponse struct { func (x *QueryClassResponse) Reset() { *x = QueryClassResponse{} if protoimpl.UnsafeEnabled { - mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[11] + mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[20] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7049,7 +11799,7 @@ func (*QueryClassResponse) ProtoMessage() {} // Deprecated: Use QueryClassResponse.ProtoReflect.Descriptor instead. func (*QueryClassResponse) Descriptor() ([]byte, []int) { - return file_cosmos_nft_v1beta1_query_proto_rawDescGZIP(), []int{11} + return file_cosmos_nft_v1beta1_query_proto_rawDescGZIP(), []int{20} } func (x *QueryClassResponse) GetClass() *Class { @@ -7059,6 +11809,43 @@ func (x *QueryClassResponse) GetClass() *Class { return nil } +// QueryClassByQueryStringResponse is the response type for the Query/Class RPC method +type QueryClassByQueryStringResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // class defines the class of the nft type. + Class *Class `protobuf:"bytes,1,opt,name=class,proto3" json:"class,omitempty"` +} + +func (x *QueryClassByQueryStringResponse) Reset() { + *x = QueryClassByQueryStringResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[21] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QueryClassByQueryStringResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryClassByQueryStringResponse) ProtoMessage() {} + +// Deprecated: Use QueryClassByQueryStringResponse.ProtoReflect.Descriptor instead. +func (*QueryClassByQueryStringResponse) Descriptor() ([]byte, []int) { + return file_cosmos_nft_v1beta1_query_proto_rawDescGZIP(), []int{21} +} + +func (x *QueryClassByQueryStringResponse) GetClass() *Class { + if x != nil { + return x.Class + } + return nil +} + // QueryClassesRequest is the request type for the Query/Classes RPC method type QueryClassesRequest struct { state protoimpl.MessageState @@ -7072,7 +11859,7 @@ type QueryClassesRequest struct { func (x *QueryClassesRequest) Reset() { *x = QueryClassesRequest{} if protoimpl.UnsafeEnabled { - mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[12] + mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[22] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7086,7 +11873,7 @@ func (*QueryClassesRequest) ProtoMessage() {} // Deprecated: Use QueryClassesRequest.ProtoReflect.Descriptor instead. func (*QueryClassesRequest) Descriptor() ([]byte, []int) { - return file_cosmos_nft_v1beta1_query_proto_rawDescGZIP(), []int{12} + return file_cosmos_nft_v1beta1_query_proto_rawDescGZIP(), []int{22} } func (x *QueryClassesRequest) GetPagination() *v1beta1.PageRequest { @@ -7111,7 +11898,7 @@ type QueryClassesResponse struct { func (x *QueryClassesResponse) Reset() { *x = QueryClassesResponse{} if protoimpl.UnsafeEnabled { - mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[13] + mi := &file_cosmos_nft_v1beta1_query_proto_msgTypes[23] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7125,7 +11912,7 @@ func (*QueryClassesResponse) ProtoMessage() {} // Deprecated: Use QueryClassesResponse.ProtoReflect.Descriptor instead. func (*QueryClassesResponse) Descriptor() ([]byte, []int) { - return file_cosmos_nft_v1beta1_query_proto_rawDescGZIP(), []int{13} + return file_cosmos_nft_v1beta1_query_proto_rawDescGZIP(), []int{23} } func (x *QueryClassesResponse) GetClasses() []*Class { @@ -7159,143 +11946,238 @@ var file_cosmos_nft_v1beta1_query_proto_rawDesc = []byte{ 0x65, 0x73, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x49, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x6f, - 0x77, 0x6e, 0x65, 0x72, 0x22, 0x2e, 0x0a, 0x14, 0x51, 0x75, 0x65, 0x72, 0x79, 0x42, 0x61, 0x6c, - 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x16, 0x0a, 0x06, - 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x61, 0x6d, - 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3e, 0x0a, 0x11, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4f, 0x77, 0x6e, - 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x63, 0x6c, 0x61, - 0x73, 0x73, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x6c, 0x61, - 0x73, 0x73, 0x49, 0x64, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x02, 0x69, 0x64, 0x22, 0x2a, 0x0a, 0x12, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4f, 0x77, 0x6e, - 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x6f, 0x77, - 0x6e, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x6f, 0x77, 0x6e, 0x65, 0x72, - 0x22, 0x2f, 0x0a, 0x12, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x5f, - 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x49, - 0x64, 0x22, 0x2d, 0x0a, 0x13, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x75, 0x70, 0x70, 0x6c, 0x79, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, - 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, - 0x22, 0x8b, 0x01, 0x0a, 0x10, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4e, 0x46, 0x54, 0x73, 0x52, 0x65, + 0x77, 0x6e, 0x65, 0x72, 0x22, 0x53, 0x0a, 0x20, 0x51, 0x75, 0x65, 0x72, 0x79, 0x42, 0x61, 0x6c, + 0x61, 0x6e, 0x63, 0x65, 0x42, 0x79, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x74, 0x72, 0x69, 0x6e, + 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x63, 0x6c, 0x61, 0x73, + 0x73, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x6c, 0x61, 0x73, + 0x73, 0x49, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x05, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x22, 0x2e, 0x0a, 0x14, 0x51, 0x75, 0x65, + 0x72, 0x79, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x04, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3b, 0x0a, 0x21, 0x51, 0x75, 0x65, + 0x72, 0x79, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x42, 0x79, 0x51, 0x75, 0x65, 0x72, 0x79, + 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x16, + 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, + 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3e, 0x0a, 0x11, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4f, + 0x77, 0x6e, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x63, + 0x6c, 0x61, 0x73, 0x73, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, + 0x6c, 0x61, 0x73, 0x73, 0x49, 0x64, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x22, 0x4b, 0x0a, 0x1e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4f, + 0x77, 0x6e, 0x65, 0x72, 0x42, 0x79, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x74, 0x72, 0x69, 0x6e, + 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x63, 0x6c, 0x61, 0x73, + 0x73, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x6c, 0x61, 0x73, + 0x73, 0x49, 0x64, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x02, 0x69, 0x64, 0x22, 0x2a, 0x0a, 0x12, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4f, 0x77, 0x6e, 0x65, + 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x6f, 0x77, 0x6e, + 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x22, + 0x37, 0x0a, 0x1f, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4f, 0x77, 0x6e, 0x65, 0x72, 0x42, 0x79, 0x51, + 0x75, 0x65, 0x72, 0x79, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x05, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x22, 0x2f, 0x0a, 0x12, 0x51, 0x75, 0x65, 0x72, + 0x79, 0x53, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x19, + 0x0a, 0x08, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x07, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x49, 0x64, 0x22, 0x3c, 0x0a, 0x1f, 0x51, 0x75, 0x65, + 0x72, 0x79, 0x53, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x42, 0x79, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, + 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x19, 0x0a, 0x08, + 0x63, 0x6c, 0x61, 0x73, 0x73, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, + 0x63, 0x6c, 0x61, 0x73, 0x73, 0x49, 0x64, 0x22, 0x2d, 0x0a, 0x13, 0x51, 0x75, 0x65, 0x72, 0x79, + 0x53, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x16, + 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, + 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x3a, 0x0a, 0x20, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, + 0x75, 0x70, 0x70, 0x6c, 0x79, 0x42, 0x79, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x74, 0x72, 0x69, + 0x6e, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d, + 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, + 0x6e, 0x74, 0x22, 0x8b, 0x01, 0x0a, 0x10, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4e, 0x46, 0x54, 0x73, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x63, 0x6c, 0x61, 0x73, 0x73, + 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x6c, 0x61, 0x73, 0x73, + 0x49, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x05, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x12, 0x46, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, + 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x63, + 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, + 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x22, 0x89, 0x01, 0x0a, 0x11, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4e, 0x46, 0x54, 0x73, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2b, 0x0a, 0x04, 0x6e, 0x66, 0x74, 0x73, 0x18, 0x01, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x6e, 0x66, + 0x74, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x4e, 0x46, 0x54, 0x52, 0x04, 0x6e, + 0x66, 0x74, 0x73, 0x12, 0x47, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, + 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, + 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3c, 0x0a, 0x0f, + 0x51, 0x75, 0x65, 0x72, 0x79, 0x4e, 0x46, 0x54, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, + 0x19, 0x0a, 0x08, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x07, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x49, 0x64, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x22, 0x49, 0x0a, 0x1c, 0x51, 0x75, + 0x65, 0x72, 0x79, 0x4e, 0x46, 0x54, 0x42, 0x79, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x74, 0x72, + 0x69, 0x6e, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x63, 0x6c, + 0x61, 0x73, 0x73, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x6c, + 0x61, 0x73, 0x73, 0x49, 0x64, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x02, 0x69, 0x64, 0x22, 0x3d, 0x0a, 0x10, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4e, 0x46, + 0x54, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x29, 0x0a, 0x03, 0x6e, 0x66, 0x74, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, + 0x6e, 0x66, 0x74, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x4e, 0x46, 0x54, 0x52, + 0x03, 0x6e, 0x66, 0x74, 0x22, 0x4a, 0x0a, 0x1d, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4e, 0x46, 0x54, + 0x42, 0x79, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x29, 0x0a, 0x03, 0x6e, 0x66, 0x74, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x6e, 0x66, 0x74, 0x2e, + 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x4e, 0x46, 0x54, 0x52, 0x03, 0x6e, 0x66, 0x74, + 0x22, 0x2e, 0x0a, 0x11, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x49, 0x64, - 0x12, 0x14, 0x0a, 0x05, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x05, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x12, 0x46, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x63, 0x6f, 0x73, - 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, - 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x89, - 0x01, 0x0a, 0x11, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4e, 0x46, 0x54, 0x73, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2b, 0x0a, 0x04, 0x6e, 0x66, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, - 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x6e, 0x66, 0x74, 0x2e, - 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x4e, 0x46, 0x54, 0x52, 0x04, 0x6e, 0x66, 0x74, - 0x73, 0x12, 0x47, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, - 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, - 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, - 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x0a, - 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3c, 0x0a, 0x0f, 0x51, 0x75, - 0x65, 0x72, 0x79, 0x4e, 0x46, 0x54, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x19, 0x0a, - 0x08, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x07, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x49, 0x64, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x22, 0x3d, 0x0a, 0x10, 0x51, 0x75, 0x65, 0x72, - 0x79, 0x4e, 0x46, 0x54, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x29, 0x0a, 0x03, - 0x6e, 0x66, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x63, 0x6f, 0x73, 0x6d, - 0x6f, 0x73, 0x2e, 0x6e, 0x66, 0x74, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x4e, - 0x46, 0x54, 0x52, 0x03, 0x6e, 0x66, 0x74, 0x22, 0x2e, 0x0a, 0x11, 0x51, 0x75, 0x65, 0x72, 0x79, - 0x43, 0x6c, 0x61, 0x73, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x19, 0x0a, 0x08, - 0x63, 0x6c, 0x61, 0x73, 0x73, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, - 0x63, 0x6c, 0x61, 0x73, 0x73, 0x49, 0x64, 0x22, 0x45, 0x0a, 0x12, 0x51, 0x75, 0x65, 0x72, 0x79, - 0x43, 0x6c, 0x61, 0x73, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2f, 0x0a, - 0x05, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x63, - 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x6e, 0x66, 0x74, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, - 0x31, 0x2e, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x52, 0x05, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x22, 0x5d, - 0x0a, 0x13, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x65, 0x73, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x46, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x63, 0x6f, 0x73, 0x6d, - 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, - 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, - 0x74, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x94, 0x01, - 0x0a, 0x14, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x65, 0x73, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x33, 0x0a, 0x07, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x65, - 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, - 0x2e, 0x6e, 0x66, 0x74, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x43, 0x6c, 0x61, - 0x73, 0x73, 0x52, 0x07, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x65, 0x73, 0x12, 0x47, 0x0a, 0x0a, 0x70, - 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x27, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, - 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x32, 0xbe, 0x07, 0x0a, 0x05, 0x51, 0x75, 0x65, 0x72, 0x79, 0x12, 0x94, - 0x01, 0x0a, 0x07, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x27, 0x2e, 0x63, 0x6f, 0x73, - 0x6d, 0x6f, 0x73, 0x2e, 0x6e, 0x66, 0x74, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, - 0x51, 0x75, 0x65, 0x72, 0x79, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x6e, 0x66, 0x74, - 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x42, 0x61, - 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x36, 0x82, - 0xd3, 0xe4, 0x93, 0x02, 0x30, 0x12, 0x2e, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x6e, - 0x66, 0x74, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x62, 0x61, 0x6c, 0x61, 0x6e, - 0x63, 0x65, 0x2f, 0x7b, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x7d, 0x2f, 0x7b, 0x63, 0x6c, 0x61, 0x73, - 0x73, 0x5f, 0x69, 0x64, 0x7d, 0x12, 0x89, 0x01, 0x0a, 0x05, 0x4f, 0x77, 0x6e, 0x65, 0x72, 0x12, - 0x25, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x6e, 0x66, 0x74, 0x2e, 0x76, 0x31, 0x62, - 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4f, 0x77, 0x6e, 0x65, 0x72, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, - 0x6e, 0x66, 0x74, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, - 0x79, 0x4f, 0x77, 0x6e, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x31, - 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x2b, 0x12, 0x29, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, - 0x6e, 0x66, 0x74, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x6f, 0x77, 0x6e, 0x65, - 0x72, 0x2f, 0x7b, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x5f, 0x69, 0x64, 0x7d, 0x2f, 0x7b, 0x69, 0x64, - 0x7d, 0x12, 0x88, 0x01, 0x0a, 0x06, 0x53, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x12, 0x26, 0x2e, 0x63, - 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x6e, 0x66, 0x74, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, - 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x6e, 0x66, - 0x74, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, - 0x75, 0x70, 0x70, 0x6c, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2d, 0x82, - 0xd3, 0xe4, 0x93, 0x02, 0x27, 0x12, 0x25, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x6e, - 0x66, 0x74, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x73, 0x75, 0x70, 0x70, 0x6c, - 0x79, 0x2f, 0x7b, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x5f, 0x69, 0x64, 0x7d, 0x12, 0x75, 0x0a, 0x04, - 0x4e, 0x46, 0x54, 0x73, 0x12, 0x24, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x6e, 0x66, - 0x74, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4e, - 0x46, 0x54, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x25, 0x2e, 0x63, 0x6f, 0x73, - 0x6d, 0x6f, 0x73, 0x2e, 0x6e, 0x66, 0x74, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, - 0x51, 0x75, 0x65, 0x72, 0x79, 0x4e, 0x46, 0x54, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x22, 0x20, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1a, 0x12, 0x18, 0x2f, 0x63, 0x6f, 0x73, 0x6d, - 0x6f, 0x73, 0x2f, 0x6e, 0x66, 0x74, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x6e, - 0x66, 0x74, 0x73, 0x12, 0x82, 0x01, 0x0a, 0x03, 0x4e, 0x46, 0x54, 0x12, 0x23, 0x2e, 0x63, 0x6f, - 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x6e, 0x66, 0x74, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, - 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4e, 0x46, 0x54, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x24, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x6e, 0x66, 0x74, 0x2e, 0x76, 0x31, - 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4e, 0x46, 0x54, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x30, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x2a, 0x12, 0x28, - 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x6e, 0x66, 0x74, 0x2f, 0x76, 0x31, 0x62, 0x65, - 0x74, 0x61, 0x31, 0x2f, 0x6e, 0x66, 0x74, 0x73, 0x2f, 0x7b, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x5f, - 0x69, 0x64, 0x7d, 0x2f, 0x7b, 0x69, 0x64, 0x7d, 0x12, 0x86, 0x01, 0x0a, 0x05, 0x43, 0x6c, 0x61, - 0x73, 0x73, 0x12, 0x25, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x6e, 0x66, 0x74, 0x2e, - 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6c, 0x61, - 0x73, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x63, 0x6f, 0x73, 0x6d, - 0x6f, 0x73, 0x2e, 0x6e, 0x66, 0x74, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, - 0x75, 0x65, 0x72, 0x79, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x22, 0x2e, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x28, 0x12, 0x26, 0x2f, 0x63, 0x6f, 0x73, 0x6d, - 0x6f, 0x73, 0x2f, 0x6e, 0x66, 0x74, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x63, - 0x6c, 0x61, 0x73, 0x73, 0x65, 0x73, 0x2f, 0x7b, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x5f, 0x69, 0x64, - 0x7d, 0x12, 0x81, 0x01, 0x0a, 0x07, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x65, 0x73, 0x12, 0x27, 0x2e, - 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x6e, 0x66, 0x74, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, - 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x65, 0x73, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, - 0x6e, 0x66, 0x74, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, + 0x22, 0x3b, 0x0a, 0x1e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x42, 0x79, + 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x5f, 0x69, 0x64, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x49, 0x64, 0x22, 0x45, 0x0a, + 0x12, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x12, 0x2f, 0x0a, 0x05, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x6e, 0x66, 0x74, 0x2e, + 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x52, 0x05, 0x63, + 0x6c, 0x61, 0x73, 0x73, 0x22, 0x52, 0x0a, 0x1f, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6c, 0x61, + 0x73, 0x73, 0x42, 0x79, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2f, 0x0a, 0x05, 0x63, 0x6c, 0x61, 0x73, 0x73, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, + 0x6e, 0x66, 0x74, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x43, 0x6c, 0x61, 0x73, + 0x73, 0x52, 0x05, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x22, 0x5d, 0x0a, 0x13, 0x51, 0x75, 0x65, 0x72, + 0x79, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, + 0x46, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, + 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, + 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x0a, 0x70, 0x61, 0x67, + 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x94, 0x01, 0x0a, 0x14, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x22, 0x23, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1d, 0x12, 0x1b, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, - 0x73, 0x2f, 0x6e, 0x66, 0x74, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x63, 0x6c, - 0x61, 0x73, 0x73, 0x65, 0x73, 0x42, 0xbe, 0x01, 0x0a, 0x16, 0x63, 0x6f, 0x6d, 0x2e, 0x63, 0x6f, + 0x12, 0x33, 0x0a, 0x07, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x19, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x6e, 0x66, 0x74, 0x2e, 0x76, + 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x52, 0x07, 0x63, 0x6c, + 0x61, 0x73, 0x73, 0x65, 0x73, 0x12, 0x47, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x63, 0x6f, 0x73, 0x6d, + 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x76, 0x31, + 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x50, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x32, 0xf1, + 0x0d, 0x0a, 0x05, 0x51, 0x75, 0x65, 0x72, 0x79, 0x12, 0x94, 0x01, 0x0a, 0x07, 0x42, 0x61, 0x6c, + 0x61, 0x6e, 0x63, 0x65, 0x12, 0x27, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x6e, 0x66, + 0x74, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x42, + 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, + 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x6e, 0x66, 0x74, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, + 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x36, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x30, 0x12, + 0x2e, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x6e, 0x66, 0x74, 0x2f, 0x76, 0x31, 0x62, + 0x65, 0x74, 0x61, 0x31, 0x2f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x2f, 0x7b, 0x6f, 0x77, + 0x6e, 0x65, 0x72, 0x7d, 0x2f, 0x7b, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x5f, 0x69, 0x64, 0x7d, 0x12, + 0xa8, 0x01, 0x0a, 0x14, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x42, 0x79, 0x51, 0x75, 0x65, + 0x72, 0x79, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x34, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, + 0x73, 0x2e, 0x6e, 0x66, 0x74, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, + 0x65, 0x72, 0x79, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x42, 0x79, 0x51, 0x75, 0x65, 0x72, + 0x79, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x35, + 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x6e, 0x66, 0x74, 0x2e, 0x76, 0x31, 0x62, 0x65, + 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, + 0x42, 0x79, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x23, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1d, 0x12, 0x1b, 0x2f, + 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x6e, 0x66, 0x74, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, + 0x61, 0x31, 0x2f, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x89, 0x01, 0x0a, 0x05, 0x4f, + 0x77, 0x6e, 0x65, 0x72, 0x12, 0x25, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x6e, 0x66, + 0x74, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4f, + 0x77, 0x6e, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x6e, 0x66, 0x74, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, - 0x42, 0x0a, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x2e, - 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x61, 0x70, 0x69, + 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4f, 0x77, 0x6e, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x31, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x2b, 0x12, 0x29, 0x2f, 0x63, 0x6f, + 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x6e, 0x66, 0x74, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, + 0x2f, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x2f, 0x7b, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x5f, 0x69, 0x64, + 0x7d, 0x2f, 0x7b, 0x69, 0x64, 0x7d, 0x12, 0xa0, 0x01, 0x0a, 0x12, 0x4f, 0x77, 0x6e, 0x65, 0x72, + 0x42, 0x79, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x32, 0x2e, + 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x6e, 0x66, 0x74, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, + 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4f, 0x77, 0x6e, 0x65, 0x72, 0x42, 0x79, 0x51, + 0x75, 0x65, 0x72, 0x79, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x33, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x6e, 0x66, 0x74, 0x2e, 0x76, + 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4f, 0x77, 0x6e, 0x65, + 0x72, 0x42, 0x79, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x21, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1b, 0x12, 0x19, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x6e, 0x66, 0x74, 0x2f, 0x76, 0x31, 0x62, 0x65, - 0x74, 0x61, 0x31, 0x3b, 0x6e, 0x66, 0x74, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0xa2, 0x02, - 0x03, 0x43, 0x4e, 0x58, 0xaa, 0x02, 0x12, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x4e, 0x66, - 0x74, 0x2e, 0x56, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0xca, 0x02, 0x12, 0x43, 0x6f, 0x73, 0x6d, - 0x6f, 0x73, 0x5c, 0x4e, 0x66, 0x74, 0x5c, 0x56, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0xe2, 0x02, - 0x1e, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x5c, 0x4e, 0x66, 0x74, 0x5c, 0x56, 0x31, 0x62, 0x65, - 0x74, 0x61, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, - 0x02, 0x14, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x3a, 0x3a, 0x4e, 0x66, 0x74, 0x3a, 0x3a, 0x56, - 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x74, 0x61, 0x31, 0x2f, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x12, 0x88, 0x01, 0x0a, 0x06, 0x53, 0x75, + 0x70, 0x70, 0x6c, 0x79, 0x12, 0x26, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x6e, 0x66, + 0x74, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, + 0x75, 0x70, 0x70, 0x6c, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x63, + 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x6e, 0x66, 0x74, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, + 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2d, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x27, 0x12, 0x25, 0x2f, + 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x6e, 0x66, 0x74, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, + 0x61, 0x31, 0x2f, 0x73, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x2f, 0x7b, 0x63, 0x6c, 0x61, 0x73, 0x73, + 0x5f, 0x69, 0x64, 0x7d, 0x12, 0xa4, 0x01, 0x0a, 0x13, 0x53, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x42, + 0x79, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x33, 0x2e, 0x63, + 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x6e, 0x66, 0x74, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, + 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x42, 0x79, 0x51, + 0x75, 0x65, 0x72, 0x79, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x34, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x6e, 0x66, 0x74, 0x2e, 0x76, + 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x75, 0x70, 0x70, + 0x6c, 0x79, 0x42, 0x79, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x22, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1c, 0x12, + 0x1a, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x6e, 0x66, 0x74, 0x2f, 0x76, 0x31, 0x62, + 0x65, 0x74, 0x61, 0x31, 0x2f, 0x73, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x12, 0x75, 0x0a, 0x04, 0x4e, + 0x46, 0x54, 0x73, 0x12, 0x24, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x6e, 0x66, 0x74, + 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4e, 0x46, + 0x54, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x25, 0x2e, 0x63, 0x6f, 0x73, 0x6d, + 0x6f, 0x73, 0x2e, 0x6e, 0x66, 0x74, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, + 0x75, 0x65, 0x72, 0x79, 0x4e, 0x46, 0x54, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x22, 0x20, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x1a, 0x12, 0x18, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, + 0x73, 0x2f, 0x6e, 0x66, 0x74, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x6e, 0x66, + 0x74, 0x73, 0x12, 0x82, 0x01, 0x0a, 0x03, 0x4e, 0x46, 0x54, 0x12, 0x23, 0x2e, 0x63, 0x6f, 0x73, + 0x6d, 0x6f, 0x73, 0x2e, 0x6e, 0x66, 0x74, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, + 0x51, 0x75, 0x65, 0x72, 0x79, 0x4e, 0x46, 0x54, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x24, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x6e, 0x66, 0x74, 0x2e, 0x76, 0x31, 0x62, + 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4e, 0x46, 0x54, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x30, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x2a, 0x12, 0x28, 0x2f, + 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x6e, 0x66, 0x74, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, + 0x61, 0x31, 0x2f, 0x6e, 0x66, 0x74, 0x73, 0x2f, 0x7b, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x5f, 0x69, + 0x64, 0x7d, 0x2f, 0x7b, 0x69, 0x64, 0x7d, 0x12, 0x98, 0x01, 0x0a, 0x10, 0x4e, 0x46, 0x54, 0x42, + 0x79, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x30, 0x2e, 0x63, + 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x6e, 0x66, 0x74, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, + 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4e, 0x46, 0x54, 0x42, 0x79, 0x51, 0x75, 0x65, 0x72, + 0x79, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x31, + 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x6e, 0x66, 0x74, 0x2e, 0x76, 0x31, 0x62, 0x65, + 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4e, 0x46, 0x54, 0x42, 0x79, 0x51, 0x75, + 0x65, 0x72, 0x79, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x22, 0x1f, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x19, 0x12, 0x17, 0x2f, 0x63, 0x6f, 0x73, 0x6d, + 0x6f, 0x73, 0x2f, 0x6e, 0x66, 0x74, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x6e, + 0x66, 0x74, 0x12, 0x86, 0x01, 0x0a, 0x05, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x12, 0x25, 0x2e, 0x63, + 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x6e, 0x66, 0x74, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, + 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x6e, 0x66, 0x74, + 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6c, + 0x61, 0x73, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2e, 0x82, 0xd3, 0xe4, + 0x93, 0x02, 0x28, 0x12, 0x26, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x6e, 0x66, 0x74, + 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x65, 0x73, + 0x2f, 0x7b, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x5f, 0x69, 0x64, 0x7d, 0x12, 0xa0, 0x01, 0x0a, 0x12, + 0x43, 0x6c, 0x61, 0x73, 0x73, 0x42, 0x79, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x74, 0x72, 0x69, + 0x6e, 0x67, 0x12, 0x32, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x6e, 0x66, 0x74, 0x2e, + 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6c, 0x61, + 0x73, 0x73, 0x42, 0x79, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x33, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, + 0x6e, 0x66, 0x74, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, + 0x79, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x42, 0x79, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x74, 0x72, + 0x69, 0x6e, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x21, 0x82, 0xd3, 0xe4, + 0x93, 0x02, 0x1b, 0x12, 0x19, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x6e, 0x66, 0x74, + 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x12, 0x81, + 0x01, 0x0a, 0x07, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x65, 0x73, 0x12, 0x27, 0x2e, 0x63, 0x6f, 0x73, + 0x6d, 0x6f, 0x73, 0x2e, 0x6e, 0x66, 0x74, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, + 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x6e, 0x66, 0x74, + 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6c, + 0x61, 0x73, 0x73, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x23, 0x82, + 0xd3, 0xe4, 0x93, 0x02, 0x1d, 0x12, 0x1b, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x6e, + 0x66, 0x74, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x63, 0x6c, 0x61, 0x73, 0x73, + 0x65, 0x73, 0x42, 0xbe, 0x01, 0x0a, 0x16, 0x63, 0x6f, 0x6d, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, + 0x73, 0x2e, 0x6e, 0x66, 0x74, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x42, 0x0a, 0x51, + 0x75, 0x65, 0x72, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x2e, 0x63, 0x6f, 0x73, + 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x63, 0x6f, + 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x6e, 0x66, 0x74, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, + 0x3b, 0x6e, 0x66, 0x74, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0xa2, 0x02, 0x03, 0x43, 0x4e, + 0x58, 0xaa, 0x02, 0x12, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x4e, 0x66, 0x74, 0x2e, 0x56, + 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0xca, 0x02, 0x12, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x5c, + 0x4e, 0x66, 0x74, 0x5c, 0x56, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0xe2, 0x02, 0x1e, 0x43, 0x6f, + 0x73, 0x6d, 0x6f, 0x73, 0x5c, 0x4e, 0x66, 0x74, 0x5c, 0x56, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, + 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x14, 0x43, + 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x3a, 0x3a, 0x4e, 0x66, 0x74, 0x3a, 0x3a, 0x56, 0x31, 0x62, 0x65, + 0x74, 0x61, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, } var ( @@ -7310,55 +12192,77 @@ func file_cosmos_nft_v1beta1_query_proto_rawDescGZIP() []byte { return file_cosmos_nft_v1beta1_query_proto_rawDescData } -var file_cosmos_nft_v1beta1_query_proto_msgTypes = make([]protoimpl.MessageInfo, 14) +var file_cosmos_nft_v1beta1_query_proto_msgTypes = make([]protoimpl.MessageInfo, 24) var file_cosmos_nft_v1beta1_query_proto_goTypes = []interface{}{ - (*QueryBalanceRequest)(nil), // 0: cosmos.nft.v1beta1.QueryBalanceRequest - (*QueryBalanceResponse)(nil), // 1: cosmos.nft.v1beta1.QueryBalanceResponse - (*QueryOwnerRequest)(nil), // 2: cosmos.nft.v1beta1.QueryOwnerRequest - (*QueryOwnerResponse)(nil), // 3: cosmos.nft.v1beta1.QueryOwnerResponse - (*QuerySupplyRequest)(nil), // 4: cosmos.nft.v1beta1.QuerySupplyRequest - (*QuerySupplyResponse)(nil), // 5: cosmos.nft.v1beta1.QuerySupplyResponse - (*QueryNFTsRequest)(nil), // 6: cosmos.nft.v1beta1.QueryNFTsRequest - (*QueryNFTsResponse)(nil), // 7: cosmos.nft.v1beta1.QueryNFTsResponse - (*QueryNFTRequest)(nil), // 8: cosmos.nft.v1beta1.QueryNFTRequest - (*QueryNFTResponse)(nil), // 9: cosmos.nft.v1beta1.QueryNFTResponse - (*QueryClassRequest)(nil), // 10: cosmos.nft.v1beta1.QueryClassRequest - (*QueryClassResponse)(nil), // 11: cosmos.nft.v1beta1.QueryClassResponse - (*QueryClassesRequest)(nil), // 12: cosmos.nft.v1beta1.QueryClassesRequest - (*QueryClassesResponse)(nil), // 13: cosmos.nft.v1beta1.QueryClassesResponse - (*v1beta1.PageRequest)(nil), // 14: cosmos.base.query.v1beta1.PageRequest - (*NFT)(nil), // 15: cosmos.nft.v1beta1.NFT - (*v1beta1.PageResponse)(nil), // 16: cosmos.base.query.v1beta1.PageResponse - (*Class)(nil), // 17: cosmos.nft.v1beta1.Class + (*QueryBalanceRequest)(nil), // 0: cosmos.nft.v1beta1.QueryBalanceRequest + (*QueryBalanceByQueryStringRequest)(nil), // 1: cosmos.nft.v1beta1.QueryBalanceByQueryStringRequest + (*QueryBalanceResponse)(nil), // 2: cosmos.nft.v1beta1.QueryBalanceResponse + (*QueryBalanceByQueryStringResponse)(nil), // 3: cosmos.nft.v1beta1.QueryBalanceByQueryStringResponse + (*QueryOwnerRequest)(nil), // 4: cosmos.nft.v1beta1.QueryOwnerRequest + (*QueryOwnerByQueryStringRequest)(nil), // 5: cosmos.nft.v1beta1.QueryOwnerByQueryStringRequest + (*QueryOwnerResponse)(nil), // 6: cosmos.nft.v1beta1.QueryOwnerResponse + (*QueryOwnerByQueryStringResponse)(nil), // 7: cosmos.nft.v1beta1.QueryOwnerByQueryStringResponse + (*QuerySupplyRequest)(nil), // 8: cosmos.nft.v1beta1.QuerySupplyRequest + (*QuerySupplyByQueryStringRequest)(nil), // 9: cosmos.nft.v1beta1.QuerySupplyByQueryStringRequest + (*QuerySupplyResponse)(nil), // 10: cosmos.nft.v1beta1.QuerySupplyResponse + (*QuerySupplyByQueryStringResponse)(nil), // 11: cosmos.nft.v1beta1.QuerySupplyByQueryStringResponse + (*QueryNFTsRequest)(nil), // 12: cosmos.nft.v1beta1.QueryNFTsRequest + (*QueryNFTsResponse)(nil), // 13: cosmos.nft.v1beta1.QueryNFTsResponse + (*QueryNFTRequest)(nil), // 14: cosmos.nft.v1beta1.QueryNFTRequest + (*QueryNFTByQueryStringRequest)(nil), // 15: cosmos.nft.v1beta1.QueryNFTByQueryStringRequest + (*QueryNFTResponse)(nil), // 16: cosmos.nft.v1beta1.QueryNFTResponse + (*QueryNFTByQueryStringResponse)(nil), // 17: cosmos.nft.v1beta1.QueryNFTByQueryStringResponse + (*QueryClassRequest)(nil), // 18: cosmos.nft.v1beta1.QueryClassRequest + (*QueryClassByQueryStringRequest)(nil), // 19: cosmos.nft.v1beta1.QueryClassByQueryStringRequest + (*QueryClassResponse)(nil), // 20: cosmos.nft.v1beta1.QueryClassResponse + (*QueryClassByQueryStringResponse)(nil), // 21: cosmos.nft.v1beta1.QueryClassByQueryStringResponse + (*QueryClassesRequest)(nil), // 22: cosmos.nft.v1beta1.QueryClassesRequest + (*QueryClassesResponse)(nil), // 23: cosmos.nft.v1beta1.QueryClassesResponse + (*v1beta1.PageRequest)(nil), // 24: cosmos.base.query.v1beta1.PageRequest + (*NFT)(nil), // 25: cosmos.nft.v1beta1.NFT + (*v1beta1.PageResponse)(nil), // 26: cosmos.base.query.v1beta1.PageResponse + (*Class)(nil), // 27: cosmos.nft.v1beta1.Class } var file_cosmos_nft_v1beta1_query_proto_depIdxs = []int32{ - 14, // 0: cosmos.nft.v1beta1.QueryNFTsRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest - 15, // 1: cosmos.nft.v1beta1.QueryNFTsResponse.nfts:type_name -> cosmos.nft.v1beta1.NFT - 16, // 2: cosmos.nft.v1beta1.QueryNFTsResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse - 15, // 3: cosmos.nft.v1beta1.QueryNFTResponse.nft:type_name -> cosmos.nft.v1beta1.NFT - 17, // 4: cosmos.nft.v1beta1.QueryClassResponse.class:type_name -> cosmos.nft.v1beta1.Class - 14, // 5: cosmos.nft.v1beta1.QueryClassesRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest - 17, // 6: cosmos.nft.v1beta1.QueryClassesResponse.classes:type_name -> cosmos.nft.v1beta1.Class - 16, // 7: cosmos.nft.v1beta1.QueryClassesResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse - 0, // 8: cosmos.nft.v1beta1.Query.Balance:input_type -> cosmos.nft.v1beta1.QueryBalanceRequest - 2, // 9: cosmos.nft.v1beta1.Query.Owner:input_type -> cosmos.nft.v1beta1.QueryOwnerRequest - 4, // 10: cosmos.nft.v1beta1.Query.Supply:input_type -> cosmos.nft.v1beta1.QuerySupplyRequest - 6, // 11: cosmos.nft.v1beta1.Query.NFTs:input_type -> cosmos.nft.v1beta1.QueryNFTsRequest - 8, // 12: cosmos.nft.v1beta1.Query.NFT:input_type -> cosmos.nft.v1beta1.QueryNFTRequest - 10, // 13: cosmos.nft.v1beta1.Query.Class:input_type -> cosmos.nft.v1beta1.QueryClassRequest - 12, // 14: cosmos.nft.v1beta1.Query.Classes:input_type -> cosmos.nft.v1beta1.QueryClassesRequest - 1, // 15: cosmos.nft.v1beta1.Query.Balance:output_type -> cosmos.nft.v1beta1.QueryBalanceResponse - 3, // 16: cosmos.nft.v1beta1.Query.Owner:output_type -> cosmos.nft.v1beta1.QueryOwnerResponse - 5, // 17: cosmos.nft.v1beta1.Query.Supply:output_type -> cosmos.nft.v1beta1.QuerySupplyResponse - 7, // 18: cosmos.nft.v1beta1.Query.NFTs:output_type -> cosmos.nft.v1beta1.QueryNFTsResponse - 9, // 19: cosmos.nft.v1beta1.Query.NFT:output_type -> cosmos.nft.v1beta1.QueryNFTResponse - 11, // 20: cosmos.nft.v1beta1.Query.Class:output_type -> cosmos.nft.v1beta1.QueryClassResponse - 13, // 21: cosmos.nft.v1beta1.Query.Classes:output_type -> cosmos.nft.v1beta1.QueryClassesResponse - 15, // [15:22] is the sub-list for method output_type - 8, // [8:15] is the sub-list for method input_type - 8, // [8:8] is the sub-list for extension type_name - 8, // [8:8] is the sub-list for extension extendee - 0, // [0:8] is the sub-list for field type_name + 24, // 0: cosmos.nft.v1beta1.QueryNFTsRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest + 25, // 1: cosmos.nft.v1beta1.QueryNFTsResponse.nfts:type_name -> cosmos.nft.v1beta1.NFT + 26, // 2: cosmos.nft.v1beta1.QueryNFTsResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse + 25, // 3: cosmos.nft.v1beta1.QueryNFTResponse.nft:type_name -> cosmos.nft.v1beta1.NFT + 25, // 4: cosmos.nft.v1beta1.QueryNFTByQueryStringResponse.nft:type_name -> cosmos.nft.v1beta1.NFT + 27, // 5: cosmos.nft.v1beta1.QueryClassResponse.class:type_name -> cosmos.nft.v1beta1.Class + 27, // 6: cosmos.nft.v1beta1.QueryClassByQueryStringResponse.class:type_name -> cosmos.nft.v1beta1.Class + 24, // 7: cosmos.nft.v1beta1.QueryClassesRequest.pagination:type_name -> cosmos.base.query.v1beta1.PageRequest + 27, // 8: cosmos.nft.v1beta1.QueryClassesResponse.classes:type_name -> cosmos.nft.v1beta1.Class + 26, // 9: cosmos.nft.v1beta1.QueryClassesResponse.pagination:type_name -> cosmos.base.query.v1beta1.PageResponse + 0, // 10: cosmos.nft.v1beta1.Query.Balance:input_type -> cosmos.nft.v1beta1.QueryBalanceRequest + 1, // 11: cosmos.nft.v1beta1.Query.BalanceByQueryString:input_type -> cosmos.nft.v1beta1.QueryBalanceByQueryStringRequest + 4, // 12: cosmos.nft.v1beta1.Query.Owner:input_type -> cosmos.nft.v1beta1.QueryOwnerRequest + 5, // 13: cosmos.nft.v1beta1.Query.OwnerByQueryString:input_type -> cosmos.nft.v1beta1.QueryOwnerByQueryStringRequest + 8, // 14: cosmos.nft.v1beta1.Query.Supply:input_type -> cosmos.nft.v1beta1.QuerySupplyRequest + 9, // 15: cosmos.nft.v1beta1.Query.SupplyByQueryString:input_type -> cosmos.nft.v1beta1.QuerySupplyByQueryStringRequest + 12, // 16: cosmos.nft.v1beta1.Query.NFTs:input_type -> cosmos.nft.v1beta1.QueryNFTsRequest + 14, // 17: cosmos.nft.v1beta1.Query.NFT:input_type -> cosmos.nft.v1beta1.QueryNFTRequest + 15, // 18: cosmos.nft.v1beta1.Query.NFTByQueryString:input_type -> cosmos.nft.v1beta1.QueryNFTByQueryStringRequest + 18, // 19: cosmos.nft.v1beta1.Query.Class:input_type -> cosmos.nft.v1beta1.QueryClassRequest + 19, // 20: cosmos.nft.v1beta1.Query.ClassByQueryString:input_type -> cosmos.nft.v1beta1.QueryClassByQueryStringRequest + 22, // 21: cosmos.nft.v1beta1.Query.Classes:input_type -> cosmos.nft.v1beta1.QueryClassesRequest + 2, // 22: cosmos.nft.v1beta1.Query.Balance:output_type -> cosmos.nft.v1beta1.QueryBalanceResponse + 3, // 23: cosmos.nft.v1beta1.Query.BalanceByQueryString:output_type -> cosmos.nft.v1beta1.QueryBalanceByQueryStringResponse + 6, // 24: cosmos.nft.v1beta1.Query.Owner:output_type -> cosmos.nft.v1beta1.QueryOwnerResponse + 7, // 25: cosmos.nft.v1beta1.Query.OwnerByQueryString:output_type -> cosmos.nft.v1beta1.QueryOwnerByQueryStringResponse + 10, // 26: cosmos.nft.v1beta1.Query.Supply:output_type -> cosmos.nft.v1beta1.QuerySupplyResponse + 11, // 27: cosmos.nft.v1beta1.Query.SupplyByQueryString:output_type -> cosmos.nft.v1beta1.QuerySupplyByQueryStringResponse + 13, // 28: cosmos.nft.v1beta1.Query.NFTs:output_type -> cosmos.nft.v1beta1.QueryNFTsResponse + 16, // 29: cosmos.nft.v1beta1.Query.NFT:output_type -> cosmos.nft.v1beta1.QueryNFTResponse + 17, // 30: cosmos.nft.v1beta1.Query.NFTByQueryString:output_type -> cosmos.nft.v1beta1.QueryNFTByQueryStringResponse + 20, // 31: cosmos.nft.v1beta1.Query.Class:output_type -> cosmos.nft.v1beta1.QueryClassResponse + 21, // 32: cosmos.nft.v1beta1.Query.ClassByQueryString:output_type -> cosmos.nft.v1beta1.QueryClassByQueryStringResponse + 23, // 33: cosmos.nft.v1beta1.Query.Classes:output_type -> cosmos.nft.v1beta1.QueryClassesResponse + 22, // [22:34] is the sub-list for method output_type + 10, // [10:22] is the sub-list for method input_type + 10, // [10:10] is the sub-list for extension type_name + 10, // [10:10] is the sub-list for extension extendee + 0, // [0:10] is the sub-list for field type_name } func init() { file_cosmos_nft_v1beta1_query_proto_init() } @@ -7381,7 +12285,7 @@ func file_cosmos_nft_v1beta1_query_proto_init() { } } file_cosmos_nft_v1beta1_query_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*QueryBalanceResponse); i { + switch v := v.(*QueryBalanceByQueryStringRequest); i { case 0: return &v.state case 1: @@ -7393,7 +12297,7 @@ func file_cosmos_nft_v1beta1_query_proto_init() { } } file_cosmos_nft_v1beta1_query_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*QueryOwnerRequest); i { + switch v := v.(*QueryBalanceResponse); i { case 0: return &v.state case 1: @@ -7405,7 +12309,7 @@ func file_cosmos_nft_v1beta1_query_proto_init() { } } file_cosmos_nft_v1beta1_query_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*QueryOwnerResponse); i { + switch v := v.(*QueryBalanceByQueryStringResponse); i { case 0: return &v.state case 1: @@ -7417,7 +12321,7 @@ func file_cosmos_nft_v1beta1_query_proto_init() { } } file_cosmos_nft_v1beta1_query_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*QuerySupplyRequest); i { + switch v := v.(*QueryOwnerRequest); i { case 0: return &v.state case 1: @@ -7429,7 +12333,7 @@ func file_cosmos_nft_v1beta1_query_proto_init() { } } file_cosmos_nft_v1beta1_query_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*QuerySupplyResponse); i { + switch v := v.(*QueryOwnerByQueryStringRequest); i { case 0: return &v.state case 1: @@ -7441,7 +12345,7 @@ func file_cosmos_nft_v1beta1_query_proto_init() { } } file_cosmos_nft_v1beta1_query_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*QueryNFTsRequest); i { + switch v := v.(*QueryOwnerResponse); i { case 0: return &v.state case 1: @@ -7453,7 +12357,7 @@ func file_cosmos_nft_v1beta1_query_proto_init() { } } file_cosmos_nft_v1beta1_query_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*QueryNFTsResponse); i { + switch v := v.(*QueryOwnerByQueryStringResponse); i { case 0: return &v.state case 1: @@ -7465,7 +12369,7 @@ func file_cosmos_nft_v1beta1_query_proto_init() { } } file_cosmos_nft_v1beta1_query_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*QueryNFTRequest); i { + switch v := v.(*QuerySupplyRequest); i { case 0: return &v.state case 1: @@ -7477,7 +12381,7 @@ func file_cosmos_nft_v1beta1_query_proto_init() { } } file_cosmos_nft_v1beta1_query_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*QueryNFTResponse); i { + switch v := v.(*QuerySupplyByQueryStringRequest); i { case 0: return &v.state case 1: @@ -7489,7 +12393,7 @@ func file_cosmos_nft_v1beta1_query_proto_init() { } } file_cosmos_nft_v1beta1_query_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*QueryClassRequest); i { + switch v := v.(*QuerySupplyResponse); i { case 0: return &v.state case 1: @@ -7501,7 +12405,7 @@ func file_cosmos_nft_v1beta1_query_proto_init() { } } file_cosmos_nft_v1beta1_query_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*QueryClassResponse); i { + switch v := v.(*QuerySupplyByQueryStringResponse); i { case 0: return &v.state case 1: @@ -7513,7 +12417,7 @@ func file_cosmos_nft_v1beta1_query_proto_init() { } } file_cosmos_nft_v1beta1_query_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*QueryClassesRequest); i { + switch v := v.(*QueryNFTsRequest); i { case 0: return &v.state case 1: @@ -7525,6 +12429,126 @@ func file_cosmos_nft_v1beta1_query_proto_init() { } } file_cosmos_nft_v1beta1_query_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryNFTsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cosmos_nft_v1beta1_query_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryNFTRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cosmos_nft_v1beta1_query_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryNFTByQueryStringRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cosmos_nft_v1beta1_query_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryNFTResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cosmos_nft_v1beta1_query_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryNFTByQueryStringResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cosmos_nft_v1beta1_query_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryClassRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cosmos_nft_v1beta1_query_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryClassByQueryStringRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cosmos_nft_v1beta1_query_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryClassResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cosmos_nft_v1beta1_query_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryClassByQueryStringResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cosmos_nft_v1beta1_query_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryClassesRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cosmos_nft_v1beta1_query_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*QueryClassesResponse); i { case 0: return &v.state @@ -7543,7 +12567,7 @@ func file_cosmos_nft_v1beta1_query_proto_init() { GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: file_cosmos_nft_v1beta1_query_proto_rawDesc, NumEnums: 0, - NumMessages: 14, + NumMessages: 24, NumExtensions: 0, NumServices: 1, }, diff --git a/api/cosmos/nft/v1beta1/query_grpc.pb.go b/api/cosmos/nft/v1beta1/query_grpc.pb.go index 216b998cf1..d25acc384a 100644 --- a/api/cosmos/nft/v1beta1/query_grpc.pb.go +++ b/api/cosmos/nft/v1beta1/query_grpc.pb.go @@ -19,13 +19,18 @@ import ( const _ = grpc.SupportPackageIsVersion7 const ( - Query_Balance_FullMethodName = "/cosmos.nft.v1beta1.Query/Balance" - Query_Owner_FullMethodName = "/cosmos.nft.v1beta1.Query/Owner" - Query_Supply_FullMethodName = "/cosmos.nft.v1beta1.Query/Supply" - Query_NFTs_FullMethodName = "/cosmos.nft.v1beta1.Query/NFTs" - Query_NFT_FullMethodName = "/cosmos.nft.v1beta1.Query/NFT" - Query_Class_FullMethodName = "/cosmos.nft.v1beta1.Query/Class" - Query_Classes_FullMethodName = "/cosmos.nft.v1beta1.Query/Classes" + Query_Balance_FullMethodName = "/cosmos.nft.v1beta1.Query/Balance" + Query_BalanceByQueryString_FullMethodName = "/cosmos.nft.v1beta1.Query/BalanceByQueryString" + Query_Owner_FullMethodName = "/cosmos.nft.v1beta1.Query/Owner" + Query_OwnerByQueryString_FullMethodName = "/cosmos.nft.v1beta1.Query/OwnerByQueryString" + Query_Supply_FullMethodName = "/cosmos.nft.v1beta1.Query/Supply" + Query_SupplyByQueryString_FullMethodName = "/cosmos.nft.v1beta1.Query/SupplyByQueryString" + Query_NFTs_FullMethodName = "/cosmos.nft.v1beta1.Query/NFTs" + Query_NFT_FullMethodName = "/cosmos.nft.v1beta1.Query/NFT" + Query_NFTByQueryString_FullMethodName = "/cosmos.nft.v1beta1.Query/NFTByQueryString" + Query_Class_FullMethodName = "/cosmos.nft.v1beta1.Query/Class" + Query_ClassByQueryString_FullMethodName = "/cosmos.nft.v1beta1.Query/ClassByQueryString" + Query_Classes_FullMethodName = "/cosmos.nft.v1beta1.Query/Classes" ) // QueryClient is the client API for Query service. @@ -34,17 +39,27 @@ const ( type QueryClient interface { // Balance queries the number of NFTs of a given class owned by the owner, same as balanceOf in ERC721 Balance(ctx context.Context, in *QueryBalanceRequest, opts ...grpc.CallOption) (*QueryBalanceResponse, error) + // BalancebyQueryString queries the number of NFTs of a given class owned by the owner, same as balanceOf in ERC721 + BalanceByQueryString(ctx context.Context, in *QueryBalanceByQueryStringRequest, opts ...grpc.CallOption) (*QueryBalanceByQueryStringResponse, error) // Owner queries the owner of the NFT based on its class and id, same as ownerOf in ERC721 Owner(ctx context.Context, in *QueryOwnerRequest, opts ...grpc.CallOption) (*QueryOwnerResponse, error) + // OwnerByQueryString queries the owner of the NFT based on its class and id, same as ownerOf in ERC721 + OwnerByQueryString(ctx context.Context, in *QueryOwnerByQueryStringRequest, opts ...grpc.CallOption) (*QueryOwnerByQueryStringResponse, error) // Supply queries the number of NFTs from the given class, same as totalSupply of ERC721. Supply(ctx context.Context, in *QuerySupplyRequest, opts ...grpc.CallOption) (*QuerySupplyResponse, error) + // SupplyByQueryString queries the number of NFTs from the given class, same as totalSupply of ERC721. + SupplyByQueryString(ctx context.Context, in *QuerySupplyByQueryStringRequest, opts ...grpc.CallOption) (*QuerySupplyByQueryStringResponse, error) // NFTs queries all NFTs of a given class or owner,choose at least one of the two, similar to tokenByIndex in // ERC721Enumerable NFTs(ctx context.Context, in *QueryNFTsRequest, opts ...grpc.CallOption) (*QueryNFTsResponse, error) // NFT queries an NFT based on its class and id. NFT(ctx context.Context, in *QueryNFTRequest, opts ...grpc.CallOption) (*QueryNFTResponse, error) + // NFTByQueryString queries an NFT based on its class and id. + NFTByQueryString(ctx context.Context, in *QueryNFTByQueryStringRequest, opts ...grpc.CallOption) (*QueryNFTByQueryStringResponse, error) // Class queries an NFT class based on its id Class(ctx context.Context, in *QueryClassRequest, opts ...grpc.CallOption) (*QueryClassResponse, error) + // Class queries an NFT class based on its id + ClassByQueryString(ctx context.Context, in *QueryClassByQueryStringRequest, opts ...grpc.CallOption) (*QueryClassByQueryStringResponse, error) // Classes queries all NFT classes Classes(ctx context.Context, in *QueryClassesRequest, opts ...grpc.CallOption) (*QueryClassesResponse, error) } @@ -66,6 +81,15 @@ func (c *queryClient) Balance(ctx context.Context, in *QueryBalanceRequest, opts return out, nil } +func (c *queryClient) BalanceByQueryString(ctx context.Context, in *QueryBalanceByQueryStringRequest, opts ...grpc.CallOption) (*QueryBalanceByQueryStringResponse, error) { + out := new(QueryBalanceByQueryStringResponse) + err := c.cc.Invoke(ctx, Query_BalanceByQueryString_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *queryClient) Owner(ctx context.Context, in *QueryOwnerRequest, opts ...grpc.CallOption) (*QueryOwnerResponse, error) { out := new(QueryOwnerResponse) err := c.cc.Invoke(ctx, Query_Owner_FullMethodName, in, out, opts...) @@ -75,6 +99,15 @@ func (c *queryClient) Owner(ctx context.Context, in *QueryOwnerRequest, opts ... return out, nil } +func (c *queryClient) OwnerByQueryString(ctx context.Context, in *QueryOwnerByQueryStringRequest, opts ...grpc.CallOption) (*QueryOwnerByQueryStringResponse, error) { + out := new(QueryOwnerByQueryStringResponse) + err := c.cc.Invoke(ctx, Query_OwnerByQueryString_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *queryClient) Supply(ctx context.Context, in *QuerySupplyRequest, opts ...grpc.CallOption) (*QuerySupplyResponse, error) { out := new(QuerySupplyResponse) err := c.cc.Invoke(ctx, Query_Supply_FullMethodName, in, out, opts...) @@ -84,6 +117,15 @@ func (c *queryClient) Supply(ctx context.Context, in *QuerySupplyRequest, opts . return out, nil } +func (c *queryClient) SupplyByQueryString(ctx context.Context, in *QuerySupplyByQueryStringRequest, opts ...grpc.CallOption) (*QuerySupplyByQueryStringResponse, error) { + out := new(QuerySupplyByQueryStringResponse) + err := c.cc.Invoke(ctx, Query_SupplyByQueryString_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *queryClient) NFTs(ctx context.Context, in *QueryNFTsRequest, opts ...grpc.CallOption) (*QueryNFTsResponse, error) { out := new(QueryNFTsResponse) err := c.cc.Invoke(ctx, Query_NFTs_FullMethodName, in, out, opts...) @@ -102,6 +144,15 @@ func (c *queryClient) NFT(ctx context.Context, in *QueryNFTRequest, opts ...grpc return out, nil } +func (c *queryClient) NFTByQueryString(ctx context.Context, in *QueryNFTByQueryStringRequest, opts ...grpc.CallOption) (*QueryNFTByQueryStringResponse, error) { + out := new(QueryNFTByQueryStringResponse) + err := c.cc.Invoke(ctx, Query_NFTByQueryString_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *queryClient) Class(ctx context.Context, in *QueryClassRequest, opts ...grpc.CallOption) (*QueryClassResponse, error) { out := new(QueryClassResponse) err := c.cc.Invoke(ctx, Query_Class_FullMethodName, in, out, opts...) @@ -111,6 +162,15 @@ func (c *queryClient) Class(ctx context.Context, in *QueryClassRequest, opts ... return out, nil } +func (c *queryClient) ClassByQueryString(ctx context.Context, in *QueryClassByQueryStringRequest, opts ...grpc.CallOption) (*QueryClassByQueryStringResponse, error) { + out := new(QueryClassByQueryStringResponse) + err := c.cc.Invoke(ctx, Query_ClassByQueryString_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *queryClient) Classes(ctx context.Context, in *QueryClassesRequest, opts ...grpc.CallOption) (*QueryClassesResponse, error) { out := new(QueryClassesResponse) err := c.cc.Invoke(ctx, Query_Classes_FullMethodName, in, out, opts...) @@ -126,17 +186,27 @@ func (c *queryClient) Classes(ctx context.Context, in *QueryClassesRequest, opts type QueryServer interface { // Balance queries the number of NFTs of a given class owned by the owner, same as balanceOf in ERC721 Balance(context.Context, *QueryBalanceRequest) (*QueryBalanceResponse, error) + // BalancebyQueryString queries the number of NFTs of a given class owned by the owner, same as balanceOf in ERC721 + BalanceByQueryString(context.Context, *QueryBalanceByQueryStringRequest) (*QueryBalanceByQueryStringResponse, error) // Owner queries the owner of the NFT based on its class and id, same as ownerOf in ERC721 Owner(context.Context, *QueryOwnerRequest) (*QueryOwnerResponse, error) + // OwnerByQueryString queries the owner of the NFT based on its class and id, same as ownerOf in ERC721 + OwnerByQueryString(context.Context, *QueryOwnerByQueryStringRequest) (*QueryOwnerByQueryStringResponse, error) // Supply queries the number of NFTs from the given class, same as totalSupply of ERC721. Supply(context.Context, *QuerySupplyRequest) (*QuerySupplyResponse, error) + // SupplyByQueryString queries the number of NFTs from the given class, same as totalSupply of ERC721. + SupplyByQueryString(context.Context, *QuerySupplyByQueryStringRequest) (*QuerySupplyByQueryStringResponse, error) // NFTs queries all NFTs of a given class or owner,choose at least one of the two, similar to tokenByIndex in // ERC721Enumerable NFTs(context.Context, *QueryNFTsRequest) (*QueryNFTsResponse, error) // NFT queries an NFT based on its class and id. NFT(context.Context, *QueryNFTRequest) (*QueryNFTResponse, error) + // NFTByQueryString queries an NFT based on its class and id. + NFTByQueryString(context.Context, *QueryNFTByQueryStringRequest) (*QueryNFTByQueryStringResponse, error) // Class queries an NFT class based on its id Class(context.Context, *QueryClassRequest) (*QueryClassResponse, error) + // Class queries an NFT class based on its id + ClassByQueryString(context.Context, *QueryClassByQueryStringRequest) (*QueryClassByQueryStringResponse, error) // Classes queries all NFT classes Classes(context.Context, *QueryClassesRequest) (*QueryClassesResponse, error) mustEmbedUnimplementedQueryServer() @@ -149,21 +219,36 @@ type UnimplementedQueryServer struct { func (UnimplementedQueryServer) Balance(context.Context, *QueryBalanceRequest) (*QueryBalanceResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Balance not implemented") } +func (UnimplementedQueryServer) BalanceByQueryString(context.Context, *QueryBalanceByQueryStringRequest) (*QueryBalanceByQueryStringResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method BalanceByQueryString not implemented") +} func (UnimplementedQueryServer) Owner(context.Context, *QueryOwnerRequest) (*QueryOwnerResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Owner not implemented") } +func (UnimplementedQueryServer) OwnerByQueryString(context.Context, *QueryOwnerByQueryStringRequest) (*QueryOwnerByQueryStringResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method OwnerByQueryString not implemented") +} func (UnimplementedQueryServer) Supply(context.Context, *QuerySupplyRequest) (*QuerySupplyResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Supply not implemented") } +func (UnimplementedQueryServer) SupplyByQueryString(context.Context, *QuerySupplyByQueryStringRequest) (*QuerySupplyByQueryStringResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method SupplyByQueryString not implemented") +} func (UnimplementedQueryServer) NFTs(context.Context, *QueryNFTsRequest) (*QueryNFTsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method NFTs not implemented") } func (UnimplementedQueryServer) NFT(context.Context, *QueryNFTRequest) (*QueryNFTResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method NFT not implemented") } +func (UnimplementedQueryServer) NFTByQueryString(context.Context, *QueryNFTByQueryStringRequest) (*QueryNFTByQueryStringResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method NFTByQueryString not implemented") +} func (UnimplementedQueryServer) Class(context.Context, *QueryClassRequest) (*QueryClassResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Class not implemented") } +func (UnimplementedQueryServer) ClassByQueryString(context.Context, *QueryClassByQueryStringRequest) (*QueryClassByQueryStringResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ClassByQueryString not implemented") +} func (UnimplementedQueryServer) Classes(context.Context, *QueryClassesRequest) (*QueryClassesResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Classes not implemented") } @@ -198,6 +283,24 @@ func _Query_Balance_Handler(srv interface{}, ctx context.Context, dec func(inter return interceptor(ctx, in, info, handler) } +func _Query_BalanceByQueryString_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryBalanceByQueryStringRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).BalanceByQueryString(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Query_BalanceByQueryString_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).BalanceByQueryString(ctx, req.(*QueryBalanceByQueryStringRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _Query_Owner_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(QueryOwnerRequest) if err := dec(in); err != nil { @@ -216,6 +319,24 @@ func _Query_Owner_Handler(srv interface{}, ctx context.Context, dec func(interfa return interceptor(ctx, in, info, handler) } +func _Query_OwnerByQueryString_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryOwnerByQueryStringRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).OwnerByQueryString(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Query_OwnerByQueryString_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).OwnerByQueryString(ctx, req.(*QueryOwnerByQueryStringRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _Query_Supply_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(QuerySupplyRequest) if err := dec(in); err != nil { @@ -234,6 +355,24 @@ func _Query_Supply_Handler(srv interface{}, ctx context.Context, dec func(interf return interceptor(ctx, in, info, handler) } +func _Query_SupplyByQueryString_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QuerySupplyByQueryStringRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).SupplyByQueryString(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Query_SupplyByQueryString_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).SupplyByQueryString(ctx, req.(*QuerySupplyByQueryStringRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _Query_NFTs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(QueryNFTsRequest) if err := dec(in); err != nil { @@ -270,6 +409,24 @@ func _Query_NFT_Handler(srv interface{}, ctx context.Context, dec func(interface return interceptor(ctx, in, info, handler) } +func _Query_NFTByQueryString_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryNFTByQueryStringRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).NFTByQueryString(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Query_NFTByQueryString_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).NFTByQueryString(ctx, req.(*QueryNFTByQueryStringRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _Query_Class_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(QueryClassRequest) if err := dec(in); err != nil { @@ -288,6 +445,24 @@ func _Query_Class_Handler(srv interface{}, ctx context.Context, dec func(interfa return interceptor(ctx, in, info, handler) } +func _Query_ClassByQueryString_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryClassByQueryStringRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).ClassByQueryString(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Query_ClassByQueryString_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).ClassByQueryString(ctx, req.(*QueryClassByQueryStringRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _Query_Classes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(QueryClassesRequest) if err := dec(in); err != nil { @@ -317,14 +492,26 @@ var Query_ServiceDesc = grpc.ServiceDesc{ MethodName: "Balance", Handler: _Query_Balance_Handler, }, + { + MethodName: "BalanceByQueryString", + Handler: _Query_BalanceByQueryString_Handler, + }, { MethodName: "Owner", Handler: _Query_Owner_Handler, }, + { + MethodName: "OwnerByQueryString", + Handler: _Query_OwnerByQueryString_Handler, + }, { MethodName: "Supply", Handler: _Query_Supply_Handler, }, + { + MethodName: "SupplyByQueryString", + Handler: _Query_SupplyByQueryString_Handler, + }, { MethodName: "NFTs", Handler: _Query_NFTs_Handler, @@ -333,10 +520,18 @@ var Query_ServiceDesc = grpc.ServiceDesc{ MethodName: "NFT", Handler: _Query_NFT_Handler, }, + { + MethodName: "NFTByQueryString", + Handler: _Query_NFTByQueryString_Handler, + }, { MethodName: "Class", Handler: _Query_Class_Handler, }, + { + MethodName: "ClassByQueryString", + Handler: _Query_ClassByQueryString_Handler, + }, { MethodName: "Classes", Handler: _Query_Classes_Handler, diff --git a/client/docs/swagger-ui/swagger.yaml b/client/docs/swagger-ui/swagger.yaml index 06f576c77f..7ffcaf9ffa 100644 --- a/client/docs/swagger-ui/swagger.yaml +++ b/client/docs/swagger-ui/swagger.yaml @@ -14288,6 +14288,19 @@ paths: burn_vote_veto: type: boolean title: burn deposits if quorum with vote type no_veto is met + min_deposit_ratio: + type: string + description: >- + The ratio representing the proportion of the deposit value + minimum that must be met when making a deposit. + + Default value: 0.01. Meaning that for a chain with a + min_deposit of 100stake, a deposit of 1stake would be + + required. + + + Since: cosmos-sdk 0.50 description: >- QueryParamsResponse is the response type for the Query/Params RPC method. @@ -20743,6 +20756,26 @@ paths: title: >- min_commission_rate is the chain-wide minimum commission rate that a validator can charge their delegators + key_rotation_fee: + type: object + properties: + denom: + type: string + amount: + type: string + description: >- + Coin defines a token with a denomination and an amount. + + + NOTE: The amount field is an Int which implements the + custom method + + signatures required by gogoproto. + title: >- + key_rotation_fee is fee to be spent when rotating + validator's key + + (either consensus pubkey or operator key) description: >- QueryParamsResponse is response type for the Query/Params RPC method. @@ -30282,6 +30315,235 @@ paths: type: boolean tags: - Query + /cosmos/nft/v1beta1/balance: + get: + summary: >- + BalancebyQueryString queries the number of NFTs of a given class owned + by the owner, same as balanceOf in ERC721 + operationId: BalanceByQueryString + responses: + '200': + description: A successful response. + schema: + type: object + properties: + amount: + type: string + format: uint64 + title: >- + amount is the number of all NFTs of a given class owned by the + owner + title: >- + QueryBalanceByQueryStringResponse is the response type for the + Query/Balance RPC method + default: + description: An unexpected error response. + schema: + type: object + properties: + error: + type: string + code: + type: integer + format: int32 + message: + type: string + details: + type: array + items: + type: object + properties: + type_url: + type: string + description: >- + A URL/resource name that uniquely identifies the type of + the serialized + + protocol buffer message. This string must contain at + least + + one "/" character. The last segment of the URL's path + must represent + + the fully qualified name of the type (as in + + `path/google.protobuf.Duration`). The name should be in + a canonical form + + (e.g., leading "." is not accepted). + + + In practice, teams usually precompile into the binary + all types that they + + expect it to use in the context of Any. However, for + URLs which use the + + scheme `http`, `https`, or no scheme, one can optionally + set up a type + + server that maps type URLs to message definitions as + follows: + + + * If no scheme is provided, `https` is assumed. + + * An HTTP GET on the URL must yield a + [google.protobuf.Type][] + value in binary format, or produce an error. + * Applications are allowed to cache lookup results based + on the + URL, or have them precompiled into a binary to avoid any + lookup. Therefore, binary compatibility needs to be preserved + on changes to types. (Use versioned type names to manage + breaking changes.) + + Note: this functionality is not currently available in + the official + + protobuf release, and it is not used for type URLs + beginning with + + type.googleapis.com. + + + Schemes other than `http`, `https` (or the empty scheme) + might be + + used with implementation specific semantics. + value: + type: string + format: byte + description: >- + Must be a valid serialized protocol buffer of the above + specified type. + description: >- + `Any` contains an arbitrary serialized protocol buffer + message along with a + + URL that describes the type of the serialized message. + + + Protobuf library provides support to pack/unpack Any values + in the form + + of utility functions or additional generated methods of the + Any type. + + + Example 1: Pack and unpack a message in C++. + + Foo foo = ...; + Any any; + any.PackFrom(foo); + ... + if (any.UnpackTo(&foo)) { + ... + } + + Example 2: Pack and unpack a message in Java. + + Foo foo = ...; + Any any = Any.pack(foo); + ... + if (any.is(Foo.class)) { + foo = any.unpack(Foo.class); + } + // or ... + if (any.isSameTypeAs(Foo.getDefaultInstance())) { + foo = any.unpack(Foo.getDefaultInstance()); + } + + Example 3: Pack and unpack a message in Python. + + foo = Foo(...) + any = Any() + any.Pack(foo) + ... + if any.Is(Foo.DESCRIPTOR): + any.Unpack(foo) + ... + + Example 4: Pack and unpack a message in Go + + foo := &pb.Foo{...} + any, err := anypb.New(foo) + if err != nil { + ... + } + ... + foo := &pb.Foo{} + if err := any.UnmarshalTo(foo); err != nil { + ... + } + + The pack methods provided by protobuf library will by + default use + + 'type.googleapis.com/full.type.name' as the type URL and the + unpack + + methods only use the fully qualified type name after the + last '/' + + in the type URL, for example "foo.bar.com/x/y.z" will yield + type + + name "y.z". + + + JSON + + ==== + + The JSON representation of an `Any` value uses the regular + + representation of the deserialized, embedded message, with + an + + additional field `@type` which contains the type URL. + Example: + + package google.profile; + message Person { + string first_name = 1; + string last_name = 2; + } + + { + "@type": "type.googleapis.com/google.profile.Person", + "firstName": , + "lastName": + } + + If the embedded message type is well-known and has a custom + JSON + + representation, that representation will be embedded adding + a field + + `value` which holds the custom JSON in addition to the + `@type` + + field. Example (for message [google.protobuf.Duration][]): + + { + "@type": "type.googleapis.com/google.protobuf.Duration", + "value": "1.212s" + } + parameters: + - name: class_id + description: class_id associated with the nft. + in: query + required: false + type: string + - name: owner + description: owner is the owner address of the nft. + in: query + required: false + type: string + tags: + - Query /cosmos/nft/v1beta1/balance/{owner}/{class_id}: get: summary: >- @@ -30511,6 +30773,440 @@ paths: type: string tags: - Query + /cosmos/nft/v1beta1/class: + get: + summary: Class queries an NFT class based on its id + operationId: ClassByQueryString + responses: + '200': + description: A successful response. + schema: + type: object + properties: + class: + description: class defines the class of the nft type. + type: object + properties: + id: + type: string + title: >- + id defines the unique identifier of the NFT + classification, similar to the contract address of ERC721 + name: + type: string + title: >- + name defines the human-readable name of the NFT + classification. Optional + symbol: + type: string + title: >- + symbol is an abbreviated name for nft classification. + Optional + description: + type: string + title: >- + description is a brief description of nft classification. + Optional + uri: + type: string + title: >- + uri for the class metadata stored off chain. It can define + schema for Class and NFT `Data` attributes. Optional + uri_hash: + type: string + title: >- + uri_hash is a hash of the document pointed by uri. + Optional + data: + type: object + properties: + type_url: + type: string + description: >- + A URL/resource name that uniquely identifies the type + of the serialized + + protocol buffer message. This string must contain at + least + + one "/" character. The last segment of the URL's path + must represent + + the fully qualified name of the type (as in + + `path/google.protobuf.Duration`). The name should be + in a canonical form + + (e.g., leading "." is not accepted). + + + In practice, teams usually precompile into the binary + all types that they + + expect it to use in the context of Any. However, for + URLs which use the + + scheme `http`, `https`, or no scheme, one can + optionally set up a type + + server that maps type URLs to message definitions as + follows: + + + * If no scheme is provided, `https` is assumed. + + * An HTTP GET on the URL must yield a + [google.protobuf.Type][] + value in binary format, or produce an error. + * Applications are allowed to cache lookup results + based on the + URL, or have them precompiled into a binary to avoid any + lookup. Therefore, binary compatibility needs to be preserved + on changes to types. (Use versioned type names to manage + breaking changes.) + + Note: this functionality is not currently available in + the official + + protobuf release, and it is not used for type URLs + beginning with + + type.googleapis.com. + + + Schemes other than `http`, `https` (or the empty + scheme) might be + + used with implementation specific semantics. + value: + type: string + format: byte + description: >- + Must be a valid serialized protocol buffer of the + above specified type. + description: >- + `Any` contains an arbitrary serialized protocol buffer + message along with a + + URL that describes the type of the serialized message. + + + Protobuf library provides support to pack/unpack Any + values in the form + + of utility functions or additional generated methods of + the Any type. + + + Example 1: Pack and unpack a message in C++. + + Foo foo = ...; + Any any; + any.PackFrom(foo); + ... + if (any.UnpackTo(&foo)) { + ... + } + + Example 2: Pack and unpack a message in Java. + + Foo foo = ...; + Any any = Any.pack(foo); + ... + if (any.is(Foo.class)) { + foo = any.unpack(Foo.class); + } + // or ... + if (any.isSameTypeAs(Foo.getDefaultInstance())) { + foo = any.unpack(Foo.getDefaultInstance()); + } + + Example 3: Pack and unpack a message in Python. + + foo = Foo(...) + any = Any() + any.Pack(foo) + ... + if any.Is(Foo.DESCRIPTOR): + any.Unpack(foo) + ... + + Example 4: Pack and unpack a message in Go + + foo := &pb.Foo{...} + any, err := anypb.New(foo) + if err != nil { + ... + } + ... + foo := &pb.Foo{} + if err := any.UnmarshalTo(foo); err != nil { + ... + } + + The pack methods provided by protobuf library will by + default use + + 'type.googleapis.com/full.type.name' as the type URL and + the unpack + + methods only use the fully qualified type name after the + last '/' + + in the type URL, for example "foo.bar.com/x/y.z" will + yield type + + name "y.z". + + + JSON + + ==== + + The JSON representation of an `Any` value uses the regular + + representation of the deserialized, embedded message, with + an + + additional field `@type` which contains the type URL. + Example: + + package google.profile; + message Person { + string first_name = 1; + string last_name = 2; + } + + { + "@type": "type.googleapis.com/google.profile.Person", + "firstName": , + "lastName": + } + + If the embedded message type is well-known and has a + custom JSON + + representation, that representation will be embedded + adding a field + + `value` which holds the custom JSON in addition to the + `@type` + + field. Example (for message [google.protobuf.Duration][]): + + { + "@type": "type.googleapis.com/google.protobuf.Duration", + "value": "1.212s" + } + title: >- + data is the app specific metadata of the NFT class. + Optional + title: >- + QueryClassByQueryStringResponse is the response type for the + Query/Class RPC method + default: + description: An unexpected error response. + schema: + type: object + properties: + error: + type: string + code: + type: integer + format: int32 + message: + type: string + details: + type: array + items: + type: object + properties: + type_url: + type: string + description: >- + A URL/resource name that uniquely identifies the type of + the serialized + + protocol buffer message. This string must contain at + least + + one "/" character. The last segment of the URL's path + must represent + + the fully qualified name of the type (as in + + `path/google.protobuf.Duration`). The name should be in + a canonical form + + (e.g., leading "." is not accepted). + + + In practice, teams usually precompile into the binary + all types that they + + expect it to use in the context of Any. However, for + URLs which use the + + scheme `http`, `https`, or no scheme, one can optionally + set up a type + + server that maps type URLs to message definitions as + follows: + + + * If no scheme is provided, `https` is assumed. + + * An HTTP GET on the URL must yield a + [google.protobuf.Type][] + value in binary format, or produce an error. + * Applications are allowed to cache lookup results based + on the + URL, or have them precompiled into a binary to avoid any + lookup. Therefore, binary compatibility needs to be preserved + on changes to types. (Use versioned type names to manage + breaking changes.) + + Note: this functionality is not currently available in + the official + + protobuf release, and it is not used for type URLs + beginning with + + type.googleapis.com. + + + Schemes other than `http`, `https` (or the empty scheme) + might be + + used with implementation specific semantics. + value: + type: string + format: byte + description: >- + Must be a valid serialized protocol buffer of the above + specified type. + description: >- + `Any` contains an arbitrary serialized protocol buffer + message along with a + + URL that describes the type of the serialized message. + + + Protobuf library provides support to pack/unpack Any values + in the form + + of utility functions or additional generated methods of the + Any type. + + + Example 1: Pack and unpack a message in C++. + + Foo foo = ...; + Any any; + any.PackFrom(foo); + ... + if (any.UnpackTo(&foo)) { + ... + } + + Example 2: Pack and unpack a message in Java. + + Foo foo = ...; + Any any = Any.pack(foo); + ... + if (any.is(Foo.class)) { + foo = any.unpack(Foo.class); + } + // or ... + if (any.isSameTypeAs(Foo.getDefaultInstance())) { + foo = any.unpack(Foo.getDefaultInstance()); + } + + Example 3: Pack and unpack a message in Python. + + foo = Foo(...) + any = Any() + any.Pack(foo) + ... + if any.Is(Foo.DESCRIPTOR): + any.Unpack(foo) + ... + + Example 4: Pack and unpack a message in Go + + foo := &pb.Foo{...} + any, err := anypb.New(foo) + if err != nil { + ... + } + ... + foo := &pb.Foo{} + if err := any.UnmarshalTo(foo); err != nil { + ... + } + + The pack methods provided by protobuf library will by + default use + + 'type.googleapis.com/full.type.name' as the type URL and the + unpack + + methods only use the fully qualified type name after the + last '/' + + in the type URL, for example "foo.bar.com/x/y.z" will yield + type + + name "y.z". + + + JSON + + ==== + + The JSON representation of an `Any` value uses the regular + + representation of the deserialized, embedded message, with + an + + additional field `@type` which contains the type URL. + Example: + + package google.profile; + message Person { + string first_name = 1; + string last_name = 2; + } + + { + "@type": "type.googleapis.com/google.profile.Person", + "firstName": , + "lastName": + } + + If the embedded message type is well-known and has a custom + JSON + + representation, that representation will be embedded adding + a field + + `value` which holds the custom JSON in addition to the + `@type` + + field. Example (for message [google.protobuf.Duration][]): + + { + "@type": "type.googleapis.com/google.protobuf.Duration", + "value": "1.212s" + } + parameters: + - name: class_id + description: class_id associated with the nft. + in: query + required: false + type: string + tags: + - Query /cosmos/nft/v1beta1/classes: get: summary: Classes queries all NFT classes @@ -31456,6 +32152,428 @@ paths: type: string tags: - Query + /cosmos/nft/v1beta1/nft: + get: + summary: NFTByQueryString queries an NFT based on its class and id. + operationId: NFTByQueryString + responses: + '200': + description: A successful response. + schema: + type: object + properties: + nft: + title: owner is the owner address of the nft + type: object + properties: + class_id: + type: string + title: >- + class_id associated with the NFT, similar to the contract + address of ERC721 + id: + type: string + title: id is a unique identifier of the NFT + uri: + type: string + title: uri for the NFT metadata stored off chain + uri_hash: + type: string + title: uri_hash is a hash of the document pointed by uri + data: + type: object + properties: + type_url: + type: string + description: >- + A URL/resource name that uniquely identifies the type + of the serialized + + protocol buffer message. This string must contain at + least + + one "/" character. The last segment of the URL's path + must represent + + the fully qualified name of the type (as in + + `path/google.protobuf.Duration`). The name should be + in a canonical form + + (e.g., leading "." is not accepted). + + + In practice, teams usually precompile into the binary + all types that they + + expect it to use in the context of Any. However, for + URLs which use the + + scheme `http`, `https`, or no scheme, one can + optionally set up a type + + server that maps type URLs to message definitions as + follows: + + + * If no scheme is provided, `https` is assumed. + + * An HTTP GET on the URL must yield a + [google.protobuf.Type][] + value in binary format, or produce an error. + * Applications are allowed to cache lookup results + based on the + URL, or have them precompiled into a binary to avoid any + lookup. Therefore, binary compatibility needs to be preserved + on changes to types. (Use versioned type names to manage + breaking changes.) + + Note: this functionality is not currently available in + the official + + protobuf release, and it is not used for type URLs + beginning with + + type.googleapis.com. + + + Schemes other than `http`, `https` (or the empty + scheme) might be + + used with implementation specific semantics. + value: + type: string + format: byte + description: >- + Must be a valid serialized protocol buffer of the + above specified type. + description: >- + `Any` contains an arbitrary serialized protocol buffer + message along with a + + URL that describes the type of the serialized message. + + + Protobuf library provides support to pack/unpack Any + values in the form + + of utility functions or additional generated methods of + the Any type. + + + Example 1: Pack and unpack a message in C++. + + Foo foo = ...; + Any any; + any.PackFrom(foo); + ... + if (any.UnpackTo(&foo)) { + ... + } + + Example 2: Pack and unpack a message in Java. + + Foo foo = ...; + Any any = Any.pack(foo); + ... + if (any.is(Foo.class)) { + foo = any.unpack(Foo.class); + } + // or ... + if (any.isSameTypeAs(Foo.getDefaultInstance())) { + foo = any.unpack(Foo.getDefaultInstance()); + } + + Example 3: Pack and unpack a message in Python. + + foo = Foo(...) + any = Any() + any.Pack(foo) + ... + if any.Is(Foo.DESCRIPTOR): + any.Unpack(foo) + ... + + Example 4: Pack and unpack a message in Go + + foo := &pb.Foo{...} + any, err := anypb.New(foo) + if err != nil { + ... + } + ... + foo := &pb.Foo{} + if err := any.UnmarshalTo(foo); err != nil { + ... + } + + The pack methods provided by protobuf library will by + default use + + 'type.googleapis.com/full.type.name' as the type URL and + the unpack + + methods only use the fully qualified type name after the + last '/' + + in the type URL, for example "foo.bar.com/x/y.z" will + yield type + + name "y.z". + + + JSON + + ==== + + The JSON representation of an `Any` value uses the regular + + representation of the deserialized, embedded message, with + an + + additional field `@type` which contains the type URL. + Example: + + package google.profile; + message Person { + string first_name = 1; + string last_name = 2; + } + + { + "@type": "type.googleapis.com/google.profile.Person", + "firstName": , + "lastName": + } + + If the embedded message type is well-known and has a + custom JSON + + representation, that representation will be embedded + adding a field + + `value` which holds the custom JSON in addition to the + `@type` + + field. Example (for message [google.protobuf.Duration][]): + + { + "@type": "type.googleapis.com/google.protobuf.Duration", + "value": "1.212s" + } + title: data is an app specific data of the NFT. Optional + description: NFT defines the NFT. + title: >- + QueryNFTByQueryStringResponse is the response type for the + Query/NFT RPC method + default: + description: An unexpected error response. + schema: + type: object + properties: + error: + type: string + code: + type: integer + format: int32 + message: + type: string + details: + type: array + items: + type: object + properties: + type_url: + type: string + description: >- + A URL/resource name that uniquely identifies the type of + the serialized + + protocol buffer message. This string must contain at + least + + one "/" character. The last segment of the URL's path + must represent + + the fully qualified name of the type (as in + + `path/google.protobuf.Duration`). The name should be in + a canonical form + + (e.g., leading "." is not accepted). + + + In practice, teams usually precompile into the binary + all types that they + + expect it to use in the context of Any. However, for + URLs which use the + + scheme `http`, `https`, or no scheme, one can optionally + set up a type + + server that maps type URLs to message definitions as + follows: + + + * If no scheme is provided, `https` is assumed. + + * An HTTP GET on the URL must yield a + [google.protobuf.Type][] + value in binary format, or produce an error. + * Applications are allowed to cache lookup results based + on the + URL, or have them precompiled into a binary to avoid any + lookup. Therefore, binary compatibility needs to be preserved + on changes to types. (Use versioned type names to manage + breaking changes.) + + Note: this functionality is not currently available in + the official + + protobuf release, and it is not used for type URLs + beginning with + + type.googleapis.com. + + + Schemes other than `http`, `https` (or the empty scheme) + might be + + used with implementation specific semantics. + value: + type: string + format: byte + description: >- + Must be a valid serialized protocol buffer of the above + specified type. + description: >- + `Any` contains an arbitrary serialized protocol buffer + message along with a + + URL that describes the type of the serialized message. + + + Protobuf library provides support to pack/unpack Any values + in the form + + of utility functions or additional generated methods of the + Any type. + + + Example 1: Pack and unpack a message in C++. + + Foo foo = ...; + Any any; + any.PackFrom(foo); + ... + if (any.UnpackTo(&foo)) { + ... + } + + Example 2: Pack and unpack a message in Java. + + Foo foo = ...; + Any any = Any.pack(foo); + ... + if (any.is(Foo.class)) { + foo = any.unpack(Foo.class); + } + // or ... + if (any.isSameTypeAs(Foo.getDefaultInstance())) { + foo = any.unpack(Foo.getDefaultInstance()); + } + + Example 3: Pack and unpack a message in Python. + + foo = Foo(...) + any = Any() + any.Pack(foo) + ... + if any.Is(Foo.DESCRIPTOR): + any.Unpack(foo) + ... + + Example 4: Pack and unpack a message in Go + + foo := &pb.Foo{...} + any, err := anypb.New(foo) + if err != nil { + ... + } + ... + foo := &pb.Foo{} + if err := any.UnmarshalTo(foo); err != nil { + ... + } + + The pack methods provided by protobuf library will by + default use + + 'type.googleapis.com/full.type.name' as the type URL and the + unpack + + methods only use the fully qualified type name after the + last '/' + + in the type URL, for example "foo.bar.com/x/y.z" will yield + type + + name "y.z". + + + JSON + + ==== + + The JSON representation of an `Any` value uses the regular + + representation of the deserialized, embedded message, with + an + + additional field `@type` which contains the type URL. + Example: + + package google.profile; + message Person { + string first_name = 1; + string last_name = 2; + } + + { + "@type": "type.googleapis.com/google.profile.Person", + "firstName": , + "lastName": + } + + If the embedded message type is well-known and has a custom + JSON + + representation, that representation will be embedded adding + a field + + `value` which holds the custom JSON in addition to the + `@type` + + field. Example (for message [google.protobuf.Duration][]): + + { + "@type": "type.googleapis.com/google.protobuf.Duration", + "value": "1.212s" + } + parameters: + - name: class_id + description: class_id associated with the nft. + in: query + required: false + type: string + - name: id + description: id is a unique identifier of the NFT. + in: query + required: false + type: string + tags: + - Query /cosmos/nft/v1beta1/nfts: get: summary: >- @@ -32381,6 +33499,232 @@ paths: type: string tags: - Query + /cosmos/nft/v1beta1/owner: + get: + summary: >- + OwnerByQueryString queries the owner of the NFT based on its class and + id, same as ownerOf in ERC721 + operationId: OwnerByQueryString + responses: + '200': + description: A successful response. + schema: + type: object + properties: + owner: + type: string + title: owner is the owner address of the nft + title: >- + QueryOwnerByQueryStringResponse is the response type for the + Query/Owner RPC method + default: + description: An unexpected error response. + schema: + type: object + properties: + error: + type: string + code: + type: integer + format: int32 + message: + type: string + details: + type: array + items: + type: object + properties: + type_url: + type: string + description: >- + A URL/resource name that uniquely identifies the type of + the serialized + + protocol buffer message. This string must contain at + least + + one "/" character. The last segment of the URL's path + must represent + + the fully qualified name of the type (as in + + `path/google.protobuf.Duration`). The name should be in + a canonical form + + (e.g., leading "." is not accepted). + + + In practice, teams usually precompile into the binary + all types that they + + expect it to use in the context of Any. However, for + URLs which use the + + scheme `http`, `https`, or no scheme, one can optionally + set up a type + + server that maps type URLs to message definitions as + follows: + + + * If no scheme is provided, `https` is assumed. + + * An HTTP GET on the URL must yield a + [google.protobuf.Type][] + value in binary format, or produce an error. + * Applications are allowed to cache lookup results based + on the + URL, or have them precompiled into a binary to avoid any + lookup. Therefore, binary compatibility needs to be preserved + on changes to types. (Use versioned type names to manage + breaking changes.) + + Note: this functionality is not currently available in + the official + + protobuf release, and it is not used for type URLs + beginning with + + type.googleapis.com. + + + Schemes other than `http`, `https` (or the empty scheme) + might be + + used with implementation specific semantics. + value: + type: string + format: byte + description: >- + Must be a valid serialized protocol buffer of the above + specified type. + description: >- + `Any` contains an arbitrary serialized protocol buffer + message along with a + + URL that describes the type of the serialized message. + + + Protobuf library provides support to pack/unpack Any values + in the form + + of utility functions or additional generated methods of the + Any type. + + + Example 1: Pack and unpack a message in C++. + + Foo foo = ...; + Any any; + any.PackFrom(foo); + ... + if (any.UnpackTo(&foo)) { + ... + } + + Example 2: Pack and unpack a message in Java. + + Foo foo = ...; + Any any = Any.pack(foo); + ... + if (any.is(Foo.class)) { + foo = any.unpack(Foo.class); + } + // or ... + if (any.isSameTypeAs(Foo.getDefaultInstance())) { + foo = any.unpack(Foo.getDefaultInstance()); + } + + Example 3: Pack and unpack a message in Python. + + foo = Foo(...) + any = Any() + any.Pack(foo) + ... + if any.Is(Foo.DESCRIPTOR): + any.Unpack(foo) + ... + + Example 4: Pack and unpack a message in Go + + foo := &pb.Foo{...} + any, err := anypb.New(foo) + if err != nil { + ... + } + ... + foo := &pb.Foo{} + if err := any.UnmarshalTo(foo); err != nil { + ... + } + + The pack methods provided by protobuf library will by + default use + + 'type.googleapis.com/full.type.name' as the type URL and the + unpack + + methods only use the fully qualified type name after the + last '/' + + in the type URL, for example "foo.bar.com/x/y.z" will yield + type + + name "y.z". + + + JSON + + ==== + + The JSON representation of an `Any` value uses the regular + + representation of the deserialized, embedded message, with + an + + additional field `@type` which contains the type URL. + Example: + + package google.profile; + message Person { + string first_name = 1; + string last_name = 2; + } + + { + "@type": "type.googleapis.com/google.profile.Person", + "firstName": , + "lastName": + } + + If the embedded message type is well-known and has a custom + JSON + + representation, that representation will be embedded adding + a field + + `value` which holds the custom JSON in addition to the + `@type` + + field. Example (for message [google.protobuf.Duration][]): + + { + "@type": "type.googleapis.com/google.protobuf.Duration", + "value": "1.212s" + } + parameters: + - name: class_id + description: class_id associated with the nft. + in: query + required: false + type: string + - name: id + description: id is a unique identifier of the NFT. + in: query + required: false + type: string + tags: + - Query /cosmos/nft/v1beta1/owner/{class_id}/{id}: get: summary: >- @@ -32607,6 +33951,228 @@ paths: type: string tags: - Query + /cosmos/nft/v1beta1/supply: + get: + summary: >- + SupplyByQueryString queries the number of NFTs from the given class, + same as totalSupply of ERC721. + operationId: SupplyByQueryString + responses: + '200': + description: A successful response. + schema: + type: object + properties: + amount: + type: string + format: uint64 + title: amount is the number of all NFTs from the given class + title: >- + QuerySupplyByQueryStringResponse is the response type for the + Query/Supply RPC method + default: + description: An unexpected error response. + schema: + type: object + properties: + error: + type: string + code: + type: integer + format: int32 + message: + type: string + details: + type: array + items: + type: object + properties: + type_url: + type: string + description: >- + A URL/resource name that uniquely identifies the type of + the serialized + + protocol buffer message. This string must contain at + least + + one "/" character. The last segment of the URL's path + must represent + + the fully qualified name of the type (as in + + `path/google.protobuf.Duration`). The name should be in + a canonical form + + (e.g., leading "." is not accepted). + + + In practice, teams usually precompile into the binary + all types that they + + expect it to use in the context of Any. However, for + URLs which use the + + scheme `http`, `https`, or no scheme, one can optionally + set up a type + + server that maps type URLs to message definitions as + follows: + + + * If no scheme is provided, `https` is assumed. + + * An HTTP GET on the URL must yield a + [google.protobuf.Type][] + value in binary format, or produce an error. + * Applications are allowed to cache lookup results based + on the + URL, or have them precompiled into a binary to avoid any + lookup. Therefore, binary compatibility needs to be preserved + on changes to types. (Use versioned type names to manage + breaking changes.) + + Note: this functionality is not currently available in + the official + + protobuf release, and it is not used for type URLs + beginning with + + type.googleapis.com. + + + Schemes other than `http`, `https` (or the empty scheme) + might be + + used with implementation specific semantics. + value: + type: string + format: byte + description: >- + Must be a valid serialized protocol buffer of the above + specified type. + description: >- + `Any` contains an arbitrary serialized protocol buffer + message along with a + + URL that describes the type of the serialized message. + + + Protobuf library provides support to pack/unpack Any values + in the form + + of utility functions or additional generated methods of the + Any type. + + + Example 1: Pack and unpack a message in C++. + + Foo foo = ...; + Any any; + any.PackFrom(foo); + ... + if (any.UnpackTo(&foo)) { + ... + } + + Example 2: Pack and unpack a message in Java. + + Foo foo = ...; + Any any = Any.pack(foo); + ... + if (any.is(Foo.class)) { + foo = any.unpack(Foo.class); + } + // or ... + if (any.isSameTypeAs(Foo.getDefaultInstance())) { + foo = any.unpack(Foo.getDefaultInstance()); + } + + Example 3: Pack and unpack a message in Python. + + foo = Foo(...) + any = Any() + any.Pack(foo) + ... + if any.Is(Foo.DESCRIPTOR): + any.Unpack(foo) + ... + + Example 4: Pack and unpack a message in Go + + foo := &pb.Foo{...} + any, err := anypb.New(foo) + if err != nil { + ... + } + ... + foo := &pb.Foo{} + if err := any.UnmarshalTo(foo); err != nil { + ... + } + + The pack methods provided by protobuf library will by + default use + + 'type.googleapis.com/full.type.name' as the type URL and the + unpack + + methods only use the fully qualified type name after the + last '/' + + in the type URL, for example "foo.bar.com/x/y.z" will yield + type + + name "y.z". + + + JSON + + ==== + + The JSON representation of an `Any` value uses the regular + + representation of the deserialized, embedded message, with + an + + additional field `@type` which contains the type URL. + Example: + + package google.profile; + message Person { + string first_name = 1; + string last_name = 2; + } + + { + "@type": "type.googleapis.com/google.profile.Person", + "firstName": , + "lastName": + } + + If the embedded message type is well-known and has a custom + JSON + + representation, that representation will be embedded adding + a field + + `value` which holds the custom JSON in addition to the + `@type` + + field. Example (for message [google.protobuf.Duration][]): + + { + "@type": "type.googleapis.com/google.protobuf.Duration", + "value": "1.212s" + } + parameters: + - name: class_id + description: class_id associated with the nft. + in: query + required: false + type: string + tags: + - Query /cosmos/nft/v1beta1/supply/{class_id}: get: summary: >- @@ -49791,6 +51357,19 @@ definitions: burn_vote_veto: type: boolean title: burn deposits if quorum with vote type no_veto is met + min_deposit_ratio: + type: string + description: >- + The ratio representing the proportion of the deposit value minimum + that must be met when making a deposit. + + Default value: 0.01. Meaning that for a chain with a min_deposit of + 100stake, a deposit of 1stake would be + + required. + + + Since: cosmos-sdk 0.50 description: |- Params defines the parameters for the x/gov module. @@ -50380,6 +51959,19 @@ definitions: burn_vote_veto: type: boolean title: burn deposits if quorum with vote type no_veto is met + min_deposit_ratio: + type: string + description: >- + The ratio representing the proportion of the deposit value minimum + that must be met when making a deposit. + + Default value: 0.01. Meaning that for a chain with a min_deposit + of 100stake, a deposit of 1stake would be + + required. + + + Since: cosmos-sdk 0.50 description: QueryParamsResponse is the response type for the Query/Params RPC method. cosmos.gov.v1.QueryProposalResponse: type: object @@ -52203,6 +53795,21 @@ definitions: title: >- min_commission_rate is the chain-wide minimum commission rate that a validator can charge their delegators + key_rotation_fee: + type: object + properties: + denom: + type: string + amount: + type: string + description: |- + Coin defines a token with a denomination and an amount. + + NOTE: The amount field is an Int which implements the custom method + signatures required by gogoproto. + title: |- + key_rotation_fee is fee to be spent when rotating validator's key + (either consensus pubkey or operator key) description: Params defines the parameters for the x/staking module. cosmos.staking.v1beta1.Pool: type: object @@ -53537,6 +55144,24 @@ definitions: title: >- min_commission_rate is the chain-wide minimum commission rate that a validator can charge their delegators + key_rotation_fee: + type: object + properties: + denom: + type: string + amount: + type: string + description: >- + Coin defines a token with a denomination and an amount. + + + NOTE: The amount field is an Int which implements the custom + method + + signatures required by gogoproto. + title: |- + key_rotation_fee is fee to be spent when rotating validator's key + (either consensus pubkey or operator key) description: QueryParamsResponse is response type for the Query/Params RPC method. cosmos.staking.v1beta1.QueryPoolResponse: type: object @@ -62037,6 +63662,16 @@ definitions: } title: data is an app specific data of the NFT. Optional description: NFT defines the NFT. + cosmos.nft.v1beta1.QueryBalanceByQueryStringResponse: + type: object + properties: + amount: + type: string + format: uint64 + title: amount is the number of all NFTs of a given class owned by the owner + title: >- + QueryBalanceByQueryStringResponse is the response type for the + Query/Balance RPC method cosmos.nft.v1beta1.QueryBalanceResponse: type: object properties: @@ -62045,6 +63680,212 @@ definitions: format: uint64 title: amount is the number of all NFTs of a given class owned by the owner title: QueryBalanceResponse is the response type for the Query/Balance RPC method + cosmos.nft.v1beta1.QueryClassByQueryStringResponse: + type: object + properties: + class: + description: class defines the class of the nft type. + type: object + properties: + id: + type: string + title: >- + id defines the unique identifier of the NFT classification, + similar to the contract address of ERC721 + name: + type: string + title: >- + name defines the human-readable name of the NFT classification. + Optional + symbol: + type: string + title: symbol is an abbreviated name for nft classification. Optional + description: + type: string + title: description is a brief description of nft classification. Optional + uri: + type: string + title: >- + uri for the class metadata stored off chain. It can define schema + for Class and NFT `Data` attributes. Optional + uri_hash: + type: string + title: uri_hash is a hash of the document pointed by uri. Optional + data: + type: object + properties: + type_url: + type: string + description: >- + A URL/resource name that uniquely identifies the type of the + serialized + + protocol buffer message. This string must contain at least + + one "/" character. The last segment of the URL's path must + represent + + the fully qualified name of the type (as in + + `path/google.protobuf.Duration`). The name should be in a + canonical form + + (e.g., leading "." is not accepted). + + + In practice, teams usually precompile into the binary all + types that they + + expect it to use in the context of Any. However, for URLs + which use the + + scheme `http`, `https`, or no scheme, one can optionally set + up a type + + server that maps type URLs to message definitions as follows: + + + * If no scheme is provided, `https` is assumed. + + * An HTTP GET on the URL must yield a [google.protobuf.Type][] + value in binary format, or produce an error. + * Applications are allowed to cache lookup results based on + the + URL, or have them precompiled into a binary to avoid any + lookup. Therefore, binary compatibility needs to be preserved + on changes to types. (Use versioned type names to manage + breaking changes.) + + Note: this functionality is not currently available in the + official + + protobuf release, and it is not used for type URLs beginning + with + + type.googleapis.com. + + + Schemes other than `http`, `https` (or the empty scheme) might + be + + used with implementation specific semantics. + value: + type: string + format: byte + description: >- + Must be a valid serialized protocol buffer of the above + specified type. + description: >- + `Any` contains an arbitrary serialized protocol buffer message + along with a + + URL that describes the type of the serialized message. + + + Protobuf library provides support to pack/unpack Any values in the + form + + of utility functions or additional generated methods of the Any + type. + + + Example 1: Pack and unpack a message in C++. + + Foo foo = ...; + Any any; + any.PackFrom(foo); + ... + if (any.UnpackTo(&foo)) { + ... + } + + Example 2: Pack and unpack a message in Java. + + Foo foo = ...; + Any any = Any.pack(foo); + ... + if (any.is(Foo.class)) { + foo = any.unpack(Foo.class); + } + // or ... + if (any.isSameTypeAs(Foo.getDefaultInstance())) { + foo = any.unpack(Foo.getDefaultInstance()); + } + + Example 3: Pack and unpack a message in Python. + + foo = Foo(...) + any = Any() + any.Pack(foo) + ... + if any.Is(Foo.DESCRIPTOR): + any.Unpack(foo) + ... + + Example 4: Pack and unpack a message in Go + + foo := &pb.Foo{...} + any, err := anypb.New(foo) + if err != nil { + ... + } + ... + foo := &pb.Foo{} + if err := any.UnmarshalTo(foo); err != nil { + ... + } + + The pack methods provided by protobuf library will by default use + + 'type.googleapis.com/full.type.name' as the type URL and the + unpack + + methods only use the fully qualified type name after the last '/' + + in the type URL, for example "foo.bar.com/x/y.z" will yield type + + name "y.z". + + + JSON + + ==== + + The JSON representation of an `Any` value uses the regular + + representation of the deserialized, embedded message, with an + + additional field `@type` which contains the type URL. Example: + + package google.profile; + message Person { + string first_name = 1; + string last_name = 2; + } + + { + "@type": "type.googleapis.com/google.profile.Person", + "firstName": , + "lastName": + } + + If the embedded message type is well-known and has a custom JSON + + representation, that representation will be embedded adding a + field + + `value` which holds the custom JSON in addition to the `@type` + + field. Example (for message [google.protobuf.Duration][]): + + { + "@type": "type.googleapis.com/google.protobuf.Duration", + "value": "1.212s" + } + title: data is the app specific metadata of the NFT class. Optional + title: >- + QueryClassByQueryStringResponse is the response type for the Query/Class + RPC method cosmos.nft.v1beta1.QueryClassResponse: type: object properties: @@ -62481,6 +64322,203 @@ definitions: was set, its value is undefined otherwise title: QueryClassesResponse is the response type for the Query/Classes RPC method + cosmos.nft.v1beta1.QueryNFTByQueryStringResponse: + type: object + properties: + nft: + title: owner is the owner address of the nft + type: object + properties: + class_id: + type: string + title: >- + class_id associated with the NFT, similar to the contract address + of ERC721 + id: + type: string + title: id is a unique identifier of the NFT + uri: + type: string + title: uri for the NFT metadata stored off chain + uri_hash: + type: string + title: uri_hash is a hash of the document pointed by uri + data: + type: object + properties: + type_url: + type: string + description: >- + A URL/resource name that uniquely identifies the type of the + serialized + + protocol buffer message. This string must contain at least + + one "/" character. The last segment of the URL's path must + represent + + the fully qualified name of the type (as in + + `path/google.protobuf.Duration`). The name should be in a + canonical form + + (e.g., leading "." is not accepted). + + + In practice, teams usually precompile into the binary all + types that they + + expect it to use in the context of Any. However, for URLs + which use the + + scheme `http`, `https`, or no scheme, one can optionally set + up a type + + server that maps type URLs to message definitions as follows: + + + * If no scheme is provided, `https` is assumed. + + * An HTTP GET on the URL must yield a [google.protobuf.Type][] + value in binary format, or produce an error. + * Applications are allowed to cache lookup results based on + the + URL, or have them precompiled into a binary to avoid any + lookup. Therefore, binary compatibility needs to be preserved + on changes to types. (Use versioned type names to manage + breaking changes.) + + Note: this functionality is not currently available in the + official + + protobuf release, and it is not used for type URLs beginning + with + + type.googleapis.com. + + + Schemes other than `http`, `https` (or the empty scheme) might + be + + used with implementation specific semantics. + value: + type: string + format: byte + description: >- + Must be a valid serialized protocol buffer of the above + specified type. + description: >- + `Any` contains an arbitrary serialized protocol buffer message + along with a + + URL that describes the type of the serialized message. + + + Protobuf library provides support to pack/unpack Any values in the + form + + of utility functions or additional generated methods of the Any + type. + + + Example 1: Pack and unpack a message in C++. + + Foo foo = ...; + Any any; + any.PackFrom(foo); + ... + if (any.UnpackTo(&foo)) { + ... + } + + Example 2: Pack and unpack a message in Java. + + Foo foo = ...; + Any any = Any.pack(foo); + ... + if (any.is(Foo.class)) { + foo = any.unpack(Foo.class); + } + // or ... + if (any.isSameTypeAs(Foo.getDefaultInstance())) { + foo = any.unpack(Foo.getDefaultInstance()); + } + + Example 3: Pack and unpack a message in Python. + + foo = Foo(...) + any = Any() + any.Pack(foo) + ... + if any.Is(Foo.DESCRIPTOR): + any.Unpack(foo) + ... + + Example 4: Pack and unpack a message in Go + + foo := &pb.Foo{...} + any, err := anypb.New(foo) + if err != nil { + ... + } + ... + foo := &pb.Foo{} + if err := any.UnmarshalTo(foo); err != nil { + ... + } + + The pack methods provided by protobuf library will by default use + + 'type.googleapis.com/full.type.name' as the type URL and the + unpack + + methods only use the fully qualified type name after the last '/' + + in the type URL, for example "foo.bar.com/x/y.z" will yield type + + name "y.z". + + + JSON + + ==== + + The JSON representation of an `Any` value uses the regular + + representation of the deserialized, embedded message, with an + + additional field `@type` which contains the type URL. Example: + + package google.profile; + message Person { + string first_name = 1; + string last_name = 2; + } + + { + "@type": "type.googleapis.com/google.profile.Person", + "firstName": , + "lastName": + } + + If the embedded message type is well-known and has a custom JSON + + representation, that representation will be embedded adding a + field + + `value` which holds the custom JSON in addition to the `@type` + + field. Example (for message [google.protobuf.Duration][]): + + { + "@type": "type.googleapis.com/google.protobuf.Duration", + "value": "1.212s" + } + title: data is an app specific data of the NFT. Optional + description: NFT defines the NFT. + title: >- + QueryNFTByQueryStringResponse is the response type for the Query/NFT RPC + method cosmos.nft.v1beta1.QueryNFTResponse: type: object properties: @@ -62896,6 +64934,15 @@ definitions: was set, its value is undefined otherwise title: QueryNFTsResponse is the response type for the Query/NFTs RPC methods + cosmos.nft.v1beta1.QueryOwnerByQueryStringResponse: + type: object + properties: + owner: + type: string + title: owner is the owner address of the nft + title: >- + QueryOwnerByQueryStringResponse is the response type for the Query/Owner + RPC method cosmos.nft.v1beta1.QueryOwnerResponse: type: object properties: @@ -62903,6 +64950,16 @@ definitions: type: string title: owner is the owner address of the nft title: QueryOwnerResponse is the response type for the Query/Owner RPC method + cosmos.nft.v1beta1.QuerySupplyByQueryStringResponse: + type: object + properties: + amount: + type: string + format: uint64 + title: amount is the number of all NFTs from the given class + title: >- + QuerySupplyByQueryStringResponse is the response type for the Query/Supply + RPC method cosmos.nft.v1beta1.QuerySupplyResponse: type: object properties: diff --git a/proto/cosmos/nft/v1beta1/query.proto b/proto/cosmos/nft/v1beta1/query.proto index bdc794ff6c..0f1c75c17b 100644 --- a/proto/cosmos/nft/v1beta1/query.proto +++ b/proto/cosmos/nft/v1beta1/query.proto @@ -14,16 +14,37 @@ service Query { option (google.api.http).get = "/cosmos/nft/v1beta1/balance/{owner}/{class_id}"; } + // BalancebyQueryString queries the number of NFTs of a given class owned by the owner, same as balanceOf in ERC721 + // + // Since: nft v0.1.1 + rpc BalanceByQueryString(QueryBalanceByQueryStringRequest) returns (QueryBalanceByQueryStringResponse) { + option (google.api.http).get = "/cosmos/nft/v1beta1/balance"; + } + // Owner queries the owner of the NFT based on its class and id, same as ownerOf in ERC721 rpc Owner(QueryOwnerRequest) returns (QueryOwnerResponse) { option (google.api.http).get = "/cosmos/nft/v1beta1/owner/{class_id}/{id}"; } + // OwnerByQueryString queries the owner of the NFT based on its class and id, same as ownerOf in ERC721 + // + // Since: nft v0.1.1 + rpc OwnerByQueryString(QueryOwnerByQueryStringRequest) returns (QueryOwnerByQueryStringResponse) { + option (google.api.http).get = "/cosmos/nft/v1beta1/owner"; + } + // Supply queries the number of NFTs from the given class, same as totalSupply of ERC721. rpc Supply(QuerySupplyRequest) returns (QuerySupplyResponse) { option (google.api.http).get = "/cosmos/nft/v1beta1/supply/{class_id}"; } + // SupplyByQueryString queries the number of NFTs from the given class, same as totalSupply of ERC721. + // + // Since: nft v0.1.1 + rpc SupplyByQueryString(QuerySupplyByQueryStringRequest) returns (QuerySupplyByQueryStringResponse) { + option (google.api.http).get = "/cosmos/nft/v1beta1/supply"; + } + // NFTs queries all NFTs of a given class or owner,choose at least one of the two, similar to tokenByIndex in // ERC721Enumerable rpc NFTs(QueryNFTsRequest) returns (QueryNFTsResponse) { @@ -35,11 +56,25 @@ service Query { option (google.api.http).get = "/cosmos/nft/v1beta1/nfts/{class_id}/{id}"; } + // NFTByQueryString queries an NFT based on its class and id. + // + // Since: nft v0.1.1 + rpc NFTByQueryString(QueryNFTByQueryStringRequest) returns (QueryNFTByQueryStringResponse) { + option (google.api.http).get = "/cosmos/nft/v1beta1/nft"; + } + // Class queries an NFT class based on its id rpc Class(QueryClassRequest) returns (QueryClassResponse) { option (google.api.http).get = "/cosmos/nft/v1beta1/classes/{class_id}"; } + // Class queries an NFT class based on its id + // + // Since: nft v0.1.1 + rpc ClassByQueryString(QueryClassByQueryStringRequest) returns (QueryClassByQueryStringResponse) { + option (google.api.http).get = "/cosmos/nft/v1beta1/class"; + } + // Classes queries all NFT classes rpc Classes(QueryClassesRequest) returns (QueryClassesResponse) { option (google.api.http).get = "/cosmos/nft/v1beta1/classes"; @@ -55,12 +90,31 @@ message QueryBalanceRequest { string owner = 2; } +// QueryBalanceByQueryStringRequest is the request type for the Query/Balance RPC method +// +// Since: nft v0.1.1 +message QueryBalanceByQueryStringRequest { + // class_id associated with the nft + string class_id = 1; + + // owner is the owner address of the nft + string owner = 2; +} + // QueryBalanceResponse is the response type for the Query/Balance RPC method message QueryBalanceResponse { // amount is the number of all NFTs of a given class owned by the owner uint64 amount = 1; } +// QueryBalanceByQueryStringResponse is the response type for the Query/Balance RPC method +// +// Since: nft v0.1.1 +message QueryBalanceByQueryStringResponse { + // amount is the number of all NFTs of a given class owned by the owner + uint64 amount = 1; +} + // QueryOwnerRequest is the request type for the Query/Owner RPC method message QueryOwnerRequest { // class_id associated with the nft @@ -70,24 +124,59 @@ message QueryOwnerRequest { string id = 2; } +// QueryOwnerByQueryStringRequest is the request type for the Query/Owner RPC method +// +// Since: nft v0.1.1 +message QueryOwnerByQueryStringRequest { + // class_id associated with the nft + string class_id = 1; + + // id is a unique identifier of the NFT + string id = 2; +} + // QueryOwnerResponse is the response type for the Query/Owner RPC method message QueryOwnerResponse { // owner is the owner address of the nft string owner = 1; } +// QueryOwnerByQueryStringResponse is the response type for the Query/Owner RPC method +// +// Since: nft v0.1.1 +message QueryOwnerByQueryStringResponse { + // owner is the owner address of the nft + string owner = 1; +} + // QuerySupplyRequest is the request type for the Query/Supply RPC method message QuerySupplyRequest { // class_id associated with the nft string class_id = 1; } +// QuerySupplyByQueryStringRequest is the request type for the Query/Supply RPC method +// +// Since: nft v0.1.1 +message QuerySupplyByQueryStringRequest { + // class_id associated with the nft + string class_id = 1; +} + // QuerySupplyResponse is the response type for the Query/Supply RPC method message QuerySupplyResponse { // amount is the number of all NFTs from the given class uint64 amount = 1; } +// QuerySupplyByQueryStringResponse is the response type for the Query/Supply RPC method +// +// Since: nft v0.1.1 +message QuerySupplyByQueryStringResponse { + // amount is the number of all NFTs from the given class + uint64 amount = 1; +} + // QueryNFTstRequest is the request type for the Query/NFTs RPC method message QueryNFTsRequest { // class_id associated with the nft @@ -118,24 +207,59 @@ message QueryNFTRequest { string id = 2; } +// QueryNFTByQueryStringRequest is the request type for the Query/NFT RPC method +// +// Since: nft v0.1.1 +message QueryNFTByQueryStringRequest { + // class_id associated with the nft + string class_id = 1; + + // id is a unique identifier of the NFT + string id = 2; +} + // QueryNFTResponse is the response type for the Query/NFT RPC method message QueryNFTResponse { // owner is the owner address of the nft cosmos.nft.v1beta1.NFT nft = 1; } +// QueryNFTByQueryStringResponse is the response type for the Query/NFT RPC method +// +// Since: nft v0.1.1 +message QueryNFTByQueryStringResponse { + // owner is the owner address of the nft + cosmos.nft.v1beta1.NFT nft = 1; +} + // QueryClassRequest is the request type for the Query/Class RPC method message QueryClassRequest { // class_id associated with the nft string class_id = 1; } +// QueryClassByQueryStringRequest is the request type for the Query/Class RPC method +// +// Since: nft v0.1.1 +message QueryClassByQueryStringRequest { + // class_id associated with the nft + string class_id = 1; +} + // QueryClassResponse is the response type for the Query/Class RPC method message QueryClassResponse { // class defines the class of the nft type. cosmos.nft.v1beta1.Class class = 1; } +// QueryClassByQueryStringResponse is the response type for the Query/Class RPC method +// +// Since: nft v0.1.1 +message QueryClassByQueryStringResponse { + // class defines the class of the nft type. + cosmos.nft.v1beta1.Class class = 1; +} + // QueryClassesRequest is the request type for the Query/Classes RPC method message QueryClassesRequest { // pagination defines an optional pagination for the request. diff --git a/x/nft/CHANGELOG.md b/x/nft/CHANGELOG.md index 9896b02034..bb88fc70f9 100644 --- a/x/nft/CHANGELOG.md +++ b/x/nft/CHANGELOG.md @@ -31,4 +31,7 @@ Ref: https://keepachangelog.com/en/1.0.0/ ## [Unreleased] +### Features +* [#18355](https://github.com/cosmos/cosmos-sdk/pull/18355) Addes new versions for `Balance`, `Owner`, `Supply`, `NFT`, `Class` queries that receives request via query string. + ## [v0.1.0](https://github.com/cosmos/cosmos-sdk/releases/tag/x/nft/v0.1.0) - 2023-11-07 diff --git a/x/nft/keeper/grpc_query.go b/x/nft/keeper/grpc_query.go index e4ccb1cc31..725dd2fec1 100644 --- a/x/nft/keeper/grpc_query.go +++ b/x/nft/keeper/grpc_query.go @@ -34,6 +34,19 @@ func (k Keeper) Balance(goCtx context.Context, r *nft.QueryBalanceRequest) (*nft return &nft.QueryBalanceResponse{Amount: balance}, nil } +// BalanceByQueryString return the number of NFTs of a given class owned by the owner, same as balanceOf in ERC721 +// but receives request via query string. +func (k Keeper) BalanceByQueryString(goCtx context.Context, r *nft.QueryBalanceByQueryStringRequest) (*nft.QueryBalanceByQueryStringResponse, error) { + res, err := k.Balance(goCtx, &nft.QueryBalanceRequest{ + ClassId: r.ClassId, + Owner: r.Owner, + }) + if err != nil { + return nil, err + } + return &nft.QueryBalanceByQueryStringResponse{Amount: res.Amount}, nil +} + // Owner return the owner of the NFT based on its class and id, same as ownerOf in ERC721 func (k Keeper) Owner(goCtx context.Context, r *nft.QueryOwnerRequest) (*nft.QueryOwnerResponse, error) { if r == nil { @@ -60,6 +73,19 @@ func (k Keeper) Owner(goCtx context.Context, r *nft.QueryOwnerRequest) (*nft.Que return &nft.QueryOwnerResponse{Owner: ownerstr}, nil } +// OwnerByQueryString return the owner of the NFT based on its class and id, same as ownerOf in ERC721 +// but receives request via query string. +func (k Keeper) OwnerByQueryString(goCtx context.Context, r *nft.QueryOwnerByQueryStringRequest) (*nft.QueryOwnerByQueryStringResponse, error) { + res, err := k.Owner(goCtx, &nft.QueryOwnerRequest{ + ClassId: r.ClassId, + Id: r.Id, + }) + if err != nil { + return nil, err + } + return &nft.QueryOwnerByQueryStringResponse{Owner: res.Owner}, nil +} + // Supply return the number of NFTs from the given class, same as totalSupply of ERC721. func (k Keeper) Supply(goCtx context.Context, r *nft.QuerySupplyRequest) (*nft.QuerySupplyResponse, error) { if r == nil { @@ -74,6 +100,18 @@ func (k Keeper) Supply(goCtx context.Context, r *nft.QuerySupplyRequest) (*nft.Q return &nft.QuerySupplyResponse{Amount: supply}, nil } +// SupplyByQueryString return the number of NFTs from the given class, same as totalSupply of ERC721. +// but receives request via query string. +func (k Keeper) SupplyByQueryString(goCtx context.Context, r *nft.QuerySupplyByQueryStringRequest) (*nft.QuerySupplyByQueryStringResponse, error) { + res, err := k.Supply(goCtx, &nft.QuerySupplyRequest{ + ClassId: r.ClassId, + }) + if err != nil { + return nil, err + } + return &nft.QuerySupplyByQueryStringResponse{Amount: res.Amount}, nil +} + // NFTs queries all NFTs of a given class or owner (at least one must be provided), similar to tokenByIndex in ERC721Enumerable func (k Keeper) NFTs(goCtx context.Context, r *nft.QueryNFTsRequest) (*nft.QueryNFTsResponse, error) { if r == nil { @@ -157,6 +195,19 @@ func (k Keeper) NFT(goCtx context.Context, r *nft.QueryNFTRequest) (*nft.QueryNF return &nft.QueryNFTResponse{Nft: &n}, nil } +// NFTByQueryString return an NFT based on its class and id. +// but receives request via query string. +func (k Keeper) NFTByQueryString(goCtx context.Context, r *nft.QueryNFTByQueryStringRequest) (*nft.QueryNFTByQueryStringResponse, error) { + res, err := k.NFT(goCtx, &nft.QueryNFTRequest{ + ClassId: r.ClassId, + Id: r.Id, + }) + if err != nil { + return nil, err + } + return &nft.QueryNFTByQueryStringResponse{Nft: res.Nft}, nil +} + // Class return an NFT class based on its id func (k Keeper) Class(goCtx context.Context, r *nft.QueryClassRequest) (*nft.QueryClassResponse, error) { if r == nil { @@ -175,6 +226,18 @@ func (k Keeper) Class(goCtx context.Context, r *nft.QueryClassRequest) (*nft.Que return &nft.QueryClassResponse{Class: &class}, nil } +// ClassByQueryString return an NFT class based on its id +// but receives request via query string. +func (k Keeper) ClassByQueryString(goCtx context.Context, r *nft.QueryClassByQueryStringRequest) (*nft.QueryClassByQueryStringResponse, error) { + res, err := k.Class(goCtx, &nft.QueryClassRequest{ + ClassId: r.ClassId, + }) + if err != nil { + return nil, err + } + return &nft.QueryClassByQueryStringResponse{Class: res.Class}, nil +} + // Classes return all NFT classes func (k Keeper) Classes(goCtx context.Context, r *nft.QueryClassesRequest) (*nft.QueryClassesResponse, error) { if r == nil { diff --git a/x/nft/keeper/grpc_query_test.go b/x/nft/keeper/grpc_query_test.go index 42e5c56586..dd6f336394 100644 --- a/x/nft/keeper/grpc_query_test.go +++ b/x/nft/keeper/grpc_query_test.go @@ -80,6 +80,71 @@ func (s *TestSuite) TestBalance() { } } +func (s *TestSuite) TestBalanceByQueryString() { + s.accountKeeper.EXPECT().AddressCodec().Return(address.NewBech32Codec("cosmos")).AnyTimes() + var req *nft.QueryBalanceByQueryStringRequest + testCases := []struct { + msg string + malleate func(index int, require *require.Assertions) + expError string + balance uint64 + postTest func(index int, require *require.Assertions, res *nft.QueryBalanceByQueryStringResponse, expBalance uint64) + }{ + { + "fail empty ClassId", + func(index int, require *require.Assertions) { + req = &nft.QueryBalanceByQueryStringRequest{} + }, + nft.ErrEmptyClassID.Error(), + 0, + func(index int, require *require.Assertions, res *nft.QueryBalanceByQueryStringResponse, expBalance uint64) { + }, + }, + { + "fail invalid Owner addr", + func(index int, require *require.Assertions) { + req = &nft.QueryBalanceByQueryStringRequest{ + ClassId: testClassID, + Owner: "owner", + } + }, + "decoding bech32 failed", + 0, + func(index int, require *require.Assertions, res *nft.QueryBalanceByQueryStringResponse, expBalance uint64) { + }, + }, + { + "Success", + func(index int, require *require.Assertions) { + s.TestMint() + req = &nft.QueryBalanceByQueryStringRequest{ + ClassId: testClassID, + Owner: s.encodedAddrs[0], + } + }, + "", + 2, + func(index int, require *require.Assertions, res *nft.QueryBalanceByQueryStringResponse, expBalance uint64) { + require.Equal(res.Amount, expBalance, "the error occurred on:%d", index) + }, + }, + } + for index, tc := range testCases { + s.Run(fmt.Sprintf("Case %s", tc.msg), func() { + require := s.Require() + tc.malleate(index, require) + result, err := s.queryClient.BalanceByQueryString(gocontext.Background(), req) + if tc.expError == "" { + require.NoError(err) + } else { + require.Error(err) + require.Contains(err.Error(), tc.expError) + } + tc.postTest(index, require, result, tc.balance) + }) + } +} + func (s *TestSuite) TestOwner() { var ( req *nft.QueryOwnerRequest @@ -169,6 +234,95 @@ func (s *TestSuite) TestOwner() { } } +func (s *TestSuite) TestOwnerByQueryString() { + var ( + req *nft.QueryOwnerByQueryStringRequest + owner string + ) + testCases := []struct { + msg string + malleate func(index int, require *require.Assertions) + expError string + postTest func(index int, require *require.Assertions, res *nft.QueryOwnerByQueryStringResponse) + }{ + { + "fail empty ClassId", + func(index int, require *require.Assertions) { + req = &nft.QueryOwnerByQueryStringRequest{ + Id: testID, + } + }, + nft.ErrEmptyClassID.Error(), + func(index int, require *require.Assertions, res *nft.QueryOwnerByQueryStringResponse) {}, + }, + { + "fail empty nft id", + func(index int, require *require.Assertions) { + req = &nft.QueryOwnerByQueryStringRequest{ + ClassId: testClassID, + } + }, + nft.ErrEmptyNFTID.Error(), + func(index int, require *require.Assertions, res *nft.QueryOwnerByQueryStringResponse) {}, + }, + { + "success but nft id not exist", + func(index int, require *require.Assertions) { + req = &nft.QueryOwnerByQueryStringRequest{ + ClassId: testClassID, + Id: "kitty2", + } + }, + "", + func(index int, require *require.Assertions, res *nft.QueryOwnerByQueryStringResponse) { + require.Equal(res.Owner, owner, "the error occurred on:%d", index) + }, + }, + { + "success but class id not exist", + func(index int, require *require.Assertions) { + req = &nft.QueryOwnerByQueryStringRequest{ + ClassId: "kitty1", + Id: testID, + } + }, + "", + func(index int, require *require.Assertions, res *nft.QueryOwnerByQueryStringResponse) { + require.Equal(res.Owner, owner, "the error occurred on:%d", index) + }, + }, + { + "Success", + func(index int, require *require.Assertions) { + s.TestMint() + req = &nft.QueryOwnerByQueryStringRequest{ + ClassId: testClassID, + Id: testID, + } + owner = s.encodedAddrs[0] + }, + "", + func(index int, require *require.Assertions, res *nft.QueryOwnerByQueryStringResponse) { + require.Equal(res.Owner, owner, "the error occurred on:%d", index) + }, + }, + } + for index, tc := range testCases { + s.Run(fmt.Sprintf("Case %s", tc.msg), func() { + require := s.Require() + tc.malleate(index, require) + result, err := s.queryClient.OwnerByQueryString(gocontext.Background(), req) + if tc.expError == "" { + require.NoError(err) + } else { + require.Error(err) + require.Contains(err.Error(), tc.expError) + } + tc.postTest(index, require, result) + }) + } +} + func (s *TestSuite) TestSupply() { var req *nft.QuerySupplyRequest testCases := []struct { @@ -252,6 +406,90 @@ func (s *TestSuite) TestSupply() { } } +func (s *TestSuite) TestSupplyByQueryString() { + var req *nft.QuerySupplyByQueryStringRequest + testCases := []struct { + msg string + malleate func(index int, require *require.Assertions) + expError string + supply uint64 + postTest func(index int, require *require.Assertions, res *nft.QuerySupplyByQueryStringResponse, supply uint64) + }{ + { + "fail empty ClassId", + func(index int, require *require.Assertions) { + req = &nft.QuerySupplyByQueryStringRequest{} + }, + nft.ErrEmptyClassID.Error(), + 0, + func(index int, require *require.Assertions, res *nft.QuerySupplyByQueryStringResponse, supply uint64) { + }, + }, + { + "success but class id not exist", + func(index int, require *require.Assertions) { + req = &nft.QuerySupplyByQueryStringRequest{ + ClassId: "kitty1", + } + }, + "", + 0, + func(index int, require *require.Assertions, res *nft.QuerySupplyByQueryStringResponse, supply uint64) { + require.Equal(res.Amount, supply, "the error occurred on:%d", index) + }, + }, + { + "success but supply equal zero", + func(index int, require *require.Assertions) { + req = &nft.QuerySupplyByQueryStringRequest{ + ClassId: testClassID, + } + s.TestSaveClass() + }, + "", + 0, + func(index int, require *require.Assertions, res *nft.QuerySupplyByQueryStringResponse, supply uint64) { + require.Equal(res.Amount, supply, "the error occurred on:%d", index) + }, + }, + { + "Success", + func(index int, require *require.Assertions) { + n := nft.NFT{ + ClassId: testClassID, + Id: testID, + Uri: testURI, + } + err := s.nftKeeper.Mint(s.ctx, n, s.addrs[0]) + require.NoError(err, "the error occurred on:%d", index) + + req = &nft.QuerySupplyByQueryStringRequest{ + ClassId: testClassID, + } + }, + "", + 1, + func(index int, require *require.Assertions, res *nft.QuerySupplyByQueryStringResponse, supply uint64) { + require.Equal(res.Amount, supply, "the error occurred on:%d", index) + }, + }, + } + for index, tc := range testCases { + s.Run(fmt.Sprintf("Case %s", tc.msg), func() { + require := s.Require() + tc.malleate(index, require) + result, err := s.queryClient.SupplyByQueryString(gocontext.Background(), req) + if tc.expError == "" { + require.NoError(err) + } else { + require.Error(err) + require.Contains(err.Error(), tc.expError) + } + tc.postTest(index, require, result, tc.supply) + }) + } +} + func (s *TestSuite) TestNFTs() { var ( req *nft.QueryNFTsRequest @@ -467,6 +705,93 @@ func (s *TestSuite) TestNFT() { } } +func (s *TestSuite) TestNFTByQueryString() { + var ( + req *nft.QueryNFTByQueryStringRequest + expNFT nft.NFT + ) + testCases := []struct { + msg string + malleate func(index int, require *require.Assertions) + expError string + postTest func(index int, require *require.Assertions, res *nft.QueryNFTByQueryStringResponse) + }{ + { + "fail empty ClassId", + func(index int, require *require.Assertions) { + req = &nft.QueryNFTByQueryStringRequest{} + }, + nft.ErrEmptyClassID.Error(), + func(index int, require *require.Assertions, res *nft.QueryNFTByQueryStringResponse) {}, + }, + { + "fail empty nft id", + func(index int, require *require.Assertions) { + req = &nft.QueryNFTByQueryStringRequest{ + ClassId: testClassID, + } + }, + nft.ErrEmptyNFTID.Error(), + func(index int, require *require.Assertions, res *nft.QueryNFTByQueryStringResponse) {}, + }, + { + "fail ClassId not exist", + func(index int, require *require.Assertions) { + req = &nft.QueryNFTByQueryStringRequest{ + ClassId: "kitty1", + Id: testID, + } + s.TestMint() + }, + "not found nft", + func(index int, require *require.Assertions, res *nft.QueryNFTByQueryStringResponse) {}, + }, + { + "fail nft id not exist", + func(index int, require *require.Assertions) { + req = &nft.QueryNFTByQueryStringRequest{ + ClassId: testClassID, + Id: "kitty2", + } + }, + "not found nft", + func(index int, require *require.Assertions, res *nft.QueryNFTByQueryStringResponse) {}, + }, + { + "success", + func(index int, require *require.Assertions) { + req = &nft.QueryNFTByQueryStringRequest{ + ClassId: testClassID, + Id: testID, + } + expNFT = nft.NFT{ + ClassId: testClassID, + Id: testID, + Uri: testURI, + } + }, + "", + func(index int, require *require.Assertions, res *nft.QueryNFTByQueryStringResponse) { + require.Equal(*res.Nft, expNFT, "the error occurred on:%d", index) + }, + }, + } + for index, tc := range testCases { + s.Run(fmt.Sprintf("Case %s", tc.msg), func() { + require := s.Require() + tc.malleate(index, require) + result, err := s.queryClient.NFTByQueryString(gocontext.Background(), req) + if tc.expError == "" { + require.NoError(err) + } else { + require.Error(err) + require.Contains(err.Error(), tc.expError) + } + tc.postTest(index, require, result) + }) + } +} + func (s *TestSuite) TestClass() { var ( req *nft.QueryClassRequest @@ -534,6 +859,73 @@ func (s *TestSuite) TestClass() { } } +func (s *TestSuite) TestClassByQueryString() { + var ( + req *nft.QueryClassByQueryStringRequest + class nft.Class + ) + testCases := []struct { + msg string + malleate func(index int, require *require.Assertions) + expError string + postTest func(index int, require *require.Assertions, res *nft.QueryClassByQueryStringResponse) + }{ + { + "fail empty ClassId", + func(index int, require *require.Assertions) { + req = &nft.QueryClassByQueryStringRequest{} + }, + nft.ErrEmptyClassID.Error(), + func(index int, require *require.Assertions, res *nft.QueryClassByQueryStringResponse) {}, + }, + { + "fail ClassId not exist", + func(index int, require *require.Assertions) { + req = &nft.QueryClassByQueryStringRequest{ + ClassId: "kitty1", + } + s.TestSaveClass() + }, + "not found class", + func(index int, require *require.Assertions, res *nft.QueryClassByQueryStringResponse) {}, + }, + { + "success", + func(index int, require *require.Assertions) { + class = nft.Class{ + Id: testClassID, + Name: testClassName, + Symbol: testClassSymbol, + Description: testClassDescription, + Uri: testClassURI, + UriHash: testClassURIHash, + } + req = &nft.QueryClassByQueryStringRequest{ + ClassId: testClassID, + } + }, + "", + func(index int, require *require.Assertions, res *nft.QueryClassByQueryStringResponse) { + require.Equal(*res.Class, class, "the error occurred on:%d", index) + }, + }, + } + for index, tc := range testCases { + s.Run(fmt.Sprintf("Case %s", tc.msg), func() { + require := s.Require() + tc.malleate(index, require) + result, err := s.queryClient.ClassByQueryString(gocontext.Background(), req) + if tc.expError == "" { + require.NoError(err) + } else { + require.Error(err) + require.Contains(err.Error(), tc.expError) + } + tc.postTest(index, require, result) + }) + } +} + func (s *TestSuite) TestClasses() { var ( req *nft.QueryClassesRequest diff --git a/x/nft/query.pb.go b/x/nft/query.pb.go index 25157b8ded..e6ef5e297c 100644 --- a/x/nft/query.pb.go +++ b/x/nft/query.pb.go @@ -84,6 +84,61 @@ func (m *QueryBalanceRequest) GetOwner() string { return "" } +// QueryBalanceByQueryStringRequest is the request type for the Query/Balance RPC method +type QueryBalanceByQueryStringRequest struct { + // class_id associated with the nft + ClassId string `protobuf:"bytes,1,opt,name=class_id,json=classId,proto3" json:"class_id,omitempty"` + // owner is the owner address of the nft + Owner string `protobuf:"bytes,2,opt,name=owner,proto3" json:"owner,omitempty"` +} + +func (m *QueryBalanceByQueryStringRequest) Reset() { *m = QueryBalanceByQueryStringRequest{} } +func (m *QueryBalanceByQueryStringRequest) String() string { return proto.CompactTextString(m) } +func (*QueryBalanceByQueryStringRequest) ProtoMessage() {} +func (*QueryBalanceByQueryStringRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_0d24e0db697b0f9d, []int{1} +} +func (m *QueryBalanceByQueryStringRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryBalanceByQueryStringRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryBalanceByQueryStringRequest.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 *QueryBalanceByQueryStringRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryBalanceByQueryStringRequest.Merge(m, src) +} +func (m *QueryBalanceByQueryStringRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryBalanceByQueryStringRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryBalanceByQueryStringRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryBalanceByQueryStringRequest proto.InternalMessageInfo + +func (m *QueryBalanceByQueryStringRequest) GetClassId() string { + if m != nil { + return m.ClassId + } + return "" +} + +func (m *QueryBalanceByQueryStringRequest) GetOwner() string { + if m != nil { + return m.Owner + } + return "" +} + // QueryBalanceResponse is the response type for the Query/Balance RPC method type QueryBalanceResponse struct { // amount is the number of all NFTs of a given class owned by the owner @@ -94,7 +149,7 @@ func (m *QueryBalanceResponse) Reset() { *m = QueryBalanceResponse{} } func (m *QueryBalanceResponse) String() string { return proto.CompactTextString(m) } func (*QueryBalanceResponse) ProtoMessage() {} func (*QueryBalanceResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_0d24e0db697b0f9d, []int{1} + return fileDescriptor_0d24e0db697b0f9d, []int{2} } func (m *QueryBalanceResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -130,6 +185,52 @@ func (m *QueryBalanceResponse) GetAmount() uint64 { return 0 } +// QueryBalanceByQueryStringResponse is the response type for the Query/Balance RPC method +type QueryBalanceByQueryStringResponse struct { + // amount is the number of all NFTs of a given class owned by the owner + Amount uint64 `protobuf:"varint,1,opt,name=amount,proto3" json:"amount,omitempty"` +} + +func (m *QueryBalanceByQueryStringResponse) Reset() { *m = QueryBalanceByQueryStringResponse{} } +func (m *QueryBalanceByQueryStringResponse) String() string { return proto.CompactTextString(m) } +func (*QueryBalanceByQueryStringResponse) ProtoMessage() {} +func (*QueryBalanceByQueryStringResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_0d24e0db697b0f9d, []int{3} +} +func (m *QueryBalanceByQueryStringResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryBalanceByQueryStringResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryBalanceByQueryStringResponse.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 *QueryBalanceByQueryStringResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryBalanceByQueryStringResponse.Merge(m, src) +} +func (m *QueryBalanceByQueryStringResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryBalanceByQueryStringResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryBalanceByQueryStringResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryBalanceByQueryStringResponse proto.InternalMessageInfo + +func (m *QueryBalanceByQueryStringResponse) GetAmount() uint64 { + if m != nil { + return m.Amount + } + return 0 +} + // QueryOwnerRequest is the request type for the Query/Owner RPC method type QueryOwnerRequest struct { // class_id associated with the nft @@ -142,7 +243,7 @@ func (m *QueryOwnerRequest) Reset() { *m = QueryOwnerRequest{} } func (m *QueryOwnerRequest) String() string { return proto.CompactTextString(m) } func (*QueryOwnerRequest) ProtoMessage() {} func (*QueryOwnerRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_0d24e0db697b0f9d, []int{2} + return fileDescriptor_0d24e0db697b0f9d, []int{4} } func (m *QueryOwnerRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -185,6 +286,61 @@ func (m *QueryOwnerRequest) GetId() string { return "" } +// QueryOwnerByQueryStringRequest is the request type for the Query/Owner RPC method +type QueryOwnerByQueryStringRequest struct { + // class_id associated with the nft + ClassId string `protobuf:"bytes,1,opt,name=class_id,json=classId,proto3" json:"class_id,omitempty"` + // id is a unique identifier of the NFT + Id string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"` +} + +func (m *QueryOwnerByQueryStringRequest) Reset() { *m = QueryOwnerByQueryStringRequest{} } +func (m *QueryOwnerByQueryStringRequest) String() string { return proto.CompactTextString(m) } +func (*QueryOwnerByQueryStringRequest) ProtoMessage() {} +func (*QueryOwnerByQueryStringRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_0d24e0db697b0f9d, []int{5} +} +func (m *QueryOwnerByQueryStringRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryOwnerByQueryStringRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryOwnerByQueryStringRequest.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 *QueryOwnerByQueryStringRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryOwnerByQueryStringRequest.Merge(m, src) +} +func (m *QueryOwnerByQueryStringRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryOwnerByQueryStringRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryOwnerByQueryStringRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryOwnerByQueryStringRequest proto.InternalMessageInfo + +func (m *QueryOwnerByQueryStringRequest) GetClassId() string { + if m != nil { + return m.ClassId + } + return "" +} + +func (m *QueryOwnerByQueryStringRequest) GetId() string { + if m != nil { + return m.Id + } + return "" +} + // QueryOwnerResponse is the response type for the Query/Owner RPC method type QueryOwnerResponse struct { // owner is the owner address of the nft @@ -195,7 +351,7 @@ func (m *QueryOwnerResponse) Reset() { *m = QueryOwnerResponse{} } func (m *QueryOwnerResponse) String() string { return proto.CompactTextString(m) } func (*QueryOwnerResponse) ProtoMessage() {} func (*QueryOwnerResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_0d24e0db697b0f9d, []int{3} + return fileDescriptor_0d24e0db697b0f9d, []int{6} } func (m *QueryOwnerResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -231,6 +387,52 @@ func (m *QueryOwnerResponse) GetOwner() string { return "" } +// QueryOwnerByQueryStringResponse is the response type for the Query/Owner RPC method +type QueryOwnerByQueryStringResponse struct { + // owner is the owner address of the nft + Owner string `protobuf:"bytes,1,opt,name=owner,proto3" json:"owner,omitempty"` +} + +func (m *QueryOwnerByQueryStringResponse) Reset() { *m = QueryOwnerByQueryStringResponse{} } +func (m *QueryOwnerByQueryStringResponse) String() string { return proto.CompactTextString(m) } +func (*QueryOwnerByQueryStringResponse) ProtoMessage() {} +func (*QueryOwnerByQueryStringResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_0d24e0db697b0f9d, []int{7} +} +func (m *QueryOwnerByQueryStringResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryOwnerByQueryStringResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryOwnerByQueryStringResponse.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 *QueryOwnerByQueryStringResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryOwnerByQueryStringResponse.Merge(m, src) +} +func (m *QueryOwnerByQueryStringResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryOwnerByQueryStringResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryOwnerByQueryStringResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryOwnerByQueryStringResponse proto.InternalMessageInfo + +func (m *QueryOwnerByQueryStringResponse) GetOwner() string { + if m != nil { + return m.Owner + } + return "" +} + // QuerySupplyRequest is the request type for the Query/Supply RPC method type QuerySupplyRequest struct { // class_id associated with the nft @@ -241,7 +443,7 @@ func (m *QuerySupplyRequest) Reset() { *m = QuerySupplyRequest{} } func (m *QuerySupplyRequest) String() string { return proto.CompactTextString(m) } func (*QuerySupplyRequest) ProtoMessage() {} func (*QuerySupplyRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_0d24e0db697b0f9d, []int{4} + return fileDescriptor_0d24e0db697b0f9d, []int{8} } func (m *QuerySupplyRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -277,6 +479,52 @@ func (m *QuerySupplyRequest) GetClassId() string { return "" } +// QuerySupplyByQueryStringRequest is the request type for the Query/Supply RPC method +type QuerySupplyByQueryStringRequest struct { + // class_id associated with the nft + ClassId string `protobuf:"bytes,1,opt,name=class_id,json=classId,proto3" json:"class_id,omitempty"` +} + +func (m *QuerySupplyByQueryStringRequest) Reset() { *m = QuerySupplyByQueryStringRequest{} } +func (m *QuerySupplyByQueryStringRequest) String() string { return proto.CompactTextString(m) } +func (*QuerySupplyByQueryStringRequest) ProtoMessage() {} +func (*QuerySupplyByQueryStringRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_0d24e0db697b0f9d, []int{9} +} +func (m *QuerySupplyByQueryStringRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QuerySupplyByQueryStringRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QuerySupplyByQueryStringRequest.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 *QuerySupplyByQueryStringRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QuerySupplyByQueryStringRequest.Merge(m, src) +} +func (m *QuerySupplyByQueryStringRequest) XXX_Size() int { + return m.Size() +} +func (m *QuerySupplyByQueryStringRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QuerySupplyByQueryStringRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QuerySupplyByQueryStringRequest proto.InternalMessageInfo + +func (m *QuerySupplyByQueryStringRequest) GetClassId() string { + if m != nil { + return m.ClassId + } + return "" +} + // QuerySupplyResponse is the response type for the Query/Supply RPC method type QuerySupplyResponse struct { // amount is the number of all NFTs from the given class @@ -287,7 +535,7 @@ func (m *QuerySupplyResponse) Reset() { *m = QuerySupplyResponse{} } func (m *QuerySupplyResponse) String() string { return proto.CompactTextString(m) } func (*QuerySupplyResponse) ProtoMessage() {} func (*QuerySupplyResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_0d24e0db697b0f9d, []int{5} + return fileDescriptor_0d24e0db697b0f9d, []int{10} } func (m *QuerySupplyResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -323,6 +571,52 @@ func (m *QuerySupplyResponse) GetAmount() uint64 { return 0 } +// QuerySupplyByQueryStringResponse is the response type for the Query/Supply RPC method +type QuerySupplyByQueryStringResponse struct { + // amount is the number of all NFTs from the given class + Amount uint64 `protobuf:"varint,1,opt,name=amount,proto3" json:"amount,omitempty"` +} + +func (m *QuerySupplyByQueryStringResponse) Reset() { *m = QuerySupplyByQueryStringResponse{} } +func (m *QuerySupplyByQueryStringResponse) String() string { return proto.CompactTextString(m) } +func (*QuerySupplyByQueryStringResponse) ProtoMessage() {} +func (*QuerySupplyByQueryStringResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_0d24e0db697b0f9d, []int{11} +} +func (m *QuerySupplyByQueryStringResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QuerySupplyByQueryStringResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QuerySupplyByQueryStringResponse.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 *QuerySupplyByQueryStringResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QuerySupplyByQueryStringResponse.Merge(m, src) +} +func (m *QuerySupplyByQueryStringResponse) XXX_Size() int { + return m.Size() +} +func (m *QuerySupplyByQueryStringResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QuerySupplyByQueryStringResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QuerySupplyByQueryStringResponse proto.InternalMessageInfo + +func (m *QuerySupplyByQueryStringResponse) GetAmount() uint64 { + if m != nil { + return m.Amount + } + return 0 +} + // QueryNFTstRequest is the request type for the Query/NFTs RPC method type QueryNFTsRequest struct { // class_id associated with the nft @@ -337,7 +631,7 @@ func (m *QueryNFTsRequest) Reset() { *m = QueryNFTsRequest{} } func (m *QueryNFTsRequest) String() string { return proto.CompactTextString(m) } func (*QueryNFTsRequest) ProtoMessage() {} func (*QueryNFTsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_0d24e0db697b0f9d, []int{6} + return fileDescriptor_0d24e0db697b0f9d, []int{12} } func (m *QueryNFTsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -399,7 +693,7 @@ func (m *QueryNFTsResponse) Reset() { *m = QueryNFTsResponse{} } func (m *QueryNFTsResponse) String() string { return proto.CompactTextString(m) } func (*QueryNFTsResponse) ProtoMessage() {} func (*QueryNFTsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_0d24e0db697b0f9d, []int{7} + return fileDescriptor_0d24e0db697b0f9d, []int{13} } func (m *QueryNFTsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -454,7 +748,7 @@ func (m *QueryNFTRequest) Reset() { *m = QueryNFTRequest{} } func (m *QueryNFTRequest) String() string { return proto.CompactTextString(m) } func (*QueryNFTRequest) ProtoMessage() {} func (*QueryNFTRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_0d24e0db697b0f9d, []int{8} + return fileDescriptor_0d24e0db697b0f9d, []int{14} } func (m *QueryNFTRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -497,6 +791,61 @@ func (m *QueryNFTRequest) GetId() string { return "" } +// QueryNFTByQueryStringRequest is the request type for the Query/NFT RPC method +type QueryNFTByQueryStringRequest struct { + // class_id associated with the nft + ClassId string `protobuf:"bytes,1,opt,name=class_id,json=classId,proto3" json:"class_id,omitempty"` + // id is a unique identifier of the NFT + Id string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"` +} + +func (m *QueryNFTByQueryStringRequest) Reset() { *m = QueryNFTByQueryStringRequest{} } +func (m *QueryNFTByQueryStringRequest) String() string { return proto.CompactTextString(m) } +func (*QueryNFTByQueryStringRequest) ProtoMessage() {} +func (*QueryNFTByQueryStringRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_0d24e0db697b0f9d, []int{15} +} +func (m *QueryNFTByQueryStringRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryNFTByQueryStringRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryNFTByQueryStringRequest.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 *QueryNFTByQueryStringRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryNFTByQueryStringRequest.Merge(m, src) +} +func (m *QueryNFTByQueryStringRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryNFTByQueryStringRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryNFTByQueryStringRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryNFTByQueryStringRequest proto.InternalMessageInfo + +func (m *QueryNFTByQueryStringRequest) GetClassId() string { + if m != nil { + return m.ClassId + } + return "" +} + +func (m *QueryNFTByQueryStringRequest) GetId() string { + if m != nil { + return m.Id + } + return "" +} + // QueryNFTResponse is the response type for the Query/NFT RPC method type QueryNFTResponse struct { // owner is the owner address of the nft @@ -507,7 +856,7 @@ func (m *QueryNFTResponse) Reset() { *m = QueryNFTResponse{} } func (m *QueryNFTResponse) String() string { return proto.CompactTextString(m) } func (*QueryNFTResponse) ProtoMessage() {} func (*QueryNFTResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_0d24e0db697b0f9d, []int{9} + return fileDescriptor_0d24e0db697b0f9d, []int{16} } func (m *QueryNFTResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -543,6 +892,52 @@ func (m *QueryNFTResponse) GetNft() *NFT { return nil } +// QueryNFTByQueryStringResponse is the response type for the Query/NFT RPC method +type QueryNFTByQueryStringResponse struct { + // owner is the owner address of the nft + Nft *NFT `protobuf:"bytes,1,opt,name=nft,proto3" json:"nft,omitempty"` +} + +func (m *QueryNFTByQueryStringResponse) Reset() { *m = QueryNFTByQueryStringResponse{} } +func (m *QueryNFTByQueryStringResponse) String() string { return proto.CompactTextString(m) } +func (*QueryNFTByQueryStringResponse) ProtoMessage() {} +func (*QueryNFTByQueryStringResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_0d24e0db697b0f9d, []int{17} +} +func (m *QueryNFTByQueryStringResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryNFTByQueryStringResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryNFTByQueryStringResponse.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 *QueryNFTByQueryStringResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryNFTByQueryStringResponse.Merge(m, src) +} +func (m *QueryNFTByQueryStringResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryNFTByQueryStringResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryNFTByQueryStringResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryNFTByQueryStringResponse proto.InternalMessageInfo + +func (m *QueryNFTByQueryStringResponse) GetNft() *NFT { + if m != nil { + return m.Nft + } + return nil +} + // QueryClassRequest is the request type for the Query/Class RPC method type QueryClassRequest struct { // class_id associated with the nft @@ -553,7 +948,7 @@ func (m *QueryClassRequest) Reset() { *m = QueryClassRequest{} } func (m *QueryClassRequest) String() string { return proto.CompactTextString(m) } func (*QueryClassRequest) ProtoMessage() {} func (*QueryClassRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_0d24e0db697b0f9d, []int{10} + return fileDescriptor_0d24e0db697b0f9d, []int{18} } func (m *QueryClassRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -589,6 +984,52 @@ func (m *QueryClassRequest) GetClassId() string { return "" } +// QueryClassByQueryStringRequest is the request type for the Query/Class RPC method +type QueryClassByQueryStringRequest struct { + // class_id associated with the nft + ClassId string `protobuf:"bytes,1,opt,name=class_id,json=classId,proto3" json:"class_id,omitempty"` +} + +func (m *QueryClassByQueryStringRequest) Reset() { *m = QueryClassByQueryStringRequest{} } +func (m *QueryClassByQueryStringRequest) String() string { return proto.CompactTextString(m) } +func (*QueryClassByQueryStringRequest) ProtoMessage() {} +func (*QueryClassByQueryStringRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_0d24e0db697b0f9d, []int{19} +} +func (m *QueryClassByQueryStringRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryClassByQueryStringRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryClassByQueryStringRequest.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 *QueryClassByQueryStringRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryClassByQueryStringRequest.Merge(m, src) +} +func (m *QueryClassByQueryStringRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryClassByQueryStringRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryClassByQueryStringRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryClassByQueryStringRequest proto.InternalMessageInfo + +func (m *QueryClassByQueryStringRequest) GetClassId() string { + if m != nil { + return m.ClassId + } + return "" +} + // QueryClassResponse is the response type for the Query/Class RPC method type QueryClassResponse struct { // class defines the class of the nft type. @@ -599,7 +1040,7 @@ func (m *QueryClassResponse) Reset() { *m = QueryClassResponse{} } func (m *QueryClassResponse) String() string { return proto.CompactTextString(m) } func (*QueryClassResponse) ProtoMessage() {} func (*QueryClassResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_0d24e0db697b0f9d, []int{11} + return fileDescriptor_0d24e0db697b0f9d, []int{20} } func (m *QueryClassResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -635,6 +1076,52 @@ func (m *QueryClassResponse) GetClass() *Class { return nil } +// QueryClassByQueryStringResponse is the response type for the Query/Class RPC method +type QueryClassByQueryStringResponse struct { + // class defines the class of the nft type. + Class *Class `protobuf:"bytes,1,opt,name=class,proto3" json:"class,omitempty"` +} + +func (m *QueryClassByQueryStringResponse) Reset() { *m = QueryClassByQueryStringResponse{} } +func (m *QueryClassByQueryStringResponse) String() string { return proto.CompactTextString(m) } +func (*QueryClassByQueryStringResponse) ProtoMessage() {} +func (*QueryClassByQueryStringResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_0d24e0db697b0f9d, []int{21} +} +func (m *QueryClassByQueryStringResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryClassByQueryStringResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryClassByQueryStringResponse.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 *QueryClassByQueryStringResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryClassByQueryStringResponse.Merge(m, src) +} +func (m *QueryClassByQueryStringResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryClassByQueryStringResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryClassByQueryStringResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryClassByQueryStringResponse proto.InternalMessageInfo + +func (m *QueryClassByQueryStringResponse) GetClass() *Class { + if m != nil { + return m.Class + } + return nil +} + // QueryClassesRequest is the request type for the Query/Classes RPC method type QueryClassesRequest struct { // pagination defines an optional pagination for the request. @@ -645,7 +1132,7 @@ func (m *QueryClassesRequest) Reset() { *m = QueryClassesRequest{} } func (m *QueryClassesRequest) String() string { return proto.CompactTextString(m) } func (*QueryClassesRequest) ProtoMessage() {} func (*QueryClassesRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_0d24e0db697b0f9d, []int{12} + return fileDescriptor_0d24e0db697b0f9d, []int{22} } func (m *QueryClassesRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -693,7 +1180,7 @@ func (m *QueryClassesResponse) Reset() { *m = QueryClassesResponse{} } func (m *QueryClassesResponse) String() string { return proto.CompactTextString(m) } func (*QueryClassesResponse) ProtoMessage() {} func (*QueryClassesResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_0d24e0db697b0f9d, []int{13} + return fileDescriptor_0d24e0db697b0f9d, []int{23} } func (m *QueryClassesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -738,17 +1225,27 @@ func (m *QueryClassesResponse) GetPagination() *query.PageResponse { func init() { proto.RegisterType((*QueryBalanceRequest)(nil), "cosmos.nft.v1beta1.QueryBalanceRequest") + proto.RegisterType((*QueryBalanceByQueryStringRequest)(nil), "cosmos.nft.v1beta1.QueryBalanceByQueryStringRequest") proto.RegisterType((*QueryBalanceResponse)(nil), "cosmos.nft.v1beta1.QueryBalanceResponse") + proto.RegisterType((*QueryBalanceByQueryStringResponse)(nil), "cosmos.nft.v1beta1.QueryBalanceByQueryStringResponse") proto.RegisterType((*QueryOwnerRequest)(nil), "cosmos.nft.v1beta1.QueryOwnerRequest") + proto.RegisterType((*QueryOwnerByQueryStringRequest)(nil), "cosmos.nft.v1beta1.QueryOwnerByQueryStringRequest") proto.RegisterType((*QueryOwnerResponse)(nil), "cosmos.nft.v1beta1.QueryOwnerResponse") + proto.RegisterType((*QueryOwnerByQueryStringResponse)(nil), "cosmos.nft.v1beta1.QueryOwnerByQueryStringResponse") proto.RegisterType((*QuerySupplyRequest)(nil), "cosmos.nft.v1beta1.QuerySupplyRequest") + proto.RegisterType((*QuerySupplyByQueryStringRequest)(nil), "cosmos.nft.v1beta1.QuerySupplyByQueryStringRequest") proto.RegisterType((*QuerySupplyResponse)(nil), "cosmos.nft.v1beta1.QuerySupplyResponse") + proto.RegisterType((*QuerySupplyByQueryStringResponse)(nil), "cosmos.nft.v1beta1.QuerySupplyByQueryStringResponse") proto.RegisterType((*QueryNFTsRequest)(nil), "cosmos.nft.v1beta1.QueryNFTsRequest") proto.RegisterType((*QueryNFTsResponse)(nil), "cosmos.nft.v1beta1.QueryNFTsResponse") proto.RegisterType((*QueryNFTRequest)(nil), "cosmos.nft.v1beta1.QueryNFTRequest") + proto.RegisterType((*QueryNFTByQueryStringRequest)(nil), "cosmos.nft.v1beta1.QueryNFTByQueryStringRequest") proto.RegisterType((*QueryNFTResponse)(nil), "cosmos.nft.v1beta1.QueryNFTResponse") + proto.RegisterType((*QueryNFTByQueryStringResponse)(nil), "cosmos.nft.v1beta1.QueryNFTByQueryStringResponse") proto.RegisterType((*QueryClassRequest)(nil), "cosmos.nft.v1beta1.QueryClassRequest") + proto.RegisterType((*QueryClassByQueryStringRequest)(nil), "cosmos.nft.v1beta1.QueryClassByQueryStringRequest") proto.RegisterType((*QueryClassResponse)(nil), "cosmos.nft.v1beta1.QueryClassResponse") + proto.RegisterType((*QueryClassByQueryStringResponse)(nil), "cosmos.nft.v1beta1.QueryClassByQueryStringResponse") proto.RegisterType((*QueryClassesRequest)(nil), "cosmos.nft.v1beta1.QueryClassesRequest") proto.RegisterType((*QueryClassesResponse)(nil), "cosmos.nft.v1beta1.QueryClassesResponse") } @@ -756,52 +1253,66 @@ func init() { func init() { proto.RegisterFile("cosmos/nft/v1beta1/query.proto", fileDescriptor_0d24e0db697b0f9d) } var fileDescriptor_0d24e0db697b0f9d = []byte{ - // 719 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x96, 0x4b, 0x6f, 0xd3, 0x4c, - 0x14, 0x86, 0x3b, 0x49, 0xd3, 0x7c, 0xdf, 0xa9, 0xc4, 0x65, 0xa8, 0x20, 0x35, 0x60, 0x45, 0xee, - 0x25, 0x69, 0x4b, 0x67, 0x7a, 0x91, 0x58, 0x01, 0x8b, 0x22, 0x82, 0xd8, 0x14, 0x08, 0x5d, 0x21, - 0x21, 0xe4, 0x34, 0x4e, 0x64, 0x91, 0x7a, 0xd2, 0x8e, 0x03, 0x54, 0x55, 0x17, 0x74, 0x81, 0xa8, - 0xd8, 0x20, 0xd1, 0xdf, 0xc3, 0x9a, 0x65, 0x25, 0x36, 0x2c, 0x51, 0xcb, 0x0f, 0x41, 0x9e, 0x39, - 0x4e, 0x6d, 0xea, 0xd8, 0x55, 0xc4, 0xd2, 0x99, 0xf7, 0x9c, 0xf7, 0xf1, 0x9c, 0x4b, 0x0c, 0xe6, - 0xa6, 0x90, 0x5b, 0x42, 0x72, 0xaf, 0xe5, 0xf3, 0xb7, 0xcb, 0x0d, 0xc7, 0xb7, 0x97, 0xf9, 0x76, - 0xcf, 0xd9, 0xd9, 0x65, 0xdd, 0x1d, 0xe1, 0x0b, 0x4a, 0xf5, 0x39, 0xf3, 0x5a, 0x3e, 0xc3, 0x73, - 0x63, 0x1e, 0x63, 0x1a, 0xb6, 0x74, 0xb4, 0xb8, 0x1f, 0xda, 0xb5, 0xdb, 0xae, 0x67, 0xfb, 0xae, - 0xf0, 0x74, 0xbc, 0x71, 0xab, 0x2d, 0x44, 0xbb, 0xe3, 0x70, 0xbb, 0xeb, 0x72, 0xdb, 0xf3, 0x84, - 0xaf, 0x0e, 0x65, 0x78, 0x9a, 0xe0, 0x1e, 0x38, 0xa9, 0x53, 0xab, 0x06, 0xd7, 0x9e, 0x07, 0xd9, - 0xd7, 0xec, 0x8e, 0xed, 0x6d, 0x3a, 0x75, 0x67, 0xbb, 0xe7, 0x48, 0x9f, 0x4e, 0xc2, 0x7f, 0x9b, - 0x1d, 0x5b, 0xca, 0xd7, 0x6e, 0xb3, 0x44, 0xca, 0xa4, 0xfa, 0x7f, 0xbd, 0xa8, 0x9e, 0x9f, 0x34, - 0xe9, 0x04, 0x14, 0xc4, 0x3b, 0xcf, 0xd9, 0x29, 0xe5, 0xd4, 0xef, 0xfa, 0xc1, 0x62, 0x30, 0x11, - 0xcf, 0x23, 0xbb, 0xc2, 0x93, 0x0e, 0xbd, 0x0e, 0x63, 0xf6, 0x96, 0xe8, 0x79, 0xbe, 0x4a, 0x33, - 0x5a, 0xc7, 0x27, 0xeb, 0x01, 0x5c, 0x55, 0xfa, 0xa7, 0x41, 0xf4, 0x05, 0x5c, 0x2f, 0x41, 0xce, - 0x6d, 0xa2, 0x65, 0xce, 0x6d, 0x5a, 0xf3, 0x40, 0xa3, 0xf1, 0xe8, 0xd6, 0x67, 0x23, 0x51, 0x36, - 0x8e, 0xda, 0x17, 0xbd, 0x6e, 0xb7, 0xb3, 0x9b, 0x6d, 0x66, 0x2d, 0xe2, 0xa5, 0x84, 0x01, 0x19, - 0xef, 0xf2, 0x99, 0xc0, 0x15, 0xa5, 0x5f, 0xaf, 0x6d, 0xc8, 0x61, 0x6f, 0x90, 0xd6, 0x00, 0xce, - 0x2a, 0x5b, 0xca, 0x97, 0x49, 0x75, 0x7c, 0x65, 0x96, 0x61, 0x6b, 0x04, 0x6d, 0xc0, 0x74, 0xcf, - 0x60, 0x0d, 0xd9, 0x33, 0xbb, 0x1d, 0x96, 0xab, 0x1e, 0x89, 0xb4, 0x0e, 0x09, 0x5e, 0xad, 0xa6, - 0x41, 0xf6, 0x05, 0x18, 0xf5, 0x5a, 0xbe, 0x2c, 0x91, 0x72, 0xbe, 0x3a, 0xbe, 0x72, 0x83, 0x9d, - 0x6f, 0x39, 0xb6, 0x5e, 0xdb, 0xa8, 0x2b, 0x11, 0x7d, 0x1c, 0x43, 0xc9, 0x29, 0x94, 0x4a, 0x26, - 0x8a, 0x76, 0x8a, 0xb1, 0xdc, 0x83, 0xcb, 0x21, 0xca, 0x10, 0x35, 0xbe, 0x7f, 0x76, 0xad, 0xfd, - 0xf7, 0x98, 0x83, 0xbc, 0xd7, 0xd2, 0x05, 0x48, 0x79, 0x8d, 0x40, 0x63, 0x31, 0xbc, 0x87, 0x87, - 0x41, 0xfa, 0x0b, 0x54, 0xfd, 0x11, 0xb6, 0x09, 0xea, 0xd1, 0x90, 0x43, 0x41, 0x09, 0xd0, 0x72, - 0x32, 0xc9, 0x52, 0x47, 0x68, 0x9d, 0xf5, 0x0a, 0x9b, 0x47, 0xfd, 0xe8, 0xf4, 0x8d, 0xe3, 0xe5, - 0x25, 0x43, 0x97, 0xf7, 0x88, 0xe0, 0xa4, 0xf5, 0xf3, 0x23, 0xe8, 0x2a, 0xe8, 0x37, 0x71, 0xc2, - 0x22, 0xa7, 0xa0, 0x86, 0xca, 0x7f, 0x56, 0xe9, 0x95, 0x6f, 0x45, 0x28, 0x28, 0x2c, 0x7a, 0x44, - 0xa0, 0x88, 0x5b, 0x80, 0x56, 0x92, 0x10, 0x12, 0xf6, 0x8d, 0x51, 0xcd, 0x16, 0x6a, 0x53, 0xeb, - 0xee, 0xc1, 0x8f, 0xdf, 0x5f, 0x73, 0x4b, 0x94, 0xf1, 0x84, 0xbd, 0xd6, 0xd0, 0x62, 0xbe, 0xa7, - 0x46, 0x6a, 0x9f, 0xef, 0x85, 0xb5, 0xde, 0xa7, 0x87, 0x04, 0x0a, 0x6a, 0x59, 0xd0, 0x99, 0x81, - 0x5e, 0xd1, 0x65, 0x64, 0xcc, 0x66, 0xc9, 0x10, 0x68, 0x59, 0x01, 0x2d, 0xd0, 0xb9, 0x24, 0x20, - 0xc5, 0x11, 0xc1, 0xe0, 0x7b, 0x01, 0xcb, 0x27, 0x02, 0x63, 0x7a, 0xb7, 0xd0, 0xc1, 0x2e, 0xb1, - 0x6d, 0x65, 0x54, 0x32, 0x75, 0x88, 0xb3, 0xa8, 0x70, 0x2a, 0x74, 0x26, 0x09, 0x47, 0x2a, 0x6d, - 0xf4, 0x5a, 0x7a, 0x30, 0x1a, 0xec, 0x09, 0x3a, 0x3d, 0x30, 0x7f, 0x64, 0xa9, 0x19, 0x33, 0x19, - 0x2a, 0x64, 0x28, 0x2b, 0x06, 0x83, 0x96, 0x78, 0xf2, 0x7f, 0x8f, 0xa4, 0x07, 0x04, 0xf2, 0xeb, - 0xb5, 0x0d, 0x3a, 0x95, 0x96, 0x30, 0x74, 0x9d, 0x4e, 0x17, 0xa1, 0xe9, 0x92, 0x32, 0x9d, 0xa7, - 0xd5, 0x41, 0xa6, 0xe7, 0xca, 0xf0, 0x91, 0x40, 0x41, 0xcd, 0x43, 0x4a, 0x4b, 0x44, 0x97, 0x47, - 0x4a, 0x4b, 0xc4, 0x76, 0x86, 0xc5, 0x14, 0x4a, 0x95, 0xce, 0x26, 0xa1, 0xe0, 0xe8, 0x45, 0x8b, - 0xf0, 0x81, 0x40, 0x11, 0xc7, 0x39, 0x65, 0x64, 0xe2, 0x0b, 0x25, 0x65, 0x64, 0xfe, 0xda, 0x0c, - 0xd6, 0x94, 0xc2, 0xb9, 0x4d, 0x6f, 0xa6, 0xe0, 0xac, 0xdd, 0xf9, 0x7e, 0x62, 0x92, 0xe3, 0x13, - 0x93, 0xfc, 0x3a, 0x31, 0xc9, 0x97, 0x53, 0x73, 0xe4, 0xf8, 0xd4, 0x1c, 0xf9, 0x79, 0x6a, 0x8e, - 0xbc, 0xc4, 0xcf, 0x13, 0xd9, 0x7c, 0xc3, 0x5c, 0xc1, 0xdf, 0x07, 0xd1, 0x8d, 0x31, 0xf5, 0xf5, - 0xb0, 0xfa, 0x27, 0x00, 0x00, 0xff, 0xff, 0x5b, 0x6c, 0x33, 0x5d, 0xdb, 0x08, 0x00, 0x00, + // 936 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x97, 0x41, 0x6f, 0xe3, 0x54, + 0x10, 0xc7, 0xfb, 0x92, 0xa6, 0x85, 0x59, 0x01, 0xcb, 0x6c, 0xc5, 0x26, 0xde, 0xae, 0x37, 0xeb, + 0xdd, 0x36, 0xd9, 0x2e, 0x6b, 0x37, 0xc9, 0x02, 0x12, 0xbb, 0x70, 0x28, 0x22, 0xa8, 0x20, 0x15, + 0x48, 0x7b, 0x42, 0x42, 0xc8, 0x69, 0x9c, 0xc8, 0x22, 0xb5, 0xd3, 0xd8, 0x01, 0xaa, 0xaa, 0x07, + 0x7a, 0x40, 0x54, 0x5c, 0x90, 0xe8, 0x81, 0x23, 0x07, 0x0e, 0x7c, 0x14, 0x8e, 0x95, 0xb8, 0x70, + 0x44, 0x2d, 0x5f, 0x80, 0x6f, 0x80, 0xfc, 0x3c, 0x4e, 0x9d, 0xe6, 0xf9, 0xb9, 0x0e, 0x1c, 0x1d, + 0xcf, 0xbc, 0xff, 0x2f, 0xe3, 0xf9, 0xfb, 0x9f, 0x80, 0xba, 0xeb, 0x7a, 0x7b, 0xae, 0x67, 0x38, + 0x5d, 0xdf, 0xf8, 0xaa, 0xd6, 0xb6, 0x7c, 0xb3, 0x66, 0xec, 0x8f, 0xac, 0xe1, 0x81, 0x3e, 0x18, + 0xba, 0xbe, 0x8b, 0x18, 0xde, 0xd7, 0x9d, 0xae, 0xaf, 0xd3, 0x7d, 0x65, 0x8d, 0x7a, 0xda, 0xa6, + 0x67, 0x85, 0xc5, 0xe3, 0xd6, 0x81, 0xd9, 0xb3, 0x1d, 0xd3, 0xb7, 0x5d, 0x27, 0xec, 0x57, 0x96, + 0x7b, 0xae, 0xdb, 0xeb, 0x5b, 0x86, 0x39, 0xb0, 0x0d, 0xd3, 0x71, 0x5c, 0x9f, 0xdf, 0xf4, 0xa2, + 0xbb, 0x02, 0xf5, 0x40, 0x89, 0xdf, 0xd5, 0x9a, 0x70, 0xeb, 0xd3, 0xe0, 0xf4, 0x0d, 0xb3, 0x6f, + 0x3a, 0xbb, 0x56, 0xcb, 0xda, 0x1f, 0x59, 0x9e, 0x8f, 0x25, 0x78, 0x61, 0xb7, 0x6f, 0x7a, 0xde, + 0x17, 0x76, 0xa7, 0xc8, 0xca, 0xac, 0xfa, 0x62, 0x6b, 0x91, 0x5f, 0x6f, 0x76, 0x70, 0x09, 0x0a, + 0xee, 0xd7, 0x8e, 0x35, 0x2c, 0xe6, 0xf8, 0xe7, 0xe1, 0x85, 0xb6, 0x0d, 0xe5, 0xf8, 0x39, 0x1b, + 0x07, 0xfc, 0x6a, 0xdb, 0x1f, 0xda, 0x4e, 0x6f, 0xe6, 0x43, 0x75, 0x58, 0x9a, 0x84, 0xf3, 0x06, + 0xae, 0xe3, 0x59, 0xf8, 0x1a, 0x2c, 0x98, 0x7b, 0xee, 0xc8, 0xf1, 0xf9, 0x31, 0xf3, 0x2d, 0xba, + 0xd2, 0x9e, 0xc1, 0x7d, 0x09, 0x44, 0x4a, 0xf3, 0xbb, 0xf0, 0x2a, 0x2f, 0xff, 0x38, 0x90, 0xbe, + 0x06, 0xf2, 0xcb, 0x90, 0xb3, 0x3b, 0xc4, 0x9b, 0xb3, 0x3b, 0xda, 0x47, 0xa0, 0x5e, 0xf6, 0x67, + 0xfd, 0xfe, 0x57, 0x0f, 0x5b, 0x03, 0x8c, 0xc3, 0x10, 0xfa, 0x78, 0x4a, 0x2c, 0x3e, 0xa5, 0xb7, + 0xe0, 0x5e, 0xa2, 0xb0, 0xb4, 0xd1, 0x20, 0x91, 0xed, 0xd1, 0x60, 0xd0, 0x3f, 0x48, 0xa7, 0xd4, + 0x9e, 0x93, 0x52, 0xd8, 0x90, 0xf1, 0x3b, 0x6a, 0x4f, 0x68, 0xd5, 0x22, 0xb9, 0x94, 0xe7, 0xf1, + 0x36, 0x6d, 0x94, 0x50, 0x2c, 0xa5, 0xf7, 0x07, 0x06, 0x37, 0x79, 0xfd, 0x56, 0x73, 0xc7, 0x9b, + 0x75, 0xfd, 0xb0, 0x09, 0x70, 0xe9, 0xb5, 0x62, 0xbe, 0xcc, 0xaa, 0x37, 0xea, 0xab, 0x3a, 0x99, + 0x35, 0x30, 0xa6, 0x1e, 0xba, 0x98, 0x5c, 0xa5, 0x7f, 0x62, 0xf6, 0x22, 0x03, 0xb5, 0x62, 0x9d, + 0xda, 0x09, 0xa3, 0xd5, 0x0a, 0x69, 0x88, 0xfd, 0x31, 0xcc, 0x3b, 0x5d, 0xdf, 0x2b, 0xb2, 0x72, + 0xbe, 0x7a, 0xa3, 0x7e, 0x5b, 0x9f, 0x7e, 0x09, 0xe8, 0x5b, 0xcd, 0x9d, 0x16, 0x2f, 0xc2, 0x0f, + 0x26, 0x50, 0x72, 0x1c, 0xa5, 0x92, 0x8a, 0x12, 0x2a, 0x4d, 0xb0, 0x3c, 0x87, 0x57, 0x22, 0x94, + 0x19, 0xd6, 0x72, 0x13, 0x96, 0xa3, 0xee, 0xff, 0xba, 0xe1, 0xef, 0x5c, 0x3e, 0xa1, 0xf1, 0x48, + 0x1e, 0x41, 0xde, 0xe9, 0x86, 0xcf, 0x52, 0x32, 0x91, 0xa0, 0x46, 0xfb, 0x10, 0xee, 0x26, 0x90, + 0x64, 0x3f, 0x4b, 0xa7, 0xc7, 0xf3, 0x5e, 0x80, 0x7a, 0x8d, 0x45, 0x7e, 0x46, 0x4e, 0xe7, 0xf5, + 0x59, 0x5d, 0xf0, 0x3e, 0x99, 0x8e, 0xc4, 0x88, 0xd6, 0x80, 0x02, 0x2f, 0x20, 0xde, 0x92, 0x88, + 0x37, 0xec, 0x08, 0xeb, 0xb4, 0x16, 0x59, 0x51, 0xc4, 0x30, 0xeb, 0x99, 0x9f, 0x93, 0x41, 0xf9, + 0x87, 0xd6, 0x78, 0x12, 0x93, 0x36, 0x60, 0x33, 0xdb, 0xe0, 0x94, 0xd1, 0xeb, 0x7c, 0x7c, 0x3e, + 0x81, 0x36, 0x20, 0x9c, 0x8e, 0x15, 0x99, 0x41, 0x82, 0x1a, 0x55, 0xfe, 0x6f, 0x8e, 0xa8, 0xff, + 0xf3, 0x12, 0x14, 0x38, 0x16, 0x9e, 0x32, 0x58, 0xa4, 0xe8, 0xc0, 0x8a, 0x08, 0x41, 0x90, 0x94, + 0x4a, 0x35, 0xbd, 0x30, 0x14, 0xd5, 0xde, 0x3c, 0xfe, 0xe3, 0xef, 0x9f, 0x72, 0xeb, 0xa8, 0x1b, + 0x82, 0x44, 0x6e, 0x87, 0xc5, 0xc6, 0x21, 0x7f, 0xf5, 0x1c, 0x19, 0x87, 0xd1, 0xfe, 0x1c, 0xe1, + 0x6f, 0x0c, 0x96, 0x44, 0x89, 0x86, 0x4f, 0xd3, 0xa4, 0x45, 0xbb, 0xa9, 0xbc, 0x91, 0xb1, 0x8b, + 0xe8, 0x1f, 0x70, 0xfa, 0xbb, 0x78, 0x47, 0x42, 0x8f, 0x27, 0x0c, 0x0a, 0x3c, 0x86, 0x70, 0x25, + 0x51, 0x25, 0x9e, 0xaf, 0xca, 0x6a, 0x5a, 0x19, 0xa9, 0xd7, 0xb8, 0xfa, 0x63, 0x7c, 0x24, 0x52, + 0xe7, 0x23, 0x8b, 0x4d, 0xcc, 0x38, 0x0c, 0xc6, 0xf6, 0x0b, 0x03, 0x9c, 0x8e, 0x44, 0xac, 0xcb, + 0x15, 0x85, 0x23, 0x6b, 0x64, 0xea, 0x21, 0xe4, 0xfb, 0x1c, 0xf9, 0x0e, 0x96, 0x12, 0x91, 0xf1, + 0x7b, 0x06, 0x0b, 0x61, 0xbc, 0x61, 0xf2, 0x20, 0x26, 0xd2, 0x59, 0xa9, 0xa4, 0xd6, 0x91, 0xfc, + 0x13, 0x2e, 0x5f, 0xc1, 0x15, 0x91, 0xbc, 0xc7, 0x6b, 0xe3, 0x4b, 0xf6, 0x2b, 0x83, 0x5b, 0x82, + 0xa4, 0xc5, 0x46, 0x8a, 0x9e, 0x70, 0x5e, 0x4f, 0xb3, 0x35, 0x11, 0xb1, 0xc6, 0x89, 0x97, 0x51, + 0x49, 0x26, 0xc6, 0x11, 0xcc, 0x07, 0x21, 0x8a, 0x0f, 0x13, 0x15, 0x62, 0x89, 0xaf, 0xac, 0xa4, + 0x54, 0x91, 0x70, 0x99, 0x0b, 0x2b, 0x58, 0x34, 0xc4, 0x3f, 0x95, 0x3d, 0x3c, 0x66, 0x90, 0xdf, + 0x6a, 0xee, 0xe0, 0x03, 0xd9, 0x81, 0x91, 0xea, 0x43, 0x79, 0x11, 0x89, 0xae, 0x73, 0xd1, 0x35, + 0xac, 0x26, 0x89, 0x4e, 0x2d, 0xf4, 0xcf, 0x0c, 0x6e, 0x5e, 0x8d, 0x3b, 0x5c, 0x97, 0x89, 0x09, + 0x1f, 0x4e, 0x2d, 0x43, 0x07, 0xb1, 0xde, 0xe3, 0xac, 0x25, 0xbc, 0x9d, 0xc0, 0x8a, 0xdf, 0x31, + 0x28, 0xf0, 0xf7, 0xb3, 0xc4, 0xf7, 0xf1, 0x74, 0x95, 0xf8, 0x7e, 0x22, 0x17, 0x35, 0x9d, 0x2b, + 0x57, 0x71, 0x55, 0xa4, 0x4c, 0x51, 0x10, 0x5f, 0xe3, 0xc0, 0xf4, 0xd3, 0x91, 0x28, 0x31, 0x7d, + 0x62, 0x86, 0x4b, 0x4c, 0x9f, 0x9c, 0xb9, 0x72, 0xd3, 0x73, 0x4c, 0xfc, 0x96, 0xc1, 0x22, 0x25, + 0xa0, 0x24, 0x65, 0x26, 0x33, 0x58, 0x92, 0x32, 0x57, 0xc2, 0x54, 0xfe, 0x9e, 0xa6, 0x89, 0x6d, + 0xbc, 0xfe, 0xfb, 0xb9, 0xca, 0xce, 0xce, 0x55, 0xf6, 0xd7, 0xb9, 0xca, 0x7e, 0xbc, 0x50, 0xe7, + 0xce, 0x2e, 0xd4, 0xb9, 0x3f, 0x2f, 0xd4, 0xb9, 0xcf, 0xe8, 0xbf, 0xa8, 0xd7, 0xf9, 0x52, 0xb7, + 0x5d, 0xe3, 0x9b, 0xa0, 0xbb, 0xbd, 0xc0, 0xff, 0x2a, 0x36, 0xfe, 0x0d, 0x00, 0x00, 0xff, 0xff, + 0xc0, 0x88, 0xda, 0x47, 0xc8, 0x0e, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -818,17 +1329,27 @@ const _ = grpc.SupportPackageIsVersion4 type QueryClient interface { // Balance queries the number of NFTs of a given class owned by the owner, same as balanceOf in ERC721 Balance(ctx context.Context, in *QueryBalanceRequest, opts ...grpc.CallOption) (*QueryBalanceResponse, error) + // BalancebyQueryString queries the number of NFTs of a given class owned by the owner, same as balanceOf in ERC721 + BalanceByQueryString(ctx context.Context, in *QueryBalanceByQueryStringRequest, opts ...grpc.CallOption) (*QueryBalanceByQueryStringResponse, error) // Owner queries the owner of the NFT based on its class and id, same as ownerOf in ERC721 Owner(ctx context.Context, in *QueryOwnerRequest, opts ...grpc.CallOption) (*QueryOwnerResponse, error) + // OwnerByQueryString queries the owner of the NFT based on its class and id, same as ownerOf in ERC721 + OwnerByQueryString(ctx context.Context, in *QueryOwnerByQueryStringRequest, opts ...grpc.CallOption) (*QueryOwnerByQueryStringResponse, error) // Supply queries the number of NFTs from the given class, same as totalSupply of ERC721. Supply(ctx context.Context, in *QuerySupplyRequest, opts ...grpc.CallOption) (*QuerySupplyResponse, error) + // SupplyByQueryString queries the number of NFTs from the given class, same as totalSupply of ERC721. + SupplyByQueryString(ctx context.Context, in *QuerySupplyByQueryStringRequest, opts ...grpc.CallOption) (*QuerySupplyByQueryStringResponse, error) // NFTs queries all NFTs of a given class or owner,choose at least one of the two, similar to tokenByIndex in // ERC721Enumerable NFTs(ctx context.Context, in *QueryNFTsRequest, opts ...grpc.CallOption) (*QueryNFTsResponse, error) // NFT queries an NFT based on its class and id. NFT(ctx context.Context, in *QueryNFTRequest, opts ...grpc.CallOption) (*QueryNFTResponse, error) + // NFTByQueryString queries an NFT based on its class and id. + NFTByQueryString(ctx context.Context, in *QueryNFTByQueryStringRequest, opts ...grpc.CallOption) (*QueryNFTByQueryStringResponse, error) // Class queries an NFT class based on its id Class(ctx context.Context, in *QueryClassRequest, opts ...grpc.CallOption) (*QueryClassResponse, error) + // Class queries an NFT class based on its id + ClassByQueryString(ctx context.Context, in *QueryClassByQueryStringRequest, opts ...grpc.CallOption) (*QueryClassByQueryStringResponse, error) // Classes queries all NFT classes Classes(ctx context.Context, in *QueryClassesRequest, opts ...grpc.CallOption) (*QueryClassesResponse, error) } @@ -850,6 +1371,15 @@ func (c *queryClient) Balance(ctx context.Context, in *QueryBalanceRequest, opts return out, nil } +func (c *queryClient) BalanceByQueryString(ctx context.Context, in *QueryBalanceByQueryStringRequest, opts ...grpc.CallOption) (*QueryBalanceByQueryStringResponse, error) { + out := new(QueryBalanceByQueryStringResponse) + err := c.cc.Invoke(ctx, "/cosmos.nft.v1beta1.Query/BalanceByQueryString", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *queryClient) Owner(ctx context.Context, in *QueryOwnerRequest, opts ...grpc.CallOption) (*QueryOwnerResponse, error) { out := new(QueryOwnerResponse) err := c.cc.Invoke(ctx, "/cosmos.nft.v1beta1.Query/Owner", in, out, opts...) @@ -859,6 +1389,15 @@ func (c *queryClient) Owner(ctx context.Context, in *QueryOwnerRequest, opts ... return out, nil } +func (c *queryClient) OwnerByQueryString(ctx context.Context, in *QueryOwnerByQueryStringRequest, opts ...grpc.CallOption) (*QueryOwnerByQueryStringResponse, error) { + out := new(QueryOwnerByQueryStringResponse) + err := c.cc.Invoke(ctx, "/cosmos.nft.v1beta1.Query/OwnerByQueryString", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *queryClient) Supply(ctx context.Context, in *QuerySupplyRequest, opts ...grpc.CallOption) (*QuerySupplyResponse, error) { out := new(QuerySupplyResponse) err := c.cc.Invoke(ctx, "/cosmos.nft.v1beta1.Query/Supply", in, out, opts...) @@ -868,6 +1407,15 @@ func (c *queryClient) Supply(ctx context.Context, in *QuerySupplyRequest, opts . return out, nil } +func (c *queryClient) SupplyByQueryString(ctx context.Context, in *QuerySupplyByQueryStringRequest, opts ...grpc.CallOption) (*QuerySupplyByQueryStringResponse, error) { + out := new(QuerySupplyByQueryStringResponse) + err := c.cc.Invoke(ctx, "/cosmos.nft.v1beta1.Query/SupplyByQueryString", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *queryClient) NFTs(ctx context.Context, in *QueryNFTsRequest, opts ...grpc.CallOption) (*QueryNFTsResponse, error) { out := new(QueryNFTsResponse) err := c.cc.Invoke(ctx, "/cosmos.nft.v1beta1.Query/NFTs", in, out, opts...) @@ -886,6 +1434,15 @@ func (c *queryClient) NFT(ctx context.Context, in *QueryNFTRequest, opts ...grpc return out, nil } +func (c *queryClient) NFTByQueryString(ctx context.Context, in *QueryNFTByQueryStringRequest, opts ...grpc.CallOption) (*QueryNFTByQueryStringResponse, error) { + out := new(QueryNFTByQueryStringResponse) + err := c.cc.Invoke(ctx, "/cosmos.nft.v1beta1.Query/NFTByQueryString", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *queryClient) Class(ctx context.Context, in *QueryClassRequest, opts ...grpc.CallOption) (*QueryClassResponse, error) { out := new(QueryClassResponse) err := c.cc.Invoke(ctx, "/cosmos.nft.v1beta1.Query/Class", in, out, opts...) @@ -895,6 +1452,15 @@ func (c *queryClient) Class(ctx context.Context, in *QueryClassRequest, opts ... return out, nil } +func (c *queryClient) ClassByQueryString(ctx context.Context, in *QueryClassByQueryStringRequest, opts ...grpc.CallOption) (*QueryClassByQueryStringResponse, error) { + out := new(QueryClassByQueryStringResponse) + err := c.cc.Invoke(ctx, "/cosmos.nft.v1beta1.Query/ClassByQueryString", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *queryClient) Classes(ctx context.Context, in *QueryClassesRequest, opts ...grpc.CallOption) (*QueryClassesResponse, error) { out := new(QueryClassesResponse) err := c.cc.Invoke(ctx, "/cosmos.nft.v1beta1.Query/Classes", in, out, opts...) @@ -908,17 +1474,27 @@ func (c *queryClient) Classes(ctx context.Context, in *QueryClassesRequest, opts type QueryServer interface { // Balance queries the number of NFTs of a given class owned by the owner, same as balanceOf in ERC721 Balance(context.Context, *QueryBalanceRequest) (*QueryBalanceResponse, error) + // BalancebyQueryString queries the number of NFTs of a given class owned by the owner, same as balanceOf in ERC721 + BalanceByQueryString(context.Context, *QueryBalanceByQueryStringRequest) (*QueryBalanceByQueryStringResponse, error) // Owner queries the owner of the NFT based on its class and id, same as ownerOf in ERC721 Owner(context.Context, *QueryOwnerRequest) (*QueryOwnerResponse, error) + // OwnerByQueryString queries the owner of the NFT based on its class and id, same as ownerOf in ERC721 + OwnerByQueryString(context.Context, *QueryOwnerByQueryStringRequest) (*QueryOwnerByQueryStringResponse, error) // Supply queries the number of NFTs from the given class, same as totalSupply of ERC721. Supply(context.Context, *QuerySupplyRequest) (*QuerySupplyResponse, error) + // SupplyByQueryString queries the number of NFTs from the given class, same as totalSupply of ERC721. + SupplyByQueryString(context.Context, *QuerySupplyByQueryStringRequest) (*QuerySupplyByQueryStringResponse, error) // NFTs queries all NFTs of a given class or owner,choose at least one of the two, similar to tokenByIndex in // ERC721Enumerable NFTs(context.Context, *QueryNFTsRequest) (*QueryNFTsResponse, error) // NFT queries an NFT based on its class and id. NFT(context.Context, *QueryNFTRequest) (*QueryNFTResponse, error) + // NFTByQueryString queries an NFT based on its class and id. + NFTByQueryString(context.Context, *QueryNFTByQueryStringRequest) (*QueryNFTByQueryStringResponse, error) // Class queries an NFT class based on its id Class(context.Context, *QueryClassRequest) (*QueryClassResponse, error) + // Class queries an NFT class based on its id + ClassByQueryString(context.Context, *QueryClassByQueryStringRequest) (*QueryClassByQueryStringResponse, error) // Classes queries all NFT classes Classes(context.Context, *QueryClassesRequest) (*QueryClassesResponse, error) } @@ -930,21 +1506,36 @@ type UnimplementedQueryServer struct { func (*UnimplementedQueryServer) Balance(ctx context.Context, req *QueryBalanceRequest) (*QueryBalanceResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Balance not implemented") } +func (*UnimplementedQueryServer) BalanceByQueryString(ctx context.Context, req *QueryBalanceByQueryStringRequest) (*QueryBalanceByQueryStringResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method BalanceByQueryString not implemented") +} func (*UnimplementedQueryServer) Owner(ctx context.Context, req *QueryOwnerRequest) (*QueryOwnerResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Owner not implemented") } +func (*UnimplementedQueryServer) OwnerByQueryString(ctx context.Context, req *QueryOwnerByQueryStringRequest) (*QueryOwnerByQueryStringResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method OwnerByQueryString not implemented") +} func (*UnimplementedQueryServer) Supply(ctx context.Context, req *QuerySupplyRequest) (*QuerySupplyResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Supply not implemented") } +func (*UnimplementedQueryServer) SupplyByQueryString(ctx context.Context, req *QuerySupplyByQueryStringRequest) (*QuerySupplyByQueryStringResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method SupplyByQueryString not implemented") +} func (*UnimplementedQueryServer) NFTs(ctx context.Context, req *QueryNFTsRequest) (*QueryNFTsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method NFTs not implemented") } func (*UnimplementedQueryServer) NFT(ctx context.Context, req *QueryNFTRequest) (*QueryNFTResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method NFT not implemented") } +func (*UnimplementedQueryServer) NFTByQueryString(ctx context.Context, req *QueryNFTByQueryStringRequest) (*QueryNFTByQueryStringResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method NFTByQueryString not implemented") +} func (*UnimplementedQueryServer) Class(ctx context.Context, req *QueryClassRequest) (*QueryClassResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Class not implemented") } +func (*UnimplementedQueryServer) ClassByQueryString(ctx context.Context, req *QueryClassByQueryStringRequest) (*QueryClassByQueryStringResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ClassByQueryString not implemented") +} func (*UnimplementedQueryServer) Classes(ctx context.Context, req *QueryClassesRequest) (*QueryClassesResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Classes not implemented") } @@ -971,6 +1562,24 @@ func _Query_Balance_Handler(srv interface{}, ctx context.Context, dec func(inter return interceptor(ctx, in, info, handler) } +func _Query_BalanceByQueryString_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryBalanceByQueryStringRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).BalanceByQueryString(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmos.nft.v1beta1.Query/BalanceByQueryString", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).BalanceByQueryString(ctx, req.(*QueryBalanceByQueryStringRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _Query_Owner_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(QueryOwnerRequest) if err := dec(in); err != nil { @@ -989,6 +1598,24 @@ func _Query_Owner_Handler(srv interface{}, ctx context.Context, dec func(interfa return interceptor(ctx, in, info, handler) } +func _Query_OwnerByQueryString_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryOwnerByQueryStringRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).OwnerByQueryString(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmos.nft.v1beta1.Query/OwnerByQueryString", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).OwnerByQueryString(ctx, req.(*QueryOwnerByQueryStringRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _Query_Supply_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(QuerySupplyRequest) if err := dec(in); err != nil { @@ -1007,6 +1634,24 @@ func _Query_Supply_Handler(srv interface{}, ctx context.Context, dec func(interf return interceptor(ctx, in, info, handler) } +func _Query_SupplyByQueryString_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QuerySupplyByQueryStringRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).SupplyByQueryString(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmos.nft.v1beta1.Query/SupplyByQueryString", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).SupplyByQueryString(ctx, req.(*QuerySupplyByQueryStringRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _Query_NFTs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(QueryNFTsRequest) if err := dec(in); err != nil { @@ -1043,6 +1688,24 @@ func _Query_NFT_Handler(srv interface{}, ctx context.Context, dec func(interface return interceptor(ctx, in, info, handler) } +func _Query_NFTByQueryString_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryNFTByQueryStringRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).NFTByQueryString(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmos.nft.v1beta1.Query/NFTByQueryString", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).NFTByQueryString(ctx, req.(*QueryNFTByQueryStringRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _Query_Class_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(QueryClassRequest) if err := dec(in); err != nil { @@ -1061,6 +1724,24 @@ func _Query_Class_Handler(srv interface{}, ctx context.Context, dec func(interfa return interceptor(ctx, in, info, handler) } +func _Query_ClassByQueryString_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryClassByQueryStringRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).ClassByQueryString(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmos.nft.v1beta1.Query/ClassByQueryString", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).ClassByQueryString(ctx, req.(*QueryClassByQueryStringRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _Query_Classes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(QueryClassesRequest) if err := dec(in); err != nil { @@ -1087,14 +1768,26 @@ var _Query_serviceDesc = grpc.ServiceDesc{ MethodName: "Balance", Handler: _Query_Balance_Handler, }, + { + MethodName: "BalanceByQueryString", + Handler: _Query_BalanceByQueryString_Handler, + }, { MethodName: "Owner", Handler: _Query_Owner_Handler, }, + { + MethodName: "OwnerByQueryString", + Handler: _Query_OwnerByQueryString_Handler, + }, { MethodName: "Supply", Handler: _Query_Supply_Handler, }, + { + MethodName: "SupplyByQueryString", + Handler: _Query_SupplyByQueryString_Handler, + }, { MethodName: "NFTs", Handler: _Query_NFTs_Handler, @@ -1103,10 +1796,18 @@ var _Query_serviceDesc = grpc.ServiceDesc{ MethodName: "NFT", Handler: _Query_NFT_Handler, }, + { + MethodName: "NFTByQueryString", + Handler: _Query_NFTByQueryString_Handler, + }, { MethodName: "Class", Handler: _Query_Class_Handler, }, + { + MethodName: "ClassByQueryString", + Handler: _Query_ClassByQueryString_Handler, + }, { MethodName: "Classes", Handler: _Query_Classes_Handler, @@ -1153,6 +1854,43 @@ func (m *QueryBalanceRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *QueryBalanceByQueryStringRequest) 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 *QueryBalanceByQueryStringRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryBalanceByQueryStringRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Owner) > 0 { + i -= len(m.Owner) + copy(dAtA[i:], m.Owner) + i = encodeVarintQuery(dAtA, i, uint64(len(m.Owner))) + i-- + dAtA[i] = 0x12 + } + if len(m.ClassId) > 0 { + i -= len(m.ClassId) + copy(dAtA[i:], m.ClassId) + i = encodeVarintQuery(dAtA, i, uint64(len(m.ClassId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + func (m *QueryBalanceResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -1181,6 +1919,34 @@ func (m *QueryBalanceResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *QueryBalanceByQueryStringResponse) 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 *QueryBalanceByQueryStringResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryBalanceByQueryStringResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Amount != 0 { + i = encodeVarintQuery(dAtA, i, uint64(m.Amount)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + func (m *QueryOwnerRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -1218,6 +1984,43 @@ func (m *QueryOwnerRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *QueryOwnerByQueryStringRequest) 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 *QueryOwnerByQueryStringRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryOwnerByQueryStringRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Id) > 0 { + i -= len(m.Id) + copy(dAtA[i:], m.Id) + i = encodeVarintQuery(dAtA, i, uint64(len(m.Id))) + i-- + dAtA[i] = 0x12 + } + if len(m.ClassId) > 0 { + i -= len(m.ClassId) + copy(dAtA[i:], m.ClassId) + i = encodeVarintQuery(dAtA, i, uint64(len(m.ClassId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + func (m *QueryOwnerResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -1248,6 +2051,36 @@ func (m *QueryOwnerResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *QueryOwnerByQueryStringResponse) 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 *QueryOwnerByQueryStringResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryOwnerByQueryStringResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Owner) > 0 { + i -= len(m.Owner) + copy(dAtA[i:], m.Owner) + i = encodeVarintQuery(dAtA, i, uint64(len(m.Owner))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + func (m *QuerySupplyRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -1278,6 +2111,36 @@ func (m *QuerySupplyRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *QuerySupplyByQueryStringRequest) 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 *QuerySupplyByQueryStringRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QuerySupplyByQueryStringRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.ClassId) > 0 { + i -= len(m.ClassId) + copy(dAtA[i:], m.ClassId) + i = encodeVarintQuery(dAtA, i, uint64(len(m.ClassId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + func (m *QuerySupplyResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -1306,6 +2169,34 @@ func (m *QuerySupplyResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *QuerySupplyByQueryStringResponse) 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 *QuerySupplyByQueryStringResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QuerySupplyByQueryStringResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Amount != 0 { + i = encodeVarintQuery(dAtA, i, uint64(m.Amount)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + func (m *QueryNFTsRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -1441,6 +2332,43 @@ func (m *QueryNFTRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *QueryNFTByQueryStringRequest) 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 *QueryNFTByQueryStringRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryNFTByQueryStringRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Id) > 0 { + i -= len(m.Id) + copy(dAtA[i:], m.Id) + i = encodeVarintQuery(dAtA, i, uint64(len(m.Id))) + i-- + dAtA[i] = 0x12 + } + if len(m.ClassId) > 0 { + i -= len(m.ClassId) + copy(dAtA[i:], m.ClassId) + i = encodeVarintQuery(dAtA, i, uint64(len(m.ClassId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + func (m *QueryNFTResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -1476,6 +2404,41 @@ func (m *QueryNFTResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *QueryNFTByQueryStringResponse) 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 *QueryNFTByQueryStringResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryNFTByQueryStringResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Nft != nil { + { + size, err := m.Nft.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 *QueryClassRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -1506,6 +2469,36 @@ func (m *QueryClassRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *QueryClassByQueryStringRequest) 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 *QueryClassByQueryStringRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryClassByQueryStringRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.ClassId) > 0 { + i -= len(m.ClassId) + copy(dAtA[i:], m.ClassId) + i = encodeVarintQuery(dAtA, i, uint64(len(m.ClassId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + func (m *QueryClassResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -1541,6 +2534,41 @@ func (m *QueryClassResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *QueryClassByQueryStringResponse) 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 *QueryClassByQueryStringResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryClassByQueryStringResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Class != nil { + { + size, err := m.Class.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 *QueryClassesRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -1653,6 +2681,23 @@ func (m *QueryBalanceRequest) Size() (n int) { return n } +func (m *QueryBalanceByQueryStringRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ClassId) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + l = len(m.Owner) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + func (m *QueryBalanceResponse) Size() (n int) { if m == nil { return 0 @@ -1665,6 +2710,18 @@ func (m *QueryBalanceResponse) Size() (n int) { return n } +func (m *QueryBalanceByQueryStringResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Amount != 0 { + n += 1 + sovQuery(uint64(m.Amount)) + } + return n +} + func (m *QueryOwnerRequest) Size() (n int) { if m == nil { return 0 @@ -1682,6 +2739,23 @@ func (m *QueryOwnerRequest) Size() (n int) { return n } +func (m *QueryOwnerByQueryStringRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ClassId) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + l = len(m.Id) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + func (m *QueryOwnerResponse) Size() (n int) { if m == nil { return 0 @@ -1695,6 +2769,19 @@ func (m *QueryOwnerResponse) Size() (n int) { return n } +func (m *QueryOwnerByQueryStringResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Owner) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + func (m *QuerySupplyRequest) Size() (n int) { if m == nil { return 0 @@ -1708,6 +2795,19 @@ func (m *QuerySupplyRequest) Size() (n int) { return n } +func (m *QuerySupplyByQueryStringRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ClassId) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + func (m *QuerySupplyResponse) Size() (n int) { if m == nil { return 0 @@ -1720,6 +2820,18 @@ func (m *QuerySupplyResponse) Size() (n int) { return n } +func (m *QuerySupplyByQueryStringResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Amount != 0 { + n += 1 + sovQuery(uint64(m.Amount)) + } + return n +} + func (m *QueryNFTsRequest) Size() (n int) { if m == nil { return 0 @@ -1777,6 +2889,23 @@ func (m *QueryNFTRequest) Size() (n int) { return n } +func (m *QueryNFTByQueryStringRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ClassId) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + l = len(m.Id) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + func (m *QueryNFTResponse) Size() (n int) { if m == nil { return 0 @@ -1790,6 +2919,19 @@ func (m *QueryNFTResponse) Size() (n int) { return n } +func (m *QueryNFTByQueryStringResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Nft != nil { + l = m.Nft.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + func (m *QueryClassRequest) Size() (n int) { if m == nil { return 0 @@ -1803,6 +2945,19 @@ func (m *QueryClassRequest) Size() (n int) { return n } +func (m *QueryClassByQueryStringRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ClassId) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + func (m *QueryClassResponse) Size() (n int) { if m == nil { return 0 @@ -1816,6 +2971,19 @@ func (m *QueryClassResponse) Size() (n int) { return n } +func (m *QueryClassByQueryStringResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Class != nil { + l = m.Class.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + func (m *QueryClassesRequest) Size() (n int) { if m == nil { return 0 @@ -1968,6 +3136,120 @@ func (m *QueryBalanceRequest) Unmarshal(dAtA []byte) error { } return nil } +func (m *QueryBalanceByQueryStringRequest) 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: QueryBalanceByQueryStringRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryBalanceByQueryStringRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ClassId", 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.ClassId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Owner", 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.Owner = 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 *QueryBalanceResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2037,6 +3319,75 @@ func (m *QueryBalanceResponse) Unmarshal(dAtA []byte) error { } return nil } +func (m *QueryBalanceByQueryStringResponse) 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: QueryBalanceByQueryStringResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryBalanceByQueryStringResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) + } + m.Amount = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Amount |= 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 *QueryOwnerRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2151,6 +3502,120 @@ func (m *QueryOwnerRequest) Unmarshal(dAtA []byte) error { } return nil } +func (m *QueryOwnerByQueryStringRequest) 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: QueryOwnerByQueryStringRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryOwnerByQueryStringRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ClassId", 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.ClassId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", 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.Id = 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 *QueryOwnerResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2233,6 +3698,88 @@ func (m *QueryOwnerResponse) Unmarshal(dAtA []byte) error { } return nil } +func (m *QueryOwnerByQueryStringResponse) 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: QueryOwnerByQueryStringResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryOwnerByQueryStringResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Owner", 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.Owner = 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 *QuerySupplyRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2315,6 +3862,88 @@ func (m *QuerySupplyRequest) Unmarshal(dAtA []byte) error { } return nil } +func (m *QuerySupplyByQueryStringRequest) 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: QuerySupplyByQueryStringRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QuerySupplyByQueryStringRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ClassId", 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.ClassId = 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 *QuerySupplyResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2384,6 +4013,75 @@ func (m *QuerySupplyResponse) Unmarshal(dAtA []byte) error { } return nil } +func (m *QuerySupplyByQueryStringResponse) 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: QuerySupplyByQueryStringResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QuerySupplyByQueryStringResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) + } + m.Amount = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Amount |= 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 *QueryNFTsRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2768,6 +4466,120 @@ func (m *QueryNFTRequest) Unmarshal(dAtA []byte) error { } return nil } +func (m *QueryNFTByQueryStringRequest) 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: QueryNFTByQueryStringRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryNFTByQueryStringRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ClassId", 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.ClassId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", 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.Id = 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 *QueryNFTResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2854,6 +4666,92 @@ func (m *QueryNFTResponse) Unmarshal(dAtA []byte) error { } return nil } +func (m *QueryNFTByQueryStringResponse) 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: QueryNFTByQueryStringResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryNFTByQueryStringResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Nft", 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.Nft == nil { + m.Nft = &NFT{} + } + if err := m.Nft.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 *QueryClassRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -2936,6 +4834,88 @@ func (m *QueryClassRequest) Unmarshal(dAtA []byte) error { } return nil } +func (m *QueryClassByQueryStringRequest) 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: QueryClassByQueryStringRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryClassByQueryStringRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ClassId", 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.ClassId = 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 *QueryClassResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -3022,6 +5002,92 @@ func (m *QueryClassResponse) Unmarshal(dAtA []byte) error { } return nil } +func (m *QueryClassByQueryStringResponse) 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: QueryClassByQueryStringResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryClassByQueryStringResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Class", 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.Class == nil { + m.Class = &Class{} + } + if err := m.Class.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 *QueryClassesRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 diff --git a/x/nft/query.pb.gw.go b/x/nft/query.pb.gw.go index b9e88db2e8..d711fc3bc1 100644 --- a/x/nft/query.pb.gw.go +++ b/x/nft/query.pb.gw.go @@ -109,6 +109,42 @@ func local_request_Query_Balance_0(ctx context.Context, marshaler runtime.Marsha } +var ( + filter_Query_BalanceByQueryString_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} +) + +func request_Query_BalanceByQueryString_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryBalanceByQueryStringRequest + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_BalanceByQueryString_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.BalanceByQueryString(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_BalanceByQueryString_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryBalanceByQueryStringRequest + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_BalanceByQueryString_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.BalanceByQueryString(ctx, &protoReq) + return msg, metadata, err + +} + func request_Query_Owner_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { var protoReq QueryOwnerRequest var metadata runtime.ServerMetadata @@ -185,6 +221,42 @@ func local_request_Query_Owner_0(ctx context.Context, marshaler runtime.Marshale } +var ( + filter_Query_OwnerByQueryString_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} +) + +func request_Query_OwnerByQueryString_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryOwnerByQueryStringRequest + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_OwnerByQueryString_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.OwnerByQueryString(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_OwnerByQueryString_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryOwnerByQueryStringRequest + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_OwnerByQueryString_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.OwnerByQueryString(ctx, &protoReq) + return msg, metadata, err + +} + func request_Query_Supply_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { var protoReq QuerySupplyRequest var metadata runtime.ServerMetadata @@ -239,6 +311,42 @@ func local_request_Query_Supply_0(ctx context.Context, marshaler runtime.Marshal } +var ( + filter_Query_SupplyByQueryString_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} +) + +func request_Query_SupplyByQueryString_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QuerySupplyByQueryStringRequest + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_SupplyByQueryString_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.SupplyByQueryString(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_SupplyByQueryString_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QuerySupplyByQueryStringRequest + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_SupplyByQueryString_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.SupplyByQueryString(ctx, &protoReq) + return msg, metadata, err + +} + var ( filter_Query_NFTs_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} ) @@ -351,6 +459,42 @@ func local_request_Query_NFT_0(ctx context.Context, marshaler runtime.Marshaler, } +var ( + filter_Query_NFTByQueryString_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} +) + +func request_Query_NFTByQueryString_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryNFTByQueryStringRequest + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_NFTByQueryString_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.NFTByQueryString(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_NFTByQueryString_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryNFTByQueryStringRequest + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_NFTByQueryString_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.NFTByQueryString(ctx, &protoReq) + return msg, metadata, err + +} + func request_Query_Class_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { var protoReq QueryClassRequest var metadata runtime.ServerMetadata @@ -405,6 +549,42 @@ func local_request_Query_Class_0(ctx context.Context, marshaler runtime.Marshale } +var ( + filter_Query_ClassByQueryString_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} +) + +func request_Query_ClassByQueryString_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryClassByQueryStringRequest + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_ClassByQueryString_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.ClassByQueryString(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_ClassByQueryString_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryClassByQueryStringRequest + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_ClassByQueryString_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.ClassByQueryString(ctx, &protoReq) + return msg, metadata, err + +} + var ( filter_Query_Classes_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} ) @@ -470,6 +650,29 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv }) + mux.Handle("GET", pattern_Query_BalanceByQueryString_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_Query_BalanceByQueryString_0(rctx, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_BalanceByQueryString_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + mux.Handle("GET", pattern_Query_Owner_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() @@ -493,6 +696,29 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv }) + mux.Handle("GET", pattern_Query_OwnerByQueryString_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_Query_OwnerByQueryString_0(rctx, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_OwnerByQueryString_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + mux.Handle("GET", pattern_Query_Supply_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() @@ -516,6 +742,29 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv }) + mux.Handle("GET", pattern_Query_SupplyByQueryString_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_Query_SupplyByQueryString_0(rctx, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_SupplyByQueryString_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + mux.Handle("GET", pattern_Query_NFTs_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() @@ -562,6 +811,29 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv }) + mux.Handle("GET", pattern_Query_NFTByQueryString_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_Query_NFTByQueryString_0(rctx, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_NFTByQueryString_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + mux.Handle("GET", pattern_Query_Class_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() @@ -585,6 +857,29 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv }) + mux.Handle("GET", pattern_Query_ClassByQueryString_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_Query_ClassByQueryString_0(rctx, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_ClassByQueryString_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + mux.Handle("GET", pattern_Query_Classes_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() @@ -669,6 +964,26 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie }) + mux.Handle("GET", pattern_Query_BalanceByQueryString_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_Query_BalanceByQueryString_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_BalanceByQueryString_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + mux.Handle("GET", pattern_Query_Owner_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() @@ -689,6 +1004,26 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie }) + mux.Handle("GET", pattern_Query_OwnerByQueryString_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_Query_OwnerByQueryString_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_OwnerByQueryString_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + mux.Handle("GET", pattern_Query_Supply_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() @@ -709,6 +1044,26 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie }) + mux.Handle("GET", pattern_Query_SupplyByQueryString_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_Query_SupplyByQueryString_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_SupplyByQueryString_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + mux.Handle("GET", pattern_Query_NFTs_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() @@ -749,6 +1104,26 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie }) + mux.Handle("GET", pattern_Query_NFTByQueryString_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_Query_NFTByQueryString_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_NFTByQueryString_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + mux.Handle("GET", pattern_Query_Class_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() @@ -769,6 +1144,26 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie }) + mux.Handle("GET", pattern_Query_ClassByQueryString_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_Query_ClassByQueryString_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_ClassByQueryString_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + mux.Handle("GET", pattern_Query_Classes_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() @@ -795,31 +1190,51 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie var ( pattern_Query_Balance_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 1, 0, 4, 1, 5, 5}, []string{"cosmos", "nft", "v1beta1", "balance", "owner", "class_id"}, "", runtime.AssumeColonVerbOpt(false))) + pattern_Query_BalanceByQueryString_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"cosmos", "nft", "v1beta1", "balance"}, "", runtime.AssumeColonVerbOpt(false))) + pattern_Query_Owner_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 1, 0, 4, 1, 5, 5}, []string{"cosmos", "nft", "v1beta1", "owner", "class_id", "id"}, "", runtime.AssumeColonVerbOpt(false))) + pattern_Query_OwnerByQueryString_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"cosmos", "nft", "v1beta1", "owner"}, "", runtime.AssumeColonVerbOpt(false))) + pattern_Query_Supply_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"cosmos", "nft", "v1beta1", "supply", "class_id"}, "", runtime.AssumeColonVerbOpt(false))) + pattern_Query_SupplyByQueryString_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"cosmos", "nft", "v1beta1", "supply"}, "", runtime.AssumeColonVerbOpt(false))) + pattern_Query_NFTs_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"cosmos", "nft", "v1beta1", "nfts"}, "", runtime.AssumeColonVerbOpt(false))) pattern_Query_NFT_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 1, 0, 4, 1, 5, 5}, []string{"cosmos", "nft", "v1beta1", "nfts", "class_id", "id"}, "", runtime.AssumeColonVerbOpt(false))) + pattern_Query_NFTByQueryString_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 1}, []string{"cosmos", "nft", "v1beta1"}, "", runtime.AssumeColonVerbOpt(false))) + pattern_Query_Class_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"cosmos", "nft", "v1beta1", "classes", "class_id"}, "", runtime.AssumeColonVerbOpt(false))) + pattern_Query_ClassByQueryString_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"cosmos", "nft", "v1beta1", "class"}, "", runtime.AssumeColonVerbOpt(false))) + pattern_Query_Classes_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"cosmos", "nft", "v1beta1", "classes"}, "", runtime.AssumeColonVerbOpt(false))) ) var ( forward_Query_Balance_0 = runtime.ForwardResponseMessage + forward_Query_BalanceByQueryString_0 = runtime.ForwardResponseMessage + forward_Query_Owner_0 = runtime.ForwardResponseMessage + forward_Query_OwnerByQueryString_0 = runtime.ForwardResponseMessage + forward_Query_Supply_0 = runtime.ForwardResponseMessage + forward_Query_SupplyByQueryString_0 = runtime.ForwardResponseMessage + forward_Query_NFTs_0 = runtime.ForwardResponseMessage forward_Query_NFT_0 = runtime.ForwardResponseMessage + forward_Query_NFTByQueryString_0 = runtime.ForwardResponseMessage + forward_Query_Class_0 = runtime.ForwardResponseMessage + forward_Query_ClassByQueryString_0 = runtime.ForwardResponseMessage + forward_Query_Classes_0 = runtime.ForwardResponseMessage )