diff --git a/api/cosmos/accounts/defaults/lockup/v1/tx.pulsar.go b/api/cosmos/accounts/defaults/lockup/v1/tx.pulsar.go new file mode 100644 index 000000000000..ca17fe4635e9 --- /dev/null +++ b/api/cosmos/accounts/defaults/lockup/v1/tx.pulsar.go @@ -0,0 +1,5106 @@ +// Code generated by protoc-gen-go-pulsar. DO NOT EDIT. +package lockupv1 + +import ( + _ "cosmossdk.io/api/amino" + v1beta1 "cosmossdk.io/api/cosmos/base/v1beta1" + fmt "fmt" + _ "github.com/cosmos/cosmos-proto" + runtime "github.com/cosmos/cosmos-proto/runtime" + _ "github.com/cosmos/gogoproto/gogoproto" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoiface "google.golang.org/protobuf/runtime/protoiface" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + anypb "google.golang.org/protobuf/types/known/anypb" + timestamppb "google.golang.org/protobuf/types/known/timestamppb" + io "io" + reflect "reflect" + sync "sync" +) + +var ( + md_MsgInitLockupAccount protoreflect.MessageDescriptor + fd_MsgInitLockupAccount_owner protoreflect.FieldDescriptor + fd_MsgInitLockupAccount_end_time protoreflect.FieldDescriptor + fd_MsgInitLockupAccount_start_time protoreflect.FieldDescriptor +) + +func init() { + file_cosmos_accounts_defaults_lockup_v1_tx_proto_init() + md_MsgInitLockupAccount = File_cosmos_accounts_defaults_lockup_v1_tx_proto.Messages().ByName("MsgInitLockupAccount") + fd_MsgInitLockupAccount_owner = md_MsgInitLockupAccount.Fields().ByName("owner") + fd_MsgInitLockupAccount_end_time = md_MsgInitLockupAccount.Fields().ByName("end_time") + fd_MsgInitLockupAccount_start_time = md_MsgInitLockupAccount.Fields().ByName("start_time") +} + +var _ protoreflect.Message = (*fastReflection_MsgInitLockupAccount)(nil) + +type fastReflection_MsgInitLockupAccount MsgInitLockupAccount + +func (x *MsgInitLockupAccount) ProtoReflect() protoreflect.Message { + return (*fastReflection_MsgInitLockupAccount)(x) +} + +func (x *MsgInitLockupAccount) slowProtoReflect() protoreflect.Message { + mi := &file_cosmos_accounts_defaults_lockup_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_MsgInitLockupAccount_messageType fastReflection_MsgInitLockupAccount_messageType +var _ protoreflect.MessageType = fastReflection_MsgInitLockupAccount_messageType{} + +type fastReflection_MsgInitLockupAccount_messageType struct{} + +func (x fastReflection_MsgInitLockupAccount_messageType) Zero() protoreflect.Message { + return (*fastReflection_MsgInitLockupAccount)(nil) +} +func (x fastReflection_MsgInitLockupAccount_messageType) New() protoreflect.Message { + return new(fastReflection_MsgInitLockupAccount) +} +func (x fastReflection_MsgInitLockupAccount_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_MsgInitLockupAccount +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_MsgInitLockupAccount) Descriptor() protoreflect.MessageDescriptor { + return md_MsgInitLockupAccount +} + +// 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_MsgInitLockupAccount) Type() protoreflect.MessageType { + return _fastReflection_MsgInitLockupAccount_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_MsgInitLockupAccount) New() protoreflect.Message { + return new(fastReflection_MsgInitLockupAccount) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_MsgInitLockupAccount) Interface() protoreflect.ProtoMessage { + return (*MsgInitLockupAccount)(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_MsgInitLockupAccount) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Owner != "" { + value := protoreflect.ValueOfString(x.Owner) + if !f(fd_MsgInitLockupAccount_owner, value) { + return + } + } + if x.EndTime != nil { + value := protoreflect.ValueOfMessage(x.EndTime.ProtoReflect()) + if !f(fd_MsgInitLockupAccount_end_time, value) { + return + } + } + if x.StartTime != nil { + value := protoreflect.ValueOfMessage(x.StartTime.ProtoReflect()) + if !f(fd_MsgInitLockupAccount_start_time, 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_MsgInitLockupAccount) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "cosmos.accounts.defaults.lockup.v1.MsgInitLockupAccount.owner": + return x.Owner != "" + case "cosmos.accounts.defaults.lockup.v1.MsgInitLockupAccount.end_time": + return x.EndTime != nil + case "cosmos.accounts.defaults.lockup.v1.MsgInitLockupAccount.start_time": + return x.StartTime != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgInitLockupAccount")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgInitLockupAccount 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_MsgInitLockupAccount) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "cosmos.accounts.defaults.lockup.v1.MsgInitLockupAccount.owner": + x.Owner = "" + case "cosmos.accounts.defaults.lockup.v1.MsgInitLockupAccount.end_time": + x.EndTime = nil + case "cosmos.accounts.defaults.lockup.v1.MsgInitLockupAccount.start_time": + x.StartTime = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgInitLockupAccount")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgInitLockupAccount 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_MsgInitLockupAccount) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "cosmos.accounts.defaults.lockup.v1.MsgInitLockupAccount.owner": + value := x.Owner + return protoreflect.ValueOfString(value) + case "cosmos.accounts.defaults.lockup.v1.MsgInitLockupAccount.end_time": + value := x.EndTime + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "cosmos.accounts.defaults.lockup.v1.MsgInitLockupAccount.start_time": + value := x.StartTime + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgInitLockupAccount")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgInitLockupAccount 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_MsgInitLockupAccount) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "cosmos.accounts.defaults.lockup.v1.MsgInitLockupAccount.owner": + x.Owner = value.Interface().(string) + case "cosmos.accounts.defaults.lockup.v1.MsgInitLockupAccount.end_time": + x.EndTime = value.Message().Interface().(*timestamppb.Timestamp) + case "cosmos.accounts.defaults.lockup.v1.MsgInitLockupAccount.start_time": + x.StartTime = value.Message().Interface().(*timestamppb.Timestamp) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgInitLockupAccount")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgInitLockupAccount 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_MsgInitLockupAccount) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.accounts.defaults.lockup.v1.MsgInitLockupAccount.end_time": + if x.EndTime == nil { + x.EndTime = new(timestamppb.Timestamp) + } + return protoreflect.ValueOfMessage(x.EndTime.ProtoReflect()) + case "cosmos.accounts.defaults.lockup.v1.MsgInitLockupAccount.start_time": + if x.StartTime == nil { + x.StartTime = new(timestamppb.Timestamp) + } + return protoreflect.ValueOfMessage(x.StartTime.ProtoReflect()) + case "cosmos.accounts.defaults.lockup.v1.MsgInitLockupAccount.owner": + panic(fmt.Errorf("field owner of message cosmos.accounts.defaults.lockup.v1.MsgInitLockupAccount is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgInitLockupAccount")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgInitLockupAccount 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_MsgInitLockupAccount) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.accounts.defaults.lockup.v1.MsgInitLockupAccount.owner": + return protoreflect.ValueOfString("") + case "cosmos.accounts.defaults.lockup.v1.MsgInitLockupAccount.end_time": + m := new(timestamppb.Timestamp) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "cosmos.accounts.defaults.lockup.v1.MsgInitLockupAccount.start_time": + m := new(timestamppb.Timestamp) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgInitLockupAccount")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgInitLockupAccount 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_MsgInitLockupAccount) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in cosmos.accounts.defaults.lockup.v1.MsgInitLockupAccount", 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_MsgInitLockupAccount) 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_MsgInitLockupAccount) 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_MsgInitLockupAccount) 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_MsgInitLockupAccount) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*MsgInitLockupAccount) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + l = len(x.Owner) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.EndTime != nil { + l = options.Size(x.EndTime) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.StartTime != nil { + l = options.Size(x.StartTime) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*MsgInitLockupAccount) + 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.StartTime != nil { + encoded, err := options.Marshal(x.StartTime) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x1a + } + if x.EndTime != nil { + encoded, err := options.Marshal(x.EndTime) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x12 + } + if len(x.Owner) > 0 { + i -= len(x.Owner) + copy(dAtA[i:], x.Owner) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Owner))) + i-- + dAtA[i] = 0xa + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*MsgInitLockupAccount) + 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: MsgInitLockupAccount: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgInitLockupAccount: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Owner", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Owner = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field EndTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.EndTime == nil { + x.EndTime = ×tamppb.Timestamp{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.EndTime); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field StartTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.StartTime == nil { + x.StartTime = ×tamppb.Timestamp{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.StartTime); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_MsgInitLockupAccountResponse protoreflect.MessageDescriptor +) + +func init() { + file_cosmos_accounts_defaults_lockup_v1_tx_proto_init() + md_MsgInitLockupAccountResponse = File_cosmos_accounts_defaults_lockup_v1_tx_proto.Messages().ByName("MsgInitLockupAccountResponse") +} + +var _ protoreflect.Message = (*fastReflection_MsgInitLockupAccountResponse)(nil) + +type fastReflection_MsgInitLockupAccountResponse MsgInitLockupAccountResponse + +func (x *MsgInitLockupAccountResponse) ProtoReflect() protoreflect.Message { + return (*fastReflection_MsgInitLockupAccountResponse)(x) +} + +func (x *MsgInitLockupAccountResponse) slowProtoReflect() protoreflect.Message { + mi := &file_cosmos_accounts_defaults_lockup_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_MsgInitLockupAccountResponse_messageType fastReflection_MsgInitLockupAccountResponse_messageType +var _ protoreflect.MessageType = fastReflection_MsgInitLockupAccountResponse_messageType{} + +type fastReflection_MsgInitLockupAccountResponse_messageType struct{} + +func (x fastReflection_MsgInitLockupAccountResponse_messageType) Zero() protoreflect.Message { + return (*fastReflection_MsgInitLockupAccountResponse)(nil) +} +func (x fastReflection_MsgInitLockupAccountResponse_messageType) New() protoreflect.Message { + return new(fastReflection_MsgInitLockupAccountResponse) +} +func (x fastReflection_MsgInitLockupAccountResponse_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_MsgInitLockupAccountResponse +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_MsgInitLockupAccountResponse) Descriptor() protoreflect.MessageDescriptor { + return md_MsgInitLockupAccountResponse +} + +// 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_MsgInitLockupAccountResponse) Type() protoreflect.MessageType { + return _fastReflection_MsgInitLockupAccountResponse_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_MsgInitLockupAccountResponse) New() protoreflect.Message { + return new(fastReflection_MsgInitLockupAccountResponse) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_MsgInitLockupAccountResponse) Interface() protoreflect.ProtoMessage { + return (*MsgInitLockupAccountResponse)(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_MsgInitLockupAccountResponse) 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_MsgInitLockupAccountResponse) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgInitLockupAccountResponse")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgInitLockupAccountResponse 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_MsgInitLockupAccountResponse) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgInitLockupAccountResponse")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgInitLockupAccountResponse 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_MsgInitLockupAccountResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgInitLockupAccountResponse")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgInitLockupAccountResponse 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_MsgInitLockupAccountResponse) 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.accounts.defaults.lockup.v1.MsgInitLockupAccountResponse")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgInitLockupAccountResponse 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_MsgInitLockupAccountResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgInitLockupAccountResponse")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgInitLockupAccountResponse 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_MsgInitLockupAccountResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgInitLockupAccountResponse")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgInitLockupAccountResponse 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_MsgInitLockupAccountResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in cosmos.accounts.defaults.lockup.v1.MsgInitLockupAccountResponse", 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_MsgInitLockupAccountResponse) 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_MsgInitLockupAccountResponse) 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_MsgInitLockupAccountResponse) 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_MsgInitLockupAccountResponse) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*MsgInitLockupAccountResponse) + 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().(*MsgInitLockupAccountResponse) + 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().(*MsgInitLockupAccountResponse) + 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: MsgInitLockupAccountResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgInitLockupAccountResponse: 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 _ protoreflect.List = (*_MsgInitPeriodicLockingAccount_3_list)(nil) + +type _MsgInitPeriodicLockingAccount_3_list struct { + list *[]*Period +} + +func (x *_MsgInitPeriodicLockingAccount_3_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_MsgInitPeriodicLockingAccount_3_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_MsgInitPeriodicLockingAccount_3_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*Period) + (*x.list)[i] = concreteValue +} + +func (x *_MsgInitPeriodicLockingAccount_3_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*Period) + *x.list = append(*x.list, concreteValue) +} + +func (x *_MsgInitPeriodicLockingAccount_3_list) AppendMutable() protoreflect.Value { + v := new(Period) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_MsgInitPeriodicLockingAccount_3_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_MsgInitPeriodicLockingAccount_3_list) NewElement() protoreflect.Value { + v := new(Period) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_MsgInitPeriodicLockingAccount_3_list) IsValid() bool { + return x.list != nil +} + +var ( + md_MsgInitPeriodicLockingAccount protoreflect.MessageDescriptor + fd_MsgInitPeriodicLockingAccount_owner protoreflect.FieldDescriptor + fd_MsgInitPeriodicLockingAccount_start_time protoreflect.FieldDescriptor + fd_MsgInitPeriodicLockingAccount_locking_periods protoreflect.FieldDescriptor +) + +func init() { + file_cosmos_accounts_defaults_lockup_v1_tx_proto_init() + md_MsgInitPeriodicLockingAccount = File_cosmos_accounts_defaults_lockup_v1_tx_proto.Messages().ByName("MsgInitPeriodicLockingAccount") + fd_MsgInitPeriodicLockingAccount_owner = md_MsgInitPeriodicLockingAccount.Fields().ByName("owner") + fd_MsgInitPeriodicLockingAccount_start_time = md_MsgInitPeriodicLockingAccount.Fields().ByName("start_time") + fd_MsgInitPeriodicLockingAccount_locking_periods = md_MsgInitPeriodicLockingAccount.Fields().ByName("locking_periods") +} + +var _ protoreflect.Message = (*fastReflection_MsgInitPeriodicLockingAccount)(nil) + +type fastReflection_MsgInitPeriodicLockingAccount MsgInitPeriodicLockingAccount + +func (x *MsgInitPeriodicLockingAccount) ProtoReflect() protoreflect.Message { + return (*fastReflection_MsgInitPeriodicLockingAccount)(x) +} + +func (x *MsgInitPeriodicLockingAccount) slowProtoReflect() protoreflect.Message { + mi := &file_cosmos_accounts_defaults_lockup_v1_tx_proto_msgTypes[2] + 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_MsgInitPeriodicLockingAccount_messageType fastReflection_MsgInitPeriodicLockingAccount_messageType +var _ protoreflect.MessageType = fastReflection_MsgInitPeriodicLockingAccount_messageType{} + +type fastReflection_MsgInitPeriodicLockingAccount_messageType struct{} + +func (x fastReflection_MsgInitPeriodicLockingAccount_messageType) Zero() protoreflect.Message { + return (*fastReflection_MsgInitPeriodicLockingAccount)(nil) +} +func (x fastReflection_MsgInitPeriodicLockingAccount_messageType) New() protoreflect.Message { + return new(fastReflection_MsgInitPeriodicLockingAccount) +} +func (x fastReflection_MsgInitPeriodicLockingAccount_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_MsgInitPeriodicLockingAccount +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_MsgInitPeriodicLockingAccount) Descriptor() protoreflect.MessageDescriptor { + return md_MsgInitPeriodicLockingAccount +} + +// 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_MsgInitPeriodicLockingAccount) Type() protoreflect.MessageType { + return _fastReflection_MsgInitPeriodicLockingAccount_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_MsgInitPeriodicLockingAccount) New() protoreflect.Message { + return new(fastReflection_MsgInitPeriodicLockingAccount) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_MsgInitPeriodicLockingAccount) Interface() protoreflect.ProtoMessage { + return (*MsgInitPeriodicLockingAccount)(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_MsgInitPeriodicLockingAccount) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.Owner != "" { + value := protoreflect.ValueOfString(x.Owner) + if !f(fd_MsgInitPeriodicLockingAccount_owner, value) { + return + } + } + if x.StartTime != nil { + value := protoreflect.ValueOfMessage(x.StartTime.ProtoReflect()) + if !f(fd_MsgInitPeriodicLockingAccount_start_time, value) { + return + } + } + if len(x.LockingPeriods) != 0 { + value := protoreflect.ValueOfList(&_MsgInitPeriodicLockingAccount_3_list{list: &x.LockingPeriods}) + if !f(fd_MsgInitPeriodicLockingAccount_locking_periods, 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_MsgInitPeriodicLockingAccount) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "cosmos.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccount.owner": + return x.Owner != "" + case "cosmos.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccount.start_time": + return x.StartTime != nil + case "cosmos.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccount.locking_periods": + return len(x.LockingPeriods) != 0 + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccount")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccount 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_MsgInitPeriodicLockingAccount) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "cosmos.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccount.owner": + x.Owner = "" + case "cosmos.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccount.start_time": + x.StartTime = nil + case "cosmos.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccount.locking_periods": + x.LockingPeriods = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccount")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccount 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_MsgInitPeriodicLockingAccount) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "cosmos.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccount.owner": + value := x.Owner + return protoreflect.ValueOfString(value) + case "cosmos.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccount.start_time": + value := x.StartTime + return protoreflect.ValueOfMessage(value.ProtoReflect()) + case "cosmos.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccount.locking_periods": + if len(x.LockingPeriods) == 0 { + return protoreflect.ValueOfList(&_MsgInitPeriodicLockingAccount_3_list{}) + } + listValue := &_MsgInitPeriodicLockingAccount_3_list{list: &x.LockingPeriods} + return protoreflect.ValueOfList(listValue) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccount")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccount 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_MsgInitPeriodicLockingAccount) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "cosmos.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccount.owner": + x.Owner = value.Interface().(string) + case "cosmos.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccount.start_time": + x.StartTime = value.Message().Interface().(*timestamppb.Timestamp) + case "cosmos.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccount.locking_periods": + lv := value.List() + clv := lv.(*_MsgInitPeriodicLockingAccount_3_list) + x.LockingPeriods = *clv.list + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccount")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccount 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_MsgInitPeriodicLockingAccount) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccount.start_time": + if x.StartTime == nil { + x.StartTime = new(timestamppb.Timestamp) + } + return protoreflect.ValueOfMessage(x.StartTime.ProtoReflect()) + case "cosmos.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccount.locking_periods": + if x.LockingPeriods == nil { + x.LockingPeriods = []*Period{} + } + value := &_MsgInitPeriodicLockingAccount_3_list{list: &x.LockingPeriods} + return protoreflect.ValueOfList(value) + case "cosmos.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccount.owner": + panic(fmt.Errorf("field owner of message cosmos.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccount is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccount")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccount 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_MsgInitPeriodicLockingAccount) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccount.owner": + return protoreflect.ValueOfString("") + case "cosmos.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccount.start_time": + m := new(timestamppb.Timestamp) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + case "cosmos.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccount.locking_periods": + list := []*Period{} + return protoreflect.ValueOfList(&_MsgInitPeriodicLockingAccount_3_list{list: &list}) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccount")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccount 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_MsgInitPeriodicLockingAccount) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in cosmos.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccount", 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_MsgInitPeriodicLockingAccount) 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_MsgInitPeriodicLockingAccount) 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_MsgInitPeriodicLockingAccount) 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_MsgInitPeriodicLockingAccount) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*MsgInitPeriodicLockingAccount) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + l = len(x.Owner) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.StartTime != nil { + l = options.Size(x.StartTime) + n += 1 + l + runtime.Sov(uint64(l)) + } + if len(x.LockingPeriods) > 0 { + for _, e := range x.LockingPeriods { + l = options.Size(e) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*MsgInitPeriodicLockingAccount) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if len(x.LockingPeriods) > 0 { + for iNdEx := len(x.LockingPeriods) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.LockingPeriods[iNdEx]) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x1a + } + } + if x.StartTime != nil { + encoded, err := options.Marshal(x.StartTime) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x12 + } + if len(x.Owner) > 0 { + i -= len(x.Owner) + copy(dAtA[i:], x.Owner) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.Owner))) + i-- + dAtA[i] = 0xa + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*MsgInitPeriodicLockingAccount) + 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: MsgInitPeriodicLockingAccount: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgInitPeriodicLockingAccount: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Owner", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Owner = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field StartTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.StartTime == nil { + x.StartTime = ×tamppb.Timestamp{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.StartTime); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field LockingPeriods", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.LockingPeriods = append(x.LockingPeriods, &Period{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.LockingPeriods[len(x.LockingPeriods)-1]); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_MsgInitPeriodicLockingAccountResponse protoreflect.MessageDescriptor +) + +func init() { + file_cosmos_accounts_defaults_lockup_v1_tx_proto_init() + md_MsgInitPeriodicLockingAccountResponse = File_cosmos_accounts_defaults_lockup_v1_tx_proto.Messages().ByName("MsgInitPeriodicLockingAccountResponse") +} + +var _ protoreflect.Message = (*fastReflection_MsgInitPeriodicLockingAccountResponse)(nil) + +type fastReflection_MsgInitPeriodicLockingAccountResponse MsgInitPeriodicLockingAccountResponse + +func (x *MsgInitPeriodicLockingAccountResponse) ProtoReflect() protoreflect.Message { + return (*fastReflection_MsgInitPeriodicLockingAccountResponse)(x) +} + +func (x *MsgInitPeriodicLockingAccountResponse) slowProtoReflect() protoreflect.Message { + mi := &file_cosmos_accounts_defaults_lockup_v1_tx_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_MsgInitPeriodicLockingAccountResponse_messageType fastReflection_MsgInitPeriodicLockingAccountResponse_messageType +var _ protoreflect.MessageType = fastReflection_MsgInitPeriodicLockingAccountResponse_messageType{} + +type fastReflection_MsgInitPeriodicLockingAccountResponse_messageType struct{} + +func (x fastReflection_MsgInitPeriodicLockingAccountResponse_messageType) Zero() protoreflect.Message { + return (*fastReflection_MsgInitPeriodicLockingAccountResponse)(nil) +} +func (x fastReflection_MsgInitPeriodicLockingAccountResponse_messageType) New() protoreflect.Message { + return new(fastReflection_MsgInitPeriodicLockingAccountResponse) +} +func (x fastReflection_MsgInitPeriodicLockingAccountResponse_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_MsgInitPeriodicLockingAccountResponse +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_MsgInitPeriodicLockingAccountResponse) Descriptor() protoreflect.MessageDescriptor { + return md_MsgInitPeriodicLockingAccountResponse +} + +// 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_MsgInitPeriodicLockingAccountResponse) Type() protoreflect.MessageType { + return _fastReflection_MsgInitPeriodicLockingAccountResponse_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_MsgInitPeriodicLockingAccountResponse) New() protoreflect.Message { + return new(fastReflection_MsgInitPeriodicLockingAccountResponse) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_MsgInitPeriodicLockingAccountResponse) Interface() protoreflect.ProtoMessage { + return (*MsgInitPeriodicLockingAccountResponse)(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_MsgInitPeriodicLockingAccountResponse) 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_MsgInitPeriodicLockingAccountResponse) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccountResponse")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccountResponse 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_MsgInitPeriodicLockingAccountResponse) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccountResponse")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccountResponse 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_MsgInitPeriodicLockingAccountResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccountResponse")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccountResponse 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_MsgInitPeriodicLockingAccountResponse) 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.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccountResponse")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccountResponse 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_MsgInitPeriodicLockingAccountResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccountResponse")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccountResponse 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_MsgInitPeriodicLockingAccountResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccountResponse")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccountResponse 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_MsgInitPeriodicLockingAccountResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in cosmos.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccountResponse", 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_MsgInitPeriodicLockingAccountResponse) 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_MsgInitPeriodicLockingAccountResponse) 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_MsgInitPeriodicLockingAccountResponse) 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_MsgInitPeriodicLockingAccountResponse) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*MsgInitPeriodicLockingAccountResponse) + 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().(*MsgInitPeriodicLockingAccountResponse) + 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().(*MsgInitPeriodicLockingAccountResponse) + 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: MsgInitPeriodicLockingAccountResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgInitPeriodicLockingAccountResponse: 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_MsgDelegate protoreflect.MessageDescriptor + fd_MsgDelegate_validator_address protoreflect.FieldDescriptor + fd_MsgDelegate_amount protoreflect.FieldDescriptor +) + +func init() { + file_cosmos_accounts_defaults_lockup_v1_tx_proto_init() + md_MsgDelegate = File_cosmos_accounts_defaults_lockup_v1_tx_proto.Messages().ByName("MsgDelegate") + fd_MsgDelegate_validator_address = md_MsgDelegate.Fields().ByName("validator_address") + fd_MsgDelegate_amount = md_MsgDelegate.Fields().ByName("amount") +} + +var _ protoreflect.Message = (*fastReflection_MsgDelegate)(nil) + +type fastReflection_MsgDelegate MsgDelegate + +func (x *MsgDelegate) ProtoReflect() protoreflect.Message { + return (*fastReflection_MsgDelegate)(x) +} + +func (x *MsgDelegate) slowProtoReflect() protoreflect.Message { + mi := &file_cosmos_accounts_defaults_lockup_v1_tx_proto_msgTypes[4] + 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_MsgDelegate_messageType fastReflection_MsgDelegate_messageType +var _ protoreflect.MessageType = fastReflection_MsgDelegate_messageType{} + +type fastReflection_MsgDelegate_messageType struct{} + +func (x fastReflection_MsgDelegate_messageType) Zero() protoreflect.Message { + return (*fastReflection_MsgDelegate)(nil) +} +func (x fastReflection_MsgDelegate_messageType) New() protoreflect.Message { + return new(fastReflection_MsgDelegate) +} +func (x fastReflection_MsgDelegate_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_MsgDelegate +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_MsgDelegate) Descriptor() protoreflect.MessageDescriptor { + return md_MsgDelegate +} + +// 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_MsgDelegate) Type() protoreflect.MessageType { + return _fastReflection_MsgDelegate_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_MsgDelegate) New() protoreflect.Message { + return new(fastReflection_MsgDelegate) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_MsgDelegate) Interface() protoreflect.ProtoMessage { + return (*MsgDelegate)(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_MsgDelegate) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.ValidatorAddress != "" { + value := protoreflect.ValueOfString(x.ValidatorAddress) + if !f(fd_MsgDelegate_validator_address, value) { + return + } + } + if x.Amount != nil { + value := protoreflect.ValueOfMessage(x.Amount.ProtoReflect()) + if !f(fd_MsgDelegate_amount, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_MsgDelegate) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "cosmos.accounts.defaults.lockup.v1.MsgDelegate.validator_address": + return x.ValidatorAddress != "" + case "cosmos.accounts.defaults.lockup.v1.MsgDelegate.amount": + return x.Amount != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgDelegate")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgDelegate 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_MsgDelegate) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "cosmos.accounts.defaults.lockup.v1.MsgDelegate.validator_address": + x.ValidatorAddress = "" + case "cosmos.accounts.defaults.lockup.v1.MsgDelegate.amount": + x.Amount = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgDelegate")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgDelegate 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_MsgDelegate) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "cosmos.accounts.defaults.lockup.v1.MsgDelegate.validator_address": + value := x.ValidatorAddress + return protoreflect.ValueOfString(value) + case "cosmos.accounts.defaults.lockup.v1.MsgDelegate.amount": + value := x.Amount + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgDelegate")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgDelegate 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_MsgDelegate) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "cosmos.accounts.defaults.lockup.v1.MsgDelegate.validator_address": + x.ValidatorAddress = value.Interface().(string) + case "cosmos.accounts.defaults.lockup.v1.MsgDelegate.amount": + x.Amount = value.Message().Interface().(*v1beta1.Coin) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgDelegate")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgDelegate 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_MsgDelegate) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.accounts.defaults.lockup.v1.MsgDelegate.amount": + if x.Amount == nil { + x.Amount = new(v1beta1.Coin) + } + return protoreflect.ValueOfMessage(x.Amount.ProtoReflect()) + case "cosmos.accounts.defaults.lockup.v1.MsgDelegate.validator_address": + panic(fmt.Errorf("field validator_address of message cosmos.accounts.defaults.lockup.v1.MsgDelegate is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgDelegate")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgDelegate 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_MsgDelegate) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.accounts.defaults.lockup.v1.MsgDelegate.validator_address": + return protoreflect.ValueOfString("") + case "cosmos.accounts.defaults.lockup.v1.MsgDelegate.amount": + m := new(v1beta1.Coin) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgDelegate")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgDelegate 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_MsgDelegate) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in cosmos.accounts.defaults.lockup.v1.MsgDelegate", 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_MsgDelegate) 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_MsgDelegate) 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_MsgDelegate) 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_MsgDelegate) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*MsgDelegate) + 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.ValidatorAddress) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.Amount != nil { + l = options.Size(x.Amount) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*MsgDelegate) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if x.Amount != nil { + encoded, err := options.Marshal(x.Amount) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x1a + } + if len(x.ValidatorAddress) > 0 { + i -= len(x.ValidatorAddress) + copy(dAtA[i:], x.ValidatorAddress) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ValidatorAddress))) + i-- + dAtA[i] = 0x12 + } + 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().(*MsgDelegate) + 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: MsgDelegate: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgDelegate: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddress", 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.ValidatorAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.Amount == nil { + x.Amount = &v1beta1.Coin{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Amount); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_MsgUndelegate protoreflect.MessageDescriptor + fd_MsgUndelegate_validator_address protoreflect.FieldDescriptor + fd_MsgUndelegate_amount protoreflect.FieldDescriptor +) + +func init() { + file_cosmos_accounts_defaults_lockup_v1_tx_proto_init() + md_MsgUndelegate = File_cosmos_accounts_defaults_lockup_v1_tx_proto.Messages().ByName("MsgUndelegate") + fd_MsgUndelegate_validator_address = md_MsgUndelegate.Fields().ByName("validator_address") + fd_MsgUndelegate_amount = md_MsgUndelegate.Fields().ByName("amount") +} + +var _ protoreflect.Message = (*fastReflection_MsgUndelegate)(nil) + +type fastReflection_MsgUndelegate MsgUndelegate + +func (x *MsgUndelegate) ProtoReflect() protoreflect.Message { + return (*fastReflection_MsgUndelegate)(x) +} + +func (x *MsgUndelegate) slowProtoReflect() protoreflect.Message { + mi := &file_cosmos_accounts_defaults_lockup_v1_tx_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_MsgUndelegate_messageType fastReflection_MsgUndelegate_messageType +var _ protoreflect.MessageType = fastReflection_MsgUndelegate_messageType{} + +type fastReflection_MsgUndelegate_messageType struct{} + +func (x fastReflection_MsgUndelegate_messageType) Zero() protoreflect.Message { + return (*fastReflection_MsgUndelegate)(nil) +} +func (x fastReflection_MsgUndelegate_messageType) New() protoreflect.Message { + return new(fastReflection_MsgUndelegate) +} +func (x fastReflection_MsgUndelegate_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_MsgUndelegate +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_MsgUndelegate) Descriptor() protoreflect.MessageDescriptor { + return md_MsgUndelegate +} + +// 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_MsgUndelegate) Type() protoreflect.MessageType { + return _fastReflection_MsgUndelegate_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_MsgUndelegate) New() protoreflect.Message { + return new(fastReflection_MsgUndelegate) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_MsgUndelegate) Interface() protoreflect.ProtoMessage { + return (*MsgUndelegate)(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_MsgUndelegate) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.ValidatorAddress != "" { + value := protoreflect.ValueOfString(x.ValidatorAddress) + if !f(fd_MsgUndelegate_validator_address, value) { + return + } + } + if x.Amount != nil { + value := protoreflect.ValueOfMessage(x.Amount.ProtoReflect()) + if !f(fd_MsgUndelegate_amount, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_MsgUndelegate) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "cosmos.accounts.defaults.lockup.v1.MsgUndelegate.validator_address": + return x.ValidatorAddress != "" + case "cosmos.accounts.defaults.lockup.v1.MsgUndelegate.amount": + return x.Amount != nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgUndelegate")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgUndelegate 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_MsgUndelegate) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "cosmos.accounts.defaults.lockup.v1.MsgUndelegate.validator_address": + x.ValidatorAddress = "" + case "cosmos.accounts.defaults.lockup.v1.MsgUndelegate.amount": + x.Amount = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgUndelegate")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgUndelegate 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_MsgUndelegate) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "cosmos.accounts.defaults.lockup.v1.MsgUndelegate.validator_address": + value := x.ValidatorAddress + return protoreflect.ValueOfString(value) + case "cosmos.accounts.defaults.lockup.v1.MsgUndelegate.amount": + value := x.Amount + return protoreflect.ValueOfMessage(value.ProtoReflect()) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgUndelegate")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgUndelegate 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_MsgUndelegate) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "cosmos.accounts.defaults.lockup.v1.MsgUndelegate.validator_address": + x.ValidatorAddress = value.Interface().(string) + case "cosmos.accounts.defaults.lockup.v1.MsgUndelegate.amount": + x.Amount = value.Message().Interface().(*v1beta1.Coin) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgUndelegate")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgUndelegate 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_MsgUndelegate) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.accounts.defaults.lockup.v1.MsgUndelegate.amount": + if x.Amount == nil { + x.Amount = new(v1beta1.Coin) + } + return protoreflect.ValueOfMessage(x.Amount.ProtoReflect()) + case "cosmos.accounts.defaults.lockup.v1.MsgUndelegate.validator_address": + panic(fmt.Errorf("field validator_address of message cosmos.accounts.defaults.lockup.v1.MsgUndelegate is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgUndelegate")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgUndelegate 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_MsgUndelegate) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.accounts.defaults.lockup.v1.MsgUndelegate.validator_address": + return protoreflect.ValueOfString("") + case "cosmos.accounts.defaults.lockup.v1.MsgUndelegate.amount": + m := new(v1beta1.Coin) + return protoreflect.ValueOfMessage(m.ProtoReflect()) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgUndelegate")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgUndelegate 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_MsgUndelegate) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in cosmos.accounts.defaults.lockup.v1.MsgUndelegate", 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_MsgUndelegate) 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_MsgUndelegate) 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_MsgUndelegate) 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_MsgUndelegate) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*MsgUndelegate) + 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.ValidatorAddress) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.Amount != nil { + l = options.Size(x.Amount) + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*MsgUndelegate) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if x.Amount != nil { + encoded, err := options.Marshal(x.Amount) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x1a + } + if len(x.ValidatorAddress) > 0 { + i -= len(x.ValidatorAddress) + copy(dAtA[i:], x.ValidatorAddress) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ValidatorAddress))) + i-- + dAtA[i] = 0x12 + } + 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().(*MsgUndelegate) + 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: MsgUndelegate: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgUndelegate: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddress", 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.ValidatorAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if x.Amount == nil { + x.Amount = &v1beta1.Coin{} + } + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Amount); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var ( + md_MsgWithdrawReward protoreflect.MessageDescriptor + fd_MsgWithdrawReward_validator_address protoreflect.FieldDescriptor +) + +func init() { + file_cosmos_accounts_defaults_lockup_v1_tx_proto_init() + md_MsgWithdrawReward = File_cosmos_accounts_defaults_lockup_v1_tx_proto.Messages().ByName("MsgWithdrawReward") + fd_MsgWithdrawReward_validator_address = md_MsgWithdrawReward.Fields().ByName("validator_address") +} + +var _ protoreflect.Message = (*fastReflection_MsgWithdrawReward)(nil) + +type fastReflection_MsgWithdrawReward MsgWithdrawReward + +func (x *MsgWithdrawReward) ProtoReflect() protoreflect.Message { + return (*fastReflection_MsgWithdrawReward)(x) +} + +func (x *MsgWithdrawReward) slowProtoReflect() protoreflect.Message { + mi := &file_cosmos_accounts_defaults_lockup_v1_tx_proto_msgTypes[6] + 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_MsgWithdrawReward_messageType fastReflection_MsgWithdrawReward_messageType +var _ protoreflect.MessageType = fastReflection_MsgWithdrawReward_messageType{} + +type fastReflection_MsgWithdrawReward_messageType struct{} + +func (x fastReflection_MsgWithdrawReward_messageType) Zero() protoreflect.Message { + return (*fastReflection_MsgWithdrawReward)(nil) +} +func (x fastReflection_MsgWithdrawReward_messageType) New() protoreflect.Message { + return new(fastReflection_MsgWithdrawReward) +} +func (x fastReflection_MsgWithdrawReward_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_MsgWithdrawReward +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_MsgWithdrawReward) Descriptor() protoreflect.MessageDescriptor { + return md_MsgWithdrawReward +} + +// 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_MsgWithdrawReward) Type() protoreflect.MessageType { + return _fastReflection_MsgWithdrawReward_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_MsgWithdrawReward) New() protoreflect.Message { + return new(fastReflection_MsgWithdrawReward) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_MsgWithdrawReward) Interface() protoreflect.ProtoMessage { + return (*MsgWithdrawReward)(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_MsgWithdrawReward) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.ValidatorAddress != "" { + value := protoreflect.ValueOfString(x.ValidatorAddress) + if !f(fd_MsgWithdrawReward_validator_address, 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_MsgWithdrawReward) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "cosmos.accounts.defaults.lockup.v1.MsgWithdrawReward.validator_address": + return x.ValidatorAddress != "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgWithdrawReward")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgWithdrawReward 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_MsgWithdrawReward) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "cosmos.accounts.defaults.lockup.v1.MsgWithdrawReward.validator_address": + x.ValidatorAddress = "" + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgWithdrawReward")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgWithdrawReward 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_MsgWithdrawReward) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "cosmos.accounts.defaults.lockup.v1.MsgWithdrawReward.validator_address": + value := x.ValidatorAddress + return protoreflect.ValueOfString(value) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgWithdrawReward")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgWithdrawReward 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_MsgWithdrawReward) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "cosmos.accounts.defaults.lockup.v1.MsgWithdrawReward.validator_address": + x.ValidatorAddress = value.Interface().(string) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgWithdrawReward")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgWithdrawReward 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_MsgWithdrawReward) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.accounts.defaults.lockup.v1.MsgWithdrawReward.validator_address": + panic(fmt.Errorf("field validator_address of message cosmos.accounts.defaults.lockup.v1.MsgWithdrawReward is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgWithdrawReward")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgWithdrawReward 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_MsgWithdrawReward) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.accounts.defaults.lockup.v1.MsgWithdrawReward.validator_address": + return protoreflect.ValueOfString("") + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgWithdrawReward")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgWithdrawReward 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_MsgWithdrawReward) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in cosmos.accounts.defaults.lockup.v1.MsgWithdrawReward", 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_MsgWithdrawReward) 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_MsgWithdrawReward) 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_MsgWithdrawReward) 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_MsgWithdrawReward) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*MsgWithdrawReward) + 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.ValidatorAddress) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*MsgWithdrawReward) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if len(x.ValidatorAddress) > 0 { + i -= len(x.ValidatorAddress) + copy(dAtA[i:], x.ValidatorAddress) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ValidatorAddress))) + i-- + dAtA[i] = 0x12 + } + 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().(*MsgWithdrawReward) + 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: MsgWithdrawReward: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgWithdrawReward: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddress", 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.ValidatorAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var _ protoreflect.List = (*_MsgSend_3_list)(nil) + +type _MsgSend_3_list struct { + list *[]*v1beta1.Coin +} + +func (x *_MsgSend_3_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_MsgSend_3_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_MsgSend_3_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*v1beta1.Coin) + (*x.list)[i] = concreteValue +} + +func (x *_MsgSend_3_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*v1beta1.Coin) + *x.list = append(*x.list, concreteValue) +} + +func (x *_MsgSend_3_list) AppendMutable() protoreflect.Value { + v := new(v1beta1.Coin) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_MsgSend_3_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_MsgSend_3_list) NewElement() protoreflect.Value { + v := new(v1beta1.Coin) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_MsgSend_3_list) IsValid() bool { + return x.list != nil +} + +var ( + md_MsgSend protoreflect.MessageDescriptor + fd_MsgSend_to_address protoreflect.FieldDescriptor + fd_MsgSend_amount protoreflect.FieldDescriptor +) + +func init() { + file_cosmos_accounts_defaults_lockup_v1_tx_proto_init() + md_MsgSend = File_cosmos_accounts_defaults_lockup_v1_tx_proto.Messages().ByName("MsgSend") + fd_MsgSend_to_address = md_MsgSend.Fields().ByName("to_address") + fd_MsgSend_amount = md_MsgSend.Fields().ByName("amount") +} + +var _ protoreflect.Message = (*fastReflection_MsgSend)(nil) + +type fastReflection_MsgSend MsgSend + +func (x *MsgSend) ProtoReflect() protoreflect.Message { + return (*fastReflection_MsgSend)(x) +} + +func (x *MsgSend) slowProtoReflect() protoreflect.Message { + mi := &file_cosmos_accounts_defaults_lockup_v1_tx_proto_msgTypes[7] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +var _fastReflection_MsgSend_messageType fastReflection_MsgSend_messageType +var _ protoreflect.MessageType = fastReflection_MsgSend_messageType{} + +type fastReflection_MsgSend_messageType struct{} + +func (x fastReflection_MsgSend_messageType) Zero() protoreflect.Message { + return (*fastReflection_MsgSend)(nil) +} +func (x fastReflection_MsgSend_messageType) New() protoreflect.Message { + return new(fastReflection_MsgSend) +} +func (x fastReflection_MsgSend_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_MsgSend +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_MsgSend) Descriptor() protoreflect.MessageDescriptor { + return md_MsgSend +} + +// 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_MsgSend) Type() protoreflect.MessageType { + return _fastReflection_MsgSend_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_MsgSend) New() protoreflect.Message { + return new(fastReflection_MsgSend) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_MsgSend) Interface() protoreflect.ProtoMessage { + return (*MsgSend)(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_MsgSend) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if x.ToAddress != "" { + value := protoreflect.ValueOfString(x.ToAddress) + if !f(fd_MsgSend_to_address, value) { + return + } + } + if len(x.Amount) != 0 { + value := protoreflect.ValueOfList(&_MsgSend_3_list{list: &x.Amount}) + if !f(fd_MsgSend_amount, value) { + return + } + } +} + +// Has reports whether a field is populated. +// +// Some fields have the property of nullability where it is possible to +// distinguish between the default value of a field and whether the field +// was explicitly populated with the default value. Singular message fields, +// member fields of a oneof, and proto2 scalar fields are nullable. Such +// fields are populated only if explicitly set. +// +// In other cases (aside from the nullable cases above), +// a proto3 scalar field is populated if it contains a non-zero value, and +// a repeated field is populated if it is non-empty. +func (x *fastReflection_MsgSend) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "cosmos.accounts.defaults.lockup.v1.MsgSend.to_address": + return x.ToAddress != "" + case "cosmos.accounts.defaults.lockup.v1.MsgSend.amount": + return len(x.Amount) != 0 + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgSend")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgSend 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_MsgSend) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "cosmos.accounts.defaults.lockup.v1.MsgSend.to_address": + x.ToAddress = "" + case "cosmos.accounts.defaults.lockup.v1.MsgSend.amount": + x.Amount = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgSend")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgSend 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_MsgSend) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "cosmos.accounts.defaults.lockup.v1.MsgSend.to_address": + value := x.ToAddress + return protoreflect.ValueOfString(value) + case "cosmos.accounts.defaults.lockup.v1.MsgSend.amount": + if len(x.Amount) == 0 { + return protoreflect.ValueOfList(&_MsgSend_3_list{}) + } + listValue := &_MsgSend_3_list{list: &x.Amount} + return protoreflect.ValueOfList(listValue) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgSend")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgSend 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_MsgSend) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "cosmos.accounts.defaults.lockup.v1.MsgSend.to_address": + x.ToAddress = value.Interface().(string) + case "cosmos.accounts.defaults.lockup.v1.MsgSend.amount": + lv := value.List() + clv := lv.(*_MsgSend_3_list) + x.Amount = *clv.list + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgSend")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgSend 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_MsgSend) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.accounts.defaults.lockup.v1.MsgSend.amount": + if x.Amount == nil { + x.Amount = []*v1beta1.Coin{} + } + value := &_MsgSend_3_list{list: &x.Amount} + return protoreflect.ValueOfList(value) + case "cosmos.accounts.defaults.lockup.v1.MsgSend.to_address": + panic(fmt.Errorf("field to_address of message cosmos.accounts.defaults.lockup.v1.MsgSend is not mutable")) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgSend")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgSend 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_MsgSend) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.accounts.defaults.lockup.v1.MsgSend.to_address": + return protoreflect.ValueOfString("") + case "cosmos.accounts.defaults.lockup.v1.MsgSend.amount": + list := []*v1beta1.Coin{} + return protoreflect.ValueOfList(&_MsgSend_3_list{list: &list}) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgSend")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgSend 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_MsgSend) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in cosmos.accounts.defaults.lockup.v1.MsgSend", 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_MsgSend) 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_MsgSend) 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_MsgSend) 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_MsgSend) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*MsgSend) + 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.ToAddress) + if l > 0 { + n += 1 + l + runtime.Sov(uint64(l)) + } + if len(x.Amount) > 0 { + for _, e := range x.Amount { + l = options.Size(e) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*MsgSend) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if len(x.Amount) > 0 { + for iNdEx := len(x.Amount) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.Amount[iNdEx]) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0x1a + } + } + if len(x.ToAddress) > 0 { + i -= len(x.ToAddress) + copy(dAtA[i:], x.ToAddress) + i = runtime.EncodeVarint(dAtA, i, uint64(len(x.ToAddress))) + i-- + dAtA[i] = 0x12 + } + 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().(*MsgSend) + 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: MsgSend: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgSend: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 2: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field ToAddress", 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.ToAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Amount = append(x.Amount, &v1beta1.Coin{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Amount[len(x.Amount)-1]); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +var _ protoreflect.List = (*_MsgExecuteMessagesResponse_1_list)(nil) + +type _MsgExecuteMessagesResponse_1_list struct { + list *[]*anypb.Any +} + +func (x *_MsgExecuteMessagesResponse_1_list) Len() int { + if x.list == nil { + return 0 + } + return len(*x.list) +} + +func (x *_MsgExecuteMessagesResponse_1_list) Get(i int) protoreflect.Value { + return protoreflect.ValueOfMessage((*x.list)[i].ProtoReflect()) +} + +func (x *_MsgExecuteMessagesResponse_1_list) Set(i int, value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*anypb.Any) + (*x.list)[i] = concreteValue +} + +func (x *_MsgExecuteMessagesResponse_1_list) Append(value protoreflect.Value) { + valueUnwrapped := value.Message() + concreteValue := valueUnwrapped.Interface().(*anypb.Any) + *x.list = append(*x.list, concreteValue) +} + +func (x *_MsgExecuteMessagesResponse_1_list) AppendMutable() protoreflect.Value { + v := new(anypb.Any) + *x.list = append(*x.list, v) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_MsgExecuteMessagesResponse_1_list) Truncate(n int) { + for i := n; i < len(*x.list); i++ { + (*x.list)[i] = nil + } + *x.list = (*x.list)[:n] +} + +func (x *_MsgExecuteMessagesResponse_1_list) NewElement() protoreflect.Value { + v := new(anypb.Any) + return protoreflect.ValueOfMessage(v.ProtoReflect()) +} + +func (x *_MsgExecuteMessagesResponse_1_list) IsValid() bool { + return x.list != nil +} + +var ( + md_MsgExecuteMessagesResponse protoreflect.MessageDescriptor + fd_MsgExecuteMessagesResponse_responses protoreflect.FieldDescriptor +) + +func init() { + file_cosmos_accounts_defaults_lockup_v1_tx_proto_init() + md_MsgExecuteMessagesResponse = File_cosmos_accounts_defaults_lockup_v1_tx_proto.Messages().ByName("MsgExecuteMessagesResponse") + fd_MsgExecuteMessagesResponse_responses = md_MsgExecuteMessagesResponse.Fields().ByName("responses") +} + +var _ protoreflect.Message = (*fastReflection_MsgExecuteMessagesResponse)(nil) + +type fastReflection_MsgExecuteMessagesResponse MsgExecuteMessagesResponse + +func (x *MsgExecuteMessagesResponse) ProtoReflect() protoreflect.Message { + return (*fastReflection_MsgExecuteMessagesResponse)(x) +} + +func (x *MsgExecuteMessagesResponse) slowProtoReflect() protoreflect.Message { + mi := &file_cosmos_accounts_defaults_lockup_v1_tx_proto_msgTypes[8] + 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_MsgExecuteMessagesResponse_messageType fastReflection_MsgExecuteMessagesResponse_messageType +var _ protoreflect.MessageType = fastReflection_MsgExecuteMessagesResponse_messageType{} + +type fastReflection_MsgExecuteMessagesResponse_messageType struct{} + +func (x fastReflection_MsgExecuteMessagesResponse_messageType) Zero() protoreflect.Message { + return (*fastReflection_MsgExecuteMessagesResponse)(nil) +} +func (x fastReflection_MsgExecuteMessagesResponse_messageType) New() protoreflect.Message { + return new(fastReflection_MsgExecuteMessagesResponse) +} +func (x fastReflection_MsgExecuteMessagesResponse_messageType) Descriptor() protoreflect.MessageDescriptor { + return md_MsgExecuteMessagesResponse +} + +// Descriptor returns message descriptor, which contains only the protobuf +// type information for the message. +func (x *fastReflection_MsgExecuteMessagesResponse) Descriptor() protoreflect.MessageDescriptor { + return md_MsgExecuteMessagesResponse +} + +// 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_MsgExecuteMessagesResponse) Type() protoreflect.MessageType { + return _fastReflection_MsgExecuteMessagesResponse_messageType +} + +// New returns a newly allocated and mutable empty message. +func (x *fastReflection_MsgExecuteMessagesResponse) New() protoreflect.Message { + return new(fastReflection_MsgExecuteMessagesResponse) +} + +// Interface unwraps the message reflection interface and +// returns the underlying ProtoMessage interface. +func (x *fastReflection_MsgExecuteMessagesResponse) Interface() protoreflect.ProtoMessage { + return (*MsgExecuteMessagesResponse)(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_MsgExecuteMessagesResponse) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) { + if len(x.Responses) != 0 { + value := protoreflect.ValueOfList(&_MsgExecuteMessagesResponse_1_list{list: &x.Responses}) + if !f(fd_MsgExecuteMessagesResponse_responses, 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_MsgExecuteMessagesResponse) Has(fd protoreflect.FieldDescriptor) bool { + switch fd.FullName() { + case "cosmos.accounts.defaults.lockup.v1.MsgExecuteMessagesResponse.responses": + return len(x.Responses) != 0 + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgExecuteMessagesResponse")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgExecuteMessagesResponse 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_MsgExecuteMessagesResponse) Clear(fd protoreflect.FieldDescriptor) { + switch fd.FullName() { + case "cosmos.accounts.defaults.lockup.v1.MsgExecuteMessagesResponse.responses": + x.Responses = nil + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgExecuteMessagesResponse")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgExecuteMessagesResponse 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_MsgExecuteMessagesResponse) Get(descriptor protoreflect.FieldDescriptor) protoreflect.Value { + switch descriptor.FullName() { + case "cosmos.accounts.defaults.lockup.v1.MsgExecuteMessagesResponse.responses": + if len(x.Responses) == 0 { + return protoreflect.ValueOfList(&_MsgExecuteMessagesResponse_1_list{}) + } + listValue := &_MsgExecuteMessagesResponse_1_list{list: &x.Responses} + return protoreflect.ValueOfList(listValue) + default: + if descriptor.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgExecuteMessagesResponse")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgExecuteMessagesResponse 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_MsgExecuteMessagesResponse) Set(fd protoreflect.FieldDescriptor, value protoreflect.Value) { + switch fd.FullName() { + case "cosmos.accounts.defaults.lockup.v1.MsgExecuteMessagesResponse.responses": + lv := value.List() + clv := lv.(*_MsgExecuteMessagesResponse_1_list) + x.Responses = *clv.list + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgExecuteMessagesResponse")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgExecuteMessagesResponse 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_MsgExecuteMessagesResponse) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.accounts.defaults.lockup.v1.MsgExecuteMessagesResponse.responses": + if x.Responses == nil { + x.Responses = []*anypb.Any{} + } + value := &_MsgExecuteMessagesResponse_1_list{list: &x.Responses} + return protoreflect.ValueOfList(value) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgExecuteMessagesResponse")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgExecuteMessagesResponse 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_MsgExecuteMessagesResponse) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value { + switch fd.FullName() { + case "cosmos.accounts.defaults.lockup.v1.MsgExecuteMessagesResponse.responses": + list := []*anypb.Any{} + return protoreflect.ValueOfList(&_MsgExecuteMessagesResponse_1_list{list: &list}) + default: + if fd.IsExtension() { + panic(fmt.Errorf("proto3 declared messages do not support extensions: cosmos.accounts.defaults.lockup.v1.MsgExecuteMessagesResponse")) + } + panic(fmt.Errorf("message cosmos.accounts.defaults.lockup.v1.MsgExecuteMessagesResponse 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_MsgExecuteMessagesResponse) WhichOneof(d protoreflect.OneofDescriptor) protoreflect.FieldDescriptor { + switch d.FullName() { + default: + panic(fmt.Errorf("%s is not a oneof field in cosmos.accounts.defaults.lockup.v1.MsgExecuteMessagesResponse", 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_MsgExecuteMessagesResponse) 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_MsgExecuteMessagesResponse) 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_MsgExecuteMessagesResponse) 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_MsgExecuteMessagesResponse) ProtoMethods() *protoiface.Methods { + size := func(input protoiface.SizeInput) protoiface.SizeOutput { + x := input.Message.Interface().(*MsgExecuteMessagesResponse) + if x == nil { + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: 0, + } + } + options := runtime.SizeInputToOptions(input) + _ = options + var n int + var l int + _ = l + if len(x.Responses) > 0 { + for _, e := range x.Responses { + l = options.Size(e) + n += 1 + l + runtime.Sov(uint64(l)) + } + } + if x.unknownFields != nil { + n += len(x.unknownFields) + } + return protoiface.SizeOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Size: n, + } + } + + marshal := func(input protoiface.MarshalInput) (protoiface.MarshalOutput, error) { + x := input.Message.Interface().(*MsgExecuteMessagesResponse) + if x == nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + options := runtime.MarshalInputToOptions(input) + _ = options + size := options.Size(x) + dAtA := make([]byte, size) + i := len(dAtA) + _ = i + var l int + _ = l + if x.unknownFields != nil { + i -= len(x.unknownFields) + copy(dAtA[i:], x.unknownFields) + } + if len(x.Responses) > 0 { + for iNdEx := len(x.Responses) - 1; iNdEx >= 0; iNdEx-- { + encoded, err := options.Marshal(x.Responses[iNdEx]) + if err != nil { + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, err + } + i -= len(encoded) + copy(dAtA[i:], encoded) + i = runtime.EncodeVarint(dAtA, i, uint64(len(encoded))) + i-- + dAtA[i] = 0xa + } + } + if input.Buf != nil { + input.Buf = append(input.Buf, dAtA...) + } else { + input.Buf = dAtA + } + return protoiface.MarshalOutput{ + NoUnkeyedLiterals: input.NoUnkeyedLiterals, + Buf: input.Buf, + }, nil + } + unmarshal := func(input protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { + x := input.Message.Interface().(*MsgExecuteMessagesResponse) + 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: MsgExecuteMessagesResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, fmt.Errorf("proto: MsgExecuteMessagesResponse: 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 Responses", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrIntOverflow + } + if iNdEx >= l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if postIndex > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + x.Responses = append(x.Responses, &anypb.Any{}) + if err := options.Unmarshal(dAtA[iNdEx:postIndex], x.Responses[len(x.Responses)-1]); err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := runtime.Skip(dAtA[iNdEx:]) + if err != nil { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, runtime.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + if !options.DiscardUnknown { + x.unknownFields = append(x.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + } + iNdEx += skippy + } + } + + if iNdEx > l { + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, io.ErrUnexpectedEOF + } + return protoiface.UnmarshalOutput{NoUnkeyedLiterals: input.NoUnkeyedLiterals, Flags: input.Flags}, nil + } + return &protoiface.Methods{ + NoUnkeyedLiterals: struct{}{}, + Flags: protoiface.SupportMarshalDeterministic | protoiface.SupportUnmarshalDiscardUnknown, + Size: size, + Marshal: marshal, + Unmarshal: unmarshal, + Merge: nil, + CheckInitialized: nil, + } +} + +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.27.0 +// protoc (unknown) +// source: cosmos/accounts/defaults/lockup/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) +) + +// MsgInitLockupAccount defines a message that enables creating a lockup account. +type MsgInitLockupAccount struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // owner of the vesting account + Owner string `protobuf:"bytes,1,opt,name=owner,proto3" json:"owner,omitempty"` + // end_time is end of lockup + EndTime *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=end_time,json=endTime,proto3" json:"end_time,omitempty"` + // start_time is start of lockup + StartTime *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"` +} + +func (x *MsgInitLockupAccount) Reset() { + *x = MsgInitLockupAccount{} + if protoimpl.UnsafeEnabled { + mi := &file_cosmos_accounts_defaults_lockup_v1_tx_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MsgInitLockupAccount) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MsgInitLockupAccount) ProtoMessage() {} + +// Deprecated: Use MsgInitLockupAccount.ProtoReflect.Descriptor instead. +func (*MsgInitLockupAccount) Descriptor() ([]byte, []int) { + return file_cosmos_accounts_defaults_lockup_v1_tx_proto_rawDescGZIP(), []int{0} +} + +func (x *MsgInitLockupAccount) GetOwner() string { + if x != nil { + return x.Owner + } + return "" +} + +func (x *MsgInitLockupAccount) GetEndTime() *timestamppb.Timestamp { + if x != nil { + return x.EndTime + } + return nil +} + +func (x *MsgInitLockupAccount) GetStartTime() *timestamppb.Timestamp { + if x != nil { + return x.StartTime + } + return nil +} + +// MsgInitLockupAccountResponse defines the Msg/InitLockupAccount response type. +type MsgInitLockupAccountResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *MsgInitLockupAccountResponse) Reset() { + *x = MsgInitLockupAccountResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_cosmos_accounts_defaults_lockup_v1_tx_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MsgInitLockupAccountResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MsgInitLockupAccountResponse) ProtoMessage() {} + +// Deprecated: Use MsgInitLockupAccountResponse.ProtoReflect.Descriptor instead. +func (*MsgInitLockupAccountResponse) Descriptor() ([]byte, []int) { + return file_cosmos_accounts_defaults_lockup_v1_tx_proto_rawDescGZIP(), []int{1} +} + +// MsgInitPeriodicLockingAccount defines a message that enables creating a periodic locking +// account. +type MsgInitPeriodicLockingAccount struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // owner of the lockup account + Owner string `protobuf:"bytes,1,opt,name=owner,proto3" json:"owner,omitempty"` + // start of lockup + StartTime *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"` + LockingPeriods []*Period `protobuf:"bytes,3,rep,name=locking_periods,json=lockingPeriods,proto3" json:"locking_periods,omitempty"` +} + +func (x *MsgInitPeriodicLockingAccount) Reset() { + *x = MsgInitPeriodicLockingAccount{} + if protoimpl.UnsafeEnabled { + mi := &file_cosmos_accounts_defaults_lockup_v1_tx_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MsgInitPeriodicLockingAccount) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MsgInitPeriodicLockingAccount) ProtoMessage() {} + +// Deprecated: Use MsgInitPeriodicLockingAccount.ProtoReflect.Descriptor instead. +func (*MsgInitPeriodicLockingAccount) Descriptor() ([]byte, []int) { + return file_cosmos_accounts_defaults_lockup_v1_tx_proto_rawDescGZIP(), []int{2} +} + +func (x *MsgInitPeriodicLockingAccount) GetOwner() string { + if x != nil { + return x.Owner + } + return "" +} + +func (x *MsgInitPeriodicLockingAccount) GetStartTime() *timestamppb.Timestamp { + if x != nil { + return x.StartTime + } + return nil +} + +func (x *MsgInitPeriodicLockingAccount) GetLockingPeriods() []*Period { + if x != nil { + return x.LockingPeriods + } + return nil +} + +// MsgInitPeriodicLockingAccountResponse defines the Msg/InitPeriodicLockingAccount +// response type. +type MsgInitPeriodicLockingAccountResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *MsgInitPeriodicLockingAccountResponse) Reset() { + *x = MsgInitPeriodicLockingAccountResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_cosmos_accounts_defaults_lockup_v1_tx_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MsgInitPeriodicLockingAccountResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MsgInitPeriodicLockingAccountResponse) ProtoMessage() {} + +// Deprecated: Use MsgInitPeriodicLockingAccountResponse.ProtoReflect.Descriptor instead. +func (*MsgInitPeriodicLockingAccountResponse) Descriptor() ([]byte, []int) { + return file_cosmos_accounts_defaults_lockup_v1_tx_proto_rawDescGZIP(), []int{3} +} + +// MsgDelegate defines a message that enable lockup account to execute delegate message +type MsgDelegate struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // sender is the owner of the lockup account + ValidatorAddress string `protobuf:"bytes,2,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty"` + Amount *v1beta1.Coin `protobuf:"bytes,3,opt,name=amount,proto3" json:"amount,omitempty"` +} + +func (x *MsgDelegate) Reset() { + *x = MsgDelegate{} + if protoimpl.UnsafeEnabled { + mi := &file_cosmos_accounts_defaults_lockup_v1_tx_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MsgDelegate) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MsgDelegate) ProtoMessage() {} + +// Deprecated: Use MsgDelegate.ProtoReflect.Descriptor instead. +func (*MsgDelegate) Descriptor() ([]byte, []int) { + return file_cosmos_accounts_defaults_lockup_v1_tx_proto_rawDescGZIP(), []int{4} +} + +func (x *MsgDelegate) GetValidatorAddress() string { + if x != nil { + return x.ValidatorAddress + } + return "" +} + +func (x *MsgDelegate) GetAmount() *v1beta1.Coin { + if x != nil { + return x.Amount + } + return nil +} + +// MsgUndelegate defines a message that enable lockup account to execute undelegate message +type MsgUndelegate struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ValidatorAddress string `protobuf:"bytes,2,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty"` + Amount *v1beta1.Coin `protobuf:"bytes,3,opt,name=amount,proto3" json:"amount,omitempty"` +} + +func (x *MsgUndelegate) Reset() { + *x = MsgUndelegate{} + if protoimpl.UnsafeEnabled { + mi := &file_cosmos_accounts_defaults_lockup_v1_tx_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MsgUndelegate) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MsgUndelegate) ProtoMessage() {} + +// Deprecated: Use MsgUndelegate.ProtoReflect.Descriptor instead. +func (*MsgUndelegate) Descriptor() ([]byte, []int) { + return file_cosmos_accounts_defaults_lockup_v1_tx_proto_rawDescGZIP(), []int{5} +} + +func (x *MsgUndelegate) GetValidatorAddress() string { + if x != nil { + return x.ValidatorAddress + } + return "" +} + +func (x *MsgUndelegate) GetAmount() *v1beta1.Coin { + if x != nil { + return x.Amount + } + return nil +} + +// MsgWithdrawReward defines a message that enable lockup account to execute withdraw reward message +type MsgWithdrawReward struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ValidatorAddress string `protobuf:"bytes,2,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty"` +} + +func (x *MsgWithdrawReward) Reset() { + *x = MsgWithdrawReward{} + if protoimpl.UnsafeEnabled { + mi := &file_cosmos_accounts_defaults_lockup_v1_tx_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MsgWithdrawReward) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MsgWithdrawReward) ProtoMessage() {} + +// Deprecated: Use MsgWithdrawReward.ProtoReflect.Descriptor instead. +func (*MsgWithdrawReward) Descriptor() ([]byte, []int) { + return file_cosmos_accounts_defaults_lockup_v1_tx_proto_rawDescGZIP(), []int{6} +} + +func (x *MsgWithdrawReward) GetValidatorAddress() string { + if x != nil { + return x.ValidatorAddress + } + return "" +} + +// MsgSend defines a message that enable lockup account to execute send message +type MsgSend struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ToAddress string `protobuf:"bytes,2,opt,name=to_address,json=toAddress,proto3" json:"to_address,omitempty"` + Amount []*v1beta1.Coin `protobuf:"bytes,3,rep,name=amount,proto3" json:"amount,omitempty"` +} + +func (x *MsgSend) Reset() { + *x = MsgSend{} + if protoimpl.UnsafeEnabled { + mi := &file_cosmos_accounts_defaults_lockup_v1_tx_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MsgSend) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MsgSend) ProtoMessage() {} + +// Deprecated: Use MsgSend.ProtoReflect.Descriptor instead. +func (*MsgSend) Descriptor() ([]byte, []int) { + return file_cosmos_accounts_defaults_lockup_v1_tx_proto_rawDescGZIP(), []int{7} +} + +func (x *MsgSend) GetToAddress() string { + if x != nil { + return x.ToAddress + } + return "" +} + +func (x *MsgSend) GetAmount() []*v1beta1.Coin { + if x != nil { + return x.Amount + } + return nil +} + +// MsgExecuteMessagesResponse defines the response for lockup execute operations +type MsgExecuteMessagesResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Responses []*anypb.Any `protobuf:"bytes,1,rep,name=responses,proto3" json:"responses,omitempty"` +} + +func (x *MsgExecuteMessagesResponse) Reset() { + *x = MsgExecuteMessagesResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_cosmos_accounts_defaults_lockup_v1_tx_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MsgExecuteMessagesResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MsgExecuteMessagesResponse) ProtoMessage() {} + +// Deprecated: Use MsgExecuteMessagesResponse.ProtoReflect.Descriptor instead. +func (*MsgExecuteMessagesResponse) Descriptor() ([]byte, []int) { + return file_cosmos_accounts_defaults_lockup_v1_tx_proto_rawDescGZIP(), []int{8} +} + +func (x *MsgExecuteMessagesResponse) GetResponses() []*anypb.Any { + if x != nil { + return x.Responses + } + return nil +} + +var File_cosmos_accounts_defaults_lockup_v1_tx_proto protoreflect.FileDescriptor + +var file_cosmos_accounts_defaults_lockup_v1_tx_proto_rawDesc = []byte{ + 0x0a, 0x2b, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, + 0x73, 0x2f, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x73, 0x2f, 0x6c, 0x6f, 0x63, 0x6b, 0x75, + 0x70, 0x2f, 0x76, 0x31, 0x2f, 0x74, 0x78, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x22, 0x63, + 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x2e, 0x64, + 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x73, 0x2e, 0x6c, 0x6f, 0x63, 0x6b, 0x75, 0x70, 0x2e, 0x76, + 0x31, 0x1a, 0x11, 0x61, 0x6d, 0x69, 0x6e, 0x6f, 0x2f, 0x61, 0x6d, 0x69, 0x6e, 0x6f, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x62, 0x61, 0x73, + 0x65, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x63, 0x6f, 0x69, 0x6e, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x2f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x61, 0x63, 0x63, + 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x2f, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x73, 0x2f, 0x6c, + 0x6f, 0x63, 0x6b, 0x75, 0x70, 0x2f, 0x76, 0x31, 0x2f, 0x6c, 0x6f, 0x63, 0x6b, 0x75, 0x70, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 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, 0x14, 0x67, 0x6f, 0x67, 0x6f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x67, 0x6f, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x19, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x61, 0x6e, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, + 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x22, 0x80, 0x02, 0x0a, 0x14, 0x4d, 0x73, 0x67, 0x49, 0x6e, 0x69, 0x74, 0x4c, 0x6f, + 0x63, 0x6b, 0x75, 0x70, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x2e, 0x0a, 0x05, 0x6f, + 0x77, 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, 0x05, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x12, 0x44, 0x0a, 0x08, 0x65, + 0x6e, 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, + 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, + 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x42, 0x0d, 0xc8, 0xde, 0x1f, 0x00, 0x90, + 0xdf, 0x1f, 0x01, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x07, 0x65, 0x6e, 0x64, 0x54, 0x69, 0x6d, + 0x65, 0x12, 0x48, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, + 0x70, 0x42, 0x0d, 0xc8, 0xde, 0x1f, 0x00, 0x90, 0xdf, 0x1f, 0x01, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, + 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x3a, 0x28, 0xe8, 0xa0, 0x1f, + 0x01, 0x8a, 0xe7, 0xb0, 0x2a, 0x1f, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2d, 0x73, 0x64, 0x6b, + 0x2f, 0x4d, 0x73, 0x67, 0x49, 0x6e, 0x69, 0x74, 0x4c, 0x6f, 0x63, 0x6b, 0x75, 0x70, 0x41, 0x63, + 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x1e, 0x0a, 0x1c, 0x4d, 0x73, 0x67, 0x49, 0x6e, 0x69, 0x74, + 0x4c, 0x6f, 0x63, 0x6b, 0x75, 0x70, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xa9, 0x02, 0x0a, 0x1d, 0x4d, 0x73, 0x67, 0x49, 0x6e, 0x69, + 0x74, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x69, 0x63, 0x4c, 0x6f, 0x63, 0x6b, 0x69, 0x6e, 0x67, + 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x2e, 0x0a, 0x05, 0x6f, 0x77, 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, 0x05, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x12, 0x48, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, + 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, + 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x42, 0x0d, 0xc8, 0xde, 0x1f, 0x00, 0x90, 0xdf, 0x1f, + 0x01, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, + 0x65, 0x12, 0x5e, 0x0a, 0x0f, 0x6c, 0x6f, 0x63, 0x6b, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x65, 0x72, + 0x69, 0x6f, 0x64, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x63, 0x6f, 0x73, + 0x6d, 0x6f, 0x73, 0x2e, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x2e, 0x64, 0x65, 0x66, + 0x61, 0x75, 0x6c, 0x74, 0x73, 0x2e, 0x6c, 0x6f, 0x63, 0x6b, 0x75, 0x70, 0x2e, 0x76, 0x31, 0x2e, + 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, + 0x01, 0x52, 0x0e, 0x6c, 0x6f, 0x63, 0x6b, 0x69, 0x6e, 0x67, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, + 0x73, 0x3a, 0x2e, 0xe8, 0xa0, 0x1f, 0x00, 0x8a, 0xe7, 0xb0, 0x2a, 0x25, 0x63, 0x6f, 0x73, 0x6d, + 0x6f, 0x73, 0x2d, 0x73, 0x64, 0x6b, 0x2f, 0x4d, 0x73, 0x67, 0x49, 0x6e, 0x69, 0x74, 0x50, 0x65, + 0x72, 0x69, 0x6f, 0x64, 0x4c, 0x6f, 0x63, 0x6b, 0x75, 0x70, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, + 0x74, 0x22, 0x27, 0x0a, 0x25, 0x4d, 0x73, 0x67, 0x49, 0x6e, 0x69, 0x74, 0x50, 0x65, 0x72, 0x69, + 0x6f, 0x64, 0x69, 0x63, 0x4c, 0x6f, 0x63, 0x6b, 0x69, 0x6e, 0x67, 0x41, 0x63, 0x63, 0x6f, 0x75, + 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xa5, 0x01, 0x0a, 0x0b, 0x4d, + 0x73, 0x67, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x65, 0x12, 0x4e, 0x0a, 0x11, 0x76, 0x61, + 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x21, 0xd2, 0xb4, 0x2d, 0x1d, 0x63, 0x6f, 0x73, 0x6d, 0x6f, + 0x73, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, + 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x10, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, + 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x3c, 0x0a, 0x06, 0x61, 0x6d, + 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x63, 0x6f, 0x73, + 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, + 0x2e, 0x43, 0x6f, 0x69, 0x6e, 0x42, 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, + 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x3a, 0x08, 0x88, 0xa0, 0x1f, 0x00, 0xe8, 0xa0, + 0x1f, 0x00, 0x22, 0xa7, 0x01, 0x0a, 0x0d, 0x4d, 0x73, 0x67, 0x55, 0x6e, 0x64, 0x65, 0x6c, 0x65, + 0x67, 0x61, 0x74, 0x65, 0x12, 0x4e, 0x0a, 0x11, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, + 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, + 0x21, 0xd2, 0xb4, 0x2d, 0x1d, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x56, 0x61, 0x6c, 0x69, + 0x64, 0x61, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, + 0x6e, 0x67, 0x52, 0x10, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, + 0x72, 0x65, 0x73, 0x73, 0x12, 0x3c, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, + 0x73, 0x65, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x43, 0x6f, 0x69, 0x6e, 0x42, + 0x09, 0xc8, 0xde, 0x1f, 0x00, 0xa8, 0xe7, 0xb0, 0x2a, 0x01, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, + 0x6e, 0x74, 0x3a, 0x08, 0x88, 0xa0, 0x1f, 0x00, 0xe8, 0xa0, 0x1f, 0x00, 0x22, 0x6d, 0x0a, 0x11, + 0x4d, 0x73, 0x67, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x52, 0x65, 0x77, 0x61, 0x72, + 0x64, 0x12, 0x4e, 0x0a, 0x11, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x5f, 0x61, + 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x21, 0xd2, 0xb4, + 0x2d, 0x1d, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, + 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, + 0x10, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, + 0x73, 0x3a, 0x08, 0x88, 0xa0, 0x1f, 0x00, 0xe8, 0xa0, 0x1f, 0x00, 0x22, 0xc7, 0x01, 0x0a, 0x07, + 0x4d, 0x73, 0x67, 0x53, 0x65, 0x6e, 0x64, 0x12, 0x37, 0x0a, 0x0a, 0x74, 0x6f, 0x5f, 0x61, 0x64, + 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x02, 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, 0x09, 0x74, 0x6f, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, + 0x12, 0x79, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x19, 0x2e, 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x62, 0x61, 0x73, 0x65, 0x2e, 0x76, + 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x43, 0x6f, 0x69, 0x6e, 0x42, 0x46, 0xc8, 0xde, 0x1f, + 0x00, 0xaa, 0xdf, 0x1f, 0x28, 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, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x43, 0x6f, 0x69, 0x6e, 0x73, 0x9a, 0xe7, 0xb0, + 0x2a, 0x0c, 0x6c, 0x65, 0x67, 0x61, 0x63, 0x79, 0x5f, 0x63, 0x6f, 0x69, 0x6e, 0x73, 0xa8, 0xe7, + 0xb0, 0x2a, 0x01, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x3a, 0x08, 0x88, 0xa0, 0x1f, + 0x00, 0xe8, 0xa0, 0x1f, 0x00, 0x22, 0x50, 0x0a, 0x1a, 0x4d, 0x73, 0x67, 0x45, 0x78, 0x65, 0x63, + 0x75, 0x74, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x12, 0x32, 0x0a, 0x09, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x73, + 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x41, 0x6e, 0x79, 0x52, 0x09, 0x72, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x73, 0x42, 0x9c, 0x02, 0x0a, 0x26, 0x63, 0x6f, 0x6d, 0x2e, + 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x2e, + 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x73, 0x2e, 0x6c, 0x6f, 0x63, 0x6b, 0x75, 0x70, 0x2e, + 0x76, 0x31, 0x42, 0x07, 0x54, 0x78, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x3c, 0x63, + 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x73, 0x64, 0x6b, 0x2e, 0x69, 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2f, + 0x63, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2f, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x2f, + 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x73, 0x2f, 0x6c, 0x6f, 0x63, 0x6b, 0x75, 0x70, 0x2f, + 0x76, 0x31, 0x3b, 0x6c, 0x6f, 0x63, 0x6b, 0x75, 0x70, 0x76, 0x31, 0xa2, 0x02, 0x04, 0x43, 0x41, + 0x44, 0x4c, 0xaa, 0x02, 0x22, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x2e, 0x41, 0x63, 0x63, 0x6f, + 0x75, 0x6e, 0x74, 0x73, 0x2e, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x73, 0x2e, 0x4c, 0x6f, + 0x63, 0x6b, 0x75, 0x70, 0x2e, 0x56, 0x31, 0xca, 0x02, 0x22, 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, + 0x5c, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x5c, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, + 0x74, 0x73, 0x5c, 0x4c, 0x6f, 0x63, 0x6b, 0x75, 0x70, 0x5c, 0x56, 0x31, 0xe2, 0x02, 0x2e, 0x43, + 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x5c, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x5c, 0x44, + 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x73, 0x5c, 0x4c, 0x6f, 0x63, 0x6b, 0x75, 0x70, 0x5c, 0x56, + 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x26, + 0x43, 0x6f, 0x73, 0x6d, 0x6f, 0x73, 0x3a, 0x3a, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, + 0x3a, 0x3a, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x73, 0x3a, 0x3a, 0x4c, 0x6f, 0x63, 0x6b, + 0x75, 0x70, 0x3a, 0x3a, 0x56, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_cosmos_accounts_defaults_lockup_v1_tx_proto_rawDescOnce sync.Once + file_cosmos_accounts_defaults_lockup_v1_tx_proto_rawDescData = file_cosmos_accounts_defaults_lockup_v1_tx_proto_rawDesc +) + +func file_cosmos_accounts_defaults_lockup_v1_tx_proto_rawDescGZIP() []byte { + file_cosmos_accounts_defaults_lockup_v1_tx_proto_rawDescOnce.Do(func() { + file_cosmos_accounts_defaults_lockup_v1_tx_proto_rawDescData = protoimpl.X.CompressGZIP(file_cosmos_accounts_defaults_lockup_v1_tx_proto_rawDescData) + }) + return file_cosmos_accounts_defaults_lockup_v1_tx_proto_rawDescData +} + +var file_cosmos_accounts_defaults_lockup_v1_tx_proto_msgTypes = make([]protoimpl.MessageInfo, 9) +var file_cosmos_accounts_defaults_lockup_v1_tx_proto_goTypes = []interface{}{ + (*MsgInitLockupAccount)(nil), // 0: cosmos.accounts.defaults.lockup.v1.MsgInitLockupAccount + (*MsgInitLockupAccountResponse)(nil), // 1: cosmos.accounts.defaults.lockup.v1.MsgInitLockupAccountResponse + (*MsgInitPeriodicLockingAccount)(nil), // 2: cosmos.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccount + (*MsgInitPeriodicLockingAccountResponse)(nil), // 3: cosmos.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccountResponse + (*MsgDelegate)(nil), // 4: cosmos.accounts.defaults.lockup.v1.MsgDelegate + (*MsgUndelegate)(nil), // 5: cosmos.accounts.defaults.lockup.v1.MsgUndelegate + (*MsgWithdrawReward)(nil), // 6: cosmos.accounts.defaults.lockup.v1.MsgWithdrawReward + (*MsgSend)(nil), // 7: cosmos.accounts.defaults.lockup.v1.MsgSend + (*MsgExecuteMessagesResponse)(nil), // 8: cosmos.accounts.defaults.lockup.v1.MsgExecuteMessagesResponse + (*timestamppb.Timestamp)(nil), // 9: google.protobuf.Timestamp + (*Period)(nil), // 10: cosmos.accounts.defaults.lockup.v1.Period + (*v1beta1.Coin)(nil), // 11: cosmos.base.v1beta1.Coin + (*anypb.Any)(nil), // 12: google.protobuf.Any +} +var file_cosmos_accounts_defaults_lockup_v1_tx_proto_depIdxs = []int32{ + 9, // 0: cosmos.accounts.defaults.lockup.v1.MsgInitLockupAccount.end_time:type_name -> google.protobuf.Timestamp + 9, // 1: cosmos.accounts.defaults.lockup.v1.MsgInitLockupAccount.start_time:type_name -> google.protobuf.Timestamp + 9, // 2: cosmos.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccount.start_time:type_name -> google.protobuf.Timestamp + 10, // 3: cosmos.accounts.defaults.lockup.v1.MsgInitPeriodicLockingAccount.locking_periods:type_name -> cosmos.accounts.defaults.lockup.v1.Period + 11, // 4: cosmos.accounts.defaults.lockup.v1.MsgDelegate.amount:type_name -> cosmos.base.v1beta1.Coin + 11, // 5: cosmos.accounts.defaults.lockup.v1.MsgUndelegate.amount:type_name -> cosmos.base.v1beta1.Coin + 11, // 6: cosmos.accounts.defaults.lockup.v1.MsgSend.amount:type_name -> cosmos.base.v1beta1.Coin + 12, // 7: cosmos.accounts.defaults.lockup.v1.MsgExecuteMessagesResponse.responses:type_name -> google.protobuf.Any + 8, // [8:8] is the sub-list for method output_type + 8, // [8:8] is the sub-list for method input_type + 8, // [8:8] is the sub-list for extension type_name + 8, // [8:8] is the sub-list for extension extendee + 0, // [0:8] is the sub-list for field type_name +} + +func init() { file_cosmos_accounts_defaults_lockup_v1_tx_proto_init() } +func file_cosmos_accounts_defaults_lockup_v1_tx_proto_init() { + if File_cosmos_accounts_defaults_lockup_v1_tx_proto != nil { + return + } + file_cosmos_accounts_defaults_lockup_v1_lockup_proto_init() + if !protoimpl.UnsafeEnabled { + file_cosmos_accounts_defaults_lockup_v1_tx_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MsgInitLockupAccount); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cosmos_accounts_defaults_lockup_v1_tx_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MsgInitLockupAccountResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cosmos_accounts_defaults_lockup_v1_tx_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MsgInitPeriodicLockingAccount); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cosmos_accounts_defaults_lockup_v1_tx_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MsgInitPeriodicLockingAccountResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cosmos_accounts_defaults_lockup_v1_tx_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MsgDelegate); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cosmos_accounts_defaults_lockup_v1_tx_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MsgUndelegate); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cosmos_accounts_defaults_lockup_v1_tx_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MsgWithdrawReward); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cosmos_accounts_defaults_lockup_v1_tx_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MsgSend); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cosmos_accounts_defaults_lockup_v1_tx_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MsgExecuteMessagesResponse); 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_accounts_defaults_lockup_v1_tx_proto_rawDesc, + NumEnums: 0, + NumMessages: 9, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_cosmos_accounts_defaults_lockup_v1_tx_proto_goTypes, + DependencyIndexes: file_cosmos_accounts_defaults_lockup_v1_tx_proto_depIdxs, + MessageInfos: file_cosmos_accounts_defaults_lockup_v1_tx_proto_msgTypes, + }.Build() + File_cosmos_accounts_defaults_lockup_v1_tx_proto = out.File + file_cosmos_accounts_defaults_lockup_v1_tx_proto_rawDesc = nil + file_cosmos_accounts_defaults_lockup_v1_tx_proto_goTypes = nil + file_cosmos_accounts_defaults_lockup_v1_tx_proto_depIdxs = nil +} diff --git a/tests/integration/accounts/lockup/continous_lockup_test_suite.go b/tests/integration/accounts/lockup/continous_lockup_test_suite.go index f3de1f753319..2407f59c6858 100644 --- a/tests/integration/accounts/lockup/continous_lockup_test_suite.go +++ b/tests/integration/accounts/lockup/continous_lockup_test_suite.go @@ -46,7 +46,6 @@ func (s *IntegrationTestSuite) TestContinuousLockingAccount() { t.Run("error - execute message, wrong sender", func(t *testing.T) { msg := &types.MsgSend{ - Sender: addr, ToAddress: addr, Amount: sdk.Coins{sdk.NewCoin("stake", math.NewInt(100))}, } @@ -55,7 +54,6 @@ func (s *IntegrationTestSuite) TestContinuousLockingAccount() { }) t.Run("error - execute send message, insufficient fund", func(t *testing.T) { msg := &types.MsgSend{ - Sender: ownerAddrStr, ToAddress: addr, Amount: sdk.Coins{sdk.NewCoin("stake", math.NewInt(100))}, } @@ -72,7 +70,6 @@ func (s *IntegrationTestSuite) TestContinuousLockingAccount() { // Check if token is sendable t.Run("ok - execute send message", func(t *testing.T) { msg := &types.MsgSend{ - Sender: ownerAddrStr, ToAddress: addr, Amount: sdk.Coins{sdk.NewCoin("stake", math.NewInt(100))}, } @@ -85,7 +82,6 @@ func (s *IntegrationTestSuite) TestContinuousLockingAccount() { t.Run("ok - execute delegate message", func(t *testing.T) { msg := &types.MsgDelegate{ - Sender: ownerAddrStr, ValidatorAddress: val.OperatorAddress, Amount: sdk.NewCoin("stake", math.NewInt(100)), } @@ -108,7 +104,6 @@ func (s *IntegrationTestSuite) TestContinuousLockingAccount() { }) t.Run("ok - execute withdraw reward message", func(t *testing.T) { msg := &types.MsgWithdrawReward{ - Sender: ownerAddrStr, ValidatorAddress: val.OperatorAddress, } err = s.executeTx(ctx, msg, app, accountAddr, accOwner) @@ -119,7 +114,6 @@ func (s *IntegrationTestSuite) TestContinuousLockingAccount() { require.NoError(t, err) val := vals[0] msg := &types.MsgUndelegate{ - Sender: ownerAddrStr, ValidatorAddress: val.OperatorAddress, Amount: sdk.NewCoin("stake", math.NewInt(100)), } @@ -153,7 +147,6 @@ func (s *IntegrationTestSuite) TestContinuousLockingAccount() { // test if tracking delegate work perfectly t.Run("ok - execute delegate message", func(t *testing.T) { msg := &types.MsgDelegate{ - Sender: ownerAddrStr, ValidatorAddress: val.OperatorAddress, Amount: sdk.NewCoin("stake", math.NewInt(100)), } diff --git a/tests/integration/accounts/lockup/delayed_lockup_test_suite.go b/tests/integration/accounts/lockup/delayed_lockup_test_suite.go index 046240d9df3d..6a39cacd003a 100644 --- a/tests/integration/accounts/lockup/delayed_lockup_test_suite.go +++ b/tests/integration/accounts/lockup/delayed_lockup_test_suite.go @@ -45,7 +45,6 @@ func (s *IntegrationTestSuite) TestDelayedLockingAccount() { t.Run("error - execute message, wrong sender", func(t *testing.T) { msg := &types.MsgSend{ - Sender: addr, ToAddress: addr, Amount: sdk.Coins{sdk.NewCoin("stake", math.NewInt(100))}, } @@ -54,7 +53,6 @@ func (s *IntegrationTestSuite) TestDelayedLockingAccount() { }) t.Run("error - execute send message, insufficient fund", func(t *testing.T) { msg := &types.MsgSend{ - Sender: ownerAddrStr, ToAddress: addr, Amount: sdk.Coins{sdk.NewCoin("stake", math.NewInt(100))}, } @@ -63,7 +61,6 @@ func (s *IntegrationTestSuite) TestDelayedLockingAccount() { }) t.Run("ok - execute delegate message", func(t *testing.T) { msg := &types.MsgDelegate{ - Sender: ownerAddrStr, ValidatorAddress: val.OperatorAddress, Amount: sdk.NewCoin("stake", math.NewInt(100)), } @@ -86,7 +83,6 @@ func (s *IntegrationTestSuite) TestDelayedLockingAccount() { }) t.Run("ok - execute withdraw reward message", func(t *testing.T) { msg := &types.MsgWithdrawReward{ - Sender: ownerAddrStr, ValidatorAddress: val.OperatorAddress, } err = s.executeTx(ctx, msg, app, accountAddr, accOwner) @@ -97,7 +93,6 @@ func (s *IntegrationTestSuite) TestDelayedLockingAccount() { require.NoError(t, err) val := vals[0] msg := &types.MsgUndelegate{ - Sender: ownerAddrStr, ValidatorAddress: val.OperatorAddress, Amount: sdk.NewCoin("stake", math.NewInt(100)), } @@ -133,7 +128,6 @@ func (s *IntegrationTestSuite) TestDelayedLockingAccount() { // Check if token is sendable after unlock t.Run("ok - execute send message", func(t *testing.T) { msg := &types.MsgSend{ - Sender: ownerAddrStr, ToAddress: addr, Amount: sdk.Coins{sdk.NewCoin("stake", math.NewInt(100))}, } diff --git a/tests/integration/accounts/lockup/periodic_lockup_test_suite.go b/tests/integration/accounts/lockup/periodic_lockup_test_suite.go index fa2b33f83c37..e76230d8cba5 100644 --- a/tests/integration/accounts/lockup/periodic_lockup_test_suite.go +++ b/tests/integration/accounts/lockup/periodic_lockup_test_suite.go @@ -59,7 +59,6 @@ func (s *IntegrationTestSuite) TestPeriodicLockingAccount() { t.Run("error - execute message, wrong sender", func(t *testing.T) { msg := &types.MsgSend{ - Sender: addr, ToAddress: addr, Amount: sdk.Coins{sdk.NewCoin("stake", math.NewInt(100))}, } @@ -69,7 +68,6 @@ func (s *IntegrationTestSuite) TestPeriodicLockingAccount() { // No token being unlocked yet t.Run("error - execute send message, insufficient fund", func(t *testing.T) { msg := &types.MsgSend{ - Sender: ownerAddrStr, ToAddress: addr, Amount: sdk.Coins{sdk.NewCoin("stake", math.NewInt(100))}, } @@ -86,7 +84,6 @@ func (s *IntegrationTestSuite) TestPeriodicLockingAccount() { // Check if 500 stake is sendable now t.Run("ok - execute send message", func(t *testing.T) { msg := &types.MsgSend{ - Sender: ownerAddrStr, ToAddress: addr, Amount: sdk.Coins{sdk.NewCoin("stake", math.NewInt(500))}, } @@ -105,7 +102,6 @@ func (s *IntegrationTestSuite) TestPeriodicLockingAccount() { t.Run("ok - execute delegate message", func(t *testing.T) { msg := &types.MsgDelegate{ - Sender: ownerAddrStr, ValidatorAddress: val.OperatorAddress, Amount: sdk.NewCoin("stake", math.NewInt(100)), } @@ -129,7 +125,6 @@ func (s *IntegrationTestSuite) TestPeriodicLockingAccount() { }) t.Run("ok - execute withdraw reward message", func(t *testing.T) { msg := &types.MsgWithdrawReward{ - Sender: ownerAddrStr, ValidatorAddress: val.OperatorAddress, } err = s.executeTx(ctx, msg, app, accountAddr, accOwner) @@ -140,7 +135,6 @@ func (s *IntegrationTestSuite) TestPeriodicLockingAccount() { require.NoError(t, err) val := vals[0] msg := &types.MsgUndelegate{ - Sender: ownerAddrStr, ValidatorAddress: val.OperatorAddress, Amount: sdk.NewCoin("stake", math.NewInt(100)), } @@ -174,7 +168,6 @@ func (s *IntegrationTestSuite) TestPeriodicLockingAccount() { t.Run("ok - execute delegate message", func(t *testing.T) { msg := &types.MsgDelegate{ - Sender: ownerAddrStr, ValidatorAddress: val.OperatorAddress, Amount: sdk.NewCoin("stake", math.NewInt(100)), } diff --git a/tests/integration/accounts/lockup/permanent_lockup_test_suite.go b/tests/integration/accounts/lockup/permanent_lockup_test_suite.go index ca38f5629eb5..c4555cce8146 100644 --- a/tests/integration/accounts/lockup/permanent_lockup_test_suite.go +++ b/tests/integration/accounts/lockup/permanent_lockup_test_suite.go @@ -43,7 +43,6 @@ func (s *IntegrationTestSuite) TestPermanentLockingAccount() { t.Run("error - execute message, wrong sender", func(t *testing.T) { msg := &types.MsgSend{ - Sender: addr, ToAddress: addr, Amount: sdk.Coins{sdk.NewCoin("stake", math.NewInt(100))}, } @@ -52,7 +51,6 @@ func (s *IntegrationTestSuite) TestPermanentLockingAccount() { }) t.Run("error - execute send message, insufficient fund", func(t *testing.T) { msg := &types.MsgSend{ - Sender: ownerAddrStr, ToAddress: addr, Amount: sdk.Coins{sdk.NewCoin("stake", math.NewInt(100))}, } @@ -61,7 +59,6 @@ func (s *IntegrationTestSuite) TestPermanentLockingAccount() { }) t.Run("ok - execute delegate message", func(t *testing.T) { msg := &types.MsgDelegate{ - Sender: ownerAddrStr, ValidatorAddress: val.OperatorAddress, Amount: sdk.NewCoin("stake", math.NewInt(100)), } @@ -84,7 +81,6 @@ func (s *IntegrationTestSuite) TestPermanentLockingAccount() { }) t.Run("ok - execute withdraw reward message", func(t *testing.T) { msg := &types.MsgWithdrawReward{ - Sender: ownerAddrStr, ValidatorAddress: val.OperatorAddress, } err = s.executeTx(ctx, msg, app, accountAddr, accOwner) @@ -95,7 +91,6 @@ func (s *IntegrationTestSuite) TestPermanentLockingAccount() { require.NoError(t, err) val := vals[0] msg := &types.MsgUndelegate{ - Sender: ownerAddrStr, ValidatorAddress: val.OperatorAddress, Amount: sdk.NewCoin("stake", math.NewInt(100)), } @@ -121,7 +116,6 @@ func (s *IntegrationTestSuite) TestPermanentLockingAccount() { t.Run("ok - execute send message", func(t *testing.T) { msg := &types.MsgSend{ - Sender: ownerAddrStr, ToAddress: addr, Amount: sdk.Coins{sdk.NewCoin("stake", math.NewInt(100))}, } @@ -143,7 +137,6 @@ func (s *IntegrationTestSuite) TestPermanentLockingAccount() { t.Run("ok - execute delegate message", func(t *testing.T) { msg := &types.MsgDelegate{ - Sender: ownerAddrStr, ValidatorAddress: val.OperatorAddress, Amount: sdk.NewCoin("stake", math.NewInt(10)), } diff --git a/x/accounts/defaults/lockup/continuous_locking_account_test.go b/x/accounts/defaults/lockup/continuous_locking_account_test.go index 28d4cc9e063f..7e639e2c8a1e 100644 --- a/x/accounts/defaults/lockup/continuous_locking_account_test.go +++ b/x/accounts/defaults/lockup/continuous_locking_account_test.go @@ -41,8 +41,12 @@ func TestContinuousAccountDelegate(t *testing.T) { acc := setupContinuousAccount(t, sdkCtx, ss) _, err := acc.Delegate(sdkCtx, &lockuptypes.MsgDelegate{ +<<<<<<< HEAD Sender: "owner", ValidatorAddress: "val_address", +======= + ValidatorAddress: valAddress, +>>>>>>> 5cedd5048 (fix(accounts): lockup check sender in context not in message (#23621)) Amount: sdk.NewCoin("test", math.NewInt(1)), }) require.NoError(t, err) @@ -60,8 +64,12 @@ func TestContinuousAccountDelegate(t *testing.T) { }) _, err = acc.Delegate(sdkCtx, &lockuptypes.MsgDelegate{ +<<<<<<< HEAD Sender: "owner", ValidatorAddress: "val_address", +======= + ValidatorAddress: valAddress, +>>>>>>> 5cedd5048 (fix(accounts): lockup check sender in context not in message (#23621)) Amount: sdk.NewCoin("test", math.NewInt(5)), }) require.NoError(t, err) @@ -86,7 +94,6 @@ func TestContinuousAccountUndelegate(t *testing.T) { acc := setupContinuousAccount(t, sdkCtx, ss) // Delegate first _, err := acc.Delegate(sdkCtx, &lockuptypes.MsgDelegate{ - Sender: "owner", ValidatorAddress: valAddress, Amount: sdk.NewCoin("test", math.NewInt(1)), }) @@ -98,7 +105,6 @@ func TestContinuousAccountUndelegate(t *testing.T) { // Undelegate _, err = acc.Undelegate(sdkCtx, &lockuptypes.MsgUndelegate{ - Sender: "owner", ValidatorAddress: valAddress, Amount: sdk.NewCoin("test", math.NewInt(1)), }) @@ -129,7 +135,6 @@ func TestContinuousAccountSendCoins(t *testing.T) { acc := setupContinuousAccount(t, sdkCtx, ss) _, err := acc.SendCoins(sdkCtx, &lockuptypes.MsgSend{ - Sender: "owner", ToAddress: "receiver", Amount: sdk.NewCoins(sdk.NewCoin("test", math.NewInt(5))), }) @@ -144,7 +149,6 @@ func TestContinuousAccountSendCoins(t *testing.T) { }) _, err = acc.SendCoins(sdkCtx, &lockuptypes.MsgSend{ - Sender: "owner", ToAddress: "receiver", Amount: sdk.NewCoins(sdk.NewCoin("test", math.NewInt(5))), }) diff --git a/x/accounts/defaults/lockup/delayed_locking_account_test.go b/x/accounts/defaults/lockup/delayed_locking_account_test.go index 972a46f8dd4b..86698ed0815d 100644 --- a/x/accounts/defaults/lockup/delayed_locking_account_test.go +++ b/x/accounts/defaults/lockup/delayed_locking_account_test.go @@ -42,7 +42,6 @@ func TestDelayedAccountDelegate(t *testing.T) { acc := setupDelayedAccount(t, sdkCtx, ss) _, err := acc.Delegate(sdkCtx, &lockuptypes.MsgDelegate{ - Sender: "owner", ValidatorAddress: valAddress, Amount: sdk.NewCoin("test", math.NewInt(1)), }) @@ -61,7 +60,6 @@ func TestDelayedAccountDelegate(t *testing.T) { }) _, err = acc.Delegate(sdkCtx, &lockuptypes.MsgDelegate{ - Sender: "owner", ValidatorAddress: valAddress, Amount: sdk.NewCoin("test", math.NewInt(5)), }) @@ -87,7 +85,6 @@ func TestDelayedAccountUndelegate(t *testing.T) { acc := setupDelayedAccount(t, sdkCtx, ss) // Delegate first _, err := acc.Delegate(sdkCtx, &lockuptypes.MsgDelegate{ - Sender: "owner", ValidatorAddress: valAddress, Amount: sdk.NewCoin("test", math.NewInt(1)), }) @@ -99,7 +96,6 @@ func TestDelayedAccountUndelegate(t *testing.T) { // Undelegate _, err = acc.Undelegate(sdkCtx, &lockuptypes.MsgUndelegate{ - Sender: "owner", ValidatorAddress: valAddress, Amount: sdk.NewCoin("test", math.NewInt(1)), }) @@ -130,7 +126,6 @@ func TestDelayedAccountSendCoins(t *testing.T) { acc := setupDelayedAccount(t, sdkCtx, ss) _, err := acc.SendCoins(sdkCtx, &lockuptypes.MsgSend{ - Sender: "owner", ToAddress: "receiver", Amount: sdk.NewCoins(sdk.NewCoin("test", math.NewInt(5))), }) @@ -145,7 +140,6 @@ func TestDelayedAccountSendCoins(t *testing.T) { }) _, err = acc.SendCoins(sdkCtx, &lockuptypes.MsgSend{ - Sender: "owner", ToAddress: "receiver", Amount: sdk.NewCoins(sdk.NewCoin("test", math.NewInt(5))), }) diff --git a/x/accounts/defaults/lockup/lockup.go b/x/accounts/defaults/lockup/lockup.go index ce12f66880ae..c850f80d3300 100644 --- a/x/accounts/defaults/lockup/lockup.go +++ b/x/accounts/defaults/lockup/lockup.go @@ -128,7 +128,8 @@ func (bva *BaseLockup) Delegate( ) ( *lockuptypes.MsgExecuteMessagesResponse, error, ) { - err := bva.checkSender(ctx, msg.Sender) + sender := accountstd.Sender(ctx) + err := bva.checkSender(ctx, sender) if err != nil { return nil, err } @@ -183,7 +184,8 @@ func (bva *BaseLockup) Undelegate( ) ( *lockuptypes.MsgExecuteMessagesResponse, error, ) { - err := bva.checkSender(ctx, msg.Sender) + sender := accountstd.Sender(ctx) + err := bva.checkSender(ctx, sender) if err != nil { return nil, err } @@ -255,7 +257,8 @@ func (bva *BaseLockup) WithdrawReward( ) ( *lockuptypes.MsgExecuteMessagesResponse, error, ) { - err := bva.checkSender(ctx, msg.Sender) + sender := accountstd.Sender(ctx) + err := bva.checkSender(ctx, sender) if err != nil { return nil, err } @@ -282,7 +285,8 @@ func (bva *BaseLockup) SendCoins( ) ( *lockuptypes.MsgExecuteMessagesResponse, error, ) { - err := bva.checkSender(ctx, msg.Sender) + sender := accountstd.Sender(ctx) + err := bva.checkSender(ctx, sender) if err != nil { return nil, err } @@ -321,16 +325,12 @@ func (bva *BaseLockup) SendCoins( return &lockuptypes.MsgExecuteMessagesResponse{Responses: resp}, nil } -func (bva *BaseLockup) checkSender(ctx context.Context, sender string) error { +func (bva *BaseLockup) checkSender(ctx context.Context, sender []byte) error { owner, err := bva.Owner.Get(ctx) if err != nil { return sdkerrors.ErrInvalidAddress.Wrapf("invalid owner address: %s", err.Error()) } - senderBytes, err := bva.addressCodec.StringToBytes(sender) - if err != nil { - return sdkerrors.ErrInvalidAddress.Wrapf("invalid sender address: %s", err.Error()) - } - if !bytes.Equal(owner, senderBytes) { + if !bytes.Equal(owner, sender) { return errors.New("sender is not the owner of this vesting account") } diff --git a/x/accounts/defaults/lockup/periodic_locking_account_test.go b/x/accounts/defaults/lockup/periodic_locking_account_test.go index bff11684e7f3..ebc23c3b705e 100644 --- a/x/accounts/defaults/lockup/periodic_locking_account_test.go +++ b/x/accounts/defaults/lockup/periodic_locking_account_test.go @@ -2,6 +2,7 @@ package lockup import ( "context" + "errors" "testing" "time" @@ -9,9 +10,12 @@ import ( "cosmossdk.io/core/header" "cosmossdk.io/core/store" + "cosmossdk.io/core/transaction" "cosmossdk.io/log" "cosmossdk.io/math" + "cosmossdk.io/x/accounts/accountstd" lockuptypes "cosmossdk.io/x/accounts/defaults/lockup/v1" + banktypes "cosmossdk.io/x/bank/types" sdk "github.com/cosmos/cosmos-sdk/types" ) @@ -54,8 +58,12 @@ func TestPeriodicAccountDelegate(t *testing.T) { acc := setupPeriodicAccount(t, sdkCtx, ss) _, err := acc.Delegate(sdkCtx, &lockuptypes.MsgDelegate{ +<<<<<<< HEAD Sender: "owner", ValidatorAddress: "val_address", +======= + ValidatorAddress: valAddress, +>>>>>>> 5cedd5048 (fix(accounts): lockup check sender in context not in message (#23621)) Amount: sdk.NewCoin("test", math.NewInt(1)), }) require.NoError(t, err) @@ -73,8 +81,12 @@ func TestPeriodicAccountDelegate(t *testing.T) { }) _, err = acc.Delegate(sdkCtx, &lockuptypes.MsgDelegate{ +<<<<<<< HEAD Sender: "owner", ValidatorAddress: "val_address", +======= + ValidatorAddress: valAddress, +>>>>>>> 5cedd5048 (fix(accounts): lockup check sender in context not in message (#23621)) Amount: sdk.NewCoin("test", math.NewInt(5)), }) require.NoError(t, err) @@ -93,8 +105,12 @@ func TestPeriodicAccountDelegate(t *testing.T) { }) _, err = acc.Delegate(sdkCtx, &lockuptypes.MsgDelegate{ +<<<<<<< HEAD Sender: "owner", ValidatorAddress: "val_address", +======= + ValidatorAddress: valAddress, +>>>>>>> 5cedd5048 (fix(accounts): lockup check sender in context not in message (#23621)) Amount: sdk.NewCoin("test", math.NewInt(4)), }) require.NoError(t, err) @@ -117,8 +133,12 @@ func TestPeriodicAccountUndelegate(t *testing.T) { acc := setupPeriodicAccount(t, sdkCtx, ss) // Delegate first _, err := acc.Delegate(sdkCtx, &lockuptypes.MsgDelegate{ +<<<<<<< HEAD Sender: "owner", ValidatorAddress: "val_address", +======= + ValidatorAddress: valAddress, +>>>>>>> 5cedd5048 (fix(accounts): lockup check sender in context not in message (#23621)) Amount: sdk.NewCoin("test", math.NewInt(1)), }) require.NoError(t, err) @@ -129,8 +149,12 @@ func TestPeriodicAccountUndelegate(t *testing.T) { // Undelegate _, err = acc.Undelegate(sdkCtx, &lockuptypes.MsgUndelegate{ +<<<<<<< HEAD Sender: "owner", ValidatorAddress: "val_address", +======= + ValidatorAddress: valAddress, +>>>>>>> 5cedd5048 (fix(accounts): lockup check sender in context not in message (#23621)) Amount: sdk.NewCoin("test", math.NewInt(1)), }) require.NoError(t, err) @@ -161,7 +185,6 @@ func TestPeriodicAccountSendCoins(t *testing.T) { acc := setupPeriodicAccount(t, sdkCtx, ss) _, err := acc.SendCoins(sdkCtx, &lockuptypes.MsgSend{ - Sender: "owner", ToAddress: "receiver", Amount: sdk.NewCoins(sdk.NewCoin("test", math.NewInt(5))), }) @@ -176,7 +199,6 @@ func TestPeriodicAccountSendCoins(t *testing.T) { }) _, err = acc.SendCoins(sdkCtx, &lockuptypes.MsgSend{ - Sender: "owner", ToAddress: "receiver", Amount: sdk.NewCoins(sdk.NewCoin("test", math.NewInt(5))), }) @@ -217,3 +239,62 @@ func TestPeriodicAccountGetLockCoinInfo(t *testing.T) { require.True(t, unlocked.AmountOf("test").Equal(math.NewInt(10))) require.True(t, locked.AmountOf("test").Equal(math.ZeroInt())) } + +func TestPeriodicAccountSendCoinsUnauthorized(t *testing.T) { + ctx, ss := newMockContext(t) + // Initialize context with current time. + sdkCtx := sdk.NewContext(nil, true, log.NewNopLogger()).WithContext(ctx).WithHeaderInfo(header.Info{ + Time: time.Now(), + }) + + // Create a periodic locking account for the "owner". + acc := setupPeriodicAccount(t, sdkCtx, ss) + + // Fast-forward block time so that all tokens are unlocked. + startTime, err := acc.StartTime.Get(sdkCtx) + require.NoError(t, err) + // In our setup, the total locking periods add up to 3 minutes. + sdkCtx = sdkCtx.WithHeaderInfo(header.Info{ + Time: startTime.Add(3 * time.Minute), + }) + + // Verify that the tokens are fully unlocked. + unlocked, locked, err := acc.GetLockCoinsInfo(sdkCtx, sdkCtx.HeaderInfo().Time) + require.NoError(t, err) + require.True(t, unlocked.AmountOf("test").Equal(math.NewInt(10)), "expected all tokens to be unlocked") + require.True(t, locked.AmountOf("test").Equal(math.ZeroInt()), "expected no locked tokens") + + ctx2, _ := newMockContext2(t) + sdkCtx2 := sdk.NewContext(nil, true, log.NewNopLogger()).WithContext(ctx2).WithHeaderInfo(header.Info{ + Time: startTime.Add(3 * time.Minute), + }) + // Attempt to send coins using an unauthorized sender "hacker" instead of "owner". + _, err = acc.SendCoins(sdkCtx2, &lockuptypes.MsgSend{ + ToAddress: "receiver", + Amount: sdk.NewCoins(sdk.NewCoin("test", math.NewInt(5))), + }) + require.Error(t, err, "non-owner should not be able to send coins") +} + +// Create new mock context with different sender +func newMockContext2(t *testing.T) (context.Context, store.KVStoreService) { + t.Helper() + return accountstd.NewMockContext( + 0, []byte("lockup_account"), []byte("hacker"), TestFunds, + func(ctx context.Context, sender []byte, msg transaction.Msg) (transaction.Msg, error) { + typeUrl := sdk.MsgTypeURL(msg) + switch typeUrl { + case "/cosmos.bank.v1beta1.MsgSend": + return &banktypes.MsgSendResponse{}, nil + default: + return nil, errors.New("unrecognized request type") + } + }, func(ctx context.Context, req transaction.Msg) (transaction.Msg, error) { + typeUrl := sdk.MsgTypeURL(req) + switch typeUrl { + default: + return nil, errors.New("unrecognized request type") + } + }, + ) +} diff --git a/x/accounts/defaults/lockup/permanent_locking_account_test.go b/x/accounts/defaults/lockup/permanent_locking_account_test.go index 224bfbb83e0a..71ae3a6a0f26 100644 --- a/x/accounts/defaults/lockup/permanent_locking_account_test.go +++ b/x/accounts/defaults/lockup/permanent_locking_account_test.go @@ -39,8 +39,12 @@ func TestPermanentAccountDelegate(t *testing.T) { acc := setupPermanentAccount(t, sdkCtx, ss) _, err := acc.Delegate(sdkCtx, &lockuptypes.MsgDelegate{ +<<<<<<< HEAD Sender: "owner", ValidatorAddress: "val_address", +======= + ValidatorAddress: valAddress, +>>>>>>> 5cedd5048 (fix(accounts): lockup check sender in context not in message (#23621)) Amount: sdk.NewCoin("test", math.NewInt(1)), }) require.NoError(t, err) @@ -59,8 +63,12 @@ func TestPermanentAccountUndelegate(t *testing.T) { acc := setupPermanentAccount(t, sdkCtx, ss) // Delegate first _, err := acc.Delegate(sdkCtx, &lockuptypes.MsgDelegate{ +<<<<<<< HEAD Sender: "owner", ValidatorAddress: "val_address", +======= + ValidatorAddress: valAddress, +>>>>>>> 5cedd5048 (fix(accounts): lockup check sender in context not in message (#23621)) Amount: sdk.NewCoin("test", math.NewInt(1)), }) require.NoError(t, err) @@ -71,8 +79,12 @@ func TestPermanentAccountUndelegate(t *testing.T) { // Undelegate _, err = acc.Undelegate(sdkCtx, &lockuptypes.MsgUndelegate{ +<<<<<<< HEAD Sender: "owner", ValidatorAddress: "val_address", +======= + ValidatorAddress: valAddress, +>>>>>>> 5cedd5048 (fix(accounts): lockup check sender in context not in message (#23621)) Amount: sdk.NewCoin("test", math.NewInt(1)), }) require.NoError(t, err) @@ -103,7 +115,6 @@ func TestPermanentAccountSendCoins(t *testing.T) { acc := setupPermanentAccount(t, sdkCtx, ss) _, err := acc.SendCoins(sdkCtx, &lockuptypes.MsgSend{ - Sender: "owner", ToAddress: "receiver", Amount: sdk.NewCoins(sdk.NewCoin("test", math.NewInt(5))), }) diff --git a/x/accounts/defaults/lockup/utils_test.go b/x/accounts/defaults/lockup/utils_test.go index 18a8672467f5..cbf3079b3aa1 100644 --- a/x/accounts/defaults/lockup/utils_test.go +++ b/x/accounts/defaults/lockup/utils_test.go @@ -70,7 +70,7 @@ func (h headerService) HeaderInfo(ctx context.Context) header.Info { func newMockContext(t *testing.T) (context.Context, store.KVStoreService) { t.Helper() return accountstd.NewMockContext( - 0, []byte("lockup_account"), []byte("sender"), TestFunds, + 0, []byte("lockup_account"), []byte("owner"), TestFunds, func(ctx context.Context, sender []byte, msg transaction.Msg) (transaction.Msg, error) { typeUrl := sdk.MsgTypeURL(msg) switch typeUrl { diff --git a/x/accounts/defaults/lockup/v1/tx.pb.go b/x/accounts/defaults/lockup/v1/tx.pb.go index 858e49e2758b..54724910548b 100644 --- a/x/accounts/defaults/lockup/v1/tx.pb.go +++ b/x/accounts/defaults/lockup/v1/tx.pb.go @@ -8,7 +8,6 @@ import ( _ "github.com/cosmos/cosmos-proto" github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" types "github.com/cosmos/cosmos-sdk/types" - _ "github.com/cosmos/cosmos-sdk/types/msgservice" _ "github.com/cosmos/cosmos-sdk/types/tx/amino" _ "github.com/cosmos/gogoproto/gogoproto" proto "github.com/cosmos/gogoproto/proto" @@ -239,7 +238,6 @@ var xxx_messageInfo_MsgInitPeriodicLockingAccountResponse proto.InternalMessageI // MsgDelegate defines a message that enable lockup account to execute delegate message type MsgDelegate struct { // sender is the owner of the lockup account - Sender string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"` ValidatorAddress string `protobuf:"bytes,2,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty"` Amount types.Coin `protobuf:"bytes,3,opt,name=amount,proto3" json:"amount"` } @@ -279,7 +277,6 @@ var xxx_messageInfo_MsgDelegate proto.InternalMessageInfo // MsgUndelegate defines a message that enable lockup account to execute undelegate message type MsgUndelegate struct { - Sender string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"` ValidatorAddress string `protobuf:"bytes,2,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty"` Amount types.Coin `protobuf:"bytes,3,opt,name=amount,proto3" json:"amount"` } @@ -319,7 +316,6 @@ var xxx_messageInfo_MsgUndelegate proto.InternalMessageInfo // MsgWithdrawReward defines a message that enable lockup account to execute withdraw reward message type MsgWithdrawReward struct { - Sender string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"` ValidatorAddress string `protobuf:"bytes,2,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty"` } @@ -358,7 +354,6 @@ var xxx_messageInfo_MsgWithdrawReward proto.InternalMessageInfo // MsgSend defines a message that enable lockup account to execute send message type MsgSend struct { - Sender string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"` ToAddress string `protobuf:"bytes,2,opt,name=to_address,json=toAddress,proto3" json:"to_address,omitempty"` Amount github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,3,rep,name=amount,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"amount"` } @@ -458,53 +453,51 @@ func init() { } var fileDescriptor_84e5f410632b9d39 = []byte{ - // 735 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x55, 0xbf, 0x4f, 0x1b, 0x49, - 0x18, 0xf5, 0xda, 0x3a, 0x38, 0x0f, 0xc7, 0xdd, 0xb1, 0x67, 0xe9, 0x8c, 0x75, 0xec, 0x72, 0x96, - 0xd0, 0x59, 0x3e, 0x31, 0x7b, 0xe6, 0x8a, 0x48, 0x28, 0x0d, 0x0e, 0x89, 0x12, 0x29, 0x8e, 0x90, - 0xc9, 0x0f, 0x29, 0x45, 0xac, 0xf1, 0xee, 0x30, 0xac, 0xf0, 0xce, 0x58, 0xfb, 0x8d, 0x0d, 0xee, - 0xa2, 0x28, 0x45, 0x94, 0x8a, 0x3a, 0x15, 0x65, 0x42, 0xe5, 0x82, 0x3f, 0x82, 0x12, 0x51, 0xa5, - 0x0a, 0x91, 0x89, 0x64, 0xfe, 0x8c, 0x68, 0x77, 0x66, 0x13, 0x7e, 0x85, 0x10, 0x9a, 0x48, 0x69, - 0xac, 0xdd, 0x79, 0xef, 0x7b, 0xdf, 0xfb, 0x9e, 0x67, 0x76, 0xd0, 0xbf, 0xae, 0x80, 0x40, 0x80, - 0x43, 0x5c, 0x57, 0x74, 0xb8, 0x04, 0xc7, 0xa3, 0x2b, 0xa4, 0xd3, 0x92, 0xe0, 0xb4, 0x84, 0xbb, - 0xd6, 0x69, 0x3b, 0xdd, 0x8a, 0x23, 0x37, 0x70, 0x3b, 0x14, 0x52, 0x98, 0x45, 0x45, 0xc6, 0x09, - 0x19, 0x27, 0x64, 0xac, 0xc8, 0xb8, 0x5b, 0x29, 0x4c, 0x90, 0xc0, 0xe7, 0xc2, 0x89, 0x7f, 0x55, - 0x59, 0xc1, 0xd2, 0x3d, 0x9a, 0x04, 0xa8, 0xd3, 0xad, 0x34, 0xa9, 0x24, 0x15, 0xc7, 0x15, 0x3e, - 0xd7, 0xb8, 0x73, 0x09, 0x0f, 0xba, 0x81, 0x2a, 0xf8, 0x53, 0x17, 0x04, 0xc0, 0x22, 0x2c, 0x00, - 0xa6, 0x81, 0x49, 0x05, 0x34, 0xe2, 0x37, 0x2d, 0xab, 0xa1, 0x1c, 0x13, 0x4c, 0xa8, 0xf5, 0xe8, - 0x29, 0x29, 0x60, 0x42, 0xb0, 0x16, 0x75, 0xe2, 0xb7, 0x66, 0x67, 0xc5, 0x21, 0xbc, 0xa7, 0x21, - 0xfb, 0x34, 0x24, 0xfd, 0x80, 0x82, 0x24, 0x81, 0x76, 0x51, 0x7c, 0x9a, 0x46, 0xb9, 0x1a, 0xb0, - 0x3b, 0xdc, 0x97, 0x77, 0x63, 0x77, 0x0b, 0xca, 0xbf, 0x89, 0xd1, 0x4f, 0x62, 0x9d, 0xd3, 0x30, - 0x6f, 0x4c, 0x1b, 0xa5, 0x6c, 0x35, 0xbf, 0xbf, 0x33, 0x9b, 0xd3, 0x5e, 0x16, 0x3c, 0x2f, 0xa4, - 0x00, 0xcb, 0x32, 0xf4, 0x39, 0xab, 0x2b, 0x9a, 0xb9, 0x88, 0x7e, 0xa6, 0xdc, 0x6b, 0x44, 0xfa, - 0xf9, 0xf4, 0xb4, 0x51, 0x1a, 0x9b, 0x2b, 0x60, 0xd5, 0x1c, 0x27, 0xcd, 0xf1, 0xfd, 0xa4, 0x79, - 0x75, 0x7c, 0xf7, 0x9d, 0x9d, 0xda, 0x3c, 0xb0, 0x8d, 0xd7, 0xc3, 0x7e, 0xd9, 0xa8, 0x8f, 0x52, - 0xee, 0x45, 0xa0, 0x79, 0x1b, 0x21, 0x90, 0x24, 0x94, 0x4a, 0x27, 0xf3, 0xad, 0x3a, 0xd9, 0xb8, - 0x38, 0x82, 0xe7, 0x4b, 0x47, 0x5b, 0xb6, 0xf1, 0x72, 0xd8, 0x2f, 0xdb, 0xca, 0xf5, 0x2c, 0x78, - 0x6b, 0xce, 0x79, 0x93, 0x16, 0x2d, 0xf4, 0xd7, 0x79, 0xeb, 0x75, 0x0a, 0x6d, 0xc1, 0x81, 0x16, - 0xdf, 0xa4, 0xd1, 0x94, 0x26, 0x2c, 0xd1, 0xd0, 0x17, 0x9e, 0xef, 0x46, 0x44, 0x9f, 0xb3, 0xab, - 0x66, 0x75, 0x72, 0xca, 0xf4, 0xd5, 0xa7, 0x34, 0x9f, 0xa0, 0xdf, 0x5a, 0xca, 0x4b, 0xa3, 0x1d, - 0x7b, 0x83, 0x7c, 0x66, 0x3a, 0x53, 0x1a, 0x9b, 0x2b, 0xe3, 0xaf, 0x6f, 0x73, 0xac, 0xc6, 0xa9, - 0x66, 0x23, 0x79, 0x25, 0xfd, 0xab, 0x56, 0x53, 0x08, 0xcc, 0xe3, 0xa3, 0x2d, 0x3b, 0x15, 0xa5, - 0x38, 0x73, 0x36, 0x45, 0xc5, 0x39, 0x99, 0xe5, 0x3f, 0x68, 0xe6, 0xc2, 0xa8, 0x3e, 0x85, 0x3a, - 0x30, 0xd0, 0x58, 0x0d, 0xd8, 0x22, 0x6d, 0x51, 0x46, 0x24, 0x35, 0xff, 0x43, 0x23, 0x40, 0xb9, - 0x77, 0x89, 0x0c, 0x35, 0xcf, 0xbc, 0x87, 0x26, 0xba, 0xa4, 0xe5, 0x7b, 0x44, 0x8a, 0xb0, 0x41, - 0x14, 0x25, 0xce, 0x32, 0x5b, 0xfd, 0x7b, 0x7f, 0x67, 0x76, 0x4a, 0x17, 0x3f, 0x4c, 0x38, 0x27, - 0x55, 0x7e, 0xef, 0x9e, 0x5a, 0x37, 0xaf, 0xa3, 0x11, 0x12, 0x44, 0x1e, 0xf5, 0xb6, 0x9b, 0x4c, - 0x12, 0x8c, 0x4e, 0x3c, 0xd6, 0x27, 0x1e, 0xdf, 0x10, 0x3e, 0x3f, 0x1e, 0x98, 0xae, 0x99, 0xff, - 0xe3, 0xc5, 0x96, 0x9d, 0x8a, 0xc2, 0x7a, 0x36, 0xec, 0x97, 0xb5, 0xc5, 0xe2, 0x07, 0x03, 0x8d, - 0xd7, 0x80, 0x3d, 0xe0, 0xde, 0x0f, 0x3d, 0xe6, 0xb6, 0x81, 0x26, 0x6a, 0xc0, 0x1e, 0xf9, 0x72, - 0xd5, 0x0b, 0xc9, 0x7a, 0x9d, 0xae, 0x93, 0xd0, 0xfb, 0xfe, 0xa3, 0x9e, 0x6f, 0xf6, 0x79, 0x1a, - 0x8d, 0xd6, 0x80, 0x2d, 0x53, 0x7e, 0x15, 0x8b, 0xd7, 0x10, 0x92, 0xe2, 0x94, 0xb7, 0x2f, 0x57, - 0x65, 0xa5, 0x48, 0x62, 0xef, 0x1d, 0x8b, 0x3d, 0x73, 0x71, 0xec, 0xb7, 0xa2, 0xd8, 0xb7, 0x0f, - 0xec, 0x12, 0xf3, 0xe5, 0x6a, 0xa7, 0x89, 0x5d, 0x11, 0x24, 0x97, 0xcb, 0xb1, 0x43, 0x28, 0x7b, - 0x6d, 0x0a, 0x71, 0x01, 0xbc, 0x1a, 0xf6, 0xcb, 0xbf, 0x44, 0x1b, 0xcc, 0xed, 0x35, 0xa2, 0x1b, - 0x09, 0x2e, 0xf1, 0x9f, 0x2d, 0xa1, 0x42, 0x0d, 0xd8, 0xcd, 0x0d, 0xea, 0x76, 0x24, 0xad, 0x51, - 0x00, 0xc2, 0x28, 0x24, 0xa7, 0xd3, 0x9c, 0x43, 0xd9, 0x50, 0x3f, 0x43, 0xde, 0x88, 0x0d, 0xe7, - 0xce, 0x7c, 0x9f, 0x16, 0x78, 0xaf, 0xfe, 0x99, 0x56, 0x5d, 0xdc, 0x1d, 0x58, 0xc6, 0xde, 0xc0, - 0x32, 0xde, 0x0f, 0x2c, 0x63, 0xf3, 0xd0, 0x4a, 0xed, 0x1d, 0x5a, 0xa9, 0xb7, 0x87, 0x56, 0xea, - 0x71, 0x59, 0xd9, 0x06, 0x6f, 0x0d, 0xfb, 0xc2, 0xd9, 0xb8, 0xe8, 0x8a, 0x6c, 0x8e, 0xc4, 0xf2, - 0xff, 0x7f, 0x0c, 0x00, 0x00, 0xff, 0xff, 0x08, 0x33, 0x56, 0xd8, 0xd3, 0x07, 0x00, 0x00, + // 700 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x55, 0xcb, 0x4f, 0x13, 0x41, + 0x18, 0xef, 0xb6, 0x11, 0xe8, 0x20, 0x2a, 0x9b, 0x1e, 0x4a, 0x23, 0xbb, 0xd8, 0x84, 0xd8, 0xd4, + 0x30, 0x9b, 0xe2, 0xc1, 0x84, 0x78, 0xa1, 0xa2, 0xd1, 0xc4, 0x1a, 0x52, 0x7c, 0x24, 0x1e, 0x6c, + 0xa6, 0xbb, 0xc3, 0xb0, 0xa1, 0x3b, 0xd3, 0xec, 0x37, 0x2d, 0xf4, 0xe6, 0xd1, 0x78, 0xe2, 0xec, + 0x89, 0x8b, 0xf1, 0x71, 0xe2, 0xc0, 0xff, 0x20, 0x47, 0xc2, 0xc9, 0x93, 0x18, 0x38, 0xc0, 0x9f, + 0x61, 0x76, 0x67, 0x56, 0xcb, 0x53, 0x25, 0x1e, 0xbc, 0x34, 0xbb, 0xf3, 0xfd, 0xbe, 0xef, 0xf7, + 0xe8, 0xcc, 0x2c, 0xba, 0xe5, 0x0a, 0x08, 0x04, 0x38, 0xc4, 0x75, 0x45, 0x87, 0x4b, 0x70, 0x3c, + 0xba, 0x48, 0x3a, 0x2d, 0x09, 0x4e, 0x4b, 0xb8, 0xcb, 0x9d, 0xb6, 0xd3, 0xad, 0x38, 0x72, 0x15, + 0xb7, 0x43, 0x21, 0x85, 0x59, 0x54, 0x60, 0x9c, 0x80, 0x71, 0x02, 0xc6, 0x0a, 0x8c, 0xbb, 0x95, + 0xc2, 0x28, 0x09, 0x7c, 0x2e, 0x9c, 0xf8, 0x57, 0xb5, 0x15, 0x2c, 0xcd, 0xd1, 0x24, 0x40, 0x9d, + 0x6e, 0xa5, 0x49, 0x25, 0xa9, 0x38, 0xae, 0xf0, 0xb9, 0xae, 0x3b, 0x7f, 0xa0, 0x41, 0x13, 0xa8, + 0x86, 0x31, 0xd5, 0xd0, 0x88, 0xdf, 0x74, 0xb7, 0x2e, 0xe5, 0x98, 0x60, 0x42, 0xad, 0x47, 0x4f, + 0x49, 0x03, 0x13, 0x82, 0xb5, 0xa8, 0x13, 0xbf, 0x35, 0x3b, 0x8b, 0x0e, 0xe1, 0x3d, 0x5d, 0xb2, + 0x8f, 0x97, 0xa4, 0x1f, 0x50, 0x90, 0x24, 0xd0, 0x64, 0xc5, 0xd7, 0x69, 0x94, 0xab, 0x01, 0x7b, + 0xc4, 0x7d, 0xf9, 0x38, 0x16, 0x31, 0xab, 0x64, 0x9a, 0x18, 0x5d, 0x12, 0x2b, 0x9c, 0x86, 0x79, + 0x63, 0xc2, 0x28, 0x65, 0xab, 0xf9, 0x9d, 0xcd, 0xa9, 0x9c, 0xd6, 0x32, 0xeb, 0x79, 0x21, 0x05, + 0x58, 0x90, 0xa1, 0xcf, 0x59, 0x5d, 0xc1, 0xcc, 0x39, 0x34, 0x44, 0xb9, 0xd7, 0x88, 0xe6, 0xe7, + 0xd3, 0x13, 0x46, 0x69, 0x78, 0xba, 0x80, 0x15, 0x39, 0x4e, 0xc8, 0xf1, 0xd3, 0x84, 0xbc, 0x3a, + 0xb2, 0xf5, 0xcd, 0x4e, 0xad, 0xed, 0xda, 0xc6, 0xc7, 0x83, 0x8d, 0xb2, 0x51, 0x1f, 0xa4, 0xdc, + 0x8b, 0x8a, 0xe6, 0x43, 0x84, 0x40, 0x92, 0x50, 0xaa, 0x39, 0x99, 0xbf, 0x9d, 0x93, 0x8d, 0x9b, + 0xa3, 0xf2, 0x4c, 0xe9, 0x70, 0xdd, 0x36, 0xde, 0x1e, 0x6c, 0x94, 0x6d, 0xa5, 0x7a, 0x0a, 0xbc, + 0x65, 0xe7, 0x34, 0xa7, 0x45, 0x0b, 0x5d, 0x3f, 0x6d, 0xbd, 0x4e, 0xa1, 0x2d, 0x38, 0xd0, 0xe2, + 0xa7, 0x34, 0x1a, 0xd7, 0x80, 0x79, 0x1a, 0xfa, 0xc2, 0xf3, 0xdd, 0x08, 0xe8, 0x73, 0x76, 0xd1, + 0xac, 0x8e, 0xba, 0x4c, 0x5f, 0xdc, 0xa5, 0xf9, 0x0a, 0x5d, 0x6d, 0x29, 0x2d, 0x8d, 0x76, 0xac, + 0x0d, 0xf2, 0x99, 0x89, 0x4c, 0x69, 0x78, 0xba, 0x8c, 0x7f, 0xbf, 0x9b, 0xb1, 0xb2, 0x53, 0xcd, + 0x46, 0xe3, 0xd5, 0xe8, 0x2b, 0x7a, 0x9a, 0xaa, 0xc0, 0x0c, 0x3e, 0x5c, 0xb7, 0x53, 0x51, 0x8a, + 0x93, 0x27, 0x53, 0x54, 0x98, 0xa3, 0x59, 0xde, 0x44, 0x93, 0xe7, 0x46, 0xf5, 0x33, 0xd4, 0xf7, + 0x06, 0x1a, 0xae, 0x01, 0x9b, 0xa3, 0x2d, 0xca, 0x88, 0xa4, 0xe6, 0x13, 0x34, 0xda, 0x25, 0x2d, + 0xdf, 0x23, 0x52, 0x84, 0x0d, 0xa2, 0x42, 0x8b, 0x93, 0xc9, 0x56, 0x6f, 0xec, 0x6c, 0x4e, 0x8d, + 0x6b, 0x37, 0xcf, 0x13, 0xcc, 0xd1, 0x5c, 0xaf, 0x75, 0x8f, 0xad, 0x9b, 0x77, 0xd1, 0x00, 0x09, + 0x22, 0x46, 0xbd, 0x89, 0xc6, 0x92, 0x3c, 0xa2, 0x63, 0x8a, 0xf5, 0x31, 0xc5, 0xf7, 0x84, 0xcf, + 0xfb, 0xed, 0xeb, 0x9e, 0x99, 0xa1, 0x37, 0xeb, 0x76, 0x2a, 0xb2, 0x5e, 0xfc, 0x60, 0xa0, 0x91, + 0x1a, 0xb0, 0x67, 0xdc, 0xfb, 0xdf, 0x95, 0x06, 0x68, 0xb4, 0x06, 0xec, 0x85, 0x2f, 0x97, 0xbc, + 0x90, 0xac, 0xd4, 0xe9, 0x0a, 0x09, 0xbd, 0x7f, 0x2d, 0xb6, 0x8f, 0xee, 0x8b, 0x81, 0x06, 0x6b, + 0xc0, 0x16, 0x28, 0xf7, 0xcc, 0x3b, 0x08, 0x49, 0x71, 0x6c, 0xfc, 0xd9, 0x87, 0x20, 0x2b, 0x45, + 0xe2, 0xbd, 0xd7, 0xe7, 0x3d, 0x73, 0xbe, 0xf7, 0x07, 0x91, 0xf7, 0xcf, 0xbb, 0x76, 0x89, 0xf9, + 0x72, 0xa9, 0xd3, 0xc4, 0xae, 0x08, 0x92, 0x9b, 0xb5, 0x6f, 0x6b, 0xca, 0x5e, 0x9b, 0x42, 0xdc, + 0x00, 0xef, 0x0e, 0x36, 0xca, 0x97, 0xa3, 0xff, 0xcc, 0xed, 0x35, 0xa2, 0xeb, 0x18, 0xce, 0x0a, + 0x6e, 0x1e, 0x15, 0x6a, 0xc0, 0xee, 0xaf, 0x52, 0xb7, 0x23, 0x69, 0x8d, 0x02, 0x10, 0x46, 0x21, + 0xd9, 0xa8, 0xe6, 0x34, 0xca, 0x86, 0xfa, 0x19, 0xf2, 0x46, 0xac, 0x32, 0x77, 0xe2, 0xa8, 0xce, + 0xf2, 0x5e, 0xfd, 0x17, 0xac, 0x3a, 0xb7, 0xb5, 0x67, 0x19, 0xdb, 0x7b, 0x96, 0xf1, 0x7d, 0xcf, + 0x32, 0xd6, 0xf6, 0xad, 0xd4, 0xf6, 0xbe, 0x95, 0xfa, 0xba, 0x6f, 0xa5, 0x5e, 0x96, 0x95, 0x56, + 0xf0, 0x96, 0xb1, 0x2f, 0x9c, 0xd5, 0xf3, 0x3e, 0x0a, 0xcd, 0x81, 0x78, 0xfc, 0xed, 0x1f, 0x01, + 0x00, 0x00, 0xff, 0xff, 0x1e, 0xf1, 0x2a, 0x6f, 0xc5, 0x06, 0x00, 0x00, } func (this *MsgInitLockupAccount) Equal(that interface{}) bool { @@ -718,13 +711,6 @@ func (m *MsgDelegate) MarshalToSizedBuffer(dAtA []byte) (int, error) { i-- dAtA[i] = 0x12 } - if len(m.Sender) > 0 { - i -= len(m.Sender) - copy(dAtA[i:], m.Sender) - i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) - i-- - dAtA[i] = 0xa - } return len(dAtA) - i, nil } @@ -765,13 +751,6 @@ func (m *MsgUndelegate) MarshalToSizedBuffer(dAtA []byte) (int, error) { i-- dAtA[i] = 0x12 } - if len(m.Sender) > 0 { - i -= len(m.Sender) - copy(dAtA[i:], m.Sender) - i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) - i-- - dAtA[i] = 0xa - } return len(dAtA) - i, nil } @@ -802,13 +781,6 @@ func (m *MsgWithdrawReward) MarshalToSizedBuffer(dAtA []byte) (int, error) { i-- dAtA[i] = 0x12 } - if len(m.Sender) > 0 { - i -= len(m.Sender) - copy(dAtA[i:], m.Sender) - i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) - i-- - dAtA[i] = 0xa - } return len(dAtA) - i, nil } @@ -853,13 +825,6 @@ func (m *MsgSend) MarshalToSizedBuffer(dAtA []byte) (int, error) { i-- dAtA[i] = 0x12 } - if len(m.Sender) > 0 { - i -= len(m.Sender) - copy(dAtA[i:], m.Sender) - i = encodeVarintTx(dAtA, i, uint64(len(m.Sender))) - i-- - dAtA[i] = 0xa - } return len(dAtA) - i, nil } @@ -973,10 +938,6 @@ func (m *MsgDelegate) Size() (n int) { } var l int _ = l - l = len(m.Sender) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) - } l = len(m.ValidatorAddress) if l > 0 { n += 1 + l + sovTx(uint64(l)) @@ -992,10 +953,6 @@ func (m *MsgUndelegate) Size() (n int) { } var l int _ = l - l = len(m.Sender) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) - } l = len(m.ValidatorAddress) if l > 0 { n += 1 + l + sovTx(uint64(l)) @@ -1011,10 +968,6 @@ func (m *MsgWithdrawReward) Size() (n int) { } var l int _ = l - l = len(m.Sender) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) - } l = len(m.ValidatorAddress) if l > 0 { n += 1 + l + sovTx(uint64(l)) @@ -1028,10 +981,6 @@ func (m *MsgSend) Size() (n int) { } var l int _ = l - l = len(m.Sender) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) - } l = len(m.ToAddress) if l > 0 { n += 1 + l + sovTx(uint64(l)) @@ -1492,38 +1441,6 @@ func (m *MsgDelegate) Unmarshal(dAtA []byte) error { return fmt.Errorf("proto: MsgDelegate: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Sender", 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.Sender = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddress", wireType) @@ -1639,38 +1556,6 @@ func (m *MsgUndelegate) Unmarshal(dAtA []byte) error { return fmt.Errorf("proto: MsgUndelegate: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Sender", 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.Sender = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddress", wireType) @@ -1786,38 +1671,6 @@ func (m *MsgWithdrawReward) Unmarshal(dAtA []byte) error { return fmt.Errorf("proto: MsgWithdrawReward: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Sender", 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.Sender = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddress", wireType) @@ -1900,38 +1753,6 @@ func (m *MsgSend) Unmarshal(dAtA []byte) error { return fmt.Errorf("proto: MsgSend: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Sender", 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.Sender = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ToAddress", wireType) diff --git a/x/accounts/msg_server.go b/x/accounts/msg_server.go index 2ee9a9334a95..1c46986854f1 100644 --- a/x/accounts/msg_server.go +++ b/x/accounts/msg_server.go @@ -82,6 +82,7 @@ func (m msgServer) Execute(ctx context.Context, execute *v1.MsgExecute) (*v1.Msg if err != nil { return nil, err } + return &v1.MsgExecuteResponse{ Response: respAny, }, nil diff --git a/x/accounts/proto/cosmos/accounts/defaults/lockup/v1/tx.proto b/x/accounts/proto/cosmos/accounts/defaults/lockup/v1/tx.proto index 11fb09726186..c9eb62015593 100644 --- a/x/accounts/proto/cosmos/accounts/defaults/lockup/v1/tx.proto +++ b/x/accounts/proto/cosmos/accounts/defaults/lockup/v1/tx.proto @@ -4,7 +4,6 @@ package cosmos.accounts.defaults.lockup.v1; import "amino/amino.proto"; import "cosmos/base/v1beta1/coin.proto"; import "cosmos/accounts/defaults/lockup/v1/lockup.proto"; -import "cosmos/msg/v1/msg.proto"; import "cosmos_proto/cosmos.proto"; import "gogoproto/gogo.proto"; import "google/protobuf/any.proto"; @@ -50,44 +49,36 @@ message MsgInitPeriodicLockingAccountResponse {} // MsgDelegate defines a message that enable lockup account to execute delegate message message MsgDelegate { - option (cosmos.msg.v1.signer) = "sender"; option (gogoproto.equal) = false; option (gogoproto.goproto_getters) = false; // sender is the owner of the lockup account - string sender = 1 [(cosmos_proto.scalar) = "cosmos.AddressString"]; string validator_address = 2 [(cosmos_proto.scalar) = "cosmos.ValidatorAddressString"]; cosmos.base.v1beta1.Coin amount = 3 [(gogoproto.nullable) = false, (amino.dont_omitempty) = true]; } // MsgUndelegate defines a message that enable lockup account to execute undelegate message message MsgUndelegate { - option (cosmos.msg.v1.signer) = "sender"; option (gogoproto.equal) = false; option (gogoproto.goproto_getters) = false; - string sender = 1 [(cosmos_proto.scalar) = "cosmos.AddressString"]; string validator_address = 2 [(cosmos_proto.scalar) = "cosmos.ValidatorAddressString"]; cosmos.base.v1beta1.Coin amount = 3 [(gogoproto.nullable) = false, (amino.dont_omitempty) = true]; } // MsgWithdrawReward defines a message that enable lockup account to execute withdraw reward message message MsgWithdrawReward { - option (cosmos.msg.v1.signer) = "sender"; option (gogoproto.equal) = false; option (gogoproto.goproto_getters) = false; - string sender = 1 [(cosmos_proto.scalar) = "cosmos.AddressString"]; string validator_address = 2 [(cosmos_proto.scalar) = "cosmos.ValidatorAddressString"]; } // MsgSend defines a message that enable lockup account to execute send message message MsgSend { - option (cosmos.msg.v1.signer) = "sender"; option (gogoproto.equal) = false; option (gogoproto.goproto_getters) = false; - string sender = 1 [(cosmos_proto.scalar) = "cosmos.AddressString"]; string to_address = 2 [(cosmos_proto.scalar) = "cosmos.AddressString"]; repeated cosmos.base.v1beta1.Coin amount = 3 [ (gogoproto.nullable) = false,