From 6af7f30bfd541689b02777477fede22555dfb8cd Mon Sep 17 00:00:00 2001 From: Marko Date: Sun, 29 Oct 2023 21:09:40 +0100 Subject: [PATCH] feat(x/counter): add module protos (#18291) --- api/cosmos/counter/v1/query.pulsar.go | 959 +++++++++++++++++ api/cosmos/counter/v1/query_grpc.pb.go | 111 ++ api/cosmos/counter/v1/tx.pulsar.go | 1102 ++++++++++++++++++++ api/cosmos/counter/v1/tx_grpc.pb.go | 111 ++ api/cosmos/mint/module/v1/module.pulsar.go | 45 +- proto/cosmos/counter/v1/query.proto | 18 + proto/cosmos/counter/v1/tx.proto | 33 + x/counter/types/query.pb.go | 510 +++++++++ x/counter/types/tx.pb.go | 606 +++++++++++ x/mint/types/genesis.pb.go | 11 +- x/mint/types/mint.pb.go | 57 +- x/mint/types/query.pb.go | 63 +- x/mint/types/tx.pb.go | 12 +- 13 files changed, 3542 insertions(+), 96 deletions(-) create mode 100644 api/cosmos/counter/v1/query.pulsar.go create mode 100644 api/cosmos/counter/v1/query_grpc.pb.go create mode 100644 api/cosmos/counter/v1/tx.pulsar.go create mode 100644 api/cosmos/counter/v1/tx_grpc.pb.go create mode 100644 proto/cosmos/counter/v1/query.proto create mode 100644 proto/cosmos/counter/v1/tx.proto create mode 100644 x/counter/types/query.pb.go create mode 100644 x/counter/types/tx.pb.go diff --git a/api/cosmos/counter/v1/query.pulsar.go b/api/cosmos/counter/v1/query.pulsar.go new file mode 100644 index 0000000000..945f11547d --- /dev/null +++ b/api/cosmos/counter/v1/query.pulsar.go @@ -0,0 +1,959 @@ +// Code generated by protoc-gen-go-pulsar. DO NOT EDIT. +package counterv1 + +import ( + fmt "fmt" + runtime "github.com/cosmos/cosmos-proto/runtime" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoiface "google.golang.org/protobuf/runtime/protoiface" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + io "io" + reflect "reflect" + sync "sync" +) + +var ( + md_QueryGetCountRequest protoreflect.MessageDescriptor +) + +func init() { + file_cosmos_counter_v1_query_proto_init() + md_QueryGetCountRequest = File_cosmos_counter_v1_query_proto.Messages().ByName("QueryGetCountRequest") +} + +var _ protoreflect.Message = (*fastReflection_QueryGetCountRequest)(nil) + +type fastReflection_QueryGetCountRequest QueryGetCountRequest + +func (x *QueryGetCountRequest) ProtoReflect() protoreflect.Message { + return (*fastReflection_QueryGetCountRequest)(x) +} + +func (x *QueryGetCountRequest) slowProtoReflect() protoreflect.Message { + mi := &file_cosmos_counter_v1_query_proto_msgTypes[0] + 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_QueryGetCountRequest_messageType fastReflection_QueryGetCountRequest_messageType +var _ protoreflect.MessageType = fastReflection_QueryGetCountRequest_messageType{} + +type fastReflection_QueryGetCountRequest_messageType struct{} + +func (x fastReflection_QueryGetCountRequest_messageType) Zero() protoreflect.Message { + return (*fastReflection_QueryGetCountRequest)(nil) +} +func (x fastReflection_QueryGetCountRequest_messageType) New() protoreflect.Message { + return new(fastReflection_QueryGetCountRequest) +} +func (x fastReflection_QueryGetCountRequest_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QueryGetCountRequest +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QueryGetCountRequest) Descriptor() protoreflect.MessageDescriptor { + return md_QueryGetCountRequest +} + +// 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_QueryGetCountRequest) Type() protoreflect.MessageType { + return _fastReflection_QueryGetCountRequest_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QueryGetCountRequest) New() protoreflect.Message { + return new(fastReflection_QueryGetCountRequest) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QueryGetCountRequest) Interface() protoreflect.ProtoMessage { + return (*QueryGetCountRequest)(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_QueryGetCountRequest) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { +} + +// 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_QueryGetCountRequest) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.counter.v1.QueryGetCountRequest")) + } + panic(fmt.Errorf("message cosmos.counter.v1.QueryGetCountRequest 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_QueryGetCountRequest) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.counter.v1.QueryGetCountRequest")) + } + panic(fmt.Errorf("message cosmos.counter.v1.QueryGetCountRequest 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_QueryGetCountRequest) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.counter.v1.QueryGetCountRequest")) + } + panic(fmt.Errorf("message cosmos.counter.v1.QueryGetCountRequest 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_QueryGetCountRequest) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.counter.v1.QueryGetCountRequest")) + } + panic(fmt.Errorf("message cosmos.counter.v1.QueryGetCountRequest 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_QueryGetCountRequest) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.counter.v1.QueryGetCountRequest")) + } + panic(fmt.Errorf("message cosmos.counter.v1.QueryGetCountRequest 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_QueryGetCountRequest) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.counter.v1.QueryGetCountRequest")) + } + panic(fmt.Errorf("message cosmos.counter.v1.QueryGetCountRequest 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_QueryGetCountRequest) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in cosmos.counter.v1.QueryGetCountRequest", 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_QueryGetCountRequest) 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_QueryGetCountRequest) 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_QueryGetCountRequest) 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_QueryGetCountRequest) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QueryGetCountRequest) + 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.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().(*QueryGetCountRequest) + 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 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().(*QueryGetCountRequest) + 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: QueryGetCountRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetCountRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + 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_QueryGetCountResponse protoreflect.MessageDescriptor + fd_QueryGetCountResponse_total_count protoreflect.FieldDescriptor +) + +func init() { + file_cosmos_counter_v1_query_proto_init() + md_QueryGetCountResponse = File_cosmos_counter_v1_query_proto.Messages().ByName("QueryGetCountResponse") + fd_QueryGetCountResponse_total_count = md_QueryGetCountResponse.Fields().ByName("total_count") +} + +var _ protoreflect.Message = (*fastReflection_QueryGetCountResponse)(nil) + +type fastReflection_QueryGetCountResponse QueryGetCountResponse + +func (x *QueryGetCountResponse) ProtoReflect() protoreflect.Message { + return (*fastReflection_QueryGetCountResponse)(x) +} + +func (x *QueryGetCountResponse) slowProtoReflect() protoreflect.Message { + mi := &file_cosmos_counter_v1_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_QueryGetCountResponse_messageType fastReflection_QueryGetCountResponse_messageType +var _ protoreflect.MessageType = fastReflection_QueryGetCountResponse_messageType{} + +type fastReflection_QueryGetCountResponse_messageType struct{} + +func (x fastReflection_QueryGetCountResponse_messageType) Zero() protoreflect.Message { + return (*fastReflection_QueryGetCountResponse)(nil) +} +func (x fastReflection_QueryGetCountResponse_messageType) New() protoreflect.Message { + return new(fastReflection_QueryGetCountResponse) +} +func (x fastReflection_QueryGetCountResponse_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_QueryGetCountResponse +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_QueryGetCountResponse) Descriptor() protoreflect.MessageDescriptor { + return md_QueryGetCountResponse +} + +// 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_QueryGetCountResponse) Type() protoreflect.MessageType { + return _fastReflection_QueryGetCountResponse_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_QueryGetCountResponse) New() protoreflect.Message { + return new(fastReflection_QueryGetCountResponse) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_QueryGetCountResponse) Interface() protoreflect.ProtoMessage { + return (*QueryGetCountResponse)(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_QueryGetCountResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.TotalCount != int64(0) { + value := protoreflect.ValueOfInt64(x.TotalCount) + if !f(fd_QueryGetCountResponse_total_count, 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_QueryGetCountResponse) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "cosmos.counter.v1.QueryGetCountResponse.total_count": + return x.TotalCount != int64(0) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.counter.v1.QueryGetCountResponse")) + } + panic(fmt.Errorf("message cosmos.counter.v1.QueryGetCountResponse 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_QueryGetCountResponse) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "cosmos.counter.v1.QueryGetCountResponse.total_count": + x.TotalCount = int64(0) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.counter.v1.QueryGetCountResponse")) + } + panic(fmt.Errorf("message cosmos.counter.v1.QueryGetCountResponse 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_QueryGetCountResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "cosmos.counter.v1.QueryGetCountResponse.total_count": + value := x.TotalCount + return protoreflect.ValueOfInt64(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.counter.v1.QueryGetCountResponse")) + } + panic(fmt.Errorf("message cosmos.counter.v1.QueryGetCountResponse 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_QueryGetCountResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "cosmos.counter.v1.QueryGetCountResponse.total_count": + x.TotalCount = value.Int() + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.counter.v1.QueryGetCountResponse")) + } + panic(fmt.Errorf("message cosmos.counter.v1.QueryGetCountResponse 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_QueryGetCountResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.counter.v1.QueryGetCountResponse.total_count": + panic(fmt.Errorf("field total_count of message cosmos.counter.v1.QueryGetCountResponse is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.counter.v1.QueryGetCountResponse")) + } + panic(fmt.Errorf("message cosmos.counter.v1.QueryGetCountResponse 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_QueryGetCountResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.counter.v1.QueryGetCountResponse.total_count": + return protoreflect.ValueOfInt64(int64(0)) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.counter.v1.QueryGetCountResponse")) + } + panic(fmt.Errorf("message cosmos.counter.v1.QueryGetCountResponse 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_QueryGetCountResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in cosmos.counter.v1.QueryGetCountResponse", 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_QueryGetCountResponse) 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_QueryGetCountResponse) 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_QueryGetCountResponse) 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_QueryGetCountResponse) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*QueryGetCountResponse) + 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.TotalCount != 0 { + n += 1 + runtime.Sov(uint64(x.TotalCount)) + } + 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().(*QueryGetCountResponse) + 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.TotalCount != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.TotalCount)) + 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().(*QueryGetCountResponse) + 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: QueryGetCountResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: QueryGetCountResponse: 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 TotalCount", wireType) + } + x.TotalCount = 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.TotalCount |= int64(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, + } +} + +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.27.0 +// protoc (unknown) +// source: cosmos/counter/v1/query.proto + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// QueryGetCountRequest defines the request type for querying x/mock count. +type QueryGetCountRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *QueryGetCountRequest) Reset() { + *x = QueryGetCountRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_cosmos_counter_v1_query_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QueryGetCountRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryGetCountRequest) ProtoMessage() {} + +// Deprecated: Use QueryGetCountRequest.ProtoReflect.Descriptor instead. +func (*QueryGetCountRequest) Descriptor() ([]byte, []int) { + return file_cosmos_counter_v1_query_proto_rawDescGZIP(), []int{0} +} + +// QueryGetCountResponse defines the response type for querying x/mock count. +type QueryGetCountResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + TotalCount int64 `protobuf:"varint,1,opt,name=total_count,json=totalCount,proto3" json:"total_count,omitempty"` +} + +func (x *QueryGetCountResponse) Reset() { + *x = QueryGetCountResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_cosmos_counter_v1_query_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *QueryGetCountResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*QueryGetCountResponse) ProtoMessage() {} + +// Deprecated: Use QueryGetCountResponse.ProtoReflect.Descriptor instead. +func (*QueryGetCountResponse) Descriptor() ([]byte, []int) { + return file_cosmos_counter_v1_query_proto_rawDescGZIP(), []int{1} +} + +func (x *QueryGetCountResponse) GetTotalCount() int64 { + if x != nil { + return x.TotalCount + } + return 0 +} + +var File_cosmos_counter_v1_query_proto protoreflect.FileDescriptor + +var file_cosmos_counter_v1_query_proto_rawDesc = []byte{ + 0x0a, 0x1d, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x72, + 0x2f, 0x76, 0x31, 0x2f, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, + 0x11, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x72, 0x2e, + 0x76, 0x31, 0x22, 0x16, 0x0a, 0x14, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x43, 0x6f, + 0x75, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x38, 0x0a, 0x15, 0x51, 0x75, + 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x63, 0x6f, 0x75, + 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x43, + 0x6f, 0x75, 0x6e, 0x74, 0x32, 0x66, 0x0a, 0x05, 0x51, 0x75, 0x65, 0x72, 0x79, 0x12, 0x5d, 0x0a, + 0x08, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x27, 0x2e, 0x63, 0x6f, 0x73, 0x6d, + 0x6f, 0x73, 0x2e, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x51, 0x75, + 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x63, 0x6f, 0x75, 0x6e, + 0x74, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x47, 0x65, 0x74, 0x43, + 0x6f, 0x75, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x42, 0xb7, 0x01, 0x0a, + 0x15, 0x63, 0x6f, 0x6d, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x63, 0x6f, 0x75, 0x6e, + 0x74, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x42, 0x0a, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x72, 0x6f, + 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x2c, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, + 0x69, 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x63, 0x6f, + 0x75, 0x6e, 0x74, 0x65, 0x72, 0x2f, 0x76, 0x31, 0x3b, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x72, + 0x76, 0x31, 0xa2, 0x02, 0x03, 0x43, 0x43, 0x58, 0xaa, 0x02, 0x11, 0x43, 0x6f, 0x73, 0x6d, 0x6f, + 0x73, 0x2e, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x72, 0x2e, 0x56, 0x31, 0xca, 0x02, 0x11, 0x43, + 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x5c, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x72, 0x5c, 0x56, 0x31, + 0xe2, 0x02, 0x1d, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x5c, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x65, + 0x72, 0x5c, 0x56, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, + 0xea, 0x02, 0x13, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x3a, 0x3a, 0x43, 0x6f, 0x75, 0x6e, 0x74, + 0x65, 0x72, 0x3a, 0x3a, 0x56, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_cosmos_counter_v1_query_proto_rawDescOnce sync.Once + file_cosmos_counter_v1_query_proto_rawDescData = file_cosmos_counter_v1_query_proto_rawDesc +) + +func file_cosmos_counter_v1_query_proto_rawDescGZIP() []byte { + file_cosmos_counter_v1_query_proto_rawDescOnce.Do(func() { + file_cosmos_counter_v1_query_proto_rawDescData = protoimpl.X.CompressGZIP(file_cosmos_counter_v1_query_proto_rawDescData) + }) + return file_cosmos_counter_v1_query_proto_rawDescData +} + +var file_cosmos_counter_v1_query_proto_msgTypes = make([]protoimpl.MessageInfo, 2) +var file_cosmos_counter_v1_query_proto_goTypes = []interface{}{ + (*QueryGetCountRequest)(nil), // 0: cosmos.counter.v1.QueryGetCountRequest + (*QueryGetCountResponse)(nil), // 1: cosmos.counter.v1.QueryGetCountResponse +} +var file_cosmos_counter_v1_query_proto_depIdxs = []int32{ + 0, // 0: cosmos.counter.v1.Query.GetCount:input_type -> cosmos.counter.v1.QueryGetCountRequest + 1, // 1: cosmos.counter.v1.Query.GetCount:output_type -> cosmos.counter.v1.QueryGetCountResponse + 1, // [1:2] is the sub-list for method output_type + 0, // [0:1] is the sub-list for method input_type + 0, // [0:0] is the sub-list for extension type_name + 0, // [0:0] is the sub-list for extension extendee + 0, // [0:0] is the sub-list for field type_name +} + +func init() { file_cosmos_counter_v1_query_proto_init() } +func file_cosmos_counter_v1_query_proto_init() { + if File_cosmos_counter_v1_query_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_cosmos_counter_v1_query_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryGetCountRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cosmos_counter_v1_query_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*QueryGetCountResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_cosmos_counter_v1_query_proto_rawDesc, + NumEnums: 0, + NumMessages: 2, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_cosmos_counter_v1_query_proto_goTypes, + DependencyIndexes: file_cosmos_counter_v1_query_proto_depIdxs, + MessageInfos: file_cosmos_counter_v1_query_proto_msgTypes, + }.Build() + File_cosmos_counter_v1_query_proto = out.File + file_cosmos_counter_v1_query_proto_rawDesc = nil + file_cosmos_counter_v1_query_proto_goTypes = nil + file_cosmos_counter_v1_query_proto_depIdxs = nil +} diff --git a/api/cosmos/counter/v1/query_grpc.pb.go b/api/cosmos/counter/v1/query_grpc.pb.go new file mode 100644 index 0000000000..c73c209928 --- /dev/null +++ b/api/cosmos/counter/v1/query_grpc.pb.go @@ -0,0 +1,111 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.3.0 +// - protoc (unknown) +// source: cosmos/counter/v1/query.proto + +package counterv1 + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.32.0 or later. +const _ = grpc.SupportPackageIsVersion7 + +const ( + Query_GetCount_FullMethodName = "/cosmos.counter.v1.Query/GetCount" +) + +// QueryClient is the client API for Query service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type QueryClient interface { + // GetCount queries the parameters of x/Counter module. + GetCount(ctx context.Context, in *QueryGetCountRequest, opts ...grpc.CallOption) (*QueryGetCountResponse, error) +} + +type queryClient struct { + cc grpc.ClientConnInterface +} + +func NewQueryClient(cc grpc.ClientConnInterface) QueryClient { + return &queryClient{cc} +} + +func (c *queryClient) GetCount(ctx context.Context, in *QueryGetCountRequest, opts ...grpc.CallOption) (*QueryGetCountResponse, error) { + out := new(QueryGetCountResponse) + err := c.cc.Invoke(ctx, Query_GetCount_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// QueryServer is the server API for Query service. +// All implementations must embed UnimplementedQueryServer +// for forward compatibility +type QueryServer interface { + // GetCount queries the parameters of x/Counter module. + GetCount(context.Context, *QueryGetCountRequest) (*QueryGetCountResponse, error) + mustEmbedUnimplementedQueryServer() +} + +// UnimplementedQueryServer must be embedded to have forward compatible implementations. +type UnimplementedQueryServer struct { +} + +func (UnimplementedQueryServer) GetCount(context.Context, *QueryGetCountRequest) (*QueryGetCountResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetCount not implemented") +} +func (UnimplementedQueryServer) mustEmbedUnimplementedQueryServer() {} + +// UnsafeQueryServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to QueryServer will +// result in compilation errors. +type UnsafeQueryServer interface { + mustEmbedUnimplementedQueryServer() +} + +func RegisterQueryServer(s grpc.ServiceRegistrar, srv QueryServer) { + s.RegisterService(&Query_ServiceDesc, srv) +} + +func _Query_GetCount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryGetCountRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).GetCount(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Query_GetCount_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).GetCount(ctx, req.(*QueryGetCountRequest)) + } + return interceptor(ctx, in, info, handler) +} + +// Query_ServiceDesc is the grpc.ServiceDesc for Query service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var Query_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "cosmos.counter.v1.Query", + HandlerType: (*QueryServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "GetCount", + Handler: _Query_GetCount_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "cosmos/counter/v1/query.proto", +} diff --git a/api/cosmos/counter/v1/tx.pulsar.go b/api/cosmos/counter/v1/tx.pulsar.go new file mode 100644 index 0000000000..0bac1a4f14 --- /dev/null +++ b/api/cosmos/counter/v1/tx.pulsar.go @@ -0,0 +1,1102 @@ +// Code generated by protoc-gen-go-pulsar. DO NOT EDIT. +package counterv1 + +import ( + _ "cosmossdk.io/api/cosmos/msg/v1" + fmt "fmt" + _ "github.com/cosmos/cosmos-proto" + runtime "github.com/cosmos/cosmos-proto/runtime" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoiface "google.golang.org/protobuf/runtime/protoiface" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + io "io" + reflect "reflect" + sync "sync" +) + +var ( + md_MsgIncreaseCounter protoreflect.MessageDescriptor + fd_MsgIncreaseCounter_signer protoreflect.FieldDescriptor + fd_MsgIncreaseCounter_count protoreflect.FieldDescriptor +) + +func init() { + file_cosmos_counter_v1_tx_proto_init() + md_MsgIncreaseCounter = File_cosmos_counter_v1_tx_proto.Messages().ByName("MsgIncreaseCounter") + fd_MsgIncreaseCounter_signer = md_MsgIncreaseCounter.Fields().ByName("signer") + fd_MsgIncreaseCounter_count = md_MsgIncreaseCounter.Fields().ByName("count") +} + +var _ protoreflect.Message = (*fastReflection_MsgIncreaseCounter)(nil) + +type fastReflection_MsgIncreaseCounter MsgIncreaseCounter + +func (x *MsgIncreaseCounter) ProtoReflect() protoreflect.Message { + return (*fastReflection_MsgIncreaseCounter)(x) +} + +func (x *MsgIncreaseCounter) slowProtoReflect() protoreflect.Message { + mi := &file_cosmos_counter_v1_tx_proto_msgTypes[0] + 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_MsgIncreaseCounter_messageType fastReflection_MsgIncreaseCounter_messageType +var _ protoreflect.MessageType = fastReflection_MsgIncreaseCounter_messageType{} + +type fastReflection_MsgIncreaseCounter_messageType struct{} + +func (x fastReflection_MsgIncreaseCounter_messageType) Zero() protoreflect.Message { + return (*fastReflection_MsgIncreaseCounter)(nil) +} +func (x fastReflection_MsgIncreaseCounter_messageType) New() protoreflect.Message { + return new(fastReflection_MsgIncreaseCounter) +} +func (x fastReflection_MsgIncreaseCounter_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_MsgIncreaseCounter +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_MsgIncreaseCounter) Descriptor() protoreflect.MessageDescriptor { + return md_MsgIncreaseCounter +} + +// 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_MsgIncreaseCounter) Type() protoreflect.MessageType { + return _fastReflection_MsgIncreaseCounter_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_MsgIncreaseCounter) New() protoreflect.Message { + return new(fastReflection_MsgIncreaseCounter) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_MsgIncreaseCounter) Interface() protoreflect.ProtoMessage { + return (*MsgIncreaseCounter)(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_MsgIncreaseCounter) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Signer != "" { + value := protoreflect.ValueOfString(x.Signer) + if !f(fd_MsgIncreaseCounter_signer, value) { + return + } + } + if x.Count != int64(0) { + value := protoreflect.ValueOfInt64(x.Count) + if !f(fd_MsgIncreaseCounter_count, 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_MsgIncreaseCounter) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "cosmos.counter.v1.MsgIncreaseCounter.signer": + return x.Signer != "" + case "cosmos.counter.v1.MsgIncreaseCounter.count": + return x.Count != int64(0) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.counter.v1.MsgIncreaseCounter")) + } + panic(fmt.Errorf("message cosmos.counter.v1.MsgIncreaseCounter 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_MsgIncreaseCounter) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "cosmos.counter.v1.MsgIncreaseCounter.signer": + x.Signer = "" + case "cosmos.counter.v1.MsgIncreaseCounter.count": + x.Count = int64(0) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.counter.v1.MsgIncreaseCounter")) + } + panic(fmt.Errorf("message cosmos.counter.v1.MsgIncreaseCounter 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_MsgIncreaseCounter) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "cosmos.counter.v1.MsgIncreaseCounter.signer": + value := x.Signer + return protoreflect.ValueOfString(value) + case "cosmos.counter.v1.MsgIncreaseCounter.count": + value := x.Count + return protoreflect.ValueOfInt64(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.counter.v1.MsgIncreaseCounter")) + } + panic(fmt.Errorf("message cosmos.counter.v1.MsgIncreaseCounter 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_MsgIncreaseCounter) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "cosmos.counter.v1.MsgIncreaseCounter.signer": + x.Signer = value.Interface().(string) + case "cosmos.counter.v1.MsgIncreaseCounter.count": + x.Count = value.Int() + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.counter.v1.MsgIncreaseCounter")) + } + panic(fmt.Errorf("message cosmos.counter.v1.MsgIncreaseCounter 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_MsgIncreaseCounter) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.counter.v1.MsgIncreaseCounter.signer": + panic(fmt.Errorf("field signer of message cosmos.counter.v1.MsgIncreaseCounter is not mutable")) + case "cosmos.counter.v1.MsgIncreaseCounter.count": + panic(fmt.Errorf("field count of message cosmos.counter.v1.MsgIncreaseCounter is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.counter.v1.MsgIncreaseCounter")) + } + panic(fmt.Errorf("message cosmos.counter.v1.MsgIncreaseCounter 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_MsgIncreaseCounter) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.counter.v1.MsgIncreaseCounter.signer": + return protoreflect.ValueOfString("") + case "cosmos.counter.v1.MsgIncreaseCounter.count": + return protoreflect.ValueOfInt64(int64(0)) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.counter.v1.MsgIncreaseCounter")) + } + panic(fmt.Errorf("message cosmos.counter.v1.MsgIncreaseCounter 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_MsgIncreaseCounter) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in cosmos.counter.v1.MsgIncreaseCounter", 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_MsgIncreaseCounter) 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_MsgIncreaseCounter) 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_MsgIncreaseCounter) 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_MsgIncreaseCounter) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*MsgIncreaseCounter) + 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.Signer) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.Count != 0 { + n += 1 + runtime.Sov(uint64(x.Count)) + } + 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().(*MsgIncreaseCounter) + 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.Count != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.Count)) + i-- + dAtA[i] = 0x10 + } + if len(x.Signer) > 0 { + i -= len(x.Signer) + copy(dAtA[i:], x.Signer) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Signer))) + 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().(*MsgIncreaseCounter) + 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: MsgIncreaseCounter: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgIncreaseCounter: 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 Signer", 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.Signer = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Count", wireType) + } + x.Count = 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.Count |= int64(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_MsgIncreaseCountResponse protoreflect.MessageDescriptor + fd_MsgIncreaseCountResponse_new_count protoreflect.FieldDescriptor +) + +func init() { + file_cosmos_counter_v1_tx_proto_init() + md_MsgIncreaseCountResponse = File_cosmos_counter_v1_tx_proto.Messages().ByName("MsgIncreaseCountResponse") + fd_MsgIncreaseCountResponse_new_count = md_MsgIncreaseCountResponse.Fields().ByName("new_count") +} + +var _ protoreflect.Message = (*fastReflection_MsgIncreaseCountResponse)(nil) + +type fastReflection_MsgIncreaseCountResponse MsgIncreaseCountResponse + +func (x *MsgIncreaseCountResponse) ProtoReflect() protoreflect.Message { + return (*fastReflection_MsgIncreaseCountResponse)(x) +} + +func (x *MsgIncreaseCountResponse) slowProtoReflect() protoreflect.Message { + mi := &file_cosmos_counter_v1_tx_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_MsgIncreaseCountResponse_messageType fastReflection_MsgIncreaseCountResponse_messageType +var _ protoreflect.MessageType = fastReflection_MsgIncreaseCountResponse_messageType{} + +type fastReflection_MsgIncreaseCountResponse_messageType struct{} + +func (x fastReflection_MsgIncreaseCountResponse_messageType) Zero() protoreflect.Message { + return (*fastReflection_MsgIncreaseCountResponse)(nil) +} +func (x fastReflection_MsgIncreaseCountResponse_messageType) New() protoreflect.Message { + return new(fastReflection_MsgIncreaseCountResponse) +} +func (x fastReflection_MsgIncreaseCountResponse_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_MsgIncreaseCountResponse +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_MsgIncreaseCountResponse) Descriptor() protoreflect.MessageDescriptor { + return md_MsgIncreaseCountResponse +} + +// 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_MsgIncreaseCountResponse) Type() protoreflect.MessageType { + return _fastReflection_MsgIncreaseCountResponse_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_MsgIncreaseCountResponse) New() protoreflect.Message { + return new(fastReflection_MsgIncreaseCountResponse) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_MsgIncreaseCountResponse) Interface() protoreflect.ProtoMessage { + return (*MsgIncreaseCountResponse)(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_MsgIncreaseCountResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.NewCount != int64(0) { + value := protoreflect.ValueOfInt64(x.NewCount) + if !f(fd_MsgIncreaseCountResponse_new_count, 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_MsgIncreaseCountResponse) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "cosmos.counter.v1.MsgIncreaseCountResponse.new_count": + return x.NewCount != int64(0) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.counter.v1.MsgIncreaseCountResponse")) + } + panic(fmt.Errorf("message cosmos.counter.v1.MsgIncreaseCountResponse 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_MsgIncreaseCountResponse) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "cosmos.counter.v1.MsgIncreaseCountResponse.new_count": + x.NewCount = int64(0) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.counter.v1.MsgIncreaseCountResponse")) + } + panic(fmt.Errorf("message cosmos.counter.v1.MsgIncreaseCountResponse 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_MsgIncreaseCountResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "cosmos.counter.v1.MsgIncreaseCountResponse.new_count": + value := x.NewCount + return protoreflect.ValueOfInt64(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.counter.v1.MsgIncreaseCountResponse")) + } + panic(fmt.Errorf("message cosmos.counter.v1.MsgIncreaseCountResponse 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_MsgIncreaseCountResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "cosmos.counter.v1.MsgIncreaseCountResponse.new_count": + x.NewCount = value.Int() + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.counter.v1.MsgIncreaseCountResponse")) + } + panic(fmt.Errorf("message cosmos.counter.v1.MsgIncreaseCountResponse 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_MsgIncreaseCountResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.counter.v1.MsgIncreaseCountResponse.new_count": + panic(fmt.Errorf("field new_count of message cosmos.counter.v1.MsgIncreaseCountResponse is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.counter.v1.MsgIncreaseCountResponse")) + } + panic(fmt.Errorf("message cosmos.counter.v1.MsgIncreaseCountResponse 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_MsgIncreaseCountResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.counter.v1.MsgIncreaseCountResponse.new_count": + return protoreflect.ValueOfInt64(int64(0)) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.counter.v1.MsgIncreaseCountResponse")) + } + panic(fmt.Errorf("message cosmos.counter.v1.MsgIncreaseCountResponse 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_MsgIncreaseCountResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in cosmos.counter.v1.MsgIncreaseCountResponse", 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_MsgIncreaseCountResponse) 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_MsgIncreaseCountResponse) 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_MsgIncreaseCountResponse) 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_MsgIncreaseCountResponse) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*MsgIncreaseCountResponse) + 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.NewCount != 0 { + n += 1 + runtime.Sov(uint64(x.NewCount)) + } + 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().(*MsgIncreaseCountResponse) + 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.NewCount != 0 { + i = runtime.EncodeVarint(dAtA, i, uint64(x.NewCount)) + 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().(*MsgIncreaseCountResponse) + 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: MsgIncreaseCountResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgIncreaseCountResponse: 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 NewCount", wireType) + } + x.NewCount = 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.NewCount |= int64(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, + } +} + +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.27.0 +// protoc (unknown) +// source: cosmos/counter/v1/tx.proto + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// MsgIncreaseCounter defines a count Msg service counter. +type MsgIncreaseCounter struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // signer is the address that controls the module (defaults to x/gov unless overwritten). + Signer string `protobuf:"bytes,1,opt,name=signer,proto3" json:"signer,omitempty"` + // count is the number of times to increment the counter. + Count int64 `protobuf:"varint,2,opt,name=count,proto3" json:"count,omitempty"` +} + +func (x *MsgIncreaseCounter) Reset() { + *x = MsgIncreaseCounter{} + if protoimpl.UnsafeEnabled { + mi := &file_cosmos_counter_v1_tx_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MsgIncreaseCounter) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MsgIncreaseCounter) ProtoMessage() {} + +// Deprecated: Use MsgIncreaseCounter.ProtoReflect.Descriptor instead. +func (*MsgIncreaseCounter) Descriptor() ([]byte, []int) { + return file_cosmos_counter_v1_tx_proto_rawDescGZIP(), []int{0} +} + +func (x *MsgIncreaseCounter) GetSigner() string { + if x != nil { + return x.Signer + } + return "" +} + +func (x *MsgIncreaseCounter) GetCount() int64 { + if x != nil { + return x.Count + } + return 0 +} + +// MsgIncreaseCountResponse is the Msg/Counter response type. +type MsgIncreaseCountResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // new_count is the number of times the counter was incremented. + NewCount int64 `protobuf:"varint,1,opt,name=new_count,json=newCount,proto3" json:"new_count,omitempty"` +} + +func (x *MsgIncreaseCountResponse) Reset() { + *x = MsgIncreaseCountResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_cosmos_counter_v1_tx_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MsgIncreaseCountResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MsgIncreaseCountResponse) ProtoMessage() {} + +// Deprecated: Use MsgIncreaseCountResponse.ProtoReflect.Descriptor instead. +func (*MsgIncreaseCountResponse) Descriptor() ([]byte, []int) { + return file_cosmos_counter_v1_tx_proto_rawDescGZIP(), []int{1} +} + +func (x *MsgIncreaseCountResponse) GetNewCount() int64 { + if x != nil { + return x.NewCount + } + return 0 +} + +var File_cosmos_counter_v1_tx_proto protoreflect.FileDescriptor + +var file_cosmos_counter_v1_tx_proto_rawDesc = []byte{ + 0x0a, 0x1a, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x72, + 0x2f, 0x76, 0x31, 0x2f, 0x74, 0x78, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x11, 0x63, 0x6f, + 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x1a, + 0x19, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x63, 0x6f, + 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x17, 0x63, 0x6f, 0x73, 0x6d, + 0x6f, 0x73, 0x2f, 0x6d, 0x73, 0x67, 0x2f, 0x76, 0x31, 0x2f, 0x6d, 0x73, 0x67, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x22, 0x69, 0x0a, 0x12, 0x4d, 0x73, 0x67, 0x49, 0x6e, 0x63, 0x72, 0x65, 0x61, + 0x73, 0x65, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x72, 0x12, 0x30, 0x0a, 0x06, 0x73, 0x69, 0x67, + 0x6e, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x18, 0xd2, 0xb4, 0x2d, 0x14, 0x63, + 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, + 0x69, 0x6e, 0x67, 0x52, 0x06, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x63, + 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x63, 0x6f, 0x75, 0x6e, + 0x74, 0x3a, 0x0b, 0x82, 0xe7, 0xb0, 0x2a, 0x06, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x72, 0x22, 0x37, + 0x0a, 0x18, 0x4d, 0x73, 0x67, 0x49, 0x6e, 0x63, 0x72, 0x65, 0x61, 0x73, 0x65, 0x43, 0x6f, 0x75, + 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x6e, 0x65, + 0x77, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x6e, + 0x65, 0x77, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x32, 0x71, 0x0a, 0x03, 0x4d, 0x73, 0x67, 0x12, 0x63, + 0x0a, 0x0d, 0x49, 0x6e, 0x63, 0x72, 0x65, 0x61, 0x73, 0x65, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, + 0x25, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x72, + 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x49, 0x6e, 0x63, 0x72, 0x65, 0x61, 0x73, 0x65, 0x43, + 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x72, 0x1a, 0x2b, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, + 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x73, 0x67, 0x49, 0x6e, + 0x63, 0x72, 0x65, 0x61, 0x73, 0x65, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x1a, 0x05, 0x80, 0xe7, 0xb0, 0x2a, 0x01, 0x42, 0xb4, 0x01, 0x0a, 0x15, 0x63, + 0x6f, 0x6d, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x65, + 0x72, 0x2e, 0x76, 0x31, 0x42, 0x07, 0x54, 0x78, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, + 0x2c, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x61, 0x70, + 0x69, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x72, + 0x2f, 0x76, 0x31, 0x3b, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x31, 0xa2, 0x02, 0x03, + 0x43, 0x43, 0x58, 0xaa, 0x02, 0x11, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x43, 0x6f, 0x75, + 0x6e, 0x74, 0x65, 0x72, 0x2e, 0x56, 0x31, 0xca, 0x02, 0x11, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, + 0x5c, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x72, 0x5c, 0x56, 0x31, 0xe2, 0x02, 0x1d, 0x43, 0x6f, + 0x73, 0x6d, 0x6f, 0x73, 0x5c, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x72, 0x5c, 0x56, 0x31, 0x5c, + 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x13, 0x43, 0x6f, + 0x73, 0x6d, 0x6f, 0x73, 0x3a, 0x3a, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x72, 0x3a, 0x3a, 0x56, + 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_cosmos_counter_v1_tx_proto_rawDescOnce sync.Once + file_cosmos_counter_v1_tx_proto_rawDescData = file_cosmos_counter_v1_tx_proto_rawDesc +) + +func file_cosmos_counter_v1_tx_proto_rawDescGZIP() []byte { + file_cosmos_counter_v1_tx_proto_rawDescOnce.Do(func() { + file_cosmos_counter_v1_tx_proto_rawDescData = protoimpl.X.CompressGZIP(file_cosmos_counter_v1_tx_proto_rawDescData) + }) + return file_cosmos_counter_v1_tx_proto_rawDescData +} + +var file_cosmos_counter_v1_tx_proto_msgTypes = make([]protoimpl.MessageInfo, 2) +var file_cosmos_counter_v1_tx_proto_goTypes = []interface{}{ + (*MsgIncreaseCounter)(nil), // 0: cosmos.counter.v1.MsgIncreaseCounter + (*MsgIncreaseCountResponse)(nil), // 1: cosmos.counter.v1.MsgIncreaseCountResponse +} +var file_cosmos_counter_v1_tx_proto_depIdxs = []int32{ + 0, // 0: cosmos.counter.v1.Msg.IncreaseCount:input_type -> cosmos.counter.v1.MsgIncreaseCounter + 1, // 1: cosmos.counter.v1.Msg.IncreaseCount:output_type -> cosmos.counter.v1.MsgIncreaseCountResponse + 1, // [1:2] is the sub-list for method output_type + 0, // [0:1] is the sub-list for method input_type + 0, // [0:0] is the sub-list for extension type_name + 0, // [0:0] is the sub-list for extension extendee + 0, // [0:0] is the sub-list for field type_name +} + +func init() { file_cosmos_counter_v1_tx_proto_init() } +func file_cosmos_counter_v1_tx_proto_init() { + if File_cosmos_counter_v1_tx_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_cosmos_counter_v1_tx_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MsgIncreaseCounter); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cosmos_counter_v1_tx_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MsgIncreaseCountResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_cosmos_counter_v1_tx_proto_rawDesc, + NumEnums: 0, + NumMessages: 2, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_cosmos_counter_v1_tx_proto_goTypes, + DependencyIndexes: file_cosmos_counter_v1_tx_proto_depIdxs, + MessageInfos: file_cosmos_counter_v1_tx_proto_msgTypes, + }.Build() + File_cosmos_counter_v1_tx_proto = out.File + file_cosmos_counter_v1_tx_proto_rawDesc = nil + file_cosmos_counter_v1_tx_proto_goTypes = nil + file_cosmos_counter_v1_tx_proto_depIdxs = nil +} diff --git a/api/cosmos/counter/v1/tx_grpc.pb.go b/api/cosmos/counter/v1/tx_grpc.pb.go new file mode 100644 index 0000000000..d72801f15a --- /dev/null +++ b/api/cosmos/counter/v1/tx_grpc.pb.go @@ -0,0 +1,111 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.3.0 +// - protoc (unknown) +// source: cosmos/counter/v1/tx.proto + +package counterv1 + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.32.0 or later. +const _ = grpc.SupportPackageIsVersion7 + +const ( + Msg_IncreaseCount_FullMethodName = "/cosmos.counter.v1.Msg/IncreaseCount" +) + +// MsgClient is the client API for Msg service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type MsgClient interface { + // IncreaseCount increments the counter by the specified amount. + IncreaseCount(ctx context.Context, in *MsgIncreaseCounter, opts ...grpc.CallOption) (*MsgIncreaseCountResponse, error) +} + +type msgClient struct { + cc grpc.ClientConnInterface +} + +func NewMsgClient(cc grpc.ClientConnInterface) MsgClient { + return &msgClient{cc} +} + +func (c *msgClient) IncreaseCount(ctx context.Context, in *MsgIncreaseCounter, opts ...grpc.CallOption) (*MsgIncreaseCountResponse, error) { + out := new(MsgIncreaseCountResponse) + err := c.cc.Invoke(ctx, Msg_IncreaseCount_FullMethodName, in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// MsgServer is the server API for Msg service. +// All implementations must embed UnimplementedMsgServer +// for forward compatibility +type MsgServer interface { + // IncreaseCount increments the counter by the specified amount. + IncreaseCount(context.Context, *MsgIncreaseCounter) (*MsgIncreaseCountResponse, error) + mustEmbedUnimplementedMsgServer() +} + +// UnimplementedMsgServer must be embedded to have forward compatible implementations. +type UnimplementedMsgServer struct { +} + +func (UnimplementedMsgServer) IncreaseCount(context.Context, *MsgIncreaseCounter) (*MsgIncreaseCountResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method IncreaseCount not implemented") +} +func (UnimplementedMsgServer) mustEmbedUnimplementedMsgServer() {} + +// UnsafeMsgServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to MsgServer will +// result in compilation errors. +type UnsafeMsgServer interface { + mustEmbedUnimplementedMsgServer() +} + +func RegisterMsgServer(s grpc.ServiceRegistrar, srv MsgServer) { + s.RegisterService(&Msg_ServiceDesc, srv) +} + +func _Msg_IncreaseCount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgIncreaseCounter) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).IncreaseCount(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Msg_IncreaseCount_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).IncreaseCount(ctx, req.(*MsgIncreaseCounter)) + } + return interceptor(ctx, in, info, handler) +} + +// Msg_ServiceDesc is the grpc.ServiceDesc for Msg service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var Msg_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "cosmos.counter.v1.Msg", + HandlerType: (*MsgServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "IncreaseCount", + Handler: _Msg_IncreaseCount_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "cosmos/counter/v1/tx.proto", +} diff --git a/api/cosmos/mint/module/v1/module.pulsar.go b/api/cosmos/mint/module/v1/module.pulsar.go index 6d9884be4b..589ab19c81 100644 --- a/api/cosmos/mint/module/v1/module.pulsar.go +++ b/api/cosmos/mint/module/v1/module.pulsar.go @@ -563,29 +563,28 @@ var file_cosmos_mint_module_v1_module_proto_rawDesc = []byte{ 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x15, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x6d, 0x69, 0x6e, 0x74, 0x2e, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x1a, 0x20, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x61, 0x70, 0x70, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, - 0x2f, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x81, 0x01, - 0x0a, 0x06, 0x4d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x12, 0x2c, 0x0a, 0x12, 0x66, 0x65, 0x65, 0x5f, - 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x66, 0x65, 0x65, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, - 0x6f, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, - 0x69, 0x74, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, - 0x72, 0x69, 0x74, 0x79, 0x3a, 0x2b, 0xba, 0xc0, 0x96, 0xda, 0x01, 0x25, 0x0a, 0x23, 0x67, 0x69, - 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, - 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2d, 0x73, 0x64, 0x6b, 0x2f, 0x78, 0x2f, 0x6d, 0x69, 0x6e, - 0x74, 0x42, 0xd0, 0x01, 0x0a, 0x19, 0x63, 0x6f, 0x6d, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, - 0x2e, 0x6d, 0x69, 0x6e, 0x74, 0x2e, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x42, - 0x0b, 0x4d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x2f, - 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x61, 0x70, 0x69, - 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x6d, 0x69, 0x6e, 0x74, 0x2f, 0x6d, 0x6f, 0x64, - 0x75, 0x6c, 0x65, 0x2f, 0x76, 0x31, 0x3b, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x76, 0x31, 0xa2, - 0x02, 0x03, 0x43, 0x4d, 0x4d, 0xaa, 0x02, 0x15, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x4d, - 0x69, 0x6e, 0x74, 0x2e, 0x4d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x2e, 0x56, 0x31, 0xca, 0x02, 0x15, - 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x5c, 0x4d, 0x69, 0x6e, 0x74, 0x5c, 0x4d, 0x6f, 0x64, 0x75, - 0x6c, 0x65, 0x5c, 0x56, 0x31, 0xe2, 0x02, 0x21, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x5c, 0x4d, - 0x69, 0x6e, 0x74, 0x5c, 0x4d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x5c, 0x56, 0x31, 0x5c, 0x47, 0x50, - 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x18, 0x43, 0x6f, 0x73, 0x6d, - 0x6f, 0x73, 0x3a, 0x3a, 0x4d, 0x69, 0x6e, 0x74, 0x3a, 0x3a, 0x4d, 0x6f, 0x64, 0x75, 0x6c, 0x65, - 0x3a, 0x3a, 0x56, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x2f, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x71, 0x0a, + 0x06, 0x4d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x12, 0x2c, 0x0a, 0x12, 0x66, 0x65, 0x65, 0x5f, 0x63, + 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x10, 0x66, 0x65, 0x65, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x6f, + 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, + 0x74, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, + 0x69, 0x74, 0x79, 0x3a, 0x1b, 0xba, 0xc0, 0x96, 0xda, 0x01, 0x15, 0x0a, 0x13, 0x63, 0x6f, 0x73, + 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x78, 0x2f, 0x6d, 0x69, 0x6e, 0x74, + 0x42, 0xd0, 0x01, 0x0a, 0x19, 0x63, 0x6f, 0x6d, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, + 0x6d, 0x69, 0x6e, 0x74, 0x2e, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x2e, 0x76, 0x31, 0x42, 0x0b, + 0x4d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x2f, 0x63, + 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2f, + 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x6d, 0x69, 0x6e, 0x74, 0x2f, 0x6d, 0x6f, 0x64, 0x75, + 0x6c, 0x65, 0x2f, 0x76, 0x31, 0x3b, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x76, 0x31, 0xa2, 0x02, + 0x03, 0x43, 0x4d, 0x4d, 0xaa, 0x02, 0x15, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x4d, 0x69, + 0x6e, 0x74, 0x2e, 0x4d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x2e, 0x56, 0x31, 0xca, 0x02, 0x15, 0x43, + 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x5c, 0x4d, 0x69, 0x6e, 0x74, 0x5c, 0x4d, 0x6f, 0x64, 0x75, 0x6c, + 0x65, 0x5c, 0x56, 0x31, 0xe2, 0x02, 0x21, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x5c, 0x4d, 0x69, + 0x6e, 0x74, 0x5c, 0x4d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x5c, 0x56, 0x31, 0x5c, 0x47, 0x50, 0x42, + 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x18, 0x43, 0x6f, 0x73, 0x6d, 0x6f, + 0x73, 0x3a, 0x3a, 0x4d, 0x69, 0x6e, 0x74, 0x3a, 0x3a, 0x4d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x3a, + 0x3a, 0x56, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, } var ( diff --git a/proto/cosmos/counter/v1/query.proto b/proto/cosmos/counter/v1/query.proto new file mode 100644 index 0000000000..18ef0b6ae9 --- /dev/null +++ b/proto/cosmos/counter/v1/query.proto @@ -0,0 +1,18 @@ +syntax = "proto3"; +package cosmos.counter.v1; + +option go_package = "github.com/cosmos/cosmos-sdk/x/counter/types"; + +// Query defines the gRPC querier service. +service Query { + // GetCount queries the parameters of x/Counter module. + rpc GetCount(QueryGetCountRequest) returns (QueryGetCountResponse); +} + +// QueryGetCountRequest defines the request type for querying x/mock count. +message QueryGetCountRequest {} + +// QueryGetCountResponse defines the response type for querying x/mock count. +message QueryGetCountResponse { + int64 total_count = 1; +} diff --git a/proto/cosmos/counter/v1/tx.proto b/proto/cosmos/counter/v1/tx.proto new file mode 100644 index 0000000000..0a733e05c1 --- /dev/null +++ b/proto/cosmos/counter/v1/tx.proto @@ -0,0 +1,33 @@ + +syntax = "proto3"; +package cosmos.counter.v1; + +import "cosmos_proto/cosmos.proto"; +import "cosmos/msg/v1/msg.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/x/counter/types"; + +// Msg defines the counter Msg service. +service Msg { + option (cosmos.msg.v1.service) = true; + + // IncreaseCount increments the counter by the specified amount. + rpc IncreaseCount(MsgIncreaseCounter) returns (MsgIncreaseCountResponse); +} + +// MsgIncreaseCounter defines a count Msg service counter. +message MsgIncreaseCounter { + option (cosmos.msg.v1.signer) = "signer"; + + // signer is the address that controls the module (defaults to x/gov unless overwritten). + string signer = 1 [(cosmos_proto.scalar) = "cosmos.AddressString"]; + + // count is the number of times to increment the counter. + int64 count = 2; +} + +// MsgIncreaseCountResponse is the Msg/Counter response type. +message MsgIncreaseCountResponse { + // new_count is the number of times the counter was incremented. + int64 new_count = 1; +} diff --git a/x/counter/types/query.pb.go b/x/counter/types/query.pb.go new file mode 100644 index 0000000000..c18515163e --- /dev/null +++ b/x/counter/types/query.pb.go @@ -0,0 +1,510 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: cosmos/counter/v1/query.proto + +package types + +import ( + context "context" + fmt "fmt" + grpc1 "github.com/cosmos/gogoproto/grpc" + proto "github.com/cosmos/gogoproto/proto" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + io "io" + math "math" + math_bits "math/bits" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +// QueryGetCountRequest defines the request type for querying x/mock count. +type QueryGetCountRequest struct { +} + +func (m *QueryGetCountRequest) Reset() { *m = QueryGetCountRequest{} } +func (m *QueryGetCountRequest) String() string { return proto.CompactTextString(m) } +func (*QueryGetCountRequest) ProtoMessage() {} +func (*QueryGetCountRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_bd21727562626c9f, []int{0} +} +func (m *QueryGetCountRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryGetCountRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryGetCountRequest.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 *QueryGetCountRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryGetCountRequest.Merge(m, src) +} +func (m *QueryGetCountRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryGetCountRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryGetCountRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryGetCountRequest proto.InternalMessageInfo + +// QueryGetCountResponse defines the response type for querying x/mock count. +type QueryGetCountResponse struct { + TotalCount int64 `protobuf:"varint,1,opt,name=total_count,json=totalCount,proto3" json:"total_count,omitempty"` +} + +func (m *QueryGetCountResponse) Reset() { *m = QueryGetCountResponse{} } +func (m *QueryGetCountResponse) String() string { return proto.CompactTextString(m) } +func (*QueryGetCountResponse) ProtoMessage() {} +func (*QueryGetCountResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_bd21727562626c9f, []int{1} +} +func (m *QueryGetCountResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryGetCountResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryGetCountResponse.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 *QueryGetCountResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryGetCountResponse.Merge(m, src) +} +func (m *QueryGetCountResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryGetCountResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryGetCountResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryGetCountResponse proto.InternalMessageInfo + +func (m *QueryGetCountResponse) GetTotalCount() int64 { + if m != nil { + return m.TotalCount + } + return 0 +} + +func init() { + proto.RegisterType((*QueryGetCountRequest)(nil), "cosmos.counter.v1.QueryGetCountRequest") + proto.RegisterType((*QueryGetCountResponse)(nil), "cosmos.counter.v1.QueryGetCountResponse") +} + +func init() { proto.RegisterFile("cosmos/counter/v1/query.proto", fileDescriptor_bd21727562626c9f) } + +var fileDescriptor_bd21727562626c9f = []byte{ + // 211 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4d, 0xce, 0x2f, 0xce, + 0xcd, 0x2f, 0xd6, 0x4f, 0xce, 0x2f, 0xcd, 0x2b, 0x49, 0x2d, 0xd2, 0x2f, 0x33, 0xd4, 0x2f, 0x2c, + 0x4d, 0x2d, 0xaa, 0xd4, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x84, 0x48, 0xeb, 0x41, 0xa5, + 0xf5, 0xca, 0x0c, 0x95, 0xc4, 0xb8, 0x44, 0x02, 0x41, 0x2a, 0xdc, 0x53, 0x4b, 0x9c, 0x41, 0xa2, + 0x41, 0xa9, 0x85, 0xa5, 0xa9, 0xc5, 0x25, 0x4a, 0x16, 0x5c, 0xa2, 0x68, 0xe2, 0xc5, 0x05, 0xf9, + 0x79, 0xc5, 0xa9, 0x42, 0xf2, 0x5c, 0xdc, 0x25, 0xf9, 0x25, 0x89, 0x39, 0xf1, 0x60, 0x43, 0x24, + 0x18, 0x15, 0x18, 0x35, 0x98, 0x83, 0xb8, 0xc0, 0x42, 0x60, 0x85, 0x46, 0x69, 0x5c, 0xac, 0x60, + 0x9d, 0x42, 0xb1, 0x5c, 0x1c, 0x30, 0xdd, 0x42, 0xea, 0x7a, 0x18, 0x56, 0xeb, 0x61, 0xb3, 0x57, + 0x4a, 0x83, 0xb0, 0x42, 0x88, 0x43, 0x9c, 0xdc, 0x4e, 0x3c, 0x92, 0x63, 0xbc, 0xf0, 0x48, 0x8e, + 0xf1, 0xc1, 0x23, 0x39, 0xc6, 0x09, 0x8f, 0xe5, 0x18, 0x2e, 0x3c, 0x96, 0x63, 0xb8, 0xf1, 0x58, + 0x8e, 0x21, 0x4a, 0x27, 0x3d, 0xb3, 0x24, 0xa3, 0x34, 0x49, 0x2f, 0x39, 0x3f, 0x57, 0x1f, 0x1e, + 0x20, 0x20, 0x4a, 0xb7, 0x38, 0x25, 0x5b, 0xbf, 0x02, 0x1e, 0x3a, 0x25, 0x95, 0x05, 0xa9, 0xc5, + 0x49, 0x6c, 0xe0, 0xb0, 0x31, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0x22, 0x18, 0xa2, 0xf4, 0x3c, + 0x01, 0x00, 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// QueryClient is the client API for Query service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type QueryClient interface { + // GetCount queries the parameters of x/Counter module. + GetCount(ctx context.Context, in *QueryGetCountRequest, opts ...grpc.CallOption) (*QueryGetCountResponse, error) +} + +type queryClient struct { + cc grpc1.ClientConn +} + +func NewQueryClient(cc grpc1.ClientConn) QueryClient { + return &queryClient{cc} +} + +func (c *queryClient) GetCount(ctx context.Context, in *QueryGetCountRequest, opts ...grpc.CallOption) (*QueryGetCountResponse, error) { + out := new(QueryGetCountResponse) + err := c.cc.Invoke(ctx, "/cosmos.counter.v1.Query/GetCount", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// QueryServer is the server API for Query service. +type QueryServer interface { + // GetCount queries the parameters of x/Counter module. + GetCount(context.Context, *QueryGetCountRequest) (*QueryGetCountResponse, error) +} + +// UnimplementedQueryServer can be embedded to have forward compatible implementations. +type UnimplementedQueryServer struct { +} + +func (*UnimplementedQueryServer) GetCount(ctx context.Context, req *QueryGetCountRequest) (*QueryGetCountResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetCount not implemented") +} + +func RegisterQueryServer(s grpc1.Server, srv QueryServer) { + s.RegisterService(&_Query_serviceDesc, srv) +} + +func _Query_GetCount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryGetCountRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).GetCount(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmos.counter.v1.Query/GetCount", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).GetCount(ctx, req.(*QueryGetCountRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _Query_serviceDesc = grpc.ServiceDesc{ + ServiceName: "cosmos.counter.v1.Query", + HandlerType: (*QueryServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "GetCount", + Handler: _Query_GetCount_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "cosmos/counter/v1/query.proto", +} + +func (m *QueryGetCountRequest) 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 *QueryGetCountRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryGetCountRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *QueryGetCountResponse) 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 *QueryGetCountResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryGetCountResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.TotalCount != 0 { + i = encodeVarintQuery(dAtA, i, uint64(m.TotalCount)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func encodeVarintQuery(dAtA []byte, offset int, v uint64) int { + offset -= sovQuery(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *QueryGetCountRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *QueryGetCountResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.TotalCount != 0 { + n += 1 + sovQuery(uint64(m.TotalCount)) + } + return n +} + +func sovQuery(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozQuery(x uint64) (n int) { + return sovQuery(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *QueryGetCountRequest) 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: QueryGetCountRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryGetCountRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryGetCountResponse) 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: QueryGetCountResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryGetCountResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TotalCount", wireType) + } + m.TotalCount = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.TotalCount |= int64(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 skipQuery(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowQuery + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowQuery + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowQuery + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthQuery + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupQuery + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthQuery + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthQuery = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowQuery = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupQuery = fmt.Errorf("proto: unexpected end of group") +) diff --git a/x/counter/types/tx.pb.go b/x/counter/types/tx.pb.go new file mode 100644 index 0000000000..4b50ec60d2 --- /dev/null +++ b/x/counter/types/tx.pb.go @@ -0,0 +1,606 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: cosmos/counter/v1/tx.proto + +package types + +import ( + context "context" + fmt "fmt" + _ "github.com/cosmos/cosmos-proto" + _ "github.com/cosmos/cosmos-sdk/types/msgservice" + grpc1 "github.com/cosmos/gogoproto/grpc" + proto "github.com/cosmos/gogoproto/proto" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + io "io" + math "math" + math_bits "math/bits" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +// MsgIncreaseCounter defines a count Msg service counter. +type MsgIncreaseCounter struct { + // signer is the address that controls the module (defaults to x/gov unless overwritten). + Signer string `protobuf:"bytes,1,opt,name=signer,proto3" json:"signer,omitempty"` + // count is the number of times to increment the counter. + Count int64 `protobuf:"varint,2,opt,name=count,proto3" json:"count,omitempty"` +} + +func (m *MsgIncreaseCounter) Reset() { *m = MsgIncreaseCounter{} } +func (m *MsgIncreaseCounter) String() string { return proto.CompactTextString(m) } +func (*MsgIncreaseCounter) ProtoMessage() {} +func (*MsgIncreaseCounter) Descriptor() ([]byte, []int) { + return fileDescriptor_16b86a09a73a7eb5, []int{0} +} +func (m *MsgIncreaseCounter) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgIncreaseCounter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgIncreaseCounter.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 *MsgIncreaseCounter) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgIncreaseCounter.Merge(m, src) +} +func (m *MsgIncreaseCounter) XXX_Size() int { + return m.Size() +} +func (m *MsgIncreaseCounter) XXX_DiscardUnknown() { + xxx_messageInfo_MsgIncreaseCounter.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgIncreaseCounter proto.InternalMessageInfo + +func (m *MsgIncreaseCounter) GetSigner() string { + if m != nil { + return m.Signer + } + return "" +} + +func (m *MsgIncreaseCounter) GetCount() int64 { + if m != nil { + return m.Count + } + return 0 +} + +// MsgIncreaseCountResponse is the Msg/Counter response type. +type MsgIncreaseCountResponse struct { + // new_count is the number of times the counter was incremented. + NewCount int64 `protobuf:"varint,1,opt,name=new_count,json=newCount,proto3" json:"new_count,omitempty"` +} + +func (m *MsgIncreaseCountResponse) Reset() { *m = MsgIncreaseCountResponse{} } +func (m *MsgIncreaseCountResponse) String() string { return proto.CompactTextString(m) } +func (*MsgIncreaseCountResponse) ProtoMessage() {} +func (*MsgIncreaseCountResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_16b86a09a73a7eb5, []int{1} +} +func (m *MsgIncreaseCountResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgIncreaseCountResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgIncreaseCountResponse.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 *MsgIncreaseCountResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgIncreaseCountResponse.Merge(m, src) +} +func (m *MsgIncreaseCountResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgIncreaseCountResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgIncreaseCountResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgIncreaseCountResponse proto.InternalMessageInfo + +func (m *MsgIncreaseCountResponse) GetNewCount() int64 { + if m != nil { + return m.NewCount + } + return 0 +} + +func init() { + proto.RegisterType((*MsgIncreaseCounter)(nil), "cosmos.counter.v1.MsgIncreaseCounter") + proto.RegisterType((*MsgIncreaseCountResponse)(nil), "cosmos.counter.v1.MsgIncreaseCountResponse") +} + +func init() { proto.RegisterFile("cosmos/counter/v1/tx.proto", fileDescriptor_16b86a09a73a7eb5) } + +var fileDescriptor_16b86a09a73a7eb5 = []byte{ + // 302 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4a, 0xce, 0x2f, 0xce, + 0xcd, 0x2f, 0xd6, 0x4f, 0xce, 0x2f, 0xcd, 0x2b, 0x49, 0x2d, 0xd2, 0x2f, 0x33, 0xd4, 0x2f, 0xa9, + 0xd0, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x84, 0xc8, 0xe9, 0x41, 0xe5, 0xf4, 0xca, 0x0c, + 0xa5, 0x24, 0x21, 0x42, 0xf1, 0x60, 0x05, 0xfa, 0x50, 0x79, 0x30, 0x47, 0x4a, 0x1c, 0x6a, 0x52, + 0x6e, 0x71, 0x3a, 0xc8, 0x94, 0xdc, 0xe2, 0x74, 0x88, 0x84, 0x52, 0x26, 0x97, 0x90, 0x6f, 0x71, + 0xba, 0x67, 0x5e, 0x72, 0x51, 0x6a, 0x62, 0x71, 0xaa, 0x33, 0xc4, 0x30, 0x21, 0x03, 0x2e, 0xb6, + 0xe2, 0xcc, 0xf4, 0xbc, 0xd4, 0x22, 0x09, 0x46, 0x05, 0x46, 0x0d, 0x4e, 0x27, 0x89, 0x4b, 0x5b, + 0x74, 0x45, 0xa0, 0x06, 0x3a, 0xa6, 0xa4, 0x14, 0xa5, 0x16, 0x17, 0x07, 0x97, 0x14, 0x65, 0xe6, + 0xa5, 0x07, 0x41, 0xd5, 0x09, 0x89, 0x70, 0xb1, 0x82, 0x5d, 0x22, 0xc1, 0xa4, 0xc0, 0xa8, 0xc1, + 0x1c, 0x04, 0xe1, 0x58, 0x71, 0x37, 0x3d, 0xdf, 0xa0, 0x05, 0x55, 0xa2, 0x64, 0xce, 0x25, 0x81, + 0x6e, 0x55, 0x50, 0x6a, 0x71, 0x41, 0x7e, 0x5e, 0x71, 0xaa, 0x90, 0x34, 0x17, 0x67, 0x5e, 0x6a, + 0x79, 0x3c, 0xc4, 0x08, 0x46, 0xb0, 0x11, 0x1c, 0x79, 0xa9, 0xe5, 0x60, 0x45, 0x46, 0x85, 0x5c, + 0xcc, 0xbe, 0xc5, 0xe9, 0x42, 0xc9, 0x5c, 0xbc, 0x28, 0x9a, 0x85, 0x54, 0xf5, 0x30, 0xc2, 0x40, + 0x0f, 0xd3, 0x33, 0x52, 0xda, 0x44, 0x28, 0x83, 0x39, 0x44, 0x8a, 0xb5, 0xe1, 0xf9, 0x06, 0x2d, + 0x46, 0x27, 0xb7, 0x13, 0x8f, 0xe4, 0x18, 0x2f, 0x3c, 0x92, 0x63, 0x7c, 0xf0, 0x48, 0x8e, 0x71, + 0xc2, 0x63, 0x39, 0x86, 0x0b, 0x8f, 0xe5, 0x18, 0x6e, 0x3c, 0x96, 0x63, 0x88, 0xd2, 0x49, 0xcf, + 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x87, 0x47, 0x0f, 0x88, 0xd2, 0x2d, 0x4e, + 0xc9, 0xd6, 0xaf, 0x80, 0xc7, 0x55, 0x49, 0x65, 0x41, 0x6a, 0x71, 0x12, 0x1b, 0x38, 0x94, 0x8d, + 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0x8d, 0x8f, 0x77, 0x03, 0xca, 0x01, 0x00, 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// MsgClient is the client API for Msg service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type MsgClient interface { + // IncreaseCount increments the counter by the specified amount. + IncreaseCount(ctx context.Context, in *MsgIncreaseCounter, opts ...grpc.CallOption) (*MsgIncreaseCountResponse, error) +} + +type msgClient struct { + cc grpc1.ClientConn +} + +func NewMsgClient(cc grpc1.ClientConn) MsgClient { + return &msgClient{cc} +} + +func (c *msgClient) IncreaseCount(ctx context.Context, in *MsgIncreaseCounter, opts ...grpc.CallOption) (*MsgIncreaseCountResponse, error) { + out := new(MsgIncreaseCountResponse) + err := c.cc.Invoke(ctx, "/cosmos.counter.v1.Msg/IncreaseCount", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// MsgServer is the server API for Msg service. +type MsgServer interface { + // IncreaseCount increments the counter by the specified amount. + IncreaseCount(context.Context, *MsgIncreaseCounter) (*MsgIncreaseCountResponse, error) +} + +// UnimplementedMsgServer can be embedded to have forward compatible implementations. +type UnimplementedMsgServer struct { +} + +func (*UnimplementedMsgServer) IncreaseCount(ctx context.Context, req *MsgIncreaseCounter) (*MsgIncreaseCountResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method IncreaseCount not implemented") +} + +func RegisterMsgServer(s grpc1.Server, srv MsgServer) { + s.RegisterService(&_Msg_serviceDesc, srv) +} + +func _Msg_IncreaseCount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgIncreaseCounter) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).IncreaseCount(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmos.counter.v1.Msg/IncreaseCount", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).IncreaseCount(ctx, req.(*MsgIncreaseCounter)) + } + return interceptor(ctx, in, info, handler) +} + +var _Msg_serviceDesc = grpc.ServiceDesc{ + ServiceName: "cosmos.counter.v1.Msg", + HandlerType: (*MsgServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "IncreaseCount", + Handler: _Msg_IncreaseCount_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "cosmos/counter/v1/tx.proto", +} + +func (m *MsgIncreaseCounter) 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 *MsgIncreaseCounter) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgIncreaseCounter) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Count != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.Count)) + i-- + dAtA[i] = 0x10 + } + if len(m.Signer) > 0 { + i -= len(m.Signer) + copy(dAtA[i:], m.Signer) + i = encodeVarintTx(dAtA, i, uint64(len(m.Signer))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgIncreaseCountResponse) 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 *MsgIncreaseCountResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgIncreaseCountResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.NewCount != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.NewCount)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func encodeVarintTx(dAtA []byte, offset int, v uint64) int { + offset -= sovTx(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *MsgIncreaseCounter) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Signer) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if m.Count != 0 { + n += 1 + sovTx(uint64(m.Count)) + } + return n +} + +func (m *MsgIncreaseCountResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.NewCount != 0 { + n += 1 + sovTx(uint64(m.NewCount)) + } + return n +} + +func sovTx(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozTx(x uint64) (n int) { + return sovTx(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *MsgIncreaseCounter) 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 ErrIntOverflowTx + } + 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: MsgIncreaseCounter: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgIncreaseCounter: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Signer", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + 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 ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Signer = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Count", wireType) + } + m.Count = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Count |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgIncreaseCountResponse) 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 ErrIntOverflowTx + } + 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: MsgIncreaseCountResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgIncreaseCountResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field NewCount", wireType) + } + m.NewCount = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.NewCount |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipTx(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTx + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTx + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTx + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthTx + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupTx + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthTx + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthTx = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowTx = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupTx = fmt.Errorf("proto: unexpected end of group") +) diff --git a/x/mint/types/genesis.pb.go b/x/mint/types/genesis.pb.go index 7a46bbf284..fc4597bc30 100644 --- a/x/mint/types/genesis.pb.go +++ b/x/mint/types/genesis.pb.go @@ -86,7 +86,7 @@ func init() { func init() { proto.RegisterFile("cosmos/mint/v1beta1/genesis.proto", fileDescriptor_0e215eb1d09cd648) } var fileDescriptor_0e215eb1d09cd648 = []byte{ - // 234 bytes of a gzipped FileDescriptorProto + // 223 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0x4c, 0xce, 0x2f, 0xce, 0xcd, 0x2f, 0xd6, 0xcf, 0xcd, 0xcc, 0x2b, 0xd1, 0x2f, 0x33, 0x4c, 0x4a, 0x2d, 0x49, 0x34, 0xd4, 0x4f, 0x4f, 0xcd, 0x4b, 0x2d, 0xce, 0x2c, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x86, @@ -96,12 +96,11 @@ var fileDescriptor_0e215eb1d09cd648 = []byte{ 0x92, 0xc4, 0x92, 0x54, 0x21, 0x3b, 0x2e, 0x36, 0x90, 0x8e, 0xd4, 0x22, 0x09, 0x46, 0x05, 0x46, 0x0d, 0x6e, 0x23, 0x69, 0x3d, 0x2c, 0xf6, 0xeb, 0xf9, 0x82, 0x95, 0x38, 0x71, 0x9e, 0xb8, 0x27, 0xcf, 0xb0, 0xe2, 0xf9, 0x06, 0x2d, 0xc6, 0x20, 0xa8, 0x2e, 0x90, 0xfe, 0x82, 0xc4, 0xa2, 0xc4, - 0xdc, 0x62, 0x09, 0x26, 0x3c, 0xfa, 0x03, 0xc0, 0x4a, 0x50, 0xf4, 0x43, 0x74, 0x39, 0x39, 0x9f, + 0xdc, 0x62, 0x09, 0x26, 0x3c, 0xfa, 0x03, 0xc0, 0x4a, 0x50, 0xf4, 0x43, 0x74, 0x39, 0x19, 0x9f, 0x78, 0x24, 0xc7, 0x78, 0xe1, 0x91, 0x1c, 0xe3, 0x83, 0x47, 0x72, 0x8c, 0x13, 0x1e, 0xcb, 0x31, - 0x5c, 0x78, 0x2c, 0xc7, 0x70, 0xe3, 0xb1, 0x1c, 0x43, 0x94, 0x66, 0x7a, 0x66, 0x49, 0x46, 0x69, - 0x92, 0x5e, 0x72, 0x7e, 0xae, 0x3e, 0xd4, 0xa3, 0x10, 0x4a, 0xb7, 0x38, 0x25, 0x5b, 0xbf, 0x02, - 0xe2, 0xeb, 0x92, 0xca, 0x82, 0xd4, 0xe2, 0x24, 0x36, 0xb0, 0xe7, 0x8c, 0x01, 0x01, 0x00, 0x00, - 0xff, 0xff, 0xf3, 0xd5, 0x6f, 0x47, 0x5f, 0x01, 0x00, 0x00, + 0x5c, 0x78, 0x2c, 0xc7, 0x70, 0xe3, 0xb1, 0x1c, 0x43, 0x94, 0x24, 0xc4, 0xa0, 0xe2, 0x94, 0x6c, + 0xbd, 0xcc, 0x7c, 0xfd, 0x0a, 0x88, 0x2f, 0x4b, 0x2a, 0x0b, 0x52, 0x8b, 0x93, 0xd8, 0xc0, 0x9e, + 0x31, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0x66, 0xa4, 0xb5, 0x5b, 0x4f, 0x01, 0x00, 0x00, } func (m *GenesisState) Marshal() (dAtA []byte, err error) { diff --git a/x/mint/types/mint.pb.go b/x/mint/types/mint.pb.go index 7080736282..9239799021 100644 --- a/x/mint/types/mint.pb.go +++ b/x/mint/types/mint.pb.go @@ -138,35 +138,34 @@ func init() { func init() { proto.RegisterFile("cosmos/mint/v1beta1/mint.proto", fileDescriptor_2df116d183c1e223) } var fileDescriptor_2df116d183c1e223 = []byte{ - // 436 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x93, 0xb1, 0x8e, 0xd3, 0x30, - 0x18, 0xc7, 0x63, 0xee, 0x88, 0x54, 0xc3, 0x09, 0xce, 0x07, 0x52, 0x38, 0x74, 0xb9, 0xd3, 0x0d, - 0xe8, 0x38, 0xe9, 0x12, 0x55, 0x48, 0x0c, 0x8c, 0xbd, 0x8e, 0x9c, 0xa8, 0xb2, 0x20, 0x40, 0x22, - 0xfa, 0x92, 0x98, 0xd4, 0x34, 0xb6, 0x2b, 0xdb, 0x57, 0xb5, 0xaf, 0xc0, 0xc4, 0x63, 0x30, 0x76, - 0x60, 0xe1, 0x0d, 0x3a, 0x56, 0x4c, 0x88, 0xa1, 0x42, 0xed, 0xd0, 0x89, 0x77, 0x40, 0x89, 0xa3, - 0x54, 0x82, 0x09, 0xca, 0x12, 0xc5, 0xff, 0xff, 0xe7, 0xdf, 0xf7, 0x97, 0xfd, 0x19, 0xfb, 0xa9, - 0xd4, 0x5c, 0xea, 0x90, 0x33, 0x61, 0xc2, 0x51, 0x3b, 0xa1, 0x06, 0xda, 0xd5, 0x22, 0x18, 0x2a, - 0x69, 0x24, 0x39, 0xb0, 0x7e, 0x50, 0x49, 0xb5, 0x7f, 0x78, 0x2f, 0x97, 0xb9, 0xac, 0xfc, 0xb0, - 0xfc, 0xb3, 0xa5, 0x87, 0x0f, 0x6c, 0x69, 0x6c, 0x8d, 0x7a, 0x9f, 0xb5, 0xf6, 0x81, 0x33, 0x21, - 0xc3, 0xea, 0x6b, 0xa5, 0xd3, 0x2f, 0x08, 0xbb, 0x57, 0x4c, 0x18, 0xaa, 0xc8, 0x0b, 0xdc, 0x62, - 0xe2, 0x5d, 0x01, 0x86, 0x49, 0xe1, 0xa1, 0x13, 0x74, 0xd6, 0xea, 0xb4, 0x67, 0x8b, 0x63, 0xe7, - 0xfb, 0xe2, 0xf8, 0xa1, 0xc5, 0xe8, 0x6c, 0x10, 0x30, 0x19, 0x72, 0x30, 0xfd, 0xe0, 0x39, 0xcd, - 0x21, 0x9d, 0x74, 0x69, 0xfa, 0xf5, 0xf3, 0x05, 0xae, 0xbb, 0x74, 0x69, 0x1a, 0x6d, 0x18, 0xe4, - 0x2d, 0xde, 0x07, 0x21, 0xae, 0xa1, 0x28, 0xb3, 0x8c, 0x98, 0x66, 0x52, 0x68, 0xef, 0xc6, 0xbf, - 0x82, 0xef, 0x5a, 0x56, 0xaf, 0x41, 0x9d, 0xfe, 0xdc, 0xc1, 0x6e, 0x0f, 0x14, 0x70, 0x4d, 0x8e, - 0x30, 0x2e, 0x8f, 0x26, 0xce, 0xa8, 0x90, 0xdc, 0x86, 0x8f, 0x5a, 0xa5, 0xd2, 0x2d, 0x05, 0xf2, - 0x1e, 0xdf, 0x6f, 0x62, 0xc5, 0x0a, 0x0c, 0x8d, 0xd3, 0x3e, 0x88, 0x9c, 0xd6, 0x69, 0x9e, 0xfe, - 0x75, 0x9a, 0x4f, 0xeb, 0xe9, 0x39, 0x8a, 0x0e, 0x1a, 0x68, 0x04, 0x86, 0x5e, 0x56, 0x48, 0xf2, - 0x06, 0xef, 0x6d, 0x7a, 0x71, 0x18, 0x7b, 0x3b, 0x5b, 0xf5, 0xb8, 0xdd, 0xc0, 0xae, 0x60, 0xfc, - 0x1b, 0x9c, 0x09, 0x6f, 0xf7, 0x7f, 0xc1, 0x99, 0x20, 0x2f, 0xf1, 0xad, 0x5c, 0x42, 0x11, 0x27, - 0x52, 0x64, 0x34, 0xf3, 0x6e, 0x6e, 0x85, 0xc6, 0x25, 0xaa, 0x53, 0x91, 0xc8, 0x23, 0x7c, 0x27, - 0x29, 0x64, 0x3a, 0xd0, 0xf1, 0x90, 0xaa, 0x78, 0x42, 0x41, 0x79, 0xee, 0x09, 0x3a, 0xdb, 0x8d, - 0xf6, 0xac, 0xdc, 0xa3, 0xea, 0x15, 0x05, 0xf5, 0xec, 0xe8, 0xc3, 0x7a, 0x7a, 0xee, 0x59, 0xd2, - 0x85, 0xce, 0x06, 0xe1, 0xd8, 0x3e, 0x08, 0x7b, 0xc9, 0x9d, 0xcb, 0xd9, 0xd2, 0x47, 0xf3, 0xa5, - 0x8f, 0x7e, 0x2c, 0x7d, 0xf4, 0x71, 0xe5, 0x3b, 0xf3, 0x95, 0xef, 0x7c, 0x5b, 0xf9, 0xce, 0xeb, - 0xc7, 0x39, 0x33, 0xfd, 0xeb, 0x24, 0x48, 0x25, 0xaf, 0x27, 0x3e, 0xfc, 0x93, 0x62, 0x26, 0x43, - 0xaa, 0x13, 0xb7, 0x9a, 0xfb, 0x27, 0xbf, 0x02, 0x00, 0x00, 0xff, 0xff, 0xc2, 0xd0, 0x42, 0xaf, - 0x72, 0x03, 0x00, 0x00, + // 426 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x93, 0x4f, 0x8b, 0xd3, 0x40, + 0x18, 0xc6, 0x33, 0xee, 0x1a, 0xe8, 0xe8, 0xa2, 0x3b, 0xab, 0x90, 0x5d, 0xd9, 0xec, 0xb2, 0x07, + 0x59, 0x0a, 0x4d, 0x28, 0x05, 0x0f, 0x1e, 0x6b, 0x8f, 0x16, 0x4b, 0x2e, 0xa2, 0x82, 0xe1, 0x4d, + 0x32, 0xa6, 0x63, 0x93, 0x99, 0x32, 0x33, 0x96, 0xf6, 0x2b, 0x78, 0xf2, 0x63, 0x78, 0xec, 0xc1, + 0x8b, 0xdf, 0xa0, 0xc7, 0xe2, 0x49, 0x3c, 0x14, 0x69, 0x0f, 0x3d, 0xf9, 0x1d, 0x24, 0x99, 0x90, + 0xa2, 0x37, 0xed, 0x5e, 0x42, 0xe6, 0x79, 0xde, 0xf7, 0xf7, 0x3e, 0xcc, 0x1f, 0xec, 0xc6, 0x42, + 0xe5, 0x42, 0xf9, 0x39, 0xe3, 0xda, 0x9f, 0xb4, 0x23, 0xaa, 0xa1, 0x5d, 0x2e, 0xbc, 0xb1, 0x14, + 0x5a, 0x90, 0x13, 0xe3, 0x7b, 0xa5, 0x54, 0xf9, 0x67, 0x0f, 0x52, 0x91, 0x8a, 0xd2, 0xf7, 0x8b, + 0x3f, 0x53, 0x7a, 0x76, 0x6a, 0x4a, 0x43, 0x63, 0x54, 0x7d, 0xc6, 0x3a, 0x86, 0x9c, 0x71, 0xe1, + 0x97, 0x5f, 0x23, 0x5d, 0x7d, 0x45, 0xd8, 0xee, 0x33, 0xae, 0xa9, 0x24, 0x2f, 0x70, 0x83, 0xf1, + 0x77, 0x19, 0x68, 0x26, 0xb8, 0x83, 0x2e, 0xd1, 0x75, 0xa3, 0xdb, 0x5e, 0xac, 0x2e, 0xac, 0x1f, + 0xab, 0x8b, 0x47, 0x06, 0xa3, 0x92, 0x91, 0xc7, 0x84, 0x9f, 0x83, 0x1e, 0x7a, 0xcf, 0x69, 0x0a, + 0xf1, 0xac, 0x47, 0xe3, 0x6f, 0x5f, 0x5a, 0xb8, 0x9a, 0xd2, 0xa3, 0x71, 0xb0, 0x63, 0x90, 0xb7, + 0xf8, 0x18, 0x38, 0xff, 0x00, 0x59, 0x91, 0x65, 0xc2, 0x14, 0x13, 0x5c, 0x39, 0xb7, 0xfe, 0x17, + 0x7c, 0xdf, 0xb0, 0x06, 0x35, 0xea, 0xea, 0xd7, 0x01, 0xb6, 0x07, 0x20, 0x21, 0x57, 0xe4, 0x1c, + 0xe3, 0x62, 0x6b, 0xc2, 0x84, 0x72, 0x91, 0x9b, 0xf0, 0x41, 0xa3, 0x50, 0x7a, 0x85, 0x40, 0xde, + 0xe3, 0x87, 0x75, 0xac, 0x50, 0x82, 0xa6, 0x61, 0x3c, 0x04, 0x9e, 0xd2, 0x2a, 0xcd, 0x93, 0x7f, + 0x4e, 0xf3, 0x79, 0x3b, 0x6f, 0xa2, 0xe0, 0xa4, 0x86, 0x06, 0xa0, 0xe9, 0xb3, 0x12, 0x49, 0xde, + 0xe0, 0xa3, 0xdd, 0xac, 0x1c, 0xa6, 0xce, 0xc1, 0x5e, 0x33, 0xee, 0xd6, 0xb0, 0x3e, 0x4c, 0xff, + 0x82, 0x33, 0xee, 0x1c, 0xde, 0x14, 0x9c, 0x71, 0xf2, 0x12, 0xdf, 0x49, 0x05, 0x64, 0x61, 0x24, + 0x78, 0x42, 0x13, 0xe7, 0xf6, 0x5e, 0x68, 0x5c, 0xa0, 0xba, 0x25, 0x89, 0x3c, 0xc6, 0xf7, 0xa2, + 0x4c, 0xc4, 0x23, 0x15, 0x8e, 0xa9, 0x0c, 0x67, 0x14, 0xa4, 0x63, 0x5f, 0xa2, 0xeb, 0xc3, 0xe0, + 0xc8, 0xc8, 0x03, 0x2a, 0x5f, 0x51, 0x90, 0x4f, 0xcf, 0x3f, 0x6e, 0xe7, 0x4d, 0xc7, 0x90, 0x5a, + 0x2a, 0x19, 0xf9, 0x53, 0xf3, 0x20, 0xcc, 0x21, 0x77, 0x3b, 0x8b, 0xb5, 0x8b, 0x96, 0x6b, 0x17, + 0xfd, 0x5c, 0xbb, 0xe8, 0xd3, 0xc6, 0xb5, 0x96, 0x1b, 0xd7, 0xfa, 0xbe, 0x71, 0xad, 0xd7, 0xa7, + 0x7f, 0x84, 0xab, 0xba, 0xf4, 0x6c, 0x4c, 0x55, 0x64, 0x97, 0xf7, 0xbc, 0xf3, 0x3b, 0x00, 0x00, + 0xff, 0xff, 0xcd, 0x30, 0x64, 0xe0, 0x62, 0x03, 0x00, 0x00, } func (m *Minter) Marshal() (dAtA []byte, err error) { diff --git a/x/mint/types/query.pb.go b/x/mint/types/query.pb.go index 838e86a840..28766d168d 100644 --- a/x/mint/types/query.pb.go +++ b/x/mint/types/query.pb.go @@ -282,38 +282,37 @@ func init() { func init() { proto.RegisterFile("cosmos/mint/v1beta1/query.proto", fileDescriptor_d0a1e393be338aea) } var fileDescriptor_d0a1e393be338aea = []byte{ - // 494 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x93, 0x4d, 0x6b, 0x14, 0x31, - 0x18, 0xc7, 0x37, 0x8a, 0x0b, 0x1b, 0x3d, 0xb4, 0x69, 0x7d, 0x9b, 0x6d, 0xb3, 0x65, 0x84, 0xba, - 0x56, 0x9a, 0xb0, 0x2b, 0x78, 0x14, 0x5c, 0x7b, 0x11, 0x3c, 0xd4, 0xa2, 0x17, 0x2f, 0x92, 0x9d, - 0xc6, 0x69, 0xe8, 0x4e, 0x32, 0xdd, 0x64, 0x8a, 0x7b, 0x13, 0xf1, 0xe8, 0x41, 0xf0, 0x4b, 0xe8, - 0xcd, 0x83, 0x5f, 0x41, 0xe8, 0xb1, 0xe8, 0x45, 0x3c, 0x14, 0xd9, 0x15, 0xfc, 0x1a, 0x32, 0x49, - 0xa6, 0xe2, 0x74, 0x06, 0x95, 0x5e, 0x76, 0x67, 0x9e, 0xb7, 0xff, 0x2f, 0xcf, 0x3f, 0x03, 0x3b, - 0x91, 0xd2, 0x89, 0xd2, 0x34, 0x11, 0xd2, 0xd0, 0xfd, 0xde, 0x90, 0x1b, 0xd6, 0xa3, 0x7b, 0x19, - 0x1f, 0x4f, 0x48, 0x3a, 0x56, 0x46, 0xa1, 0x05, 0x57, 0x40, 0xf2, 0x02, 0xe2, 0x0b, 0x82, 0xc5, - 0x58, 0xc5, 0xca, 0xe6, 0x69, 0xfe, 0xe4, 0x4a, 0x83, 0xa5, 0x58, 0xa9, 0x78, 0xc4, 0x29, 0x4b, - 0x05, 0x65, 0x52, 0x2a, 0xc3, 0x8c, 0x50, 0x52, 0xfb, 0x2c, 0xae, 0x52, 0xb2, 0x53, 0x5d, 0x7e, - 0x9e, 0x25, 0x42, 0x2a, 0x6a, 0x7f, 0x7d, 0xe8, 0xaa, 0x6b, 0x79, 0xea, 0x94, 0x3c, 0x88, 0x7d, - 0x09, 0x17, 0x21, 0x7a, 0x98, 0x53, 0x6e, 0xb2, 0x31, 0x4b, 0xf4, 0x16, 0xdf, 0xcb, 0xb8, 0x36, - 0xe1, 0x63, 0xb8, 0xf0, 0x47, 0x54, 0xa7, 0x4a, 0x6a, 0x8e, 0xee, 0xc0, 0x66, 0x6a, 0x23, 0x57, - 0xc0, 0x0a, 0xe8, 0x9e, 0xef, 0xb7, 0x49, 0xc5, 0xa1, 0x88, 0x6b, 0x1a, 0xb4, 0x0e, 0x8e, 0x3a, - 0x8d, 0x77, 0x3f, 0x3f, 0xac, 0x81, 0x2d, 0xdf, 0x15, 0x5e, 0x86, 0x17, 0xed, 0xd8, 0xfb, 0xf2, - 0xd9, 0xc8, 0x9e, 0xa9, 0xd0, 0x93, 0xf0, 0x52, 0x39, 0xe1, 0x25, 0x1f, 0xc1, 0x96, 0x28, 0x82, - 0x56, 0xf5, 0xc2, 0xe0, 0x76, 0x3e, 0xf8, 0xdb, 0x51, 0xa7, 0xed, 0xc4, 0xf5, 0xf6, 0x2e, 0x11, - 0x8a, 0x26, 0xcc, 0xec, 0x90, 0x07, 0x3c, 0x66, 0xd1, 0x64, 0x83, 0x47, 0x9f, 0x3f, 0xae, 0x43, - 0xcf, 0xb6, 0xc1, 0x23, 0x47, 0xf1, 0x7b, 0x50, 0x88, 0xe1, 0x92, 0xd5, 0xbb, 0x2b, 0x65, 0xc6, - 0x46, 0x9b, 0x63, 0xb5, 0x2f, 0x74, 0xbe, 0xe2, 0x82, 0xe7, 0x15, 0x80, 0xcb, 0x35, 0x05, 0x9e, - 0x2b, 0x82, 0xf3, 0xcc, 0xe6, 0xf2, 0xa5, 0xfa, 0xe4, 0x29, 0xf9, 0xe6, 0x58, 0x49, 0xac, 0xff, - 0xe9, 0x2c, 0x3c, 0x67, 0x31, 0xd0, 0x0b, 0x00, 0x9b, 0x6e, 0xaf, 0xe8, 0x7a, 0xe5, 0xd2, 0x4f, - 0x9a, 0x18, 0x74, 0xff, 0x5e, 0xe8, 0x0e, 0x13, 0x5e, 0x7b, 0xf9, 0xe5, 0xc7, 0xdb, 0x33, 0xcb, - 0xa8, 0x4d, 0xab, 0xee, 0x96, 0x33, 0x0f, 0xbd, 0x06, 0xb0, 0x75, 0xec, 0x0f, 0x5a, 0xab, 0x1f, - 0x5e, 0x76, 0x37, 0xb8, 0xf9, 0x4f, 0xb5, 0x9e, 0x65, 0xd5, 0xb2, 0xac, 0x20, 0x5c, 0xc9, 0x72, - 0x6c, 0x21, 0x7a, 0x0f, 0xe0, 0x5c, 0xd9, 0x1d, 0xd4, 0xab, 0x57, 0xaa, 0xb1, 0x3a, 0xe8, 0xff, - 0x4f, 0x8b, 0x67, 0x24, 0x96, 0xb1, 0x8b, 0x56, 0x2b, 0x19, 0x4f, 0xdc, 0x8b, 0xc1, 0xbd, 0x83, - 0x29, 0x06, 0x87, 0x53, 0x0c, 0xbe, 0x4f, 0x31, 0x78, 0x33, 0xc3, 0x8d, 0xc3, 0x19, 0x6e, 0x7c, - 0x9d, 0xe1, 0xc6, 0x93, 0x1b, 0xb1, 0x30, 0x3b, 0xd9, 0x90, 0x44, 0x2a, 0x29, 0x66, 0xb9, 0xbf, - 0x75, 0xbd, 0xbd, 0x4b, 0x9f, 0xbb, 0xc1, 0x66, 0x92, 0x72, 0x3d, 0x6c, 0xda, 0x0f, 0xf6, 0xd6, - 0xaf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x62, 0x1a, 0x74, 0xc5, 0x6a, 0x04, 0x00, 0x00, + // 480 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x93, 0x4d, 0x8b, 0xd3, 0x40, + 0x18, 0xc7, 0x33, 0x8a, 0x85, 0x8e, 0x1e, 0x76, 0x67, 0xd7, 0x97, 0x4d, 0x77, 0xa7, 0x4b, 0x84, + 0xb5, 0xac, 0x38, 0x43, 0xbb, 0xe0, 0x51, 0xb0, 0xec, 0x45, 0xf0, 0xb0, 0x2e, 0x7a, 0xf1, 0x22, + 0xb3, 0x71, 0x8c, 0xc1, 0x66, 0x26, 0x9b, 0x99, 0x16, 0x7b, 0x13, 0xf1, 0xe8, 0x41, 0xf0, 0x4b, + 0xe8, 0xcd, 0x83, 0x5f, 0x41, 0xe8, 0xb1, 0xe8, 0x45, 0x3c, 0x14, 0x69, 0x05, 0xbf, 0x86, 0x64, + 0x66, 0x5a, 0x69, 0x9a, 0xa0, 0xe2, 0x25, 0x24, 0xcf, 0xdb, 0xff, 0x37, 0xcf, 0x7f, 0x02, 0x9b, + 0xa1, 0x54, 0x89, 0x54, 0x34, 0x89, 0x85, 0xa6, 0x83, 0xf6, 0x09, 0xd7, 0xac, 0x4d, 0x4f, 0xfb, + 0x3c, 0x1b, 0x92, 0x34, 0x93, 0x5a, 0xa2, 0x0d, 0x5b, 0x40, 0xf2, 0x02, 0xe2, 0x0a, 0xfc, 0xcd, + 0x48, 0x46, 0xd2, 0xe4, 0x69, 0xfe, 0x66, 0x4b, 0xfd, 0xed, 0x48, 0xca, 0xa8, 0xc7, 0x29, 0x4b, + 0x63, 0xca, 0x84, 0x90, 0x9a, 0xe9, 0x58, 0x0a, 0xe5, 0xb2, 0xb8, 0x4c, 0xc9, 0x4c, 0xb5, 0xf9, + 0x75, 0x96, 0xc4, 0x42, 0x52, 0xf3, 0x74, 0xa1, 0x2d, 0xdb, 0xf2, 0xc8, 0x2a, 0x39, 0x10, 0xf3, + 0x11, 0x6c, 0x42, 0x74, 0x2f, 0xa7, 0x3c, 0x62, 0x19, 0x4b, 0xd4, 0x31, 0x3f, 0xed, 0x73, 0xa5, + 0x83, 0x07, 0x70, 0x63, 0x29, 0xaa, 0x52, 0x29, 0x14, 0x47, 0xb7, 0x60, 0x2d, 0x35, 0x91, 0x2b, + 0x60, 0x17, 0xb4, 0xce, 0x77, 0x1a, 0xa4, 0xe4, 0x50, 0xc4, 0x36, 0x75, 0xeb, 0xa3, 0x49, 0xd3, + 0x7b, 0xf7, 0xf3, 0xc3, 0x3e, 0x38, 0x76, 0x5d, 0xc1, 0x65, 0x78, 0xd1, 0x8c, 0xbd, 0x23, 0x9e, + 0xf4, 0xcc, 0x99, 0xe6, 0x7a, 0x02, 0x5e, 0x2a, 0x26, 0x9c, 0xe4, 0x7d, 0x58, 0x8f, 0xe7, 0x41, + 0xa3, 0x7a, 0xa1, 0x7b, 0x33, 0x1f, 0xfc, 0x6d, 0xd2, 0x6c, 0x58, 0x71, 0xf5, 0xf8, 0x19, 0x89, + 0x25, 0x4d, 0x98, 0x7e, 0x4a, 0xee, 0xf2, 0x88, 0x85, 0xc3, 0x43, 0x1e, 0x7e, 0xfe, 0x78, 0x03, + 0x3a, 0xb6, 0x43, 0x1e, 0x5a, 0x8a, 0xdf, 0x83, 0x02, 0x0c, 0xb7, 0x8d, 0xde, 0x6d, 0x21, 0xfa, + 0xac, 0x77, 0x94, 0xc9, 0x41, 0xac, 0xf2, 0x15, 0xcf, 0x79, 0x5e, 0x01, 0xb8, 0x53, 0x51, 0xe0, + 0xb8, 0x42, 0xb8, 0xce, 0x4c, 0x2e, 0x5f, 0xaa, 0x4b, 0xfe, 0x27, 0xdf, 0x1a, 0x2b, 0x88, 0x75, + 0x3e, 0x9d, 0x85, 0xe7, 0x0c, 0x06, 0x7a, 0x01, 0x60, 0xcd, 0xee, 0x15, 0x5d, 0x2b, 0x5d, 0xfa, + 0xaa, 0x89, 0x7e, 0xeb, 0xcf, 0x85, 0xf6, 0x30, 0xc1, 0xd5, 0x97, 0x5f, 0x7e, 0xbc, 0x3d, 0xb3, + 0x83, 0x1a, 0xb4, 0xec, 0x6e, 0x59, 0xf3, 0xd0, 0x6b, 0x00, 0xeb, 0x0b, 0x7f, 0xd0, 0x7e, 0xf5, + 0xf0, 0xa2, 0xbb, 0xfe, 0xf5, 0xbf, 0xaa, 0x75, 0x2c, 0x7b, 0x86, 0x65, 0x17, 0xe1, 0x52, 0x96, + 0x85, 0x85, 0xe8, 0x3d, 0x80, 0x6b, 0x45, 0x77, 0x50, 0xbb, 0x5a, 0xa9, 0xc2, 0x6a, 0xbf, 0xf3, + 0x2f, 0x2d, 0x8e, 0x91, 0x18, 0xc6, 0x16, 0xda, 0x2b, 0x65, 0x5c, 0xb9, 0x17, 0xdd, 0x83, 0xd1, + 0x14, 0x83, 0xf1, 0x14, 0x83, 0xef, 0x53, 0x0c, 0xde, 0xcc, 0xb0, 0x37, 0x9e, 0x61, 0xef, 0xeb, + 0x0c, 0x7b, 0x0f, 0xb7, 0x96, 0xee, 0xc8, 0x73, 0x3b, 0x48, 0x0f, 0x53, 0xae, 0x4e, 0x6a, 0xe6, + 0x07, 0x3d, 0xf8, 0x15, 0x00, 0x00, 0xff, 0xff, 0x8c, 0x7d, 0x50, 0x82, 0x5a, 0x04, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. diff --git a/x/mint/types/tx.pb.go b/x/mint/types/tx.pb.go index e4a8f909db..f780a294cc 100644 --- a/x/mint/types/tx.pb.go +++ b/x/mint/types/tx.pb.go @@ -138,7 +138,7 @@ func init() { func init() { proto.RegisterFile("cosmos/mint/v1beta1/tx.proto", fileDescriptor_a0d933a8bf5e188a) } var fileDescriptor_a0d933a8bf5e188a = []byte{ - // 343 bytes of a gzipped FileDescriptorProto + // 337 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x49, 0xce, 0x2f, 0xce, 0xcd, 0x2f, 0xd6, 0xcf, 0xcd, 0xcc, 0x2b, 0xd1, 0x2f, 0x33, 0x4c, 0x4a, 0x2d, 0x49, 0x34, 0xd4, 0x2f, 0xa9, 0xd0, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x86, 0xc8, 0xea, 0x81, 0x64, 0xf5, @@ -156,11 +156,11 @@ var fileDescriptor_a0d933a8bf5e188a = []byte{ 0x40, 0x7c, 0x8d, 0xe6, 0x5a, 0x25, 0x49, 0x2e, 0x71, 0x34, 0xa1, 0xa0, 0xd4, 0xe2, 0x82, 0xfc, 0xbc, 0xe2, 0x54, 0xa3, 0x02, 0x2e, 0x66, 0xdf, 0xe2, 0x74, 0xa1, 0x24, 0x2e, 0x1e, 0x14, 0xff, 0xa9, 0x60, 0x75, 0x17, 0x9a, 0x21, 0x52, 0x3a, 0xc4, 0xa8, 0x82, 0x59, 0x25, 0xc5, 0xda, 0x00, - 0xf2, 0x8a, 0x93, 0xf3, 0x89, 0x47, 0x72, 0x8c, 0x17, 0x1e, 0xc9, 0x31, 0x3e, 0x78, 0x24, 0xc7, - 0x38, 0xe1, 0xb1, 0x1c, 0xc3, 0x85, 0xc7, 0x72, 0x0c, 0x37, 0x1e, 0xcb, 0x31, 0x44, 0x69, 0xa6, - 0x67, 0x96, 0x64, 0x94, 0x26, 0xe9, 0x25, 0xe7, 0xe7, 0x42, 0x63, 0x40, 0x1f, 0xd3, 0x6f, 0x25, - 0x95, 0x05, 0xa9, 0xc5, 0x49, 0x6c, 0xe0, 0xa8, 0x31, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0x13, - 0x9e, 0x4f, 0xda, 0x4c, 0x02, 0x00, 0x00, + 0xf2, 0x8a, 0x93, 0xf1, 0x89, 0x47, 0x72, 0x8c, 0x17, 0x1e, 0xc9, 0x31, 0x3e, 0x78, 0x24, 0xc7, + 0x38, 0xe1, 0xb1, 0x1c, 0xc3, 0x85, 0xc7, 0x72, 0x0c, 0x37, 0x1e, 0xcb, 0x31, 0x44, 0x41, 0xe3, + 0xa0, 0x38, 0x25, 0x5b, 0x2f, 0x33, 0x1f, 0xe6, 0x97, 0x92, 0xca, 0x82, 0xd4, 0xe2, 0x24, 0x36, + 0x70, 0x54, 0x18, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff, 0x7f, 0xe5, 0xfd, 0x6d, 0x3c, 0x02, 0x00, + 0x00, } // Reference imports to suppress errors if they are not otherwise used.